polymer-rails 0.2.8 → 0.3.0

data/app/assets/javascripts/polymer/src/lib/template/x-array-selector.html

@@ -0,0 +1,178 @@
+<!--
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<!--
+Keeping structured data in sync requires that Polymer understand the path
+associations of data being bound.  The `x-array-selector` element ensures path
+linkage when selecting specific items from an array (either single or multiple).
+The `items` property accepts an array of user data, and via the `select(item)`
+and `deselect(item)` API, updates the `selected` property which may be bound to
+other parts of the application, and any changes to sub-fields of `selected`
+item(s) will be kept in sync with items in the `items` array.  When `multi`
+is false, `selected` is a property representing the last selected item.  When
+`multi` is true, `selected` is an array of multiply selected items.
+
+```html
+<dom-module id="employee-list">
+
+  <template>
+
+    <div> Employee list: </div>
+    <template is="x-repeat" id="employeeList" items="{{employees}}">
+        <div>First name: <span>{{item.first}}</span></div>
+        <div>Last name: <span>{{item.last}}</span></div>
+        <button on-click="toggleSelection">Select</button>
+    </template>
+    
+    <x-array-selector id="selector" items="{{employees}}" selected="{{selected}}" multi toggle></x-array-selector>
+    
+    <div> Selected employees: </div>
+    <template is="x-repeat" items="{{selected}}">
+        <div>First name: <span>{{item.first}}</span></div>
+        <div>Last name: <span>{{item.last}}</span></div>
+    </template>
+    
+  </template>
+
+  <script>
+    Polymer({
+      is: 'employee-list',
+      ready: function() {
+        this.employees = [
+            {first: 'Bob', last: 'Smith'},
+            {first: 'Sally', last: 'Johnson'},
+            ...
+        ];
+      },
+      toggleSelection: function(e) {
+        var item = this.$.employeeList.itemForElement(e.target);
+        this.$.selector.select(item);
+      }
+    });
+  </script>
+
+</dom-module>
+``` 
+-->
+
+<script>
+
+  Polymer({
+    is: 'x-array-selector',
+    
+    properties: {
+
+      /**
+       * An array containing items from which selection will be made.
+       */
+      items: {
+        type: Array,
+        observer: '_itemsChanged'
+      },
+
+      /**
+       * When `multi` is true, this is an array that contains any selected.
+       * When `multi` is false, this is the currently selected item, or `null`
+       * if no item is selected.
+       */
+      selected: {
+        type: Object,
+        notify: true
+      },
+
+      /**
+       * When `true`, calling `select` on an item that is already selected
+       * will deselect the item.
+       */
+      toggle: Boolean,
+
+      /**
+       * When `true`, multiple items may be selected at once (in this case,
+       * `selected` is an array of currently selected items).  When `false`,
+       * only one item may be selected at a time.
+       */
+      multi: Boolean
+    },
+    
+    _itemsChanged: function() {
+      // Unbind previous selection
+      if (Array.isArray(this.selected)) {
+        for (var i=0; i<this.selected.length; i++) {
+          this.unbindPaths('selected.' + i);
+        }
+      } else {
+        this.unbindPaths('selected');
+      }
+      // Initialize selection
+      if (this.multi) {
+        this.selected = [];
+      } else {
+        this.selected = null;
+      }
+    },
+
+    /**
+     * Deselects the given item if it is already selected.
+     */
+    deselect: function(item) {
+      if (this.multi) {
+        var scol = Polymer.Collection.get(this.selected);
+        // var skey = scol.getKey(item);
+        // if (skey >= 0) {
+        var sidx = this.selected.indexOf(item);
+        if (sidx >= 0) {
+          var skey = scol.getKey(item);
+          this.selected.splice(sidx, 1);
+          // scol.remove(item);
+          this.unbindPaths('selected.' + skey);
+          return true;
+        }
+      } else {
+        this.selected = null;
+        this.unbindPaths('selected');
+      }
+    },
+
+    /**
+     * Selects the given item.  When `toggle` is true, this will automatically
+     * deselect the item if already selected.
+     */
+    select: function(item) {
+      var icol = Polymer.Collection.get(this.items);
+      var key = icol.getKey(item);
+      if (this.multi) {
+        // var sidx = this.selected.indexOf(item);
+        // if (sidx < 0) {
+        var scol = Polymer.Collection.get(this.selected);
+        var skey = scol.getKey(item);
+        if (skey >= 0) {
+          this.deselect(item);
+        } else if (this.toggle) {
+          this.selected.push(item);
+          // this.bindPaths('selected.' + sidx, 'items.' + skey);
+          // skey = Polymer.Collection.get(this.selected).add(item);
+          this.async(function() {
+            skey = scol.getKey(item);
+            this.bindPaths('selected.' + skey, 'items.' + key);
+          });
+        }
+      } else {
+        if (this.toggle && item == this.selected) {
+          this.deselect();
+        } else {
+          this.bindPaths('selected', 'items.' + key);
+          this.selected = item;
+        }
+      }
+    }
+
+  });
+
+</script>

