third_party/polymer/v1_0/components-chromium/iron-meta/iron-meta-extracted.js

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