patch-polymer.html

<script>
"use strict";

/*
 Overwrite the Collection.add and .initMap methods.

 Here we provide the option of using "intrusive" keys
 for objects..although it's not fully intrusive, because
 the non-intrusive version still exists and is used by 
 the Collection class itself.
 
 Objects with a ._pkey=null property will have it set to the
 key when inserted into the collection, and when the 
 collection is initialized.

 Note that if the object is in multiple collections only the
 first insertion will set the pkey, because after that the
 value will no longer be null.  It is up to the user to be
 aware of this and use it appropriately.

*/
Polymer.Collection.prototype.add = function(item) {
  var key = this.store.push(item) - 1;
  if (item && typeof item == 'object') {
    this.omap.set(item, key);
    item._pkey === null && (item._pkey = '#' + key); // << this is extra
  } else {
    this.pmap[item] = key;
  }
  return '#' + key;
};

Polymer.Collection.prototype.initMap = function() {
  var omap = this.omap = new WeakMap();
  var pmap = this.pmap = {};
  var s = this.store;
  for (var i=0; i<s.length; i++) {
    var item = s[i];
    if (item && typeof item == 'object') {
      omap.set(item, i);
      item._pkey === null && (item._pkey = '#' + i); // << this is extra
    } else {
      pmap[item] = i;
    }
  }
};


/*
  The following is an important hack which allows you to avoid doing expensive
  notifications if you really have to.

  It is to be used when an object has various properties that are known to only 
  be of interest to a very specific set of elements. 

  The "target" elements should use the Polymer.ShortcutNotifyTargetBehavior(), 
  behavior factory function, passing in an array of path strings.

  For example:

    <dom-module id="lovely-view">
      <template>
        some_property is: [[my_model.some_property]]
      </template>
      <script>
        Polymer({
          is: 'lovely-view',
          behaviors: [
            Polymer.ShortcutNotifyTargetBehavior(['my_model'])
          ],
          properties: {
             my_model: {
                // whatever
             }
          }
        });
      < /script>
    </dom-module>

  The "notifiyer" element should use the Polymer.ShortcutNotifyerBehavior,
  and then replace calls like this:

    this.notifyPath('some_array.#42.some_property', mutated_object.some_property)      

  with this:

     this.shortcutNotify('some_property', mutated_object.some_property, mutated_object);

  Note how here we only use the final suffix for the path, and we provide the actual
  object as the final argument.

  I think this mechanism supports multi-part paths, but I haven't tested it.

  Using this approach very much goes against the Polymeric way of doing things, 
  but it's far easier to implement than something less hacky (I did try something
  much fancier, but ran in to all kinds of complciations and decided to abandon the effort.)
*/

(function(){

  let targetsForModel = new WeakMap();
  let OLD_MODEL_PREFIX = '_oldModelFor_';

  Polymer.ShortcutNotifyTargetBehavior = function(paths) {
    return {

      observers: (function(){
        let observers = [];
        for(let [ii, path] of paths.entries()){
          observers.push('_updateShorcutMapping("' + path + '", ' + path + ')');
        }
        return observers;
      })(),

      _updateShorcutMapping: function(path, newModel){
          this._removeAsTargetForModel(path);
          this._addAsTargetForModel(path, newModel);
      },

      attached: function(){
        this._isAttached = true;
        for(let path of paths){
          this._addAsTargetForModel(path, this.get(path));
        }
      },

      detached: function(){
        this._isAttached = false;
        for(let path of paths){
          this._removeAsTargetForModel(path);
        }
      },

      _removeAsTargetForModel: function(path){
        let oldModel = this[OLD_MODEL_PREFIX + path];
        let oldTargets;
        if(oldModel && (typeof oldModel === "object") && (oldTargets=targetsForModel.get(oldModel))){
          let oldIdx = -1;
          for(let [ii, target] of oldTargets.entries()){
            if(target.el === this){
              oldIdx = ii;
              break;
            }
          }
          if(oldIdx !== -1){
            if(oldTargets.length === 1){
              targetsForModel.delete(oldModel); // this was the only remaining target for the given model
            } else {
              oldTargets.splice(oldIdx, 1); // there are still other targets observing this model
            }
          }
        }
      },

      _addAsTargetForModel: function(path, newModel){
        if(this._isAttached && newModel && (typeof newModel === "object")){
          let newTargets = targetsForModel.get(newModel);
          if(!newTargets){
            newTargets = [];
            targetsForModel.set(newModel, newTargets);
          }
          newTargets.push({
            el: this,
            prefix: path
          });
          this[OLD_MODEL_PREFIX + path] = newModel;
        }
      }

    }
  };

  Polymer.ShortcutNotifyerBehavior = {
      shortcutNotify: function(path, value, model){
        let targets = targetsForModel.get(model) || [];
        for(let target of targets){
          target.el.notifyPath(target.prefix + "." + path, value, true);
        }
      }
  };

})();


</script>