mirror of
https://github.com/jellyfin/jellyfin-web
synced 2025-03-30 19:56:21 +00:00
update polymer
This commit is contained in:
Luke Pulverenti
parent
6825ae319e
commit
2d53ff29c5
106 changed files with 3070 additions and 1567 deletions
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "polymer",
|
||||
"version": "1.1.5",
|
||||
"version": "1.2.0",
|
||||
"main": [
|
||||
"polymer.html"
|
||||
],
|
||||
|
|
@ -25,11 +25,11 @@
|
|||
},
|
||||
"private": true,
|
||||
"homepage": "https://github.com/Polymer/polymer",
|
||||
"_release": "1.1.5",
|
||||
"_release": "1.2.0",
|
||||
"_resolution": {
|
||||
"type": "version",
|
||||
"tag": "v1.1.5",
|
||||
"commit": "4c94736fac6681e84ec8c00da53484c5d3c2226b"
|
||||
"tag": "v1.2.0",
|
||||
"commit": "84d211624cffd04d6894ec90713c2029732e8bb5"
|
||||
},
|
||||
"_source": "git://github.com/Polymer/polymer.git",
|
||||
"_target": "^1.0.0",
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
{
|
||||
"name": "polymer",
|
||||
"version": "1.1.5",
|
||||
"version": "1.2.0",
|
||||
"main": [
|
||||
"polymer.html"
|
||||
],
|
||||
|
|
|
|||
|
|
@ -264,7 +264,7 @@ document.registerElement('dom-module', DomModule);
|
|||
function forceDocumentUpgrade() {
|
||||
if (cePolyfill) {
|
||||
var script = document._currentScript || document.currentScript;
|
||||
var doc = script && script.ownerDocument;
|
||||
var doc = script && script.ownerDocument || document;
|
||||
if (doc) {
|
||||
CustomElements.upgradeAll(doc);
|
||||
}
|
||||
|
|
@ -576,7 +576,7 @@ debouncer.stop();
|
|||
}
|
||||
}
|
||||
});
|
||||
Polymer.version = '1.1.5';
|
||||
Polymer.version = '1.2.0';
|
||||
Polymer.Base._addFeature({
|
||||
_registerFeatures: function () {
|
||||
this._prepIs();
|
||||
|
|
|
|||
|
|
@ -270,61 +270,6 @@ return currentValue === previousValue;
|
|||
};
|
||||
return new ArraySplice();
|
||||
}();
|
||||
Polymer.EventApi = function () {
|
||||
var Settings = Polymer.Settings;
|
||||
var EventApi = function (event) {
|
||||
this.event = event;
|
||||
};
|
||||
if (Settings.useShadow) {
|
||||
EventApi.prototype = {
|
||||
get rootTarget() {
|
||||
return this.event.path[0];
|
||||
},
|
||||
get localTarget() {
|
||||
return this.event.target;
|
||||
},
|
||||
get path() {
|
||||
return this.event.path;
|
||||
}
|
||||
};
|
||||
} else {
|
||||
EventApi.prototype = {
|
||||
get rootTarget() {
|
||||
return this.event.target;
|
||||
},
|
||||
get localTarget() {
|
||||
var current = this.event.currentTarget;
|
||||
var currentRoot = current && Polymer.dom(current).getOwnerRoot();
|
||||
var p$ = this.path;
|
||||
for (var i = 0; i < p$.length; i++) {
|
||||
if (Polymer.dom(p$[i]).getOwnerRoot() === currentRoot) {
|
||||
return p$[i];
|
||||
}
|
||||
}
|
||||
},
|
||||
get path() {
|
||||
if (!this.event._path) {
|
||||
var path = [];
|
||||
var o = this.rootTarget;
|
||||
while (o) {
|
||||
path.push(o);
|
||||
o = Polymer.dom(o).parentNode || o.host;
|
||||
}
|
||||
path.push(window);
|
||||
this.event._path = path;
|
||||
}
|
||||
return this.event._path;
|
||||
}
|
||||
};
|
||||
}
|
||||
var factory = function (event) {
|
||||
if (!event.__eventApi) {
|
||||
event.__eventApi = new EventApi(event);
|
||||
}
|
||||
return event.__eventApi;
|
||||
};
|
||||
return { factory: factory };
|
||||
}();
|
||||
Polymer.domInnerHTML = function () {
|
||||
var escapeAttrRegExp = /[&\u00A0"]/g;
|
||||
var escapeDataRegExp = /[&\u00A0<>]/g;
|
||||
|
|
@ -463,7 +408,7 @@ insertBefore: function (node, ref_node) {
|
|||
return this._addNode(node, ref_node);
|
||||
},
|
||||
_addNode: function (node, ref_node) {
|
||||
this._removeNodeFromHost(node, true);
|
||||
this._removeNodeFromParent(node);
|
||||
var addedInsertionPoint;
|
||||
var root = this.getOwnerRoot();
|
||||
if (root) {
|
||||
|
|
@ -495,6 +440,7 @@ nativeAppendChild.call(container, node);
|
|||
if (addedInsertionPoint) {
|
||||
this._updateInsertionPoints(root.host);
|
||||
}
|
||||
this.notifyObserver();
|
||||
return node;
|
||||
},
|
||||
removeChild: function (node) {
|
||||
|
|
@ -509,6 +455,7 @@ removeFromComposedParent(container, node);
|
|||
nativeRemoveChild.call(container, node);
|
||||
}
|
||||
}
|
||||
this.notifyObserver();
|
||||
return node;
|
||||
},
|
||||
replaceChild: function (node, ref_node) {
|
||||
|
|
@ -601,6 +548,13 @@ return Boolean(node._lightChildren !== undefined);
|
|||
_parentNeedsDistribution: function (parent) {
|
||||
return parent && parent.shadyRoot && hasInsertionPoint(parent.shadyRoot);
|
||||
},
|
||||
_removeNodeFromParent: function (node) {
|
||||
var parent = node._lightParent || node.parentNode;
|
||||
if (parent && hasDomApi(parent)) {
|
||||
factory(parent).notifyObserver();
|
||||
}
|
||||
this._removeNodeFromHost(node, true);
|
||||
},
|
||||
_removeNodeFromHost: function (node, ensureComposedRemoval) {
|
||||
var hostNeedsDist;
|
||||
var root;
|
||||
|
|
@ -612,7 +566,7 @@ if (root) {
|
|||
root.host._elementRemove(node);
|
||||
hostNeedsDist = this._removeDistributedChildren(root, node);
|
||||
}
|
||||
this._removeLogicalInfo(node, node._lightParent);
|
||||
this._removeLogicalInfo(node, parent);
|
||||
}
|
||||
this._removeOwnerShadyRoot(node);
|
||||
if (root && hostNeedsDist) {
|
||||
|
|
@ -731,24 +685,29 @@ getDistributedNodes: function () {
|
|||
return this.node._distributedNodes || [];
|
||||
},
|
||||
queryDistributedElements: function (selector) {
|
||||
var c$ = this.childNodes;
|
||||
var c$ = this.getEffectiveChildNodes();
|
||||
var list = [];
|
||||
this._distributedFilter(selector, c$, list);
|
||||
for (var i = 0, l = c$.length, c; i < l && (c = c$[i]); i++) {
|
||||
if (c.localName === CONTENT) {
|
||||
this._distributedFilter(selector, factory(c).getDistributedNodes(), list);
|
||||
if (c.nodeType === Node.ELEMENT_NODE && matchesSelector.call(c, selector)) {
|
||||
list.push(c);
|
||||
}
|
||||
}
|
||||
return list;
|
||||
},
|
||||
_distributedFilter: function (selector, list, results) {
|
||||
results = results || [];
|
||||
for (var i = 0, l = list.length, d; i < l && (d = list[i]); i++) {
|
||||
if (d.nodeType === Node.ELEMENT_NODE && d.localName !== CONTENT && matchesSelector.call(d, selector)) {
|
||||
results.push(d);
|
||||
getEffectiveChildNodes: function () {
|
||||
var list = [];
|
||||
var c$ = this.childNodes;
|
||||
for (var i = 0, l = c$.length, c; i < l && (c = c$[i]); i++) {
|
||||
if (c.localName === CONTENT) {
|
||||
var d$ = factory(c).getDistributedNodes();
|
||||
for (var j = 0; j < d$.length; j++) {
|
||||
list.push(d$[j]);
|
||||
}
|
||||
} else {
|
||||
list.push(c);
|
||||
}
|
||||
}
|
||||
return results;
|
||||
return list;
|
||||
},
|
||||
_clear: function () {
|
||||
while (this.childNodes.length) {
|
||||
|
|
@ -792,36 +751,24 @@ d.appendChild(nc);
|
|||
}
|
||||
}
|
||||
return n;
|
||||
},
|
||||
observeNodes: function (callback) {
|
||||
if (callback) {
|
||||
if (!this.observer) {
|
||||
this.observer = this.node.localName === CONTENT ? new DomApi.DistributedNodesObserver(this) : new DomApi.EffectiveNodesObserver(this);
|
||||
}
|
||||
};
|
||||
Object.defineProperty(DomApi.prototype, 'classList', {
|
||||
get: function () {
|
||||
if (!this._classList) {
|
||||
this._classList = new DomApi.ClassList(this);
|
||||
return this.observer.addListener(callback);
|
||||
}
|
||||
return this._classList;
|
||||
},
|
||||
configurable: true
|
||||
});
|
||||
DomApi.ClassList = function (host) {
|
||||
this.domApi = host;
|
||||
this.node = host.node;
|
||||
};
|
||||
DomApi.ClassList.prototype = {
|
||||
add: function () {
|
||||
this.node.classList.add.apply(this.node.classList, arguments);
|
||||
this.domApi._distributeParent();
|
||||
unobserveNodes: function (handle) {
|
||||
if (this.observer) {
|
||||
this.observer.removeListener(handle);
|
||||
}
|
||||
},
|
||||
remove: function () {
|
||||
this.node.classList.remove.apply(this.node.classList, arguments);
|
||||
this.domApi._distributeParent();
|
||||
},
|
||||
toggle: function () {
|
||||
this.node.classList.toggle.apply(this.node.classList, arguments);
|
||||
this.domApi._distributeParent();
|
||||
},
|
||||
contains: function () {
|
||||
return this.node.classList.contains.apply(this.node.classList, arguments);
|
||||
notifyObserver: function () {
|
||||
if (this.observer) {
|
||||
this.observer.notify();
|
||||
}
|
||||
}
|
||||
};
|
||||
if (!Settings.useShadow) {
|
||||
|
|
@ -1003,6 +950,17 @@ return n$ ? Array.prototype.slice.call(n$) : [];
|
|||
};
|
||||
DomApi.prototype._distributeParent = function () {
|
||||
};
|
||||
var nativeForwards = [
|
||||
'appendChild',
|
||||
'insertBefore',
|
||||
'removeChild',
|
||||
'replaceChild'
|
||||
];
|
||||
nativeForwards.forEach(function (forward) {
|
||||
DomApi.prototype[forward] = function () {
|
||||
return this.node[forward].apply(this.node, arguments);
|
||||
};
|
||||
});
|
||||
Object.defineProperties(DomApi.prototype, {
|
||||
childNodes: {
|
||||
get: function () {
|
||||
|
|
@ -1056,13 +1014,17 @@ configurable: true
|
|||
});
|
||||
}
|
||||
var CONTENT = 'content';
|
||||
var factory = function (node, patch) {
|
||||
function factory(node, patch) {
|
||||
node = node || document;
|
||||
if (!node.__domApi) {
|
||||
node.__domApi = new DomApi(node, patch);
|
||||
}
|
||||
return node.__domApi;
|
||||
};
|
||||
}
|
||||
;
|
||||
function hasDomApi(node) {
|
||||
return Boolean(node.__domApi);
|
||||
}
|
||||
Polymer.dom = function (obj, patch) {
|
||||
if (obj instanceof Event) {
|
||||
return Polymer.EventApi.factory(obj);
|
||||
|
|
@ -1070,43 +1032,6 @@ return Polymer.EventApi.factory(obj);
|
|||
return factory(obj, patch);
|
||||
}
|
||||
};
|
||||
Polymer.Base.extend(Polymer.dom, {
|
||||
_flushGuard: 0,
|
||||
_FLUSH_MAX: 100,
|
||||
_needsTakeRecords: !Polymer.Settings.useNativeCustomElements,
|
||||
_debouncers: [],
|
||||
_finishDebouncer: null,
|
||||
flush: function () {
|
||||
for (var i = 0; i < this._debouncers.length; i++) {
|
||||
this._debouncers[i].complete();
|
||||
}
|
||||
if (this._finishDebouncer) {
|
||||
this._finishDebouncer.complete();
|
||||
}
|
||||
this._flushPolyfills();
|
||||
if (this._debouncers.length && this._flushGuard < this._FLUSH_MAX) {
|
||||
this._flushGuard++;
|
||||
this.flush();
|
||||
} else {
|
||||
if (this._flushGuard >= this._FLUSH_MAX) {
|
||||
console.warn('Polymer.dom.flush aborted. Flush may not be complete.');
|
||||
}
|
||||
this._flushGuard = 0;
|
||||
}
|
||||
},
|
||||
_flushPolyfills: function () {
|
||||
if (this._needsTakeRecords) {
|
||||
CustomElements.takeRecords();
|
||||
}
|
||||
},
|
||||
addDebouncer: function (debouncer) {
|
||||
this._debouncers.push(debouncer);
|
||||
this._finishDebouncer = Polymer.Debounce(this._finishDebouncer, this._finishFlush);
|
||||
},
|
||||
_finishFlush: function () {
|
||||
Polymer.dom._debouncers = [];
|
||||
}
|
||||
});
|
||||
function getLightChildren(node) {
|
||||
var children = node._lightChildren;
|
||||
return children ? children : node.childNodes;
|
||||
|
|
@ -1170,10 +1095,399 @@ saveLightChildrenIfNeeded: saveLightChildrenIfNeeded,
|
|||
matchesSelector: matchesSelector,
|
||||
hasInsertionPoint: hasInsertionPoint,
|
||||
ctor: DomApi,
|
||||
factory: factory
|
||||
factory: factory,
|
||||
hasDomApi: hasDomApi
|
||||
};
|
||||
}();
|
||||
Polymer.Base.extend(Polymer.dom, {
|
||||
_flushGuard: 0,
|
||||
_FLUSH_MAX: 100,
|
||||
_needsTakeRecords: !Polymer.Settings.useNativeCustomElements,
|
||||
_debouncers: [],
|
||||
_staticFlushList: [],
|
||||
_finishDebouncer: null,
|
||||
flush: function () {
|
||||
this._flushGuard = 0;
|
||||
this._prepareFlush();
|
||||
while (this._debouncers.length && this._flushGuard < this._FLUSH_MAX) {
|
||||
for (var i = 0; i < this._debouncers.length; i++) {
|
||||
this._debouncers[i].complete();
|
||||
}
|
||||
if (this._finishDebouncer) {
|
||||
this._finishDebouncer.complete();
|
||||
}
|
||||
this._prepareFlush();
|
||||
this._flushGuard++;
|
||||
}
|
||||
if (this._flushGuard >= this._FLUSH_MAX) {
|
||||
console.warn('Polymer.dom.flush aborted. Flush may not be complete.');
|
||||
}
|
||||
},
|
||||
_prepareFlush: function () {
|
||||
if (this._needsTakeRecords) {
|
||||
CustomElements.takeRecords();
|
||||
}
|
||||
for (var i = 0; i < this._staticFlushList.length; i++) {
|
||||
this._staticFlushList[i]();
|
||||
}
|
||||
},
|
||||
addStaticFlush: function (fn) {
|
||||
this._staticFlushList.push(fn);
|
||||
},
|
||||
removeStaticFlush: function (fn) {
|
||||
var i = this._staticFlushList.indexOf(fn);
|
||||
if (i >= 0) {
|
||||
this._staticFlushList.splice(i, 1);
|
||||
}
|
||||
},
|
||||
addDebouncer: function (debouncer) {
|
||||
this._debouncers.push(debouncer);
|
||||
this._finishDebouncer = Polymer.Debounce(this._finishDebouncer, this._finishFlush);
|
||||
},
|
||||
_finishFlush: function () {
|
||||
Polymer.dom._debouncers = [];
|
||||
}
|
||||
});
|
||||
Polymer.EventApi = function () {
|
||||
'use strict';
|
||||
var DomApi = Polymer.DomApi.ctor;
|
||||
var Settings = Polymer.Settings;
|
||||
DomApi.Event = function (event) {
|
||||
this.event = event;
|
||||
};
|
||||
if (Settings.useShadow) {
|
||||
DomApi.Event.prototype = {
|
||||
get rootTarget() {
|
||||
return this.event.path[0];
|
||||
},
|
||||
get localTarget() {
|
||||
return this.event.target;
|
||||
},
|
||||
get path() {
|
||||
return this.event.path;
|
||||
}
|
||||
};
|
||||
} else {
|
||||
DomApi.Event.prototype = {
|
||||
get rootTarget() {
|
||||
return this.event.target;
|
||||
},
|
||||
get localTarget() {
|
||||
var current = this.event.currentTarget;
|
||||
var currentRoot = current && Polymer.dom(current).getOwnerRoot();
|
||||
var p$ = this.path;
|
||||
for (var i = 0; i < p$.length; i++) {
|
||||
if (Polymer.dom(p$[i]).getOwnerRoot() === currentRoot) {
|
||||
return p$[i];
|
||||
}
|
||||
}
|
||||
},
|
||||
get path() {
|
||||
if (!this.event._path) {
|
||||
var path = [];
|
||||
var o = this.rootTarget;
|
||||
while (o) {
|
||||
path.push(o);
|
||||
o = Polymer.dom(o).parentNode || o.host;
|
||||
}
|
||||
path.push(window);
|
||||
this.event._path = path;
|
||||
}
|
||||
return this.event._path;
|
||||
}
|
||||
};
|
||||
}
|
||||
var factory = function (event) {
|
||||
if (!event.__eventApi) {
|
||||
event.__eventApi = new DomApi.Event(event);
|
||||
}
|
||||
return event.__eventApi;
|
||||
};
|
||||
return { factory: factory };
|
||||
}();
|
||||
(function () {
|
||||
'use strict';
|
||||
var DomApi = Polymer.DomApi.ctor;
|
||||
Object.defineProperty(DomApi.prototype, 'classList', {
|
||||
get: function () {
|
||||
if (!this._classList) {
|
||||
this._classList = new DomApi.ClassList(this);
|
||||
}
|
||||
return this._classList;
|
||||
},
|
||||
configurable: true
|
||||
});
|
||||
DomApi.ClassList = function (host) {
|
||||
this.domApi = host;
|
||||
this.node = host.node;
|
||||
};
|
||||
DomApi.ClassList.prototype = {
|
||||
add: function () {
|
||||
this.node.classList.add.apply(this.node.classList, arguments);
|
||||
this.domApi._distributeParent();
|
||||
},
|
||||
remove: function () {
|
||||
this.node.classList.remove.apply(this.node.classList, arguments);
|
||||
this.domApi._distributeParent();
|
||||
},
|
||||
toggle: function () {
|
||||
this.node.classList.toggle.apply(this.node.classList, arguments);
|
||||
this.domApi._distributeParent();
|
||||
},
|
||||
contains: function () {
|
||||
return this.node.classList.contains.apply(this.node.classList, arguments);
|
||||
}
|
||||
};
|
||||
}());
|
||||
(function () {
|
||||
'use strict';
|
||||
var DomApi = Polymer.DomApi.ctor;
|
||||
var Settings = Polymer.Settings;
|
||||
var hasDomApi = Polymer.DomApi.hasDomApi;
|
||||
DomApi.EffectiveNodesObserver = function (domApi) {
|
||||
this.domApi = domApi;
|
||||
this.node = this.domApi.node;
|
||||
this._listeners = [];
|
||||
};
|
||||
DomApi.EffectiveNodesObserver.prototype = {
|
||||
addListener: function (callback) {
|
||||
if (!this._isSetup) {
|
||||
this._setup();
|
||||
this._isSetup = true;
|
||||
}
|
||||
var listener = {
|
||||
fn: callback,
|
||||
_nodes: []
|
||||
};
|
||||
this._listeners.push(listener);
|
||||
this._scheduleNotify();
|
||||
return listener;
|
||||
},
|
||||
removeListener: function (handle) {
|
||||
var i = this._listeners.indexOf(handle);
|
||||
if (i >= 0) {
|
||||
this._listeners.splice(i, 1);
|
||||
handle._nodes = [];
|
||||
}
|
||||
if (!this._hasListeners()) {
|
||||
this._cleanup();
|
||||
this._isSetup = false;
|
||||
}
|
||||
},
|
||||
_setup: function () {
|
||||
this._observeContentElements(this.domApi.childNodes);
|
||||
},
|
||||
_cleanup: function () {
|
||||
this._unobserveContentElements(this.domApi.childNodes);
|
||||
},
|
||||
_hasListeners: function () {
|
||||
return Boolean(this._listeners.length);
|
||||
},
|
||||
_scheduleNotify: function () {
|
||||
if (this._debouncer) {
|
||||
this._debouncer.stop();
|
||||
}
|
||||
this._debouncer = Polymer.Debounce(this._debouncer, this._notify);
|
||||
this._debouncer.context = this;
|
||||
Polymer.dom.addDebouncer(this._debouncer);
|
||||
},
|
||||
notify: function () {
|
||||
if (this._hasListeners()) {
|
||||
this._scheduleNotify();
|
||||
}
|
||||
},
|
||||
_notify: function (mxns) {
|
||||
this._beforeCallListeners();
|
||||
this._callListeners();
|
||||
},
|
||||
_beforeCallListeners: function () {
|
||||
this._updateContentElements();
|
||||
},
|
||||
_updateContentElements: function () {
|
||||
this._observeContentElements(this.domApi.childNodes);
|
||||
},
|
||||
_observeContentElements: function (elements) {
|
||||
for (var i = 0, n; i < elements.length && (n = elements[i]); i++) {
|
||||
if (this._isContent(n)) {
|
||||
n.__observeNodesMap = n.__observeNodesMap || new WeakMap();
|
||||
if (!n.__observeNodesMap.has(this)) {
|
||||
n.__observeNodesMap.set(this, this._observeContent(n));
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
_observeContent: function (content) {
|
||||
var h = Polymer.dom(content).observeNodes(this._scheduleNotify.bind(this));
|
||||
h._avoidChangeCalculation = true;
|
||||
return h;
|
||||
},
|
||||
_unobserveContentElements: function (elements) {
|
||||
for (var i = 0, n, h; i < elements.length && (n = elements[i]); i++) {
|
||||
if (this._isContent(n)) {
|
||||
h = n.__observeNodesMap.get(this);
|
||||
if (h) {
|
||||
Polymer.dom(n).unobserveNodes(h);
|
||||
n.__observeNodesMap.delete(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
_isContent: function (node) {
|
||||
return node.localName === 'content';
|
||||
},
|
||||
_callListeners: function () {
|
||||
var o$ = this._listeners;
|
||||
var nodes = this._getEffectiveNodes();
|
||||
for (var i = 0, o; i < o$.length && (o = o$[i]); i++) {
|
||||
var info = this._generateListenerInfo(o, nodes);
|
||||
if (info || o._alwaysNotify) {
|
||||
this._callListener(o, info);
|
||||
}
|
||||
}
|
||||
},
|
||||
_getEffectiveNodes: function () {
|
||||
return this.domApi.getEffectiveChildNodes();
|
||||
},
|
||||
_generateListenerInfo: function (listener, newNodes) {
|
||||
if (listener._avoidChangeCalculation) {
|
||||
return true;
|
||||
}
|
||||
var oldNodes = listener._nodes;
|
||||
var info = {
|
||||
target: this.node,
|
||||
addedNodes: [],
|
||||
removedNodes: []
|
||||
};
|
||||
var splices = Polymer.ArraySplice.calculateSplices(newNodes, oldNodes);
|
||||
for (var i = 0, s; i < splices.length && (s = splices[i]); i++) {
|
||||
for (var j = 0, n; j < s.removed.length && (n = s.removed[j]); j++) {
|
||||
info.removedNodes.push(n);
|
||||
}
|
||||
}
|
||||
for (var i = 0, s; i < splices.length && (s = splices[i]); i++) {
|
||||
for (var j = s.index; j < s.index + s.addedCount; j++) {
|
||||
info.addedNodes.push(newNodes[j]);
|
||||
}
|
||||
}
|
||||
listener._nodes = newNodes;
|
||||
if (info.addedNodes.length || info.removedNodes.length) {
|
||||
return info;
|
||||
}
|
||||
},
|
||||
_callListener: function (listener, info) {
|
||||
return listener.fn.call(this.node, info);
|
||||
},
|
||||
enableShadowAttributeTracking: function () {
|
||||
}
|
||||
};
|
||||
if (Settings.useShadow) {
|
||||
var baseSetup = DomApi.EffectiveNodesObserver.prototype._setup;
|
||||
var baseCleanup = DomApi.EffectiveNodesObserver.prototype._cleanup;
|
||||
var beforeCallListeners = DomApi.EffectiveNodesObserver.prototype._beforeCallListeners;
|
||||
Polymer.Base.extend(DomApi.EffectiveNodesObserver.prototype, {
|
||||
_setup: function () {
|
||||
if (!this._observer) {
|
||||
var self = this;
|
||||
this._mutationHandler = function (mxns) {
|
||||
if (mxns && mxns.length) {
|
||||
self._scheduleNotify();
|
||||
}
|
||||
};
|
||||
this._observer = new MutationObserver(this._mutationHandler);
|
||||
this._boundFlush = this._flush.bind(this);
|
||||
Polymer.dom.addStaticFlush(this._boundFlush);
|
||||
this._observer.observe(this.node, { childList: true });
|
||||
}
|
||||
baseSetup.call(this);
|
||||
},
|
||||
_cleanup: function () {
|
||||
this._observer.disconnect();
|
||||
this._observer = null;
|
||||
this._mutationHandler = null;
|
||||
Polymer.dom.removeStaticFlush(this._boundFlush);
|
||||
baseCleanup.call(this);
|
||||
},
|
||||
_flush: function () {
|
||||
if (this._observer) {
|
||||
this._mutationHandler(this._observer.takeRecords());
|
||||
}
|
||||
},
|
||||
enableShadowAttributeTracking: function () {
|
||||
if (this._observer) {
|
||||
this._makeContentListenersAlwaysNotify();
|
||||
this._observer.disconnect();
|
||||
this._observer.observe(this.node, {
|
||||
childList: true,
|
||||
attributes: true,
|
||||
subtree: true
|
||||
});
|
||||
var root = this.domApi.getOwnerRoot();
|
||||
var host = root && root.host;
|
||||
if (host && Polymer.dom(host).observer) {
|
||||
Polymer.dom(host).observer.enableShadowAttributeTracking();
|
||||
}
|
||||
}
|
||||
},
|
||||
_makeContentListenersAlwaysNotify: function () {
|
||||
for (var i = 0, h; i < this._listeners.length; i++) {
|
||||
h = this._listeners[i];
|
||||
h._alwaysNotify = h._isContentListener;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}());
|
||||
(function () {
|
||||
'use strict';
|
||||
var DomApi = Polymer.DomApi.ctor;
|
||||
var Settings = Polymer.Settings;
|
||||
DomApi.DistributedNodesObserver = function (domApi) {
|
||||
DomApi.EffectiveNodesObserver.call(this, domApi);
|
||||
};
|
||||
DomApi.DistributedNodesObserver.prototype = Object.create(DomApi.EffectiveNodesObserver.prototype);
|
||||
Polymer.Base.extend(DomApi.DistributedNodesObserver.prototype, {
|
||||
_setup: function () {
|
||||
},
|
||||
_cleanup: function () {
|
||||
},
|
||||
_beforeCallListeners: function () {
|
||||
},
|
||||
_getEffectiveNodes: function () {
|
||||
return this.domApi.getDistributedNodes();
|
||||
}
|
||||
});
|
||||
if (Settings.useShadow) {
|
||||
Polymer.Base.extend(DomApi.DistributedNodesObserver.prototype, {
|
||||
_setup: function () {
|
||||
if (!this._observer) {
|
||||
var root = this.domApi.getOwnerRoot();
|
||||
var host = root && root.host;
|
||||
if (host) {
|
||||
this._observer = Polymer.dom(host).observeNodes(this._scheduleNotify.bind(this));
|
||||
this._observer._isContentListener = true;
|
||||
if (this._hasAttrSelect()) {
|
||||
Polymer.dom(host).observer.enableShadowAttributeTracking();
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
_hasAttrSelect: function () {
|
||||
var select = this.node.getAttribute('select');
|
||||
return select && select.match(/[[.]+/);
|
||||
},
|
||||
_cleanup: function () {
|
||||
var root = this.domApi.getOwnerRoot();
|
||||
var host = root && root.host;
|
||||
if (host) {
|
||||
Polymer.dom(host).unobserveNodes(this._observer);
|
||||
}
|
||||
this._observer = null;
|
||||
}
|
||||
});
|
||||
}
|
||||
}());
|
||||
(function () {
|
||||
var hasDomApi = Polymer.DomApi.hasDomApi;
|
||||
Polymer.Base._addFeature({
|
||||
_prepShady: function () {
|
||||
this._useContent = this._useContent || Boolean(this._template);
|
||||
|
|
@ -1244,6 +1558,7 @@ if (this._useContent) {
|
|||
this.shadyRoot._distributionClean = true;
|
||||
if (hasInsertionPoint(this.shadyRoot)) {
|
||||
this._composeTree();
|
||||
notifyContentObservers(this.shadyRoot);
|
||||
} else {
|
||||
if (!this.shadyRoot._hasDistributed) {
|
||||
this.textContent = '';
|
||||
|
|
@ -1254,6 +1569,9 @@ var children = this._composeNode(this);
|
|||
this._updateChildNodes(this, children);
|
||||
}
|
||||
}
|
||||
if (!this.shadyRoot._hasDistributed) {
|
||||
notifyInitialDistribution(this);
|
||||
}
|
||||
this.shadyRoot._hasDistributed = true;
|
||||
}
|
||||
},
|
||||
|
|
@ -1471,6 +1789,19 @@ return host.domHost;
|
|||
}
|
||||
}
|
||||
}
|
||||
function notifyContentObservers(root) {
|
||||
for (var i = 0, c; i < root._insertionPoints.length; i++) {
|
||||
c = root._insertionPoints[i];
|
||||
if (hasDomApi(c)) {
|
||||
Polymer.dom(c).notifyObserver();
|
||||
}
|
||||
}
|
||||
}
|
||||
function notifyInitialDistribution(host) {
|
||||
if (hasDomApi(host)) {
|
||||
Polymer.dom(host).notifyObserver();
|
||||
}
|
||||
}
|
||||
var needsUpgrade = window.CustomElements && !CustomElements.useNative;
|
||||
function upgradeLightChildren(children) {
|
||||
if (needsUpgrade && children) {
|
||||
|
|
|
|||
449
dashboard-ui/bower_components/polymer/polymer.html
vendored
449
dashboard-ui/bower_components/polymer/polymer.html
vendored
|
|
@ -27,22 +27,66 @@ return list;
|
|||
_parseNodeAnnotations: function (node, list) {
|
||||
return node.nodeType === Node.TEXT_NODE ? this._parseTextNodeAnnotation(node, list) : this._parseElementAnnotations(node, list);
|
||||
},
|
||||
_testEscape: function (value) {
|
||||
var escape = value.slice(0, 2);
|
||||
if (escape === '{{' || escape === '[[') {
|
||||
return escape;
|
||||
_bindingRegex: /([^{[]*)({{|\[\[)([^}\]]*)(?:]]|}})/g,
|
||||
_parseBindings: function (text) {
|
||||
var re = this._bindingRegex;
|
||||
var parts = [];
|
||||
var m, lastIndex;
|
||||
while ((m = re.exec(text)) !== null) {
|
||||
if (m[1]) {
|
||||
parts.push({ literal: m[1] });
|
||||
}
|
||||
var mode = m[2][0];
|
||||
var value = m[3].trim();
|
||||
var negate = false;
|
||||
if (value[0] == '!') {
|
||||
negate = true;
|
||||
value = value.substring(1).trim();
|
||||
}
|
||||
var customEvent, notifyEvent, colon;
|
||||
if (mode == '{' && (colon = value.indexOf('::')) > 0) {
|
||||
notifyEvent = value.substring(colon + 2);
|
||||
value = value.substring(0, colon);
|
||||
customEvent = true;
|
||||
}
|
||||
parts.push({
|
||||
compoundIndex: parts.length,
|
||||
value: value,
|
||||
mode: mode,
|
||||
negate: negate,
|
||||
event: notifyEvent,
|
||||
customEvent: customEvent
|
||||
});
|
||||
lastIndex = re.lastIndex;
|
||||
}
|
||||
if (lastIndex && lastIndex < text.length) {
|
||||
var literal = text.substring(lastIndex);
|
||||
if (literal) {
|
||||
parts.push({ literal: literal });
|
||||
}
|
||||
}
|
||||
if (parts.length) {
|
||||
return parts;
|
||||
}
|
||||
},
|
||||
_literalFromParts: function (parts) {
|
||||
var s = '';
|
||||
for (var i = 0; i < parts.length; i++) {
|
||||
var literal = parts[i].literal;
|
||||
s += literal || '';
|
||||
}
|
||||
return s;
|
||||
},
|
||||
_parseTextNodeAnnotation: function (node, list) {
|
||||
var v = node.textContent;
|
||||
var escape = this._testEscape(v);
|
||||
if (escape) {
|
||||
node.textContent = ' ';
|
||||
var parts = this._parseBindings(node.textContent);
|
||||
if (parts) {
|
||||
node.textContent = this._literalFromParts(parts) || ' ';
|
||||
var annote = {
|
||||
bindings: [{
|
||||
kind: 'text',
|
||||
mode: escape[0],
|
||||
value: v.slice(2, -2).trim()
|
||||
name: 'textContent',
|
||||
parts: parts,
|
||||
isCompound: parts.length !== 1
|
||||
}]
|
||||
};
|
||||
list.push(annote);
|
||||
|
|
@ -104,62 +148,50 @@ index: index
|
|||
});
|
||||
},
|
||||
_parseNodeAttributeAnnotations: function (node, annotation) {
|
||||
for (var i = node.attributes.length - 1, a; a = node.attributes[i]; i--) {
|
||||
var n = a.name, v = a.value;
|
||||
if (n === 'id' && !this._testEscape(v)) {
|
||||
annotation.id = v;
|
||||
} else if (n.slice(0, 3) === 'on-') {
|
||||
var attrs = Array.prototype.slice.call(node.attributes);
|
||||
for (var i = attrs.length - 1, a; a = attrs[i]; i--) {
|
||||
var n = a.name;
|
||||
var v = a.value;
|
||||
var b;
|
||||
if (n.slice(0, 3) === 'on-') {
|
||||
node.removeAttribute(n);
|
||||
annotation.events.push({
|
||||
name: n.slice(3),
|
||||
value: v
|
||||
});
|
||||
} else {
|
||||
var b = this._parseNodeAttributeAnnotation(node, n, v);
|
||||
if (b) {
|
||||
} else if (b = this._parseNodeAttributeAnnotation(node, n, v)) {
|
||||
annotation.bindings.push(b);
|
||||
}
|
||||
} else if (n === 'id') {
|
||||
annotation.id = v;
|
||||
}
|
||||
}
|
||||
},
|
||||
_parseNodeAttributeAnnotation: function (node, n, v) {
|
||||
var escape = this._testEscape(v);
|
||||
if (escape) {
|
||||
var customEvent;
|
||||
var name = n;
|
||||
var mode = escape[0];
|
||||
v = v.slice(2, -2).trim();
|
||||
var not = false;
|
||||
if (v[0] == '!') {
|
||||
v = v.substring(1);
|
||||
not = true;
|
||||
}
|
||||
_parseNodeAttributeAnnotation: function (node, name, value) {
|
||||
var parts = this._parseBindings(value);
|
||||
if (parts) {
|
||||
var origName = name;
|
||||
var kind = 'property';
|
||||
if (n[n.length - 1] == '$') {
|
||||
name = n.slice(0, -1);
|
||||
if (name[name.length - 1] == '$') {
|
||||
name = name.slice(0, -1);
|
||||
kind = 'attribute';
|
||||
}
|
||||
var notifyEvent, colon;
|
||||
if (mode == '{' && (colon = v.indexOf('::')) > 0) {
|
||||
notifyEvent = v.substring(colon + 2);
|
||||
v = v.substring(0, colon);
|
||||
customEvent = true;
|
||||
var literal = this._literalFromParts(parts);
|
||||
if (literal && kind == 'attribute') {
|
||||
node.setAttribute(name, literal);
|
||||
}
|
||||
if (node.localName == 'input' && n == 'value') {
|
||||
node.setAttribute(n, '');
|
||||
if (node.localName == 'input' && name == 'value') {
|
||||
node.setAttribute(origName, '');
|
||||
}
|
||||
node.removeAttribute(n);
|
||||
node.removeAttribute(origName);
|
||||
if (kind === 'property') {
|
||||
name = Polymer.CaseMap.dashToCamelCase(name);
|
||||
}
|
||||
return {
|
||||
kind: kind,
|
||||
mode: mode,
|
||||
name: name,
|
||||
value: v,
|
||||
negate: not,
|
||||
event: notifyEvent,
|
||||
customEvent: customEvent
|
||||
parts: parts,
|
||||
literal: literal,
|
||||
isCompound: parts.length !== 1
|
||||
};
|
||||
}
|
||||
},
|
||||
|
|
@ -250,9 +282,14 @@ for (var i = 0; i < notes.length; i++) {
|
|||
var note = notes[i];
|
||||
for (var j = 0; j < note.bindings.length; j++) {
|
||||
var b = note.bindings[j];
|
||||
b.signature = this._parseMethod(b.value);
|
||||
if (!b.signature) {
|
||||
b.model = this._modelForPath(b.value);
|
||||
for (var k = 0; k < b.parts.length; k++) {
|
||||
var p = b.parts[k];
|
||||
if (!p.literal) {
|
||||
p.signature = this._parseMethod(p.value);
|
||||
if (!p.signature) {
|
||||
p.model = this._modelForPath(p.value);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (note.templateContent) {
|
||||
|
|
@ -263,10 +300,12 @@ for (var prop in pp) {
|
|||
bindings.push({
|
||||
index: note.index,
|
||||
kind: 'property',
|
||||
mode: '{',
|
||||
name: '_parent_' + prop,
|
||||
parts: [{
|
||||
mode: '{',
|
||||
model: prop,
|
||||
value: prop
|
||||
}]
|
||||
});
|
||||
}
|
||||
note.bindings = note.bindings.concat(bindings);
|
||||
|
|
@ -277,15 +316,17 @@ _discoverTemplateParentProps: function (notes) {
|
|||
var pp = {};
|
||||
notes.forEach(function (n) {
|
||||
n.bindings.forEach(function (b) {
|
||||
if (b.signature) {
|
||||
var args = b.signature.args;
|
||||
b.parts.forEach(function (p) {
|
||||
if (p.signature) {
|
||||
var args = p.signature.args;
|
||||
for (var k = 0; k < args.length; k++) {
|
||||
pp[args[k].model] = true;
|
||||
}
|
||||
} else {
|
||||
pp[b.model] = true;
|
||||
pp[p.model] = true;
|
||||
}
|
||||
});
|
||||
});
|
||||
if (n.templateContent) {
|
||||
var tpp = n.templateContent._parentProps;
|
||||
Polymer.Base.mixin(pp, tpp);
|
||||
|
|
@ -304,15 +345,43 @@ this._marshalAnnotatedNodes();
|
|||
this._marshalAnnotatedListeners();
|
||||
}
|
||||
},
|
||||
_configureAnnotationReferences: function () {
|
||||
this._configureTemplateContent();
|
||||
},
|
||||
_configureTemplateContent: function () {
|
||||
this._notes.forEach(function (note, i) {
|
||||
if (note.templateContent) {
|
||||
this._nodes[i]._content = note.templateContent;
|
||||
_configureAnnotationReferences: function (config) {
|
||||
var notes = this._notes;
|
||||
var nodes = this._nodes;
|
||||
for (var i = 0; i < notes.length; i++) {
|
||||
var note = notes[i];
|
||||
var node = nodes[i];
|
||||
this._configureTemplateContent(note, node);
|
||||
this._configureCompoundBindings(note, node);
|
||||
}
|
||||
},
|
||||
_configureTemplateContent: function (note, node) {
|
||||
if (note.templateContent) {
|
||||
node._content = note.templateContent;
|
||||
}
|
||||
},
|
||||
_configureCompoundBindings: function (note, node) {
|
||||
var bindings = note.bindings;
|
||||
for (var i = 0; i < bindings.length; i++) {
|
||||
var binding = bindings[i];
|
||||
if (binding.isCompound) {
|
||||
var storage = node.__compoundStorage__ || (node.__compoundStorage__ = {});
|
||||
var parts = binding.parts;
|
||||
var literals = new Array(parts.length);
|
||||
for (var j = 0; j < parts.length; j++) {
|
||||
literals[j] = parts[j].literal;
|
||||
}
|
||||
var name = binding.name;
|
||||
storage[name] = literals;
|
||||
if (binding.literal && binding.kind == 'property') {
|
||||
if (node._configValue) {
|
||||
node._configValue(name, binding.literal);
|
||||
} else {
|
||||
node[name] = binding.literal;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}, this);
|
||||
},
|
||||
_marshalIdNodes: function () {
|
||||
this.$ = {};
|
||||
|
|
@ -651,7 +720,7 @@ prevent = dy > dx;
|
|||
prevent = dx > dy;
|
||||
}
|
||||
if (prevent) {
|
||||
//ev.preventDefault();
|
||||
ev.preventDefault();
|
||||
} else {
|
||||
Gestures.prevent('track');
|
||||
}
|
||||
|
|
@ -1104,7 +1173,9 @@ this._callbacks.splice(0, len);
|
|||
this._lastVal += len;
|
||||
}
|
||||
};
|
||||
new (window.MutationObserver || JsMutationObserver)(Polymer.Async._atEndOfMicrotask.bind(Polymer.Async)).observe(Polymer.Async._twiddle, { characterData: true });
|
||||
new window.MutationObserver(function () {
|
||||
Polymer.Async._atEndOfMicrotask();
|
||||
}).observe(Polymer.Async._twiddle, { characterData: true });
|
||||
Polymer.Debounce = function () {
|
||||
var Async = Polymer.Async;
|
||||
var Debouncer = function (context) {
|
||||
|
|
@ -1186,6 +1257,32 @@ if (toElement) {
|
|||
Polymer.dom(toElement).setAttribute(name, '');
|
||||
}
|
||||
},
|
||||
getEffectiveChildNodes: function () {
|
||||
return Polymer.dom(this).getEffectiveChildNodes();
|
||||
},
|
||||
getEffectiveChildren: function () {
|
||||
var list = Polymer.dom(this).getEffectiveChildNodes();
|
||||
return list.filter(function (n) {
|
||||
return n.nodeType === Node.ELEMENT_NODE;
|
||||
});
|
||||
},
|
||||
getEffectiveTextContent: function () {
|
||||
var cn = this.getEffectiveChildNodes();
|
||||
var tc = [];
|
||||
for (var i = 0, c; c = cn[i]; i++) {
|
||||
if (c.nodeType !== Node.COMMENT_NODE) {
|
||||
tc.push(Polymer.dom(c).textContent);
|
||||
}
|
||||
}
|
||||
return tc.join('');
|
||||
},
|
||||
queryEffectiveChildren: function (slctr) {
|
||||
var e$ = Polymer.dom(this).queryDistributedElements(slctr);
|
||||
return e$ && e$[0];
|
||||
},
|
||||
queryAllEffectiveChildren: function (slctr) {
|
||||
return Polymer.dom(this).queryAllDistributedElements(slctr);
|
||||
},
|
||||
getContentChildNodes: function (slctr) {
|
||||
var content = Polymer.dom(this.root).querySelector(slctr || 'content');
|
||||
return content ? Polymer.dom(content).getDistributedNodes() : [];
|
||||
|
|
@ -1223,7 +1320,7 @@ if (index >= 0) {
|
|||
return path.splice(index, 1);
|
||||
}
|
||||
} else {
|
||||
var arr = this.get(path);
|
||||
var arr = this._get(path);
|
||||
index = arr.indexOf(item);
|
||||
if (index >= 0) {
|
||||
return this.splice(path, index, 1);
|
||||
|
|
@ -1405,7 +1502,7 @@ _notedListenerFactory: function (property, path, isStructured, bogusTest) {
|
|||
return function (e, target) {
|
||||
if (!bogusTest(e, target)) {
|
||||
if (e.detail && e.detail.path) {
|
||||
this.notifyPath(this._fixPath(path, property, e.detail.path), e.detail.value);
|
||||
this._notifyPath(this._fixPath(path, property, e.detail.path), e.detail.value);
|
||||
} else {
|
||||
var value = target[property];
|
||||
if (!isStructured) {
|
||||
|
|
@ -1431,16 +1528,16 @@ node.addEventListener(info.event, inst._notifyListener.bind(inst, info.changedFn
|
|||
};
|
||||
Polymer.Base.extend(Polymer.Bind, {
|
||||
_shouldAddListener: function (effect) {
|
||||
return effect.name && effect.mode === '{' && !effect.negate && effect.kind != 'attribute';
|
||||
return effect.name && effect.kind != 'attribute' && effect.kind != 'text' && !effect.isCompound && effect.parts[0].mode === '{' && !effect.parts[0].negate;
|
||||
},
|
||||
_annotationEffect: function (source, value, effect) {
|
||||
if (source != effect.value) {
|
||||
value = this.get(effect.value);
|
||||
value = this._get(effect.value);
|
||||
this.__data__[effect.value] = value;
|
||||
}
|
||||
var calc = effect.negate ? !value : value;
|
||||
if (!effect.customEvent || this._nodes[effect.index][effect.name] !== calc) {
|
||||
return this._applyEffectValue(calc, effect);
|
||||
return this._applyEffectValue(effect, calc);
|
||||
}
|
||||
},
|
||||
_reflectEffect: function (source) {
|
||||
|
|
@ -1478,7 +1575,7 @@ var args = Polymer.Bind._marshalArgs(this.__data__, effect, source, value);
|
|||
if (args) {
|
||||
var fn = this[effect.method];
|
||||
if (fn) {
|
||||
this.__setProperty(effect.property, fn.apply(this, args));
|
||||
this.__setProperty(effect.name, fn.apply(this, args));
|
||||
} else {
|
||||
this._warn(this._logf('_computeEffect', 'compute method `' + effect.method + '` not defined'));
|
||||
}
|
||||
|
|
@ -1494,7 +1591,7 @@ var computedvalue = fn.apply(computedHost, args);
|
|||
if (effect.negate) {
|
||||
computedvalue = !computedvalue;
|
||||
}
|
||||
this._applyEffectValue(computedvalue, effect);
|
||||
this._applyEffectValue(effect, computedvalue);
|
||||
}
|
||||
} else {
|
||||
computedHost._warn(computedHost._logf('_annotatedComputationEffect', 'compute method `' + effect.method + '` not defined'));
|
||||
|
|
@ -1510,7 +1607,7 @@ var v;
|
|||
if (arg.literal) {
|
||||
v = arg.value;
|
||||
} else if (arg.structured) {
|
||||
v = Polymer.Base.get(name, model);
|
||||
v = Polymer.Base._get(name, model);
|
||||
} else {
|
||||
v = model[name];
|
||||
}
|
||||
|
|
@ -1573,7 +1670,7 @@ this._addPropertyEffect(arg.model, 'compute', {
|
|||
method: sig.method,
|
||||
args: sig.args,
|
||||
trigger: arg,
|
||||
property: name
|
||||
name: name
|
||||
});
|
||||
}, this);
|
||||
},
|
||||
|
|
@ -1611,35 +1708,49 @@ this._addAnnotationEffect(binding, index);
|
|||
},
|
||||
_addAnnotationEffect: function (note, index) {
|
||||
if (Polymer.Bind._shouldAddListener(note)) {
|
||||
Polymer.Bind._addAnnotatedListener(this, index, note.name, note.value, note.event);
|
||||
Polymer.Bind._addAnnotatedListener(this, index, note.name, note.parts[0].value, note.parts[0].event);
|
||||
}
|
||||
for (var i = 0; i < note.parts.length; i++) {
|
||||
var part = note.parts[i];
|
||||
if (part.signature) {
|
||||
this._addAnnotatedComputationEffect(note, part, index);
|
||||
} else if (!part.literal) {
|
||||
this._addPropertyEffect(part.model, 'annotation', {
|
||||
kind: note.kind,
|
||||
index: index,
|
||||
name: note.name,
|
||||
value: part.value,
|
||||
isCompound: note.isCompound,
|
||||
compoundIndex: part.compoundIndex,
|
||||
event: part.event,
|
||||
customEvent: part.customEvent,
|
||||
negate: part.negate
|
||||
});
|
||||
}
|
||||
if (note.signature) {
|
||||
this._addAnnotatedComputationEffect(note, index);
|
||||
} else {
|
||||
note.index = index;
|
||||
this._addPropertyEffect(note.model, 'annotation', note);
|
||||
}
|
||||
},
|
||||
_addAnnotatedComputationEffect: function (note, index) {
|
||||
var sig = note.signature;
|
||||
_addAnnotatedComputationEffect: function (note, part, index) {
|
||||
var sig = part.signature;
|
||||
if (sig.static) {
|
||||
this.__addAnnotatedComputationEffect('__static__', index, note, sig, null);
|
||||
this.__addAnnotatedComputationEffect('__static__', index, note, part, null);
|
||||
} else {
|
||||
sig.args.forEach(function (arg) {
|
||||
if (!arg.literal) {
|
||||
this.__addAnnotatedComputationEffect(arg.model, index, note, sig, arg);
|
||||
this.__addAnnotatedComputationEffect(arg.model, index, note, part, arg);
|
||||
}
|
||||
}, this);
|
||||
}
|
||||
},
|
||||
__addAnnotatedComputationEffect: function (property, index, note, sig, trigger) {
|
||||
__addAnnotatedComputationEffect: function (property, index, note, part, trigger) {
|
||||
this._addPropertyEffect(property, 'annotatedComputation', {
|
||||
index: index,
|
||||
isCompound: note.isCompound,
|
||||
compoundIndex: part.compoundIndex,
|
||||
kind: note.kind,
|
||||
property: note.name,
|
||||
negate: note.negate,
|
||||
method: sig.method,
|
||||
args: sig.args,
|
||||
name: note.name,
|
||||
negate: part.negate,
|
||||
method: part.signature.method,
|
||||
args: part.signature.args,
|
||||
trigger: trigger
|
||||
});
|
||||
},
|
||||
|
|
@ -1708,9 +1819,14 @@ _marshalInstanceEffects: function () {
|
|||
Polymer.Bind.prepareInstance(this);
|
||||
Polymer.Bind.setupBindListeners(this);
|
||||
},
|
||||
_applyEffectValue: function (value, info) {
|
||||
_applyEffectValue: function (info, value) {
|
||||
var node = this._nodes[info.index];
|
||||
var property = info.property || info.name || 'textContent';
|
||||
var property = info.name;
|
||||
if (info.isCompound) {
|
||||
var storage = node.__compoundStorage__[property];
|
||||
storage[info.compoundIndex] = value;
|
||||
value = storage.join('');
|
||||
}
|
||||
if (info.kind == 'attribute') {
|
||||
this.serializeValueToAttribute(value, property, node);
|
||||
} else {
|
||||
|
|
@ -1790,10 +1906,10 @@ for (var p in config) {
|
|||
var fx = fx$[p];
|
||||
if (fx) {
|
||||
for (var i = 0, l = fx.length, x; i < l && (x = fx[i]); i++) {
|
||||
if (x.kind === 'annotation') {
|
||||
if (x.kind === 'annotation' && !x.isCompound) {
|
||||
var node = this._nodes[x.effect.index];
|
||||
if (node._configValue) {
|
||||
var value = p === x.effect.value ? config[p] : this.get(x.effect.value, config);
|
||||
var value = p === x.effect.value ? config[p] : this._get(x.effect.value, config);
|
||||
node._configValue(x.effect.name, value);
|
||||
}
|
||||
}
|
||||
|
|
@ -1840,11 +1956,16 @@ this._handlers = [];
|
|||
'use strict';
|
||||
Polymer.Base._addFeature({
|
||||
notifyPath: function (path, value, fromAbove) {
|
||||
var info = {};
|
||||
path = this._get(path, this, info);
|
||||
this._notifyPath(info.path, value, fromAbove);
|
||||
},
|
||||
_notifyPath: function (path, value, fromAbove) {
|
||||
var old = this._propertySetter(path, value);
|
||||
if (old !== value && (old === old || value === value)) {
|
||||
this._pathEffector(path, value);
|
||||
if (!fromAbove) {
|
||||
this._notifyPath(path, value);
|
||||
this._notifyPathUp(path, value);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -1871,41 +1992,67 @@ var last = parts[parts.length - 1];
|
|||
if (parts.length > 1) {
|
||||
for (var i = 0; i < parts.length - 1; i++) {
|
||||
var part = parts[i];
|
||||
if (array && part[0] == '#') {
|
||||
prop = Polymer.Collection.get(array).getItem(part);
|
||||
} else {
|
||||
prop = prop[part];
|
||||
if (array && parseInt(part) == part) {
|
||||
if (array && parseInt(part, 10) == part) {
|
||||
parts[i] = Polymer.Collection.get(array).getKey(prop);
|
||||
}
|
||||
}
|
||||
if (!prop) {
|
||||
return;
|
||||
}
|
||||
array = Array.isArray(prop) ? prop : null;
|
||||
}
|
||||
if (array && parseInt(last) == last) {
|
||||
if (array) {
|
||||
var coll = Polymer.Collection.get(array);
|
||||
if (last[0] == '#') {
|
||||
var key = last;
|
||||
var old = coll.getItem(key);
|
||||
last = array.indexOf(old);
|
||||
coll.setItem(key, value);
|
||||
} else if (parseInt(last, 10) == last) {
|
||||
var old = prop[last];
|
||||
var key = coll.getKey(old);
|
||||
parts[i] = key;
|
||||
coll.setItem(key, value);
|
||||
}
|
||||
}
|
||||
prop[last] = value;
|
||||
if (!root) {
|
||||
this.notifyPath(parts.join('.'), value);
|
||||
this._notifyPath(parts.join('.'), value);
|
||||
}
|
||||
} else {
|
||||
prop[path] = value;
|
||||
}
|
||||
},
|
||||
get: function (path, root) {
|
||||
return this._get(path, root);
|
||||
},
|
||||
_get: function (path, root, info) {
|
||||
var prop = root || this;
|
||||
var parts = this._getPathParts(path);
|
||||
var last = parts.pop();
|
||||
while (parts.length) {
|
||||
prop = prop[parts.shift()];
|
||||
var array;
|
||||
for (var i = 0; i < parts.length; i++) {
|
||||
if (!prop) {
|
||||
return;
|
||||
}
|
||||
var part = parts[i];
|
||||
if (array && part[0] == '#') {
|
||||
prop = Polymer.Collection.get(array).getItem(part);
|
||||
} else {
|
||||
prop = prop[part];
|
||||
if (info && array && parseInt(part, 10) == part) {
|
||||
parts[i] = Polymer.Collection.get(array).getKey(prop);
|
||||
}
|
||||
return prop[last];
|
||||
}
|
||||
array = Array.isArray(prop) ? prop : null;
|
||||
}
|
||||
if (info) {
|
||||
info.path = parts.join('.');
|
||||
}
|
||||
return prop;
|
||||
},
|
||||
_pathEffector: function (path, value) {
|
||||
var model = this._modelForPath(path);
|
||||
|
|
@ -1978,7 +2125,7 @@ this.notifyPath(this._fixPath(a, b, path), value);
|
|||
_fixPath: function (property, root, path) {
|
||||
return property + path.slice(root.length);
|
||||
},
|
||||
_notifyPath: function (path, value) {
|
||||
_notifyPathUp: function (path, value) {
|
||||
var rootName = this._modelForPath(path);
|
||||
var dashCaseName = Polymer.CaseMap.camelToDashCase(rootName);
|
||||
var eventName = dashCaseName + this._EVENT_CHANGED;
|
||||
|
|
@ -1992,47 +2139,62 @@ var dot = path.indexOf('.');
|
|||
return dot < 0 ? path : path.slice(0, dot);
|
||||
},
|
||||
_EVENT_CHANGED: '-changed',
|
||||
notifySplices: function (path, splices) {
|
||||
var info = {};
|
||||
var array = this._get(path, this, info);
|
||||
this._notifySplices(array, info.path, splices);
|
||||
},
|
||||
_notifySplices: function (array, path, splices) {
|
||||
var change = {
|
||||
keySplices: Polymer.Collection.applySplices(array, splices),
|
||||
indexSplices: splices
|
||||
};
|
||||
if (!array.hasOwnProperty('splices')) {
|
||||
Object.defineProperty(array, 'splices', {
|
||||
configurable: true,
|
||||
writable: true
|
||||
});
|
||||
}
|
||||
array.splices = change;
|
||||
this._notifyPath(path + '.splices', change);
|
||||
this._notifyPath(path + '.length', array.length);
|
||||
change.keySplices = null;
|
||||
change.indexSplices = null;
|
||||
},
|
||||
_notifySplice: function (array, path, index, added, removed) {
|
||||
var splices = [{
|
||||
this._notifySplices(array, path, [{
|
||||
index: index,
|
||||
addedCount: added,
|
||||
removed: removed,
|
||||
object: array,
|
||||
type: 'splice'
|
||||
}];
|
||||
var change = {
|
||||
keySplices: Polymer.Collection.applySplices(array, splices),
|
||||
indexSplices: splices
|
||||
};
|
||||
this.set(path + '.splices', change);
|
||||
if (added != removed.length) {
|
||||
this.notifyPath(path + '.length', array.length);
|
||||
}
|
||||
change.keySplices = null;
|
||||
change.indexSplices = null;
|
||||
}]);
|
||||
},
|
||||
push: function (path) {
|
||||
var array = this.get(path);
|
||||
var info = {};
|
||||
var array = this._get(path, this, info);
|
||||
var args = Array.prototype.slice.call(arguments, 1);
|
||||
var len = array.length;
|
||||
var ret = array.push.apply(array, args);
|
||||
if (args.length) {
|
||||
this._notifySplice(array, path, len, args.length, []);
|
||||
this._notifySplice(array, info.path, len, args.length, []);
|
||||
}
|
||||
return ret;
|
||||
},
|
||||
pop: function (path) {
|
||||
var array = this.get(path);
|
||||
var info = {};
|
||||
var array = this._get(path, this, info);
|
||||
var hadLength = Boolean(array.length);
|
||||
var args = Array.prototype.slice.call(arguments, 1);
|
||||
var ret = array.pop.apply(array, args);
|
||||
if (hadLength) {
|
||||
this._notifySplice(array, path, array.length, 0, [ret]);
|
||||
this._notifySplice(array, info.path, array.length, 0, [ret]);
|
||||
}
|
||||
return ret;
|
||||
},
|
||||
splice: function (path, start, deleteCount) {
|
||||
var array = this.get(path);
|
||||
var info = {};
|
||||
var array = this._get(path, this, info);
|
||||
if (start < 0) {
|
||||
start = array.length - Math.floor(-start);
|
||||
} else {
|
||||
|
|
@ -2045,26 +2207,28 @@ var args = Array.prototype.slice.call(arguments, 1);
|
|||
var ret = array.splice.apply(array, args);
|
||||
var addedCount = Math.max(args.length - 2, 0);
|
||||
if (addedCount || ret.length) {
|
||||
this._notifySplice(array, path, start, addedCount, ret);
|
||||
this._notifySplice(array, info.path, start, addedCount, ret);
|
||||
}
|
||||
return ret;
|
||||
},
|
||||
shift: function (path) {
|
||||
var array = this.get(path);
|
||||
var info = {};
|
||||
var array = this._get(path, this, info);
|
||||
var hadLength = Boolean(array.length);
|
||||
var args = Array.prototype.slice.call(arguments, 1);
|
||||
var ret = array.shift.apply(array, args);
|
||||
if (hadLength) {
|
||||
this._notifySplice(array, path, 0, 0, [ret]);
|
||||
this._notifySplice(array, info.path, 0, 0, [ret]);
|
||||
}
|
||||
return ret;
|
||||
},
|
||||
unshift: function (path) {
|
||||
var array = this.get(path);
|
||||
var info = {};
|
||||
var array = this._get(path, this, info);
|
||||
var args = Array.prototype.slice.call(arguments, 1);
|
||||
var ret = array.unshift.apply(array, args);
|
||||
if (args.length) {
|
||||
this._notifySplice(array, path, 0, args.length, []);
|
||||
this._notifySplice(array, info.path, 0, args.length, []);
|
||||
}
|
||||
return ret;
|
||||
},
|
||||
|
|
@ -2072,8 +2236,10 @@ prepareModelNotifyPath: function (model) {
|
|||
this.mixin(model, {
|
||||
fire: Polymer.Base.fire,
|
||||
notifyPath: Polymer.Base.notifyPath,
|
||||
_get: Polymer.Base._get,
|
||||
_EVENT_CHANGED: Polymer.Base._EVENT_CHANGED,
|
||||
_notifyPath: Polymer.Base._notifyPath,
|
||||
_notifyPathUp: Polymer.Base._notifyPathUp,
|
||||
_pathEffector: Polymer.Base._pathEffector,
|
||||
_annotationPathEffect: Polymer.Base._annotationPathEffect,
|
||||
_complexObserverPathEffect: Polymer.Base._complexObserverPathEffect,
|
||||
|
|
@ -2081,7 +2247,8 @@ _annotatedComputationPathEffect: Polymer.Base._annotatedComputationPathEffect,
|
|||
_computePathEffect: Polymer.Base._computePathEffect,
|
||||
_modelForPath: Polymer.Base._modelForPath,
|
||||
_pathMatchesEffect: Polymer.Base._pathMatchesEffect,
|
||||
_notifyBoundPaths: Polymer.Base._notifyBoundPaths
|
||||
_notifyBoundPaths: Polymer.Base._notifyBoundPaths,
|
||||
_getPathParts: Polymer.Base._getPathParts
|
||||
});
|
||||
}
|
||||
});
|
||||
|
|
@ -3306,7 +3473,7 @@ archetype._prepEffects();
|
|||
this._customPrepEffects(archetype);
|
||||
archetype._prepBehaviors();
|
||||
archetype._prepBindings();
|
||||
archetype._notifyPath = this._notifyPathImpl;
|
||||
archetype._notifyPathUp = this._notifyPathUpImpl;
|
||||
archetype._scopeElementClass = this._scopeElementClassImpl;
|
||||
archetype.listen = this._listenImpl;
|
||||
archetype._showHideChildren = this._showHideChildrenImpl;
|
||||
|
|
@ -3444,7 +3611,7 @@ _forwardInstancePath: function (inst, path, value) {
|
|||
},
|
||||
_forwardInstanceProp: function (inst, prop, value) {
|
||||
},
|
||||
_notifyPathImpl: function (path, value) {
|
||||
_notifyPathUpImpl: function (path, value) {
|
||||
var dataHost = this.dataHost;
|
||||
var dot = path.indexOf('.');
|
||||
var root = dot < 0 ? path : path.slice(0, dot);
|
||||
|
|
@ -3562,9 +3729,10 @@ this.omap.set(item, key);
|
|||
} else {
|
||||
this.pmap[item] = key;
|
||||
}
|
||||
return key;
|
||||
return '#' + key;
|
||||
},
|
||||
removeKey: function (key) {
|
||||
key = this._parseKey(key);
|
||||
this._removeFromMap(this.store[key]);
|
||||
delete this.store[key];
|
||||
},
|
||||
|
|
@ -3581,16 +3749,29 @@ this.removeKey(key);
|
|||
return key;
|
||||
},
|
||||
getKey: function (item) {
|
||||
var key;
|
||||
if (item && typeof item == 'object') {
|
||||
return this.omap.get(item);
|
||||
key = this.omap.get(item);
|
||||
} else {
|
||||
return this.pmap[item];
|
||||
key = this.pmap[item];
|
||||
}
|
||||
if (key != undefined) {
|
||||
return '#' + key;
|
||||
}
|
||||
},
|
||||
getKeys: function () {
|
||||
return Object.keys(this.store);
|
||||
return Object.keys(this.store).map(function (key) {
|
||||
return '#' + key;
|
||||
});
|
||||
},
|
||||
_parseKey: function (key) {
|
||||
if (key[0] == '#') {
|
||||
return key.slice(1);
|
||||
}
|
||||
throw new Error('unexpected key ' + key);
|
||||
},
|
||||
setItem: function (key, item) {
|
||||
key = this._parseKey(key);
|
||||
var old = this.store[key];
|
||||
if (old) {
|
||||
this._removeFromMap(old);
|
||||
|
|
@ -3603,6 +3784,7 @@ this.pmap[item] = key;
|
|||
this.store[key] = item;
|
||||
},
|
||||
getItem: function (key) {
|
||||
key = this._parseKey(key);
|
||||
return this.store[key];
|
||||
},
|
||||
getItems: function () {
|
||||
|
|
@ -3996,7 +4178,7 @@ this.set('items.' + idx, value);
|
|||
},
|
||||
_forwardInstancePath: function (inst, path, value) {
|
||||
if (path.indexOf(this.as + '.') === 0) {
|
||||
this.notifyPath('items.' + inst.__key__ + '.' + path.slice(this.as.length + 1), value);
|
||||
this._notifyPath('items.' + inst.__key__ + '.' + path.slice(this.as.length + 1), value);
|
||||
}
|
||||
},
|
||||
_forwardParentProp: function (prop, value) {
|
||||
|
|
@ -4006,7 +4188,7 @@ inst.__setProperty(prop, value, true);
|
|||
},
|
||||
_forwardParentPath: function (path, value) {
|
||||
this._instances.forEach(function (inst) {
|
||||
inst.notifyPath(path, value, true);
|
||||
inst._notifyPath(path, value, true);
|
||||
}, this);
|
||||
},
|
||||
_forwardItemPath: function (path, value) {
|
||||
|
|
@ -4018,7 +4200,7 @@ var inst = this._instances[idx];
|
|||
if (inst) {
|
||||
if (dot >= 0) {
|
||||
path = this.as + '.' + path.substring(dot + 1);
|
||||
inst.notifyPath(path, value, true);
|
||||
inst._notifyPath(path, value, true);
|
||||
} else {
|
||||
inst.__setProperty(this.as, value, true);
|
||||
}
|
||||
|
|
@ -4070,6 +4252,7 @@ this.unlinkPaths('selected.' + i);
|
|||
}
|
||||
} else {
|
||||
this.unlinkPaths('selected');
|
||||
this.unlinkPaths('selectedItem');
|
||||
}
|
||||
if (this.multi) {
|
||||
if (!this.selected || this.selected.length) {
|
||||
|
|
@ -4209,7 +4392,7 @@ this._instance[prop] = value;
|
|||
},
|
||||
_forwardParentPath: function (path, value) {
|
||||
if (this._instance) {
|
||||
this._instance.notifyPath(path, value, true);
|
||||
this._instance._notifyPath(path, value, true);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue