micro-optimizations and code reductions

Author: Scott J. Miles

src/declaration/attributes.js

@@ -7,15 +7,9 @@
 
   // imports
 
-  var api = scope.api.instance.attributes;
-
-  //var PUBLISHED = api.PUBLISHED;
-  var INSTANCE_ATTRIBUTES = api.INSTANCE_ATTRIBUTES;
-
   // magic words
 
-  var PUBLISH = 'publish';
-  var ATTRIBUTES = 'attributes';
+  var ATTRIBUTES_ATTRIBUTE = 'attributes';
 
   // attributes api
 
@@ -35,26 +29,12 @@
     inheritAttributesObjects: function(prototype) {
       // chain our LC property map to our inherited version
       chainObject(prototype._publishLC, prototype.__proto__._publishLC);
-      prototype[INSTANCE_ATTRIBUTES] = {};
-      chainObject(prototype[INSTANCE_ATTRIBUTES], prototype.__proto__[INSTANCE_ATTRIBUTES]);
-      //this.inheritObject(prototype, PUBLISHED);
-      //this.inheritObject(prototype, INSTANCE_ATTRIBUTES);
+      prototype._instanceAttributes = {};
+      chainObject(prototype._instanceAttributes, prototype.__proto__._instanceAttributes);
     },
-    //
-    parsePublished: function(prototype) {
-      // transcribe `attributes` declarations onto own prototype's `publish`
-      var publish = this.publishAttributes(prototype);
-      // if we have any properties to publish
-      if (publish) {
-        // transcribe `publish` entries onto own prototype
-        this.publishProperties(publish, prototype);
-        // construct map of lower-cased property names
-        prototype._publishLC = this.lowerCaseMap(publish);
-      }
-    },
-    publishAttributes: function(prototype) {
+    publishAttributes: function(prototype, base) {
       // merge names from 'attributes' attribute
-      var attributes = this.getAttribute(ATTRIBUTES);
+      var attributes = this.getAttribute(ATTRIBUTES_ATTRIBUTE);
       if (attributes) {
         // get properties to publish
         var publish = prototype.publish || (prototype.publish = {});
@@ -65,32 +45,16 @@
           // remove excess ws
           n = names[i].trim();
           // do not override explicit entries
-          if (publish[n] === undefined) {
+          if (publish[n] === undefined && base[n] === undefined) {
             publish[n] = null;
           }
         }
       }
-      return prototype.publish;
-    },
-    publishProperties: function(published, prototype) {
-      // ensure a prototype value for each one
-      for (var n in published) {
-        if (prototype[n] === undefined) {
-          prototype[n] = published[n];
-        }
-      }
-    },
-    lowerCaseMap: function(published) {
-      var map = {};
-      for (var n in published) {
-        map[n.toLowerCase()] = n;
-      }
-      return map;
     },
     // record clonable attributes from <element>
     accumulateInstanceAttributes: function() {
       // inherit instance attributes
-      var clonable = this.prototype[INSTANCE_ATTRIBUTES];
+      var clonable = this.prototype._instanceAttributes;
       // merge attributes from element
       this.attributes.forEach(function(a) {
         if (this.isInstanceAttribute(a.name)) {
@@ -105,8 +69,8 @@
     blackList: {name: 1, 'extends': 1, constructor: 1, noscript: 1}
   };
 
-  // add ATTRIBUTES symbol to blacklist
-  attributes.blackList[ATTRIBUTES] = 1;
+  // add ATTRIBUTES_ATTRIBUTE to the blacklist
+  attributes.blackList[ATTRIBUTES_ATTRIBUTE] = 1;
 
   // exports
 

src/declaration/properties.js

@@ -19,9 +19,56 @@
           //console.log('inferring observe entry for', n);
         }
       }
+    },
+    optimizePropertyMaps: function(prototype, base) {
+      if (prototype.observe) {
+        // combine name list
+        prototype._observeNames = Object.keys(prototype.observe).concat(base._observeNames || []);
+        // build value list
+        prototype._observeValues = valuesForNames(prototype._observeNames, prototype.observe);
+      }
+      if (prototype.publish) {
+        // combine name list
+        prototype._publishNames = Object.keys(prototype.publish).concat(base._publishNames || []);
+        // build value list
+        prototype._publishValues = valuesForNames(prototype._publishNames, prototype.publish);
+      }
+    },
+    publishProperties: function(prototype, base) {
+      // if we have any properties to publish
+      var publish = prototype.publish;
+      if (publish) {
+        // transcribe `publish` entries onto own prototype
+        this.requireProperties(publish, prototype, base);
+        // construct map of lower-cased property names
+        prototype._publishLC = this.lowerCaseMap(publish);
+      }
+    },
+    requireProperties: function(properties, prototype, base) {
+      // ensure a prototype value for each one
+      for (var n in properties) {
+        if (prototype[n] === undefined && base[n] === undefined) {
+          prototype[n] = properties[n];
+        }
+      }
+    },
+    lowerCaseMap: function(properties) {
+      var map = {};
+      for (var n in properties) {
+        map[n.toLowerCase()] = n;
+      }
+      return map;
     }
   };
 
