1 | import * as util from '../util';
|
2 | import * as is from '../is';
|
3 |
|
4 | let define = {
|
5 |
|
6 |
|
7 | data: function( params ){
|
8 | let defaults = {
|
9 | field: 'data',
|
10 | bindingEvent: 'data',
|
11 | allowBinding: false,
|
12 | allowSetting: false,
|
13 | allowGetting: false,
|
14 | settingEvent: 'data',
|
15 | settingTriggersEvent: false,
|
16 | triggerFnName: 'trigger',
|
17 | immutableKeys: {},
|
18 | updateStyle: false,
|
19 | beforeGet: function( self ){},
|
20 | beforeSet: function( self, obj ){},
|
21 | onSet: function( self ){},
|
22 | canSet: function( self ){ return true; }
|
23 | };
|
24 | params = util.extend( {}, defaults, params );
|
25 |
|
26 | return function dataImpl( name, value ){
|
27 | let p = params;
|
28 | let self = this;
|
29 | let selfIsArrayLike = self.length !== undefined;
|
30 | let all = selfIsArrayLike ? self : [ self ];
|
31 | let single = selfIsArrayLike ? self[0] : self;
|
32 |
|
33 |
|
34 | if( is.string( name ) ){
|
35 |
|
36 |
|
37 | if( p.allowGetting && value === undefined ){
|
38 |
|
39 | let ret;
|
40 | if( single ){
|
41 | p.beforeGet( single );
|
42 |
|
43 | ret = single._private[ p.field ][ name ];
|
44 | }
|
45 | return ret;
|
46 |
|
47 |
|
48 | } else if( p.allowSetting && value !== undefined ){
|
49 | let valid = !p.immutableKeys[ name ];
|
50 | if( valid ){
|
51 | let change = { [name]: value };
|
52 |
|
53 | p.beforeSet( self, change );
|
54 |
|
55 | for( let i = 0, l = all.length; i < l; i++ ){
|
56 | let ele = all[i];
|
57 |
|
58 | if( p.canSet( ele ) ){
|
59 | ele._private[ p.field ][ name ] = value;
|
60 | }
|
61 | }
|
62 |
|
63 |
|
64 | if( p.updateStyle ){ self.updateStyle(); }
|
65 |
|
66 |
|
67 | p.onSet( self );
|
68 |
|
69 | if( p.settingTriggersEvent ){
|
70 | self[ p.triggerFnName ]( p.settingEvent );
|
71 | }
|
72 | }
|
73 | }
|
74 |
|
75 |
|
76 | } else if( p.allowSetting && is.plainObject( name ) ){
|
77 | let obj = name;
|
78 | let k, v;
|
79 | let keys = Object.keys( obj );
|
80 |
|
81 | p.beforeSet( self, obj );
|
82 |
|
83 | for( let i = 0; i < keys.length; i++ ){
|
84 | k = keys[ i ];
|
85 | v = obj[ k ];
|
86 |
|
87 | let valid = !p.immutableKeys[ k ];
|
88 | if( valid ){
|
89 | for( let j = 0; j < all.length; j++ ){
|
90 | let ele = all[j];
|
91 |
|
92 | if( p.canSet( ele ) ){
|
93 | ele._private[ p.field ][ k ] = v;
|
94 | }
|
95 | }
|
96 | }
|
97 | }
|
98 |
|
99 |
|
100 | if( p.updateStyle ){ self.updateStyle(); }
|
101 |
|
102 |
|
103 | p.onSet( self );
|
104 |
|
105 | if( p.settingTriggersEvent ){
|
106 | self[ p.triggerFnName ]( p.settingEvent );
|
107 | }
|
108 |
|
109 |
|
110 | } else if( p.allowBinding && is.fn( name ) ){
|
111 | let fn = name;
|
112 | self.on( p.bindingEvent, fn );
|
113 |
|
114 |
|
115 | } else if( p.allowGetting && name === undefined ){
|
116 | let ret;
|
117 | if( single ){
|
118 | p.beforeGet( single );
|
119 |
|
120 | ret = single._private[ p.field ];
|
121 | }
|
122 | return ret;
|
123 | }
|
124 |
|
125 | return self;
|
126 | };
|
127 | },
|
128 |
|
129 |
|
130 | removeData: function( params ){
|
131 | let defaults = {
|
132 | field: 'data',
|
133 | event: 'data',
|
134 | triggerFnName: 'trigger',
|
135 | triggerEvent: false,
|
136 | immutableKeys: {}
|
137 | };
|
138 | params = util.extend( {}, defaults, params );
|
139 |
|
140 | return function removeDataImpl( names ){
|
141 | let p = params;
|
142 | let self = this;
|
143 | let selfIsArrayLike = self.length !== undefined;
|
144 | let all = selfIsArrayLike ? self : [ self ];
|
145 |
|
146 |
|
147 | if( is.string( names ) ){
|
148 | let keys = names.split( /\s+/ );
|
149 | let l = keys.length;
|
150 |
|
151 | for( let i = 0; i < l; i++ ){
|
152 | let key = keys[ i ];
|
153 | if( is.emptyString( key ) ){ continue; }
|
154 |
|
155 | let valid = !p.immutableKeys[ key ];
|
156 | if( valid ){
|
157 | for( let i_a = 0, l_a = all.length; i_a < l_a; i_a++ ){
|
158 | all[ i_a ]._private[ p.field ][ key ] = undefined;
|
159 | }
|
160 | }
|
161 | }
|
162 |
|
163 | if( p.triggerEvent ){
|
164 | self[ p.triggerFnName ]( p.event );
|
165 | }
|
166 |
|
167 |
|
168 | } else if( names === undefined ){
|
169 |
|
170 | for( let i_a = 0, l_a = all.length; i_a < l_a; i_a++ ){
|
171 | let _privateFields = all[ i_a ]._private[ p.field ];
|
172 | let keys = Object.keys( _privateFields );
|
173 |
|
174 | for( let i = 0; i < keys.length; i++ ){
|
175 | let key = keys[i];
|
176 | let validKeyToDelete = !p.immutableKeys[ key ];
|
177 |
|
178 | if( validKeyToDelete ){
|
179 | _privateFields[ key ] = undefined;
|
180 | }
|
181 | }
|
182 | }
|
183 |
|
184 | if( p.triggerEvent ){
|
185 | self[ p.triggerFnName ]( p.event );
|
186 | }
|
187 | }
|
188 |
|
189 | return self;
|
190 | };
|
191 | },
|
192 | };
|
193 |
|
194 | export default define;
|