| OLD | NEW |
| (Empty) |
| 1 | |
| 2 | |
| 3 (function() { | |
| 4 | |
| 5 // monostate data | |
| 6 var metaDatas = {}; | |
| 7 var metaArrays = {}; | |
| 8 | |
| 9 Polymer.IronMeta = Polymer({ | |
| 10 | |
| 11 is: 'iron-meta', | |
| 12 | |
| 13 properties: { | |
| 14 | |
| 15 /** | |
| 16 * The type of meta-data. All meta-data of the same type is stored | |
| 17 * together. | |
| 18 * | |
| 19 * @attribute type | |
| 20 * @type String | |
| 21 * @default 'default' | |
| 22 */ | |
| 23 type: { | |
| 24 type: String, | |
| 25 value: 'default', | |
| 26 observer: '_typeChanged' | |
| 27 }, | |
| 28 | |
| 29 /** | |
| 30 * The key used to store `value` under the `type` namespace. | |
| 31 * | |
| 32 * @attribute key | |
| 33 * @type String | |
| 34 * @default '' | |
| 35 */ | |
| 36 key: { | |
| 37 type: String, | |
| 38 observer: '_keyChanged' | |
| 39 }, | |
| 40 | |
| 41 /** | |
| 42 * The meta-data to store or retrieve. | |
| 43 * | |
| 44 * @attribute value | |
| 45 * @type * | |
| 46 * @default this | |
| 47 */ | |
| 48 value: { | |
| 49 type: Object, | |
| 50 notify: true, | |
| 51 observer: '_valueChanged' | |
| 52 }, | |
| 53 | |
| 54 /** | |
| 55 * If true, `value` is set to the iron-meta instance itself. | |
| 56 * | |
| 57 * @attribute self | |
| 58 * @type Boolean | |
| 59 * @default false | |
| 60 */ | |
| 61 self: { | |
| 62 type: Boolean, | |
| 63 observer: '_selfChanged' | |
| 64 }, | |
| 65 | |
| 66 /** | |
| 67 * Array of all meta-data values for the given type. | |
| 68 * | |
| 69 * @property list | |
| 70 * @type Array | |
| 71 */ | |
| 72 list: { | |
| 73 type: Array, | |
| 74 notify: true | |
| 75 } | |
| 76 | |
| 77 }, | |
| 78 | |
| 79 /** | |
| 80 * Only runs if someone invokes the factory/constructor directly | |
| 81 * e.g. `new Polymer.IronMeta()` | |
| 82 */ | |
| 83 factoryImpl: function(config) { | |
| 84 if (config) { | |
| 85 for (var n in config) { | |
| 86 switch(n) { | |
| 87 case 'type': | |
| 88 case 'key': | |
| 89 case 'value': | |
| 90 this[n] = config[n]; | |
| 91 break; | |
| 92 } | |
| 93 } | |
| 94 } | |
| 95 }, | |
| 96 | |
| 97 created: function() { | |
| 98 // TODO(sjmiles): good for debugging? | |
| 99 this._metaDatas = metaDatas; | |
| 100 this._metaArrays = metaArrays; | |
| 101 }, | |
| 102 | |
| 103 _keyChanged: function(key, old) { | |
| 104 this._resetRegistration(old); | |
| 105 }, | |
| 106 | |
| 107 _valueChanged: function(value) { | |
| 108 this._resetRegistration(this.key); | |
| 109 }, | |
| 110 | |
| 111 _selfChanged: function(self) { | |
| 112 if (self) { | |
| 113 this.value = this; | |
| 114 } | |
| 115 }, | |
| 116 | |
| 117 _typeChanged: function(type) { | |
| 118 this._unregisterKey(this.key); | |
| 119 if (!metaDatas[type]) { | |
| 120 metaDatas[type] = {}; | |
| 121 } | |
| 122 this._metaData = metaDatas[type]; | |
| 123 if (!metaArrays[type]) { | |
| 124 metaArrays[type] = []; | |
| 125 } | |
| 126 this.list = metaArrays[type]; | |
| 127 this._registerKeyValue(this.key, this.value); | |
| 128 }, | |
| 129 | |
| 130 /** | |
| 131 * Retrieves meta data value by key. | |
| 132 * | |
| 133 * @method byKey | |
| 134 * @param {String} key The key of the meta-data to be returned. | |
| 135 * @returns * | |
| 136 */ | |
| 137 byKey: function(key) { | |
| 138 return this._metaData && this._metaData[key]; | |
| 139 }, | |
| 140 | |
| 141 _resetRegistration: function(oldKey) { | |
| 142 this._unregisterKey(oldKey); | |
| 143 this._registerKeyValue(this.key, this.value); | |
| 144 }, | |
| 145 | |
| 146 _unregisterKey: function(key) { | |
| 147 this._unregister(key, this._metaData, this.list); | |
| 148 }, | |
| 149 | |
| 150 _registerKeyValue: function(key, value) { | |
| 151 this._register(key, value, this._metaData, this.list); | |
| 152 }, | |
| 153 | |
| 154 _register: function(key, value, data, list) { | |
| 155 if (key && data && value !== undefined) { | |
| 156 data[key] = value; | |
| 157 list.push(value); | |
| 158 } | |
| 159 }, | |
| 160 | |
| 161 _unregister: function(key, data, list) { | |
| 162 if (key && data) { | |
| 163 if (key in data) { | |
| 164 var value = data[key]; | |
| 165 delete data[key]; | |
| 166 this.arrayDelete(list, value); | |
| 167 } | |
| 168 } | |
| 169 } | |
| 170 | |
| 171 }); | |
| 172 | |
| 173 /** | |
| 174 `iron-meta-query` can be used to access infomation stored in `iron-meta`. | |
| 175 | |
| 176 Examples: | |
| 177 | |
| 178 If I create an instance like this: | |
| 179 | |
| 180 <iron-meta key="info" value="foo/bar"></iron-meta> | |
| 181 | |
| 182 Note that keyUrl="foo/bar" is the metadata I've defined. I could define more | |
| 183 attributes or use child nodes to define additional metadata. | |
| 184 | |
| 185 Now I can access that element (and it's metadata) from any `iron-meta-query`
instance: | |
| 186 | |
| 187 var value = new Polymer.IronMetaQuery({key: 'info'}).value; | |
| 188 | |
| 189 @group Polymer Iron Elements | |
| 190 @element iron-meta-query | |
| 191 */ | |
| 192 Polymer.IronMetaQuery = Polymer({ | |
| 193 | |
| 194 is: 'iron-meta-query', | |
| 195 | |
| 196 properties: { | |
| 197 | |
| 198 /** | |
| 199 * The type of meta-data. All meta-data of the same type is stored | |
| 200 * together. | |
| 201 * | |
| 202 * @attribute type | |
| 203 * @type String | |
| 204 * @default 'default' | |
| 205 */ | |
| 206 type: { | |
| 207 type: String, | |
| 208 value: 'default', | |
| 209 observer: '_typeChanged' | |
| 210 }, | |
| 211 | |
| 212 /** | |
| 213 * Specifies a key to use for retrieving `value` from the `type` | |
| 214 * namespace. | |
| 215 * | |
| 216 * @attribute key | |
| 217 * @type String | |
| 218 */ | |
| 219 key: { | |
| 220 type: String, | |
| 221 observer: '_keyChanged' | |
| 222 }, | |
| 223 | |
| 224 /** | |
| 225 * The meta-data to store or retrieve. | |
| 226 * | |
| 227 * @attribute value | |
| 228 * @type * | |
| 229 * @default this | |
| 230 */ | |
| 231 value: { | |
| 232 type: Object, | |
| 233 notify: true, | |
| 234 readOnly: true | |
| 235 }, | |
| 236 | |
| 237 /** | |
| 238 * Array of all meta-data values for the given type. | |
| 239 * | |
| 240 * @property list | |
| 241 * @type Array | |
| 242 */ | |
| 243 list: { | |
| 244 type: Array, | |
| 245 notify: true | |
| 246 } | |
| 247 | |
| 248 }, | |
| 249 | |
| 250 /** | |
| 251 * Actually a factory method, not a true constructor. Only runs if | |
| 252 * someone invokes it directly (via `new Polymer.IronMeta()`); | |
| 253 */ | |
| 254 constructor: function(config) { | |
| 255 if (config) { | |
| 256 for (var n in config) { | |
| 257 switch(n) { | |
| 258 case 'type': | |
| 259 case 'key': | |
| 260 this[n] = config[n]; | |
| 261 break; | |
| 262 } | |
| 263 } | |
| 264 } | |
| 265 }, | |
| 266 | |
| 267 created: function() { | |
| 268 // TODO(sjmiles): good for debugging? | |
| 269 this._metaDatas = metaDatas; | |
| 270 this._metaArrays = metaArrays; | |
| 271 }, | |
| 272 | |
| 273 _keyChanged: function(key) { | |
| 274 this._setValue(this._metaData && this._metaData[key]); | |
| 275 }, | |
| 276 | |
| 277 _typeChanged: function(type) { | |
| 278 this._metaData = metaDatas[type]; | |
| 279 this.list = metaArrays[type]; | |
| 280 if (this.key) { | |
| 281 this._keyChanged(this.key); | |
| 282 } | |
| 283 }, | |
| 284 | |
| 285 /** | |
| 286 * Retrieves meta data value by key. | |
| 287 * | |
| 288 * @method byKey | |
| 289 * @param {String} key The key of the meta-data to be returned. | |
| 290 * @returns * | |
| 291 */ | |
| 292 byKey: function(key) { | |
| 293 return this._metaData && this._metaData[key]; | |
| 294 } | |
| 295 | |
| 296 }); | |
| 297 | |
| 298 })(); | |
| OLD | NEW |