data/app/assets/javascripts/polymer/src/lib/template/x-autobind.html

@@ -0,0 +1,80 @@
+<!--
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<!--
+
+**THIS ELEMENT IS EXPERIMENTAL.  API AND NAME SUBJECT TO CHANGE.**
+
+Polymer's binding features are only available within templates that are managed
+by Polymer.  As such, these features are available in templates used to define
+Polymer elements, for example, but not for elements placed directly in the main
+document.
+
+In order to use Polymer bindings without defining a new custom element, elements
+utilizing bindings may be wrapped with the `x-autobind` template extension.
+This template will immediately stamp itself into the main document and bind
+elements to the template itself as the binding scope.
+
+```html
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <script src="components/webcomponentsjs/webcomponents-lite.js"></script>
+  <link rel="import" href="components/polymer/polymer.html">
+  <link rel="import" href="components/core-ajax/core-ajax.html">
+
+</head>
+<body>
+
+  <template is="x-autobind">
+    
+    <core-ajax url="http://..." lastresponse="{{data}}"></core-ajax>
+    
+    <template is="x-repeat" items="{{data}}">
+        <div><span>{{item.first}}</span> <span>{{item.last}}</span></div>
+    </template>
+    
+  </template>
+
+</body>
+</html>
+```
+
+-->
+
+<script>
+
+  Polymer({
+
+    is: 'x-autobind',
+
+    extends: 'template',
+
+    registerFeatures: function() {
+      this._prepExtends();
+      this._prepConstructor();
+    },
+
+    _finishDistribute: function() {
+      var parentDom = Polymer.dom(Polymer.dom(this).parentNode);
+      parentDom.insertBefore(this.root, this);
+    },
+
+    initFeatures: function() {
+      this._template = this;
+      this._prepAnnotations();
+      this._prepEffects();
+      Polymer.Base.initFeatures.call(this);
+    }
+
+  });
+
+</script>

data/app/assets/javascripts/polymer/src/lib/template/x-if.html

@@ -0,0 +1,115 @@
+<!--
+@license
+Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<link rel="import" href="templatizer.html">
+
+<script>
+
+  /**
+   * Stamps the template iff the `if` property is truthy.
+   *
+   * When `if` becomes falsey, the stamped content is hidden but not
+   * removed from dom. When `if` subsequently becomes truthy again, the content
+   * is simply re-shown. This approach is used due to its favorable performance
+   * characteristics: the expense of creating template content is paid only 
+   * once and lazily.
+   *
+   * Set the `restamp` property to true to force the stamped content to be
+   * created / destroyed when the `if` condition changes.
+   */
+  Polymer({
+
+    is: 'x-if',
+    extends: 'template',
+
+    properties: {
+
+      'if': {
+        type: Boolean
+      },
+
+      item: {
+        type: Object
+      },
+
+      restamp: {
+        type: Boolean
+      }
+
+    },
+
+    mixins: [
+      Polymer.Templatizer
+    ],
+
+    observers: {
+      'if item restamp': 'render'
+    },
+
+    render: function() {
+      if (!this.ctor) {
+        this._wrapTextNodes(this._content);
+        this.templatize(this);
+      }
+      if (this.if) {
+        this._ensureInstance();
+      } else if (this.restamp) {
+        this._teardownInstance();
+      }
+      if (!this.restamp && this._instance) {
+        this._showHideInstance(this.if);
+      }
+    },
+
+    _ensureInstance: function() {
+      if (!this._instance) {
+        // TODO(sorvell): pickup stamping logic from x-repeat
+        this._instance = this.stamp(this.item);
+        var root = this._instance.root;
+        this._instance._children = Array.prototype.slice.call(root.childNodes);
+        // TODO(sorvell): this incantation needs to be simpler.
+        var parent = Polymer.dom(Polymer.dom(this).parentNode);
+        parent.insertBefore(root, this);
+      }
+    },
+
+    _teardownInstance: function() {
+      if (this._instance) {
+        var parent = Polymer.dom(Polymer.dom(this).parentNode);
+        this._instance._children.forEach(function(n) {
+          parent.removeChild(n);
+        });
+        this._instance = null;
+      }
+    },
+
+    _wrapTextNodes: function(root) {
+      // wrap text nodes in span so they can be hidden.
+      for (var n = root.firstChild; n; n=n.nextSibling) {
+        if (n.nodeType === Node.TEXT_NODE) {
+          var s = document.createElement('span');
+          root.insertBefore(s, n);
+          s.appendChild(n);
+          n = s;
+        }
+      }
+    },
+
+    _showHideInstance: function(showing) {
+      this._instance._children.forEach(function(n) {
+        if (n.setAttribute) {
+          this.serializeValueToAttribute(!showing, 'hidden', n);
+        }
+      }, this);
+    }
+
+  });
+
+</script>