+  function valuesForNames(names, map) {
+    var values = [];
+    for (var i=0, l=names.length; i<l; i++) {
+      values[i] = map[names[i]];
+    }
+    return values;
+  }
+
   // exports
 
   scope.api.declaration.properties = properties;

src/declaration/prototype.js

@@ -16,7 +16,7 @@
   // TODO(sjmiles): duplicated in attributes.js
   if (Object.__proto__) {
     var chainObject = function(object, inherited) {
-      if (inherited && object !== inherited) {
+      if (object && inherited && object !== inherited) {
         object.__proto__ = inherited;
       }
     }
@@ -32,17 +32,17 @@
     register: function(name, extendee) {
       // build prototype combining extendee, Polymer base, and named api
       this.prototype = this.buildPrototype(name, extendee);
-      //console.log(this.prototype);
-      // backref
+      // back reference declaration element
+      // TODO(sjmiles): replace `element` with `elementElement` or `declaration`
       this.prototype.element = this;
+      // more declarative features
+      this.desugar();
       // TODO(sorvell): install a helper method this.resolvePath to aid in 
       // setting resource paths. e.g.
       // this.$.image.src = this.resolvePath('images/foo.png')
       // Potentially remove when spec bug is addressed.
       // https://www.w3.org/Bugs/Public/show_bug.cgi?id=21407
       this.addResolvePathApi();
-      // more declarative features
-      this.desugar();
       // under ShadowDOMPolyfill, transforms to approximate missing CSS features
       if (window.ShadowDOMPolyfill) {
         Platform.ShadowCSS.shimStyling(this.templateContent(), name, extendee);
@@ -55,29 +55,20 @@
     buildPrototype: function(name, extendee) {
       // get our custom prototype (before chaining)
       var prototype = scope.getRegisteredPrototype(name);
-      // copy declared publish list to `publish` object
-      // ensure `publish` names are on prototype
-      this.parsePublished(prototype);
-      // infer observers for `observe` list based on method names
-      this.inferObservers(prototype);
       // get basal prototype
       var base = this.generateBasePrototype(extendee);
+      // transcribe `attributes` declarations onto own prototype's `publish`
+      this.publishAttributes(prototype, base);
+      // `publish` properties to the prototype and to attribute watch
+      this.publishProperties(prototype, base);
+      // infer observers for `observe` list based on method names
+      this.inferObservers(prototype);
       // chain observe object
-      if (prototype.hasOwnProperty('observe')) {
-        if (base.hasOwnProperty('observe')) {
-          chainObject(prototype.observe, base.observe);
-        }
-        // combine name list
-        prototype._observeNames = Object.keys(prototype.observe).concat(base._observeNames || []);
-      }
+      chainObject(prototype.observe, base.observe);
       // chain publish object
-      if (prototype.hasOwnProperty('publish')) {
-        if (base.hasOwnProperty('publish')) {
-          chainObject(prototype.publish, base.publish);
-        }
-        // combine name list
-        prototype._publishNames = Object.keys(prototype.publish).concat(base._publishNames || []);
-      }
+      chainObject(prototype.publish, base.publish);
+      // build side-chained lists to optimize iterations
+      this.optimizePropertyMaps(prototype, base);
       // chain custom api
       chainObject(prototype, base);
       // inherit publishing meta-data
@@ -112,15 +103,21 @@
     },
     // build prototype combining extendee, Polymer base, and named api
     generateBasePrototype: function(extnds) {
-      // create a prototype based on tag-name extension
-      var prototype = HTMLElement.getPrototypeForTag(extnds);
-      // insert base api in inheritance chain (if needed)
-      return this.ensureBaseApi(prototype);
+      var prototype = memoizedBases[extnds];
+      if (!prototype) {
+        // create a prototype based on tag-name extension
+        var prototype = HTMLElement.getPrototypeForTag(extnds);
+        // insert base api in inheritance chain (if needed)
+        prototype = this.ensureBaseApi(prototype);
+        // memoize this base
+        memoizedBases[extnds] = prototype;
+      }
+      return prototype;
     },
     // install Polymer instance api into prototype chain, as needed 
-    ensureBaseApi: function(prototype) { 
+    ensureBaseApi: function(prototype) {
       if (!prototype.PolymerBase) {
-        prototype = Object.create(prototype);
+       prototype = Object.create(prototype);
        // we need a unique copy of base api for each base prototype
        // therefore we 'extend' here instead of simply chaining
        // we could memoize instead, especially for the common cases,
@@ -150,6 +147,9 @@
     }
   };
 
+  // memoize base prototypes
+  memoizedBases = {};
+
   // On platforms that do not support __proto__ (version of IE), the prototype
   // chain of a custom element is simulated via installation of __proto__.
   // Although custom elements manages this, we install it here so it's

src/instance/attributes.js

@@ -5,18 +5,11 @@
  */
 (function(scope) {
 
-  // magic words
-
-  var INSTANCE_ATTRIBUTES = '__instance_attributes';
-  //var PUBLISHED = '__published';
-
   // instance api for attributes
 
   var attributes = {
-    //PUBLISHED: PUBLISHED,
-    INSTANCE_ATTRIBUTES: INSTANCE_ATTRIBUTES,
     copyInstanceAttributes: function () {
-      var a$ = this[INSTANCE_ATTRIBUTES];
+      var a$ = this._instanceAttributes;
       for (var k in a$) {
         this.setAttribute(k, a$[k]);
       }
@@ -94,9 +87,6 @@
     }
   };
 
-  var lowerCase = String.prototype.toLowerCase.call.bind(
-    String.prototype.toLowerCase);
-
   // exports
 
   scope.api.instance.attributes = attributes;

src/instance/properties.js

@@ -27,29 +27,30 @@
       // perhaps we can make it optional somehow
       //
       // add user's observers
-      var n$ = this._observeNames;
+      var n$ = this._observeNames, v$ = this._observeValues;
       if (n$) {
-        for (var i=0, l=n$.length, n; (i<l) && (n=n$[i]); i++) {
-          var m = this.observe[n];
+        for (var i=0, l=n$.length, n; i<l; i++) {
+          n = n$[i];
           if (this.publish && (this.publish[n] !== undefined)) {
-            this.observeBoth(n, m);
+            this.observeBoth(n, v$[i]);
           } else {
-            this.observeProperty(n, m);
+            this.observeProperty(n, v$[i]);
           }
         }
       }
       // add observers for published properties
-      var n$ = this._publishNames;
+      var n$ = this._publishNames, v$ = this._publishValues;
       if (n$) {
-        for (var i=0, l=n$.length, n; (i<l) && (n=n$[i]); i++) {
+        for (var i=0, l=n$.length, n; i<l; i++) {
+          n = n$[i];
           if (!this.observe || (this.observe[n] === undefined)) {
-            this.observeAttributeProperty(n, this.publish[n]);
+            this.observeAttributeProperty(n, v$[i]);
           }
         }
       }
     },
     _observe: function(name, cb) {
-      log.watch && console.log(LOG_OBSERVE, this.localName, name);
+      log.observe && console.log(LOG_OBSERVE, this.localName, name);
       registerObserver(this, name, 
         new PathObserver(this, name, cb));
     },