data/app/assets/javascripts/polymer/src/lib/template/x-repeat.html

@@ -0,0 +1,510 @@
+<!--
+@license
+Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
+This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
+The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
+The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
+Code distributed by Google as part of the polymer project is also
+subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
+-->
+
+<!--
+
+**THIS ELEMENT IS EXPERIMENTAL.  API AND NAME SUBJECT TO CHANGE.**
+
+The `x-repeat` element is a custom `HTMLTemplateElement` type extension that
+automatically stamps and binds one instance of template content to each object
+in a user-provided array.  `x-repeat` accepts an `items` property, and one
+instance of the template is stamped for each item into the DOM at the location
+of the `x-repeat` element.  The `item` property will be set on each instance's
+binding scope, thus templates should bind to sub-properties of `item`.
+
+Example:
+
+```html
+<dom-module id="employee-list">
+
+  <template>
+
+    <div> Employee list: </div>
+    <template is="x-repeat" items="{{employees}}">
+        <div>First name: <span>{{item.first}}</span></div>
+        <div>Last name: <span>{{item.last}}</span></div>
+    </template>
+
+  </template>
+
+  <script>
+    Polymer({
+      is: 'employee-list',
+      ready: function() {
+        this.employees = [
+            {first: 'Bob', last: 'Smith'},
+            {first: 'Sally', last: 'Johnson'},
+            ...
+        ];
+      }
+    });
+  </script>
+
+</dom-module>
+``` 
+
+Notifications for changes to items sub-properties will be forwarded to template 
+instances, which will update via the normal structured data notification system.
+
+Mutations to the `items` array itself (`push`, `pop`, `splice`, `shift`,
+`unshift`) are observed via `Array.observe` (where supported, or an
+shim of this API on unsupported browsers), and template instances are kept in
+sync with the data in the array.
+
+A view-specific filter/sort may be applied to each `x-repeat` by supplying a
+`filter` and/or `sort` property.  This may be a string that names a function on
+the host, or a function may be assigned to the property directly.  The functions
+should implemented following the standard `Array` filter/sort API.
+
+In order to re-run the filter or sort functions based on changes to sub-fields
+of `items`, the `observe` property may be set as a space-separated list of
+`item` sub-fields that should cause a re-filter/sort when modified.
+
+For example, for an `x-repeat` with a filter of the following:
+
+```js
+isEngineer: function(item) {
+    return item.type == 'engineer' || item.manager.type == 'engineer';
+}
+```
+
+Then the `observe` property should be configured as follows:
+
+```html
+<template is="x-repeat" items="{{employees}}" 
+          filter="isEngineer" observe="type manager.type">
+```
+
+-->
+
+<link rel="import" href="templatizer.html">
+<link rel="import" href="../array-observe.html">
+<link rel="import" href="../collection.html">
+
+<script>
+
+  Polymer({
+
+    is: 'x-repeat',
+    extends: 'template',
+
+    properties: {
+
+      /**
+       * An array containing items determining how many instances of the template
+       * to stamp and that that each template instance should bind to.
+       */
+      items: {
+        type: Array
+      },
+
+      /**
+       * A function that should determine the sort order of the items.  This
+       * property should either be provided as a string, indicating a method
+       * name on the element's host, or else be an actual function.  The
+       * function should match the sort function passed to `Array.sort`.
+       * Using a sort function has no effect on the underlying `items` array.
+       */
+      sort: {
+        type: Function,
+        observer: '_sortChanged'
+      },
+
+      /**
+       * A function that can be used to filter items out of the view.  This
+       * property should either be provided as a string, indicating a method
+       * name on the element's host, or else be an actual function.  The
+       * function should match the sort function passed to `Array.filter`.
+       * Using a filter function has no effect on the underlying `items` array.
+       */
+      filter: {
+        type: Function,
+        observer: '_filterChanged'
+      },
+
+      /**
+       * When using a `filter` or `sort` function, the `observe` property
+       * should be set to a space-separated list of the names of item
+       * sub-fields that should trigger a re-sort or re-filter when changed.
+       * These should generally be fields of `item` that the sort or filter
+       * function depends on.
+       */
+      observe: {
+        type: String,
+        observer: '_observeChanged'
+      },
+
+      /**
+       * When using a `filter` or `sort` function, the `delay` property
+       * determines a debounce time after a change to observed item
+       * properties that must pass before the filter or sort is re-run.
+       * This is useful in rate-limiting shuffing of the view when
+       * item changes may be frequent.
+       */
+      delay: Number
+    },
+
+    mixins: [
+      Polymer.Templatizer
+    ],
+
+    observers: {
+      'items.*': '_itemsChanged'
+    },
+
+    created: function() {
+      this.boundCollectionObserver = this.render.bind(this);
+    },
+
+    ready: function() {
+      // Templatizing (generating the instance constructor) needs to wait
+      // until attached, since it may not have its template content handed
+      // back to it until then, following its host template stamping
+      if (!this.ctor) {
+        this.templatize(this);
+      }
+      if (this._renderPendingAttach) {
+        this._renderPendingAttach = false; 
+        this.render();
+      }
+    },
+
+    _sortChanged: function() {
+      this._sortFn = this.sort && (typeof this.sort == 'function' ? 
+        this.sort : this.host[this.sort].bind(this.host));
+      this.debounce('render', this.render);
+    },
+
+    _filterChanged: function() {
+      this._filterFn = this.filter && (typeof this.filter == 'function' ? 
+        this.filter : this.host[this.filter].bind(this.host));
+      this.debounce('render', this.render);
+    },
+
+    _observeChanged: function() {
+      this._observePaths = this.observe && 
+        this.observe.replace('.*', '.').split(' ');
+    },
+
+    _itemsChanged: function(items, old, path) {
+      if (path) {
+        this._notifyElement(path, items);
+        this._checkObservedPaths(path);
+      } else {
+        if (old) {
+          this._unobserveCollection(old);
+        }
+        if (items) {
+          this._observeCollection(items);
+          this.debounce('render', this.render);
+        }
+      }          
+    },
+
+    _checkObservedPaths: function(path) {
+      if (this._observePaths && path.indexOf('items.') === 0) {
+        path = path.substring(path.indexOf('.', 6) + 1);
+        var paths = this._observePaths;
+        for (var i=0; i<paths.length; i++) {
+          if (path.indexOf(paths[i]) === 0) {
+            this.debounce('render', this.render, this.delay);
+            return;
+          }
+        }
+      }
+    },
+
+    _observeCollection: function(items) {
+      this.collection = Array.isArray(items) ? Polymer.Collection.get(items) : items;
+      this.collection.observe(this.boundCollectionObserver);
+    },
+
+    _unobserveCollection: function(items) {
+      var collection = Polymer.Collection.get(items);
+      collection.unobserve(this.boundCollectionObserver);
+    },
+
+    render: function(splices) {
+      // TODO(kschaaf): should actually queue splices also
+      if (!this.isAttached) {
+        // Render must follow attachment
+        this._renderPendingAttach = true;
+        return;
+      }
+      this._render(splices);
+    },
+
+    _render: function(splices) {
+      var c = this.collection;
+      if (splices) {
+        if (this._sortFn || splices[0].index == null) {
+          this._applySplicesViewSort(splices);
+        } else {
+          this._applySplicesArraySort(splices);
+        }
+      } else {
+        this._sortAndFilter();
+      }
+      var rowForKey = this._rowForKey = {};
+      var keys = this._orderedKeys;
+      // Assign items and keys
+      this.rows = this.rows || [];
+      for (var i=0; i<keys.length; i++) {
+        var key = keys[i];
+        var item = c.getItem(key);
+        var row = this.rows[i];
+        if (!row) {
+          this.rows.push(row = this._insertRow(i, null, item));
+        }
+        row.item = item;
+        row.key = key;
+        rowForKey[key] = i;
+      }
+      // Remove extra
+      for (; i<this.rows.length; i++) {
+        this._detachRow(i);
+      }
+      this.rows.splice(keys.length, this.rows.length-keys.length);
+    },
+
+    _sortAndFilter: function() {
+      var c = this.collection;
+      this._orderedKeys = c.getKeys();
+      // Filter
+      if (this._filterFn) {
+        this._orderedKeys = this._orderedKeys.filter(function(a) {
+          return this._filterFn(c.getItem(a));
+        }, this);
+      }
+      // Sort
+      if (this._sortFn) {
+        this._orderedKeys.sort(function(a, b) {
+          return this._sortFn(c.getItem(a), c.getItem(b));
+        }.bind(this));
+      }
+    },
+
+    _keySort: function(a, b) {
+      return this.collection.getKey(a) - this.collection.getKey(b);
+    },
+
+    _applySplicesViewSort: function(splices) {
+      var c = this.collection;
+      var keys = this._orderedKeys;
+      var rows = this.rows;
+      var removedRows = [];
+      var addedKeys = [];
+      var pool = [];
+      var sortFn = this._sortFn || this._keySort.bind(this);
+      splices.forEach(function(s) {
+        // Collect all removed row idx's
+        for (var i=0; i<s.removed.length; i++) {
+          var idx = this._rowForKey[s.removed[i]];
+          if (idx != null) {
+            removedRows.push(idx);
+          }
+        }
+        // Collect all added keys
+        for (i=0; i<s.added.length; i++) {
+          addedKeys.push(s.added[i]);
+        }
+      }, this);
+      if (removedRows.length) {
+        // Sort removed rows idx's
+        removedRows.sort();
+        // Remove keys and pool rows (backwards, so we don't invalidate rowForKey)
+        for (i=removedRows.length-1; i>=0 ; i--) {
+          var idx = removedRows[i];
+          pool.push(this._detachRow(idx));
+          rows.splice(idx, 1);
+          keys.splice(idx, 1);
+        }
+      }
+      if (addedKeys.length) {
+        // Filter added keys
+        if (this._filterFn) {
+          addedKeys = addedKeys.filter(function(a) {
+            return this._filterFn(c.getItem(a));
+          }, this);
+        }
+        // Sort added keys
+        addedKeys.sort(function(a, b) {
+          return this.sortFn(c.getItem(a), c.getItem(b));
+        }, this);
+        // Insert new rows using sort (from pool or newly created)
+        var start = 0;
+        for (i=0; i<addedKeys.length; i++) {
+          start = this._insertRowIntoViewSort(start, addedKeys[i], pool);
+        }          
+      }
+    },
+
+    _insertRowIntoViewSort: function(start, key, pool) {
+      var c = this.collection;
+      var item = c.getItem(key);
+      var end = this.rows.length - 1;
+      var idx = -1;
+      var sortFn = this._sortFn || this._keySort.bind(this);
+      // Binary search for insertion point
+      while (start <= end) {
+        var mid = (start + end) >> 1;
+        var midKey = this._orderedKeys[mid];
+        var cmp = sortFn(c.getItem(midKey), item);
+        if (cmp < 0) {
+          start = mid + 1;
+        } else if (cmp > 0) {
+          end = mid - 1;
+        } else {
+          idx = mid;
+          break;
+        }
+      }
+      if (idx < 0) {
+        idx = end + 1;
+      }
+      // Insert key & row at insertion point
+      this._orderedKeys.splice(idx, 0, key);
+      this.rows.splice(idx, 0, this._insertRow(idx, pool));
+      return idx;
+    },
+
+    _applySplicesArraySort: function(splices) {
+      var keys = this._orderedKeys;
+      var pool = [];
+      splices.forEach(function(s) {
+        // Remove & pool rows first, to ensure we can fully reuse removed rows
+        for (var i=0; i<s.removed.length; i++) {
+          pool.push(this._detachRow(s.index + i));
+        }
+        this.rows.splice(s.index, s.removed.length);
+      }, this);
+      var c = this.collection;
+      var filterDelta = 0;
+      splices.forEach(function(s) {
+        // Filter added keys
+        var addedKeys = s.added;
+        if (this._filterFn) {
+          addedKeys = addedKeys.filter(function(a) {
+            return this._filterFn(c.getItem(a));
+          }, this);
+          filterDelta += (s.added.length - addedKeys.length);            
+        }
+        var idx = s.index - filterDelta;
+        // Apply splices to keys
+        var args = [idx, s.removed.length].concat(addedKeys);
+        keys.splice.apply(keys, args);
+        // Insert new rows (from pool or newly created)
+        var addedRows = [];
+        for (i=0; i<s.added.length; i++) {
+          addedRows.push(this._insertRow(idx + i, pool));
+        }
+        args = [s.index, 0].concat(addedRows);
+        this.rows.splice.apply(this.rows, args);
+      }, this);
+    },
+
+    _detachRow: function(idx) {
+      var row = this.rows[idx];
+      var parentNode = Polymer.dom(this).parentNode;
+      for (var i=0; i<row._children.length; i++) {
+        var el = row._children[i];
+        Polymer.dom(row.root).appendChild(el);
+      }
+      return row;
+    },
+
+    _insertRow: function(idx, pool, item) {
+      var row = (pool && pool.pop()) || this._generateRow(idx, item);
+      var beforeRow = this.rows[idx];
+      var beforeNode = beforeRow ? beforeRow._children[0] : this;
+      var parentNode = Polymer.dom(this).parentNode;
+      row.root.__styleScoped = true;
+      Polymer.dom(parentNode).insertBefore(row.root, beforeNode);
+      return row;
+    },
+
+    _generateRow: function(idx, item) {
+      var row = this.stamp({
+        item: item,
+        pathDelegate: this
+      });
+      // each row is a document fragment which is lost when we appendChild,
+      // so we have to track each child individually
+      var children = [];
+      for (var n = row.root.firstChild; n; n=n.nextSibling) {
+        children.push(n);
+        n._templateInstance = row;
+      }
+      // Since archetype overrides Base/HTMLElement, Safari complains
+      // when accessing `children`
+      row._children = children;
+      return row;
+    },
+
+    _notifyDelegatePath: function(row, path, value) {
+      this.notifyPath(path.replace('item', 'items.' + row.key), value);
+    },
+
+    _notifyElement: function(path, value) {
+      if (this._rowForKey) {
+        // 'items.'.length == 6
+        var dot = path.indexOf('.', 6);
+        var key = path.substring(6, dot < 0 ? path.length : dot);
+        var idx = this._rowForKey[key];
+        var row = this.rows[idx];
+        if (row) {
+          if (dot >= 0) {
+            path = 'item.' + path.substring(dot+1);
+            row.notifyPath(path, value, true);
+          } else {
+            row.item = value;
+          }
+        }
+      }
+    },
+
+    _instanceForElement: function(el) {
+      while (el && !el._templateInstance) {
+        el = el.parentNode;
+      }
+      return el._templateInstance;
+    },
+
+    /**
+     * Returns the item associated with a given element stamped by
+     * this `x-repeat`.
+     */
+    itemForElement: function(el) {
+      var instance = this._instanceForElement(el);
+      return instance && instance.item;
+    },
+
+    /**
+     * Returns the `Polymer.Collection` key associated with a given
+     * element stamped by this `x-repeat`.
+     */
+    keyForElement: function(el) {
+      var instance = this._instanceForElement(el);
+      return instance && instance.key;
+    },
+
+    /**
+     * Returns the index in `items` associated with a given element
+     * stamped by this `x-repeat`.
+     */
+    indexForElement: function(el) {
+      var instance = this._instanceForElement(el);
+      return this.rows.indexOf(instance);
+    }
+
+  });
+
+
+</script>