| Index: polymer_1.0.4/bower_components/polymer/polymer.html
|
| diff --git a/polymer_1.0.4/bower_components/polymer/polymer.html b/polymer_1.0.4/bower_components/polymer/polymer.html
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..9d59e33d25954a42b32dc7e8aff5b71bdfed8fe3
|
| --- /dev/null
|
| +++ b/polymer_1.0.4/bower_components/polymer/polymer.html
|
| @@ -0,0 +1,3897 @@
|
| +<!--
|
| +@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
|
| +--><!--
|
| +@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="polymer-mini.html">
|
| +
|
| +<script>Polymer.nar = [];
|
| +Polymer.Annotations = {
|
| +parseAnnotations: function (template) {
|
| +var list = [];
|
| +var content = template._content || template.content;
|
| +this._parseNodeAnnotations(content, list);
|
| +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;
|
| +}
|
| +},
|
| +_parseTextNodeAnnotation: function (node, list) {
|
| +var v = node.textContent;
|
| +var escape = this._testEscape(v);
|
| +if (escape) {
|
| +node.textContent = ' ';
|
| +var annote = {
|
| +bindings: [{
|
| +kind: 'text',
|
| +mode: escape[0],
|
| +value: v.slice(2, -2).trim()
|
| +}]
|
| +};
|
| +list.push(annote);
|
| +return annote;
|
| +}
|
| +},
|
| +_parseElementAnnotations: function (element, list) {
|
| +var annote = {
|
| +bindings: [],
|
| +events: []
|
| +};
|
| +this._parseChildNodesAnnotations(element, annote, list);
|
| +if (element.attributes) {
|
| +this._parseNodeAttributeAnnotations(element, annote, list);
|
| +if (this.prepElement) {
|
| +this.prepElement(element);
|
| +}
|
| +}
|
| +if (annote.bindings.length || annote.events.length || annote.id) {
|
| +list.push(annote);
|
| +}
|
| +return annote;
|
| +},
|
| +_parseChildNodesAnnotations: function (root, annote, list, callback) {
|
| +if (root.firstChild) {
|
| +for (var i = 0, node = root.firstChild; node; node = node.nextSibling, i++) {
|
| +if (node.localName === 'template' && !node.hasAttribute('preserve-content')) {
|
| +this._parseTemplate(node, i, list, annote);
|
| +}
|
| +var childAnnotation = this._parseNodeAnnotations(node, list, callback);
|
| +if (childAnnotation) {
|
| +childAnnotation.parent = annote;
|
| +childAnnotation.index = i;
|
| +}
|
| +}
|
| +}
|
| +},
|
| +_parseTemplate: function (node, index, list, parent) {
|
| +var content = document.createDocumentFragment();
|
| +content._notes = this.parseAnnotations(node);
|
| +content.appendChild(node.content);
|
| +list.push({
|
| +bindings: Polymer.nar,
|
| +events: Polymer.nar,
|
| +templateContent: content,
|
| +parent: parent,
|
| +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-') {
|
| +node.removeAttribute(n);
|
| +annotation.events.push({
|
| +name: n.slice(3),
|
| +value: v
|
| +});
|
| +} else {
|
| +var b = this._parseNodeAttributeAnnotation(node, n, v);
|
| +if (b) {
|
| +annotation.bindings.push(b);
|
| +}
|
| +}
|
| +}
|
| +},
|
| +_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;
|
| +}
|
| +var kind = 'property';
|
| +if (n[n.length - 1] == '$') {
|
| +name = n.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;
|
| +}
|
| +if (node.localName == 'input' && n == 'value') {
|
| +node.setAttribute(n, '');
|
| +}
|
| +node.removeAttribute(n);
|
| +if (kind === 'property') {
|
| +name = Polymer.CaseMap.dashToCamelCase(name);
|
| +}
|
| +return {
|
| +kind: kind,
|
| +mode: mode,
|
| +name: name,
|
| +value: v,
|
| +negate: not,
|
| +event: notifyEvent,
|
| +customEvent: customEvent
|
| +};
|
| +}
|
| +},
|
| +_localSubTree: function (node, host) {
|
| +return node === host ? node.childNodes : node._lightChildren || node.childNodes;
|
| +},
|
| +findAnnotatedNode: function (root, annote) {
|
| +var parent = annote.parent && Polymer.Annotations.findAnnotatedNode(root, annote.parent);
|
| +return !parent ? root : Polymer.Annotations._localSubTree(parent, root)[annote.index];
|
| +}
|
| +};
|
| +(function () {
|
| +function resolveCss(cssText, ownerDocument) {
|
| +return cssText.replace(CSS_URL_RX, function (m, pre, url, post) {
|
| +return pre + '\'' + resolve(url.replace(/["']/g, ''), ownerDocument) + '\'' + post;
|
| +});
|
| +}
|
| +function resolveAttrs(element, ownerDocument) {
|
| +for (var name in URL_ATTRS) {
|
| +var a$ = URL_ATTRS[name];
|
| +for (var i = 0, l = a$.length, a, at, v; i < l && (a = a$[i]); i++) {
|
| +if (name === '*' || element.localName === name) {
|
| +at = element.attributes[a];
|
| +v = at && at.value;
|
| +if (v && v.search(BINDING_RX) < 0) {
|
| +at.value = a === 'style' ? resolveCss(v, ownerDocument) : resolve(v, ownerDocument);
|
| +}
|
| +}
|
| +}
|
| +}
|
| +}
|
| +function resolve(url, ownerDocument) {
|
| +if (url && url[0] === '#') {
|
| +return url;
|
| +}
|
| +var resolver = getUrlResolver(ownerDocument);
|
| +resolver.href = url;
|
| +return resolver.href || url;
|
| +}
|
| +var tempDoc;
|
| +var tempDocBase;
|
| +function resolveUrl(url, baseUri) {
|
| +if (!tempDoc) {
|
| +tempDoc = document.implementation.createHTMLDocument('temp');
|
| +tempDocBase = tempDoc.createElement('base');
|
| +tempDoc.head.appendChild(tempDocBase);
|
| +}
|
| +tempDocBase.href = baseUri;
|
| +return resolve(url, tempDoc);
|
| +}
|
| +function getUrlResolver(ownerDocument) {
|
| +return ownerDocument.__urlResolver || (ownerDocument.__urlResolver = ownerDocument.createElement('a'));
|
| +}
|
| +var CSS_URL_RX = /(url\()([^)]*)(\))/g;
|
| +var URL_ATTRS = {
|
| +'*': [
|
| +'href',
|
| +'src',
|
| +'style',
|
| +'url'
|
| +],
|
| +form: ['action']
|
| +};
|
| +var BINDING_RX = /\{\{|\[\[/;
|
| +Polymer.ResolveUrl = {
|
| +resolveCss: resolveCss,
|
| +resolveAttrs: resolveAttrs,
|
| +resolveUrl: resolveUrl
|
| +};
|
| +}());
|
| +Polymer.Base._addFeature({
|
| +_prepAnnotations: function () {
|
| +if (!this._template) {
|
| +this._notes = [];
|
| +} else {
|
| +Polymer.Annotations.prepElement = this._prepElement.bind(this);
|
| +this._notes = Polymer.Annotations.parseAnnotations(this._template);
|
| +this._processAnnotations(this._notes);
|
| +Polymer.Annotations.prepElement = null;
|
| +}
|
| +},
|
| +_processAnnotations: function (notes) {
|
| +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);
|
| +}
|
| +}
|
| +if (note.templateContent) {
|
| +this._processAnnotations(note.templateContent._notes);
|
| +var pp = note.templateContent._parentProps = this._discoverTemplateParentProps(note.templateContent._notes);
|
| +var bindings = [];
|
| +for (var prop in pp) {
|
| +bindings.push({
|
| +index: note.index,
|
| +kind: 'property',
|
| +mode: '{',
|
| +name: '_parent_' + prop,
|
| +model: prop,
|
| +value: prop
|
| +});
|
| +}
|
| +note.bindings = note.bindings.concat(bindings);
|
| +}
|
| +}
|
| +},
|
| +_discoverTemplateParentProps: function (notes) {
|
| +var pp = {};
|
| +notes.forEach(function (n) {
|
| +n.bindings.forEach(function (b) {
|
| +if (b.signature) {
|
| +var args = b.signature.args;
|
| +for (var k = 0; k < args.length; k++) {
|
| +pp[args[k].model] = true;
|
| +}
|
| +} else {
|
| +pp[b.model] = true;
|
| +}
|
| +});
|
| +if (n.templateContent) {
|
| +var tpp = n.templateContent._parentProps;
|
| +Polymer.Base.mixin(pp, tpp);
|
| +}
|
| +});
|
| +return pp;
|
| +},
|
| +_prepElement: function (element) {
|
| +Polymer.ResolveUrl.resolveAttrs(element, this._template.ownerDocument);
|
| +},
|
| +_findAnnotatedNode: Polymer.Annotations.findAnnotatedNode,
|
| +_marshalAnnotationReferences: function () {
|
| +if (this._template) {
|
| +this._marshalIdNodes();
|
| +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;
|
| +}
|
| +}, this);
|
| +},
|
| +_marshalIdNodes: function () {
|
| +this.$ = {};
|
| +this._notes.forEach(function (a) {
|
| +if (a.id) {
|
| +this.$[a.id] = this._findAnnotatedNode(this.root, a);
|
| +}
|
| +}, this);
|
| +},
|
| +_marshalAnnotatedNodes: function () {
|
| +if (this._nodes) {
|
| +this._nodes = this._nodes.map(function (a) {
|
| +return this._findAnnotatedNode(this.root, a);
|
| +}, this);
|
| +}
|
| +},
|
| +_marshalAnnotatedListeners: function () {
|
| +this._notes.forEach(function (a) {
|
| +if (a.events && a.events.length) {
|
| +var node = this._findAnnotatedNode(this.root, a);
|
| +a.events.forEach(function (e) {
|
| +this.listen(node, e.name, e.value);
|
| +}, this);
|
| +}
|
| +}, this);
|
| +}
|
| +});
|
| +Polymer.Base._addFeature({
|
| +listeners: {},
|
| +_listenListeners: function (listeners) {
|
| +var node, name, key;
|
| +for (key in listeners) {
|
| +if (key.indexOf('.') < 0) {
|
| +node = this;
|
| +name = key;
|
| +} else {
|
| +name = key.split('.');
|
| +node = this.$[name[0]];
|
| +name = name[1];
|
| +}
|
| +this.listen(node, name, listeners[key]);
|
| +}
|
| +},
|
| +listen: function (node, eventName, methodName) {
|
| +this._listen(node, eventName, this._createEventHandler(node, eventName, methodName));
|
| +},
|
| +_boundListenerKey: function (eventName, methodName) {
|
| +return eventName + ':' + methodName;
|
| +},
|
| +_recordEventHandler: function (host, eventName, target, methodName, handler) {
|
| +var hbl = host.__boundListeners;
|
| +if (!hbl) {
|
| +hbl = host.__boundListeners = new WeakMap();
|
| +}
|
| +var bl = hbl.get(target);
|
| +if (!bl) {
|
| +bl = {};
|
| +hbl.set(target, bl);
|
| +}
|
| +var key = this._boundListenerKey(eventName, methodName);
|
| +bl[key] = handler;
|
| +},
|
| +_recallEventHandler: function (host, eventName, target, methodName) {
|
| +var hbl = host.__boundListeners;
|
| +if (!hbl) {
|
| +return;
|
| +}
|
| +var bl = hbl.get(target);
|
| +if (!bl) {
|
| +return;
|
| +}
|
| +var key = this._boundListenerKey(eventName, methodName);
|
| +return bl[key];
|
| +},
|
| +_createEventHandler: function (node, eventName, methodName) {
|
| +var host = this;
|
| +var handler = function (e) {
|
| +if (host[methodName]) {
|
| +host[methodName](e, e.detail);
|
| +} else {
|
| +host._warn(host._logf('_createEventHandler', 'listener method `' + methodName + '` not defined'));
|
| +}
|
| +};
|
| +this._recordEventHandler(host, eventName, node, methodName, handler);
|
| +return handler;
|
| +},
|
| +unlisten: function (node, eventName, methodName) {
|
| +var handler = this._recallEventHandler(this, eventName, node, methodName);
|
| +if (handler) {
|
| +this._unlisten(node, eventName, handler);
|
| +}
|
| +},
|
| +_listen: function (node, eventName, handler) {
|
| +node.addEventListener(eventName, handler);
|
| +},
|
| +_unlisten: function (node, eventName, handler) {
|
| +node.removeEventListener(eventName, handler);
|
| +}
|
| +});
|
| +(function () {
|
| +'use strict';
|
| +var HAS_NATIVE_TA = typeof document.head.style.touchAction === 'string';
|
| +var GESTURE_KEY = '__polymerGestures';
|
| +var HANDLED_OBJ = '__polymerGesturesHandled';
|
| +var TOUCH_ACTION = '__polymerGesturesTouchAction';
|
| +var TAP_DISTANCE = 25;
|
| +var TRACK_DISTANCE = 5;
|
| +var TRACK_LENGTH = 2;
|
| +var MOUSE_TIMEOUT = 2500;
|
| +var MOUSE_EVENTS = [
|
| +'mousedown',
|
| +'mousemove',
|
| +'mouseup',
|
| +'click'
|
| +];
|
| +var mouseCanceller = function (mouseEvent) {
|
| +mouseEvent[HANDLED_OBJ] = { skip: true };
|
| +if (mouseEvent.type === 'click') {
|
| +var path = Polymer.dom(mouseEvent).path;
|
| +for (var i = 0; i < path.length; i++) {
|
| +if (path[i] === POINTERSTATE.mouse.target) {
|
| +return;
|
| +}
|
| +}
|
| +mouseEvent.preventDefault();
|
| +mouseEvent.stopPropagation();
|
| +}
|
| +};
|
| +function setupTeardownMouseCanceller(setup) {
|
| +for (var i = 0, en; i < MOUSE_EVENTS.length; i++) {
|
| +en = MOUSE_EVENTS[i];
|
| +if (setup) {
|
| +document.addEventListener(en, mouseCanceller, true);
|
| +} else {
|
| +document.removeEventListener(en, mouseCanceller, true);
|
| +}
|
| +}
|
| +}
|
| +function ignoreMouse() {
|
| +if (!POINTERSTATE.mouse.mouseIgnoreJob) {
|
| +setupTeardownMouseCanceller(true);
|
| +}
|
| +var unset = function () {
|
| +setupTeardownMouseCanceller();
|
| +POINTERSTATE.mouse.target = null;
|
| +POINTERSTATE.mouse.mouseIgnoreJob = null;
|
| +};
|
| +POINTERSTATE.mouse.mouseIgnoreJob = Polymer.Debounce(POINTERSTATE.mouse.mouseIgnoreJob, unset, MOUSE_TIMEOUT);
|
| +}
|
| +var POINTERSTATE = {
|
| +mouse: {
|
| +target: null,
|
| +mouseIgnoreJob: null
|
| +},
|
| +touch: {
|
| +x: 0,
|
| +y: 0,
|
| +id: -1,
|
| +scrollDecided: false
|
| +}
|
| +};
|
| +function firstTouchAction(ev) {
|
| +var path = Polymer.dom(ev).path;
|
| +var ta = 'auto';
|
| +for (var i = 0, n; i < path.length; i++) {
|
| +n = path[i];
|
| +if (n[TOUCH_ACTION]) {
|
| +ta = n[TOUCH_ACTION];
|
| +break;
|
| +}
|
| +}
|
| +return ta;
|
| +}
|
| +var Gestures = {
|
| +gestures: {},
|
| +recognizers: [],
|
| +deepTargetFind: function (x, y) {
|
| +var node = document.elementFromPoint(x, y);
|
| +var next = node;
|
| +while (next && next.shadowRoot) {
|
| +next = next.shadowRoot.elementFromPoint(x, y);
|
| +if (next) {
|
| +node = next;
|
| +}
|
| +}
|
| +return node;
|
| +},
|
| +handleNative: function (ev) {
|
| +var handled;
|
| +var type = ev.type;
|
| +var node = ev.currentTarget;
|
| +var gobj = node[GESTURE_KEY];
|
| +var gs = gobj[type];
|
| +if (!gs) {
|
| +return;
|
| +}
|
| +if (!ev[HANDLED_OBJ]) {
|
| +ev[HANDLED_OBJ] = {};
|
| +if (type.slice(0, 5) === 'touch') {
|
| +var t = ev.changedTouches[0];
|
| +if (type === 'touchstart') {
|
| +if (ev.touches.length === 1) {
|
| +POINTERSTATE.touch.id = t.identifier;
|
| +}
|
| +}
|
| +if (POINTERSTATE.touch.id !== t.identifier) {
|
| +return;
|
| +}
|
| +if (!HAS_NATIVE_TA) {
|
| +if (type === 'touchstart' || type === 'touchmove') {
|
| +Gestures.handleTouchAction(ev);
|
| +}
|
| +}
|
| +if (type === 'touchend') {
|
| +POINTERSTATE.mouse.target = Polymer.dom(ev).rootTarget;
|
| +ignoreMouse(true);
|
| +}
|
| +}
|
| +}
|
| +handled = ev[HANDLED_OBJ];
|
| +if (handled.skip) {
|
| +return;
|
| +}
|
| +var recognizers = Gestures.recognizers;
|
| +for (var i = 0, r; i < recognizers.length; i++) {
|
| +r = recognizers[i];
|
| +if (gs[r.name] && !handled[r.name]) {
|
| +handled[r.name] = true;
|
| +r[type](ev);
|
| +}
|
| +}
|
| +},
|
| +handleTouchAction: function (ev) {
|
| +var t = ev.changedTouches[0];
|
| +var type = ev.type;
|
| +if (type === 'touchstart') {
|
| +POINTERSTATE.touch.x = t.clientX;
|
| +POINTERSTATE.touch.y = t.clientY;
|
| +POINTERSTATE.touch.scrollDecided = false;
|
| +} else if (type === 'touchmove') {
|
| +if (POINTERSTATE.touch.scrollDecided) {
|
| +return;
|
| +}
|
| +POINTERSTATE.touch.scrollDecided = true;
|
| +var ta = firstTouchAction(ev);
|
| +var prevent = false;
|
| +var dx = Math.abs(POINTERSTATE.touch.x - t.clientX);
|
| +var dy = Math.abs(POINTERSTATE.touch.y - t.clientY);
|
| +if (!ev.cancelable) {
|
| +} else if (ta === 'none') {
|
| +prevent = true;
|
| +} else if (ta === 'pan-x') {
|
| +prevent = dy > dx;
|
| +} else if (ta === 'pan-y') {
|
| +prevent = dx > dy;
|
| +}
|
| +if (prevent) {
|
| +ev.preventDefault();
|
| +}
|
| +}
|
| +},
|
| +add: function (node, evType, handler) {
|
| +var recognizer = this.gestures[evType];
|
| +var deps = recognizer.deps;
|
| +var name = recognizer.name;
|
| +var gobj = node[GESTURE_KEY];
|
| +if (!gobj) {
|
| +node[GESTURE_KEY] = gobj = {};
|
| +}
|
| +for (var i = 0, dep, gd; i < deps.length; i++) {
|
| +dep = deps[i];
|
| +gd = gobj[dep];
|
| +if (!gd) {
|
| +gobj[dep] = gd = {};
|
| +node.addEventListener(dep, this.handleNative);
|
| +}
|
| +gd[name] = (gd[name] || 0) + 1;
|
| +}
|
| +node.addEventListener(evType, handler);
|
| +if (recognizer.touchAction) {
|
| +this.setTouchAction(node, recognizer.touchAction);
|
| +}
|
| +},
|
| +remove: function (node, evType, handler) {
|
| +var recognizer = this.gestures[evType];
|
| +var deps = recognizer.deps;
|
| +var name = recognizer.name;
|
| +var gobj = node[GESTURE_KEY];
|
| +if (gobj) {
|
| +for (var i = 0, dep, gd; i < deps.length; i++) {
|
| +dep = deps[i];
|
| +gd = gobj[dep];
|
| +if (gd && gd[name]) {
|
| +gd[name] = (gd[name] || 1) - 1;
|
| +if (gd[name] === 0) {
|
| +node.removeEventListener(dep, this.handleNative);
|
| +}
|
| +}
|
| +}
|
| +}
|
| +node.removeEventListener(evType, handler);
|
| +},
|
| +register: function (recog) {
|
| +this.recognizers.push(recog);
|
| +for (var i = 0; i < recog.emits.length; i++) {
|
| +this.gestures[recog.emits[i]] = recog;
|
| +}
|
| +},
|
| +findRecognizerByEvent: function (evName) {
|
| +for (var i = 0, r; i < this.recognizers.length; i++) {
|
| +r = this.recognizers[i];
|
| +for (var j = 0, n; j < r.emits.length; j++) {
|
| +n = r.emits[j];
|
| +if (n === evName) {
|
| +return r;
|
| +}
|
| +}
|
| +}
|
| +return null;
|
| +},
|
| +setTouchAction: function (node, value) {
|
| +if (HAS_NATIVE_TA) {
|
| +node.style.touchAction = value;
|
| +}
|
| +node[TOUCH_ACTION] = value;
|
| +},
|
| +fire: function (target, type, detail) {
|
| +var ev = Polymer.Base.fire(type, detail, {
|
| +node: target,
|
| +bubbles: true,
|
| +cancelable: true
|
| +});
|
| +if (ev.defaultPrevented) {
|
| +var se = detail.sourceEvent;
|
| +if (se && se.preventDefault) {
|
| +se.preventDefault();
|
| +}
|
| +}
|
| +},
|
| +prevent: function (evName) {
|
| +var recognizer = this.findRecognizerByEvent(evName);
|
| +if (recognizer.info) {
|
| +recognizer.info.prevent = true;
|
| +}
|
| +}
|
| +};
|
| +Gestures.register({
|
| +name: 'downup',
|
| +deps: [
|
| +'mousedown',
|
| +'touchstart',
|
| +'touchend'
|
| +],
|
| +emits: [
|
| +'down',
|
| +'up'
|
| +],
|
| +mousedown: function (e) {
|
| +var t = e.currentTarget;
|
| +var self = this;
|
| +var upfn = function upfn(e) {
|
| +self.fire('up', t, e);
|
| +document.removeEventListener('mouseup', upfn);
|
| +};
|
| +document.addEventListener('mouseup', upfn);
|
| +this.fire('down', t, e);
|
| +},
|
| +touchstart: function (e) {
|
| +this.fire('down', e.currentTarget, e.changedTouches[0]);
|
| +},
|
| +touchend: function (e) {
|
| +this.fire('up', e.currentTarget, e.changedTouches[0]);
|
| +},
|
| +fire: function (type, target, event) {
|
| +var self = this;
|
| +Gestures.fire(target, type, {
|
| +x: event.clientX,
|
| +y: event.clientY,
|
| +sourceEvent: event,
|
| +prevent: Gestures.prevent.bind(Gestures)
|
| +});
|
| +}
|
| +});
|
| +Gestures.register({
|
| +name: 'track',
|
| +touchAction: 'none',
|
| +deps: [
|
| +'mousedown',
|
| +'touchstart',
|
| +'touchmove',
|
| +'touchend'
|
| +],
|
| +emits: ['track'],
|
| +info: {
|
| +x: 0,
|
| +y: 0,
|
| +state: 'start',
|
| +started: false,
|
| +moves: [],
|
| +addMove: function (move) {
|
| +if (this.moves.length > TRACK_LENGTH) {
|
| +this.moves.shift();
|
| +}
|
| +this.moves.push(move);
|
| +},
|
| +prevent: false
|
| +},
|
| +clearInfo: function () {
|
| +this.info.state = 'start';
|
| +this.info.started = false;
|
| +this.info.moves = [];
|
| +this.info.x = 0;
|
| +this.info.y = 0;
|
| +this.info.prevent = false;
|
| +},
|
| +hasMovedEnough: function (x, y) {
|
| +if (this.info.prevent) {
|
| +return false;
|
| +}
|
| +if (this.info.started) {
|
| +return true;
|
| +}
|
| +var dx = Math.abs(this.info.x - x);
|
| +var dy = Math.abs(this.info.y - y);
|
| +return dx >= TRACK_DISTANCE || dy >= TRACK_DISTANCE;
|
| +},
|
| +mousedown: function (e) {
|
| +var t = e.currentTarget;
|
| +var self = this;
|
| +var movefn = function movefn(e) {
|
| +var x = e.clientX, y = e.clientY;
|
| +if (self.hasMovedEnough(x, y)) {
|
| +self.info.state = self.info.started ? e.type === 'mouseup' ? 'end' : 'track' : 'start';
|
| +self.info.addMove({
|
| +x: x,
|
| +y: y
|
| +});
|
| +self.fire(t, e);
|
| +self.info.started = true;
|
| +}
|
| +};
|
| +var upfn = function upfn(e) {
|
| +if (self.info.started) {
|
| +Gestures.prevent('tap');
|
| +movefn(e);
|
| +}
|
| +self.clearInfo();
|
| +document.removeEventListener('mousemove', movefn);
|
| +document.removeEventListener('mouseup', upfn);
|
| +};
|
| +document.addEventListener('mousemove', movefn);
|
| +document.addEventListener('mouseup', upfn);
|
| +this.info.x = e.clientX;
|
| +this.info.y = e.clientY;
|
| +},
|
| +touchstart: function (e) {
|
| +var ct = e.changedTouches[0];
|
| +this.info.x = ct.clientX;
|
| +this.info.y = ct.clientY;
|
| +},
|
| +touchmove: function (e) {
|
| +var t = e.currentTarget;
|
| +var ct = e.changedTouches[0];
|
| +var x = ct.clientX, y = ct.clientY;
|
| +if (this.hasMovedEnough(x, y)) {
|
| +this.info.addMove({
|
| +x: x,
|
| +y: y
|
| +});
|
| +this.fire(t, ct);
|
| +this.info.state = 'track';
|
| +this.info.started = true;
|
| +}
|
| +},
|
| +touchend: function (e) {
|
| +var t = e.currentTarget;
|
| +var ct = e.changedTouches[0];
|
| +if (this.info.started) {
|
| +Gestures.prevent('tap');
|
| +this.info.state = 'end';
|
| +this.info.addMove({
|
| +x: ct.clientX,
|
| +y: ct.clientY
|
| +});
|
| +this.fire(t, ct);
|
| +}
|
| +this.clearInfo();
|
| +},
|
| +fire: function (target, touch) {
|
| +var secondlast = this.info.moves[this.info.moves.length - 2];
|
| +var lastmove = this.info.moves[this.info.moves.length - 1];
|
| +var dx = lastmove.x - this.info.x;
|
| +var dy = lastmove.y - this.info.y;
|
| +var ddx, ddy = 0;
|
| +if (secondlast) {
|
| +ddx = lastmove.x - secondlast.x;
|
| +ddy = lastmove.y - secondlast.y;
|
| +}
|
| +return Gestures.fire(target, 'track', {
|
| +state: this.info.state,
|
| +x: touch.clientX,
|
| +y: touch.clientY,
|
| +dx: dx,
|
| +dy: dy,
|
| +ddx: ddx,
|
| +ddy: ddy,
|
| +sourceEvent: touch,
|
| +hover: function () {
|
| +return Gestures.deepTargetFind(touch.clientX, touch.clientY);
|
| +}
|
| +});
|
| +}
|
| +});
|
| +Gestures.register({
|
| +name: 'tap',
|
| +deps: [
|
| +'mousedown',
|
| +'click',
|
| +'touchstart',
|
| +'touchend'
|
| +],
|
| +emits: ['tap'],
|
| +info: {
|
| +x: NaN,
|
| +y: NaN,
|
| +prevent: false
|
| +},
|
| +reset: function () {
|
| +this.info.x = NaN;
|
| +this.info.y = NaN;
|
| +this.info.prevent = false;
|
| +},
|
| +save: function (e) {
|
| +this.info.x = e.clientX;
|
| +this.info.y = e.clientY;
|
| +},
|
| +mousedown: function (e) {
|
| +this.save(e);
|
| +},
|
| +click: function (e) {
|
| +this.forward(e);
|
| +},
|
| +touchstart: function (e) {
|
| +this.save(e.changedTouches[0]);
|
| +},
|
| +touchend: function (e) {
|
| +this.forward(e.changedTouches[0]);
|
| +},
|
| +forward: function (e) {
|
| +var dx = Math.abs(e.clientX - this.info.x);
|
| +var dy = Math.abs(e.clientY - this.info.y);
|
| +if (isNaN(dx) || isNaN(dy) || dx <= TAP_DISTANCE && dy <= TAP_DISTANCE) {
|
| +if (!this.info.prevent) {
|
| +Gestures.fire(e.target, 'tap', {
|
| +x: e.clientX,
|
| +y: e.clientY,
|
| +sourceEvent: e
|
| +});
|
| +}
|
| +}
|
| +this.reset();
|
| +}
|
| +});
|
| +var DIRECTION_MAP = {
|
| +x: 'pan-x',
|
| +y: 'pan-y',
|
| +none: 'none',
|
| +all: 'auto'
|
| +};
|
| +Polymer.Base._addFeature({
|
| +_listen: function (node, eventName, handler) {
|
| +if (Gestures.gestures[eventName]) {
|
| +Gestures.add(node, eventName, handler);
|
| +} else {
|
| +node.addEventListener(eventName, handler);
|
| +}
|
| +},
|
| +_unlisten: function (node, eventName, handler) {
|
| +if (Gestures.gestures[eventName]) {
|
| +Gestures.remove(node, eventName, handler);
|
| +} else {
|
| +node.removeEventListener(eventName, handler);
|
| +}
|
| +},
|
| +setScrollDirection: function (direction, node) {
|
| +node = node || this;
|
| +Gestures.setTouchAction(node, DIRECTION_MAP[direction] || 'auto');
|
| +}
|
| +});
|
| +Polymer.Gestures = Gestures;
|
| +}());
|
| +Polymer.Async = function () {
|
| +var currVal = 0;
|
| +var lastVal = 0;
|
| +var callbacks = [];
|
| +var twiddle = document.createTextNode('');
|
| +function runAsync(callback, waitTime) {
|
| +if (waitTime > 0) {
|
| +return ~setTimeout(callback, waitTime);
|
| +} else {
|
| +twiddle.textContent = currVal++;
|
| +callbacks.push(callback);
|
| +return currVal - 1;
|
| +}
|
| +}
|
| +function cancelAsync(handle) {
|
| +if (handle < 0) {
|
| +clearTimeout(~handle);
|
| +} else {
|
| +var idx = handle - lastVal;
|
| +if (idx >= 0) {
|
| +if (!callbacks[idx]) {
|
| +throw 'invalid async handle: ' + handle;
|
| +}
|
| +callbacks[idx] = null;
|
| +}
|
| +}
|
| +}
|
| +function atEndOfMicrotask() {
|
| +var len = callbacks.length;
|
| +for (var i = 0; i < len; i++) {
|
| +var cb = callbacks[i];
|
| +if (cb) {
|
| +cb();
|
| +}
|
| +}
|
| +callbacks.splice(0, len);
|
| +lastVal += len;
|
| +}
|
| +new (window.MutationObserver || JsMutationObserver)(atEndOfMicrotask).observe(twiddle, { characterData: true });
|
| +return {
|
| +run: runAsync,
|
| +cancel: cancelAsync
|
| +};
|
| +}();
|
| +Polymer.Debounce = function () {
|
| +var Async = Polymer.Async;
|
| +var Debouncer = function (context) {
|
| +this.context = context;
|
| +this.boundComplete = this.complete.bind(this);
|
| +};
|
| +Debouncer.prototype = {
|
| +go: function (callback, wait) {
|
| +var h;
|
| +this.finish = function () {
|
| +Async.cancel(h);
|
| +};
|
| +h = Async.run(this.boundComplete, wait);
|
| +this.callback = callback;
|
| +},
|
| +stop: function () {
|
| +if (this.finish) {
|
| +this.finish();
|
| +this.finish = null;
|
| +}
|
| +},
|
| +complete: function () {
|
| +if (this.finish) {
|
| +this.stop();
|
| +this.callback.call(this.context);
|
| +}
|
| +}
|
| +};
|
| +function debounce(debouncer, callback, wait) {
|
| +if (debouncer) {
|
| +debouncer.stop();
|
| +} else {
|
| +debouncer = new Debouncer(this);
|
| +}
|
| +debouncer.go(callback, wait);
|
| +return debouncer;
|
| +}
|
| +return debounce;
|
| +}();
|
| +Polymer.Base._addFeature({
|
| +$$: function (slctr) {
|
| +return Polymer.dom(this.root).querySelector(slctr);
|
| +},
|
| +toggleClass: function (name, bool, node) {
|
| +node = node || this;
|
| +if (arguments.length == 1) {
|
| +bool = !node.classList.contains(name);
|
| +}
|
| +if (bool) {
|
| +Polymer.dom(node).classList.add(name);
|
| +} else {
|
| +Polymer.dom(node).classList.remove(name);
|
| +}
|
| +},
|
| +toggleAttribute: function (name, bool, node) {
|
| +node = node || this;
|
| +if (arguments.length == 1) {
|
| +bool = !node.hasAttribute(name);
|
| +}
|
| +if (bool) {
|
| +Polymer.dom(node).setAttribute(name, '');
|
| +} else {
|
| +Polymer.dom(node).removeAttribute(name);
|
| +}
|
| +},
|
| +classFollows: function (name, toElement, fromElement) {
|
| +if (fromElement) {
|
| +Polymer.dom(fromElement).classList.remove(name);
|
| +}
|
| +if (toElement) {
|
| +Polymer.dom(toElement).classList.add(name);
|
| +}
|
| +},
|
| +attributeFollows: function (name, toElement, fromElement) {
|
| +if (fromElement) {
|
| +Polymer.dom(fromElement).removeAttribute(name);
|
| +}
|
| +if (toElement) {
|
| +Polymer.dom(toElement).setAttribute(name, '');
|
| +}
|
| +},
|
| +getContentChildNodes: function (slctr) {
|
| +return Polymer.dom(Polymer.dom(this.root).querySelector(slctr || 'content')).getDistributedNodes();
|
| +},
|
| +getContentChildren: function (slctr) {
|
| +return this.getContentChildNodes(slctr).filter(function (n) {
|
| +return n.nodeType === Node.ELEMENT_NODE;
|
| +});
|
| +},
|
| +fire: function (type, detail, options) {
|
| +options = options || Polymer.nob;
|
| +var node = options.node || this;
|
| +var detail = detail === null || detail === undefined ? Polymer.nob : detail;
|
| +var bubbles = options.bubbles === undefined ? true : options.bubbles;
|
| +var cancelable = Boolean(options.cancelable);
|
| +var event = new CustomEvent(type, {
|
| +bubbles: Boolean(bubbles),
|
| +cancelable: cancelable,
|
| +detail: detail
|
| +});
|
| +node.dispatchEvent(event);
|
| +return event;
|
| +},
|
| +async: function (callback, waitTime) {
|
| +return Polymer.Async.run(callback.bind(this), waitTime);
|
| +},
|
| +cancelAsync: function (handle) {
|
| +Polymer.Async.cancel(handle);
|
| +},
|
| +arrayDelete: function (path, item) {
|
| +var index;
|
| +if (Array.isArray(path)) {
|
| +index = path.indexOf(item);
|
| +if (index >= 0) {
|
| +return path.splice(index, 1);
|
| +}
|
| +} else {
|
| +var arr = this.get(path);
|
| +index = arr.indexOf(item);
|
| +if (index >= 0) {
|
| +return this.splice(path, index, 1);
|
| +}
|
| +}
|
| +},
|
| +transform: function (transform, node) {
|
| +node = node || this;
|
| +node.style.webkitTransform = transform;
|
| +node.style.transform = transform;
|
| +},
|
| +translate3d: function (x, y, z, node) {
|
| +node = node || this;
|
| +this.transform('translate3d(' + x + ',' + y + ',' + z + ')', node);
|
| +},
|
| +importHref: function (href, onload, onerror) {
|
| +var l = document.createElement('link');
|
| +l.rel = 'import';
|
| +l.href = href;
|
| +if (onload) {
|
| +l.onload = onload.bind(this);
|
| +}
|
| +if (onerror) {
|
| +l.onerror = onerror.bind(this);
|
| +}
|
| +document.head.appendChild(l);
|
| +return l;
|
| +},
|
| +create: function (tag, props) {
|
| +var elt = document.createElement(tag);
|
| +if (props) {
|
| +for (var n in props) {
|
| +elt[n] = props[n];
|
| +}
|
| +}
|
| +return elt;
|
| +},
|
| +mixin: function (target, source) {
|
| +for (var i in source) {
|
| +target[i] = source[i];
|
| +}
|
| +}
|
| +});
|
| +Polymer.Bind = {
|
| +prepareModel: function (model) {
|
| +model._propertyEffects = {};
|
| +model._bindListeners = [];
|
| +var api = this._modelApi;
|
| +for (var n in api) {
|
| +model[n] = api[n];
|
| +}
|
| +},
|
| +_modelApi: {
|
| +_notifyChange: function (property) {
|
| +var eventName = Polymer.CaseMap.camelToDashCase(property) + '-changed';
|
| +this.fire(eventName, { value: this[property] }, { bubbles: false });
|
| +},
|
| +_propertySet: function (property, value, effects) {
|
| +var old = this.__data__[property];
|
| +if (old !== value && (old === old || value === value)) {
|
| +this.__data__[property] = value;
|
| +if (typeof value == 'object') {
|
| +this._clearPath(property);
|
| +}
|
| +if (this._propertyChanged) {
|
| +this._propertyChanged(property, value, old);
|
| +}
|
| +if (effects) {
|
| +this._effectEffects(property, value, effects, old);
|
| +}
|
| +}
|
| +return old;
|
| +},
|
| +_effectEffects: function (property, value, effects, old) {
|
| +effects.forEach(function (fx) {
|
| +var fn = Polymer.Bind['_' + fx.kind + 'Effect'];
|
| +if (fn) {
|
| +fn.call(this, property, value, fx.effect, old);
|
| +}
|
| +}, this);
|
| +},
|
| +_clearPath: function (path) {
|
| +for (var prop in this.__data__) {
|
| +if (prop.indexOf(path + '.') === 0) {
|
| +this.__data__[prop] = undefined;
|
| +}
|
| +}
|
| +}
|
| +},
|
| +ensurePropertyEffects: function (model, property) {
|
| +var fx = model._propertyEffects[property];
|
| +if (!fx) {
|
| +fx = model._propertyEffects[property] = [];
|
| +}
|
| +return fx;
|
| +},
|
| +addPropertyEffect: function (model, property, kind, effect) {
|
| +var fx = this.ensurePropertyEffects(model, property);
|
| +fx.push({
|
| +kind: kind,
|
| +effect: effect
|
| +});
|
| +},
|
| +createBindings: function (model) {
|
| +var fx$ = model._propertyEffects;
|
| +if (fx$) {
|
| +for (var n in fx$) {
|
| +var fx = fx$[n];
|
| +fx.sort(this._sortPropertyEffects);
|
| +this._createAccessors(model, n, fx);
|
| +}
|
| +}
|
| +},
|
| +_sortPropertyEffects: function () {
|
| +var EFFECT_ORDER = {
|
| +'compute': 0,
|
| +'annotation': 1,
|
| +'computedAnnotation': 2,
|
| +'reflect': 3,
|
| +'notify': 4,
|
| +'observer': 5,
|
| +'complexObserver': 6,
|
| +'function': 7
|
| +};
|
| +return function (a, b) {
|
| +return EFFECT_ORDER[a.kind] - EFFECT_ORDER[b.kind];
|
| +};
|
| +}(),
|
| +_createAccessors: function (model, property, effects) {
|
| +var defun = {
|
| +get: function () {
|
| +return this.__data__[property];
|
| +}
|
| +};
|
| +var setter = function (value) {
|
| +this._propertySet(property, value, effects);
|
| +};
|
| +if (model.getPropertyInfo && model.getPropertyInfo(property).readOnly) {
|
| +model['_set' + this.upper(property)] = setter;
|
| +} else {
|
| +defun.set = setter;
|
| +}
|
| +Object.defineProperty(model, property, defun);
|
| +},
|
| +upper: function (name) {
|
| +return name[0].toUpperCase() + name.substring(1);
|
| +},
|
| +_addAnnotatedListener: function (model, index, property, path, event) {
|
| +var fn = this._notedListenerFactory(property, path, this._isStructured(path), this._isEventBogus);
|
| +var eventName = event || Polymer.CaseMap.camelToDashCase(property) + '-changed';
|
| +model._bindListeners.push({
|
| +index: index,
|
| +property: property,
|
| +path: path,
|
| +changedFn: fn,
|
| +event: eventName
|
| +});
|
| +},
|
| +_isStructured: function (path) {
|
| +return path.indexOf('.') > 0;
|
| +},
|
| +_isEventBogus: function (e, target) {
|
| +return e.path && e.path[0] !== target;
|
| +},
|
| +_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);
|
| +} else {
|
| +var value = target[property];
|
| +if (!isStructured) {
|
| +this[path] = target[property];
|
| +} else {
|
| +if (this.__data__[path] != value) {
|
| +this.set(path, value);
|
| +}
|
| +}
|
| +}
|
| +}
|
| +};
|
| +},
|
| +prepareInstance: function (inst) {
|
| +inst.__data__ = Object.create(null);
|
| +},
|
| +setupBindListeners: function (inst) {
|
| +inst._bindListeners.forEach(function (info) {
|
| +var node = inst._nodes[info.index];
|
| +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';
|
| +},
|
| +_annotationEffect: function (source, value, effect) {
|
| +if (source != 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);
|
| +}
|
| +},
|
| +_reflectEffect: function (source) {
|
| +this.reflectPropertyToAttribute(source);
|
| +},
|
| +_notifyEffect: function (source) {
|
| +this._notifyChange(source);
|
| +},
|
| +_functionEffect: function (source, value, fn, old) {
|
| +fn.call(this, source, value, old);
|
| +},
|
| +_observerEffect: function (source, value, effect, old) {
|
| +var fn = this[effect.method];
|
| +if (fn) {
|
| +fn.call(this, value, old);
|
| +} else {
|
| +this._warn(this._logf('_observerEffect', 'observer method `' + effect.method + '` not defined'));
|
| +}
|
| +},
|
| +_complexObserverEffect: function (source, value, effect) {
|
| +var fn = this[effect.method];
|
| +if (fn) {
|
| +var args = Polymer.Bind._marshalArgs(this.__data__, effect, source, value);
|
| +if (args) {
|
| +fn.apply(this, args);
|
| +}
|
| +} else {
|
| +this._warn(this._logf('_complexObserverEffect', 'observer method `' + effect.method + '` not defined'));
|
| +}
|
| +},
|
| +_computeEffect: function (source, value, effect) {
|
| +var args = Polymer.Bind._marshalArgs(this.__data__, effect, source, value);
|
| +if (args) {
|
| +var fn = this[effect.method];
|
| +if (fn) {
|
| +this[effect.property] = fn.apply(this, args);
|
| +} else {
|
| +this._warn(this._logf('_computeEffect', 'compute method `' + effect.method + '` not defined'));
|
| +}
|
| +}
|
| +},
|
| +_annotatedComputationEffect: function (source, value, effect) {
|
| +var computedHost = this._rootDataHost || this;
|
| +var fn = computedHost[effect.method];
|
| +if (fn) {
|
| +var args = Polymer.Bind._marshalArgs(this.__data__, effect, source, value);
|
| +if (args) {
|
| +var computedvalue = fn.apply(computedHost, args);
|
| +if (effect.negate) {
|
| +computedvalue = !computedvalue;
|
| +}
|
| +this._applyEffectValue(computedvalue, effect);
|
| +}
|
| +} else {
|
| +computedHost._warn(computedHost._logf('_annotatedComputationEffect', 'compute method `' + effect.method + '` not defined'));
|
| +}
|
| +},
|
| +_marshalArgs: function (model, effect, path, value) {
|
| +var values = [];
|
| +var args = effect.args;
|
| +for (var i = 0, l = args.length; i < l; i++) {
|
| +var arg = args[i];
|
| +var name = arg.name;
|
| +var v;
|
| +if (arg.literal) {
|
| +v = arg.value;
|
| +} else if (arg.structured) {
|
| +v = Polymer.Base.get(name, model);
|
| +} else {
|
| +v = model[name];
|
| +}
|
| +if (args.length > 1 && v === undefined) {
|
| +return;
|
| +}
|
| +if (arg.wildcard) {
|
| +var baseChanged = name.indexOf(path + '.') === 0;
|
| +var matches = effect.trigger.name.indexOf(name) === 0 && !baseChanged;
|
| +values[i] = {
|
| +path: matches ? path : name,
|
| +value: matches ? value : v,
|
| +base: v
|
| +};
|
| +} else {
|
| +values[i] = v;
|
| +}
|
| +}
|
| +return values;
|
| +}
|
| +});
|
| +Polymer.Base._addFeature({
|
| +_addPropertyEffect: function (property, kind, effect) {
|
| +Polymer.Bind.addPropertyEffect(this, property, kind, effect);
|
| +},
|
| +_prepEffects: function () {
|
| +Polymer.Bind.prepareModel(this);
|
| +this._addAnnotationEffects(this._notes);
|
| +},
|
| +_prepBindings: function () {
|
| +Polymer.Bind.createBindings(this);
|
| +},
|
| +_addPropertyEffects: function (properties) {
|
| +if (properties) {
|
| +for (var p in properties) {
|
| +var prop = properties[p];
|
| +if (prop.observer) {
|
| +this._addObserverEffect(p, prop.observer);
|
| +}
|
| +if (prop.computed) {
|
| +this._addComputedEffect(p, prop.computed);
|
| +}
|
| +if (prop.notify) {
|
| +this._addPropertyEffect(p, 'notify');
|
| +}
|
| +if (prop.reflectToAttribute) {
|
| +this._addPropertyEffect(p, 'reflect');
|
| +}
|
| +if (prop.readOnly) {
|
| +Polymer.Bind.ensurePropertyEffects(this, p);
|
| +}
|
| +}
|
| +}
|
| +},
|
| +_addComputedEffect: function (name, expression) {
|
| +var sig = this._parseMethod(expression);
|
| +sig.args.forEach(function (arg) {
|
| +this._addPropertyEffect(arg.model, 'compute', {
|
| +method: sig.method,
|
| +args: sig.args,
|
| +trigger: arg,
|
| +property: name
|
| +});
|
| +}, this);
|
| +},
|
| +_addObserverEffect: function (property, observer) {
|
| +this._addPropertyEffect(property, 'observer', {
|
| +method: observer,
|
| +property: property
|
| +});
|
| +},
|
| +_addComplexObserverEffects: function (observers) {
|
| +if (observers) {
|
| +observers.forEach(function (observer) {
|
| +this._addComplexObserverEffect(observer);
|
| +}, this);
|
| +}
|
| +},
|
| +_addComplexObserverEffect: function (observer) {
|
| +var sig = this._parseMethod(observer);
|
| +sig.args.forEach(function (arg) {
|
| +this._addPropertyEffect(arg.model, 'complexObserver', {
|
| +method: sig.method,
|
| +args: sig.args,
|
| +trigger: arg
|
| +});
|
| +}, this);
|
| +},
|
| +_addAnnotationEffects: function (notes) {
|
| +this._nodes = [];
|
| +notes.forEach(function (note) {
|
| +var index = this._nodes.push(note) - 1;
|
| +note.bindings.forEach(function (binding) {
|
| +this._addAnnotationEffect(binding, index);
|
| +}, this);
|
| +}, this);
|
| +},
|
| +_addAnnotationEffect: function (note, index) {
|
| +if (Polymer.Bind._shouldAddListener(note)) {
|
| +Polymer.Bind._addAnnotatedListener(this, index, note.name, note.value, note.event);
|
| +}
|
| +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;
|
| +if (sig.static) {
|
| +this.__addAnnotatedComputationEffect('__static__', index, note, sig, null);
|
| +} else {
|
| +sig.args.forEach(function (arg) {
|
| +if (!arg.literal) {
|
| +this.__addAnnotatedComputationEffect(arg.model, index, note, sig, arg);
|
| +}
|
| +}, this);
|
| +}
|
| +},
|
| +__addAnnotatedComputationEffect: function (property, index, note, sig, trigger) {
|
| +this._addPropertyEffect(property, 'annotatedComputation', {
|
| +index: index,
|
| +kind: note.kind,
|
| +property: note.name,
|
| +negate: note.negate,
|
| +method: sig.method,
|
| +args: sig.args,
|
| +trigger: trigger
|
| +});
|
| +},
|
| +_parseMethod: function (expression) {
|
| +var m = expression.match(/(\w*)\((.*)\)/);
|
| +if (m) {
|
| +var sig = {
|
| +method: m[1],
|
| +static: true
|
| +};
|
| +if (m[2].trim()) {
|
| +var args = m[2].replace(/\\,/g, ',').split(',');
|
| +return this._parseArgs(args, sig);
|
| +} else {
|
| +sig.args = Polymer.nar;
|
| +return sig;
|
| +}
|
| +}
|
| +},
|
| +_parseArgs: function (argList, sig) {
|
| +sig.args = argList.map(function (rawArg) {
|
| +var arg = this._parseArg(rawArg);
|
| +if (!arg.literal) {
|
| +sig.static = false;
|
| +}
|
| +return arg;
|
| +}, this);
|
| +return sig;
|
| +},
|
| +_parseArg: function (rawArg) {
|
| +var arg = rawArg.trim().replace(/,/g, ',').replace(/\\(.)/g, '$1');
|
| +var a = {
|
| +name: arg,
|
| +model: this._modelForPath(arg)
|
| +};
|
| +var fc = arg[0];
|
| +if (fc >= '0' && fc <= '9') {
|
| +fc = '#';
|
| +}
|
| +switch (fc) {
|
| +case '\'':
|
| +case '"':
|
| +a.value = arg.slice(1, -1);
|
| +a.literal = true;
|
| +break;
|
| +case '#':
|
| +a.value = Number(arg);
|
| +a.literal = true;
|
| +break;
|
| +}
|
| +if (!a.literal) {
|
| +a.structured = arg.indexOf('.') > 0;
|
| +if (a.structured) {
|
| +a.wildcard = arg.slice(-2) == '.*';
|
| +if (a.wildcard) {
|
| +a.name = arg.slice(0, -2);
|
| +}
|
| +}
|
| +}
|
| +return a;
|
| +},
|
| +_marshalInstanceEffects: function () {
|
| +Polymer.Bind.prepareInstance(this);
|
| +Polymer.Bind.setupBindListeners(this);
|
| +},
|
| +_applyEffectValue: function (value, info) {
|
| +var node = this._nodes[info.index];
|
| +var property = info.property || info.name || 'textContent';
|
| +if (info.kind == 'attribute') {
|
| +this.serializeValueToAttribute(value, property, node);
|
| +} else {
|
| +if (property === 'className') {
|
| +value = this._scopeElementClass(node, value);
|
| +}
|
| +if (property === 'textContent' || node.localName == 'input' && property == 'value') {
|
| +value = value == undefined ? '' : value;
|
| +}
|
| +return node[property] = value;
|
| +}
|
| +},
|
| +_executeStaticEffects: function () {
|
| +if (this._propertyEffects.__static__) {
|
| +this._effectEffects('__static__', null, this._propertyEffects.__static__);
|
| +}
|
| +}
|
| +});
|
| +Polymer.Base._addFeature({
|
| +_setupConfigure: function (initialConfig) {
|
| +this._config = initialConfig || {};
|
| +this._handlers = [];
|
| +},
|
| +_marshalAttributes: function () {
|
| +this._takeAttributesToModel(this._config);
|
| +},
|
| +_configValue: function (name, value) {
|
| +this._config[name] = value;
|
| +},
|
| +_beforeClientsReady: function () {
|
| +this._configure();
|
| +},
|
| +_configure: function () {
|
| +this._configureAnnotationReferences();
|
| +var config = {};
|
| +this.behaviors.forEach(function (b) {
|
| +this._configureProperties(b.properties, config);
|
| +}, this);
|
| +this._configureProperties(this.properties, config);
|
| +this._mixinConfigure(config, this._config);
|
| +this._config = config;
|
| +this._distributeConfig(this._config);
|
| +},
|
| +_configureProperties: function (properties, config) {
|
| +for (var i in properties) {
|
| +var c = properties[i];
|
| +if (c.value !== undefined) {
|
| +var value = c.value;
|
| +if (typeof value == 'function') {
|
| +value = value.call(this, this._config);
|
| +}
|
| +config[i] = value;
|
| +}
|
| +}
|
| +},
|
| +_mixinConfigure: function (a, b) {
|
| +for (var prop in b) {
|
| +if (!this.getPropertyInfo(prop).readOnly) {
|
| +a[prop] = b[prop];
|
| +}
|
| +}
|
| +},
|
| +_distributeConfig: function (config) {
|
| +var fx$ = this._propertyEffects;
|
| +if (fx$) {
|
| +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') {
|
| +var node = this._nodes[x.effect.index];
|
| +if (node._configValue) {
|
| +var value = p === x.effect.value ? config[p] : this.get(x.effect.value, config);
|
| +node._configValue(x.effect.name, value);
|
| +}
|
| +}
|
| +}
|
| +}
|
| +}
|
| +}
|
| +},
|
| +_afterClientsReady: function () {
|
| +this._executeStaticEffects();
|
| +this._applyConfig(this._config);
|
| +this._flushHandlers();
|
| +},
|
| +_applyConfig: function (config) {
|
| +for (var n in config) {
|
| +if (this[n] === undefined) {
|
| +var effects = this._propertyEffects[n];
|
| +if (effects) {
|
| +this._propertySet(n, config[n], effects);
|
| +} else {
|
| +this[n] = config[n];
|
| +}
|
| +}
|
| +}
|
| +},
|
| +_notifyListener: function (fn, e) {
|
| +if (!this._clientsReadied) {
|
| +this._queueHandler([
|
| +fn,
|
| +e,
|
| +e.target
|
| +]);
|
| +} else {
|
| +return fn.call(this, e, e.target);
|
| +}
|
| +},
|
| +_queueHandler: function (args) {
|
| +this._handlers.push(args);
|
| +},
|
| +_flushHandlers: function () {
|
| +var h$ = this._handlers;
|
| +for (var i = 0, l = h$.length, h; i < l && (h = h$[i]); i++) {
|
| +h[0].call(this, h[1], h[2]);
|
| +}
|
| +}
|
| +});
|
| +(function () {
|
| +'use strict';
|
| +Polymer.Base._addFeature({
|
| +notifyPath: function (path, value, fromAbove) {
|
| +var old = this._propertySet(path, value);
|
| +if (old !== value && (old === old || value === value)) {
|
| +this._pathEffector(path, value);
|
| +if (!fromAbove) {
|
| +this._notifyPath(path, value);
|
| +}
|
| +}
|
| +},
|
| +_getPathParts: function (path) {
|
| +if (Array.isArray(path)) {
|
| +var parts = [];
|
| +for (var i = 0; i < path.length; i++) {
|
| +var args = path[i].toString().split('.');
|
| +for (var j = 0; j < args.length; j++) {
|
| +parts.push(args[j]);
|
| +}
|
| +}
|
| +return parts;
|
| +} else {
|
| +return path.toString().split('.');
|
| +}
|
| +},
|
| +set: function (path, value, root) {
|
| +var prop = root || this;
|
| +var parts = this._getPathParts(path);
|
| +var array;
|
| +var last = parts[parts.length - 1];
|
| +if (parts.length > 1) {
|
| +for (var i = 0; i < parts.length - 1; i++) {
|
| +prop = prop[parts[i]];
|
| +if (array) {
|
| +parts[i] = Polymer.Collection.get(array).getKey(prop);
|
| +}
|
| +if (!prop) {
|
| +return;
|
| +}
|
| +array = Array.isArray(prop) ? prop : null;
|
| +}
|
| +prop[last] = value;
|
| +if (!root) {
|
| +this.notifyPath(parts.join('.'), value);
|
| +}
|
| +} else {
|
| +prop[path] = value;
|
| +}
|
| +},
|
| +get: function (path, root) {
|
| +var prop = root || this;
|
| +var parts = this._getPathParts(path);
|
| +var last = parts.pop();
|
| +while (parts.length) {
|
| +prop = prop[parts.shift()];
|
| +if (!prop) {
|
| +return;
|
| +}
|
| +}
|
| +return prop[last];
|
| +},
|
| +_pathEffector: function (path, value) {
|
| +var model = this._modelForPath(path);
|
| +var fx$ = this._propertyEffects[model];
|
| +if (fx$) {
|
| +fx$.forEach(function (fx) {
|
| +var fxFn = this['_' + fx.kind + 'PathEffect'];
|
| +if (fxFn) {
|
| +fxFn.call(this, path, value, fx.effect);
|
| +}
|
| +}, this);
|
| +}
|
| +if (this._boundPaths) {
|
| +this._notifyBoundPaths(path, value);
|
| +}
|
| +},
|
| +_annotationPathEffect: function (path, value, effect) {
|
| +if (effect.value === path || effect.value.indexOf(path + '.') === 0) {
|
| +Polymer.Bind._annotationEffect.call(this, path, value, effect);
|
| +} else if (path.indexOf(effect.value + '.') === 0 && !effect.negate) {
|
| +var node = this._nodes[effect.index];
|
| +if (node && node.notifyPath) {
|
| +var p = this._fixPath(effect.name, effect.value, path);
|
| +node.notifyPath(p, value, true);
|
| +}
|
| +}
|
| +},
|
| +_complexObserverPathEffect: function (path, value, effect) {
|
| +if (this._pathMatchesEffect(path, effect)) {
|
| +Polymer.Bind._complexObserverEffect.call(this, path, value, effect);
|
| +}
|
| +},
|
| +_computePathEffect: function (path, value, effect) {
|
| +if (this._pathMatchesEffect(path, effect)) {
|
| +Polymer.Bind._computeEffect.call(this, path, value, effect);
|
| +}
|
| +},
|
| +_annotatedComputationPathEffect: function (path, value, effect) {
|
| +if (this._pathMatchesEffect(path, effect)) {
|
| +Polymer.Bind._annotatedComputationEffect.call(this, path, value, effect);
|
| +}
|
| +},
|
| +_pathMatchesEffect: function (path, effect) {
|
| +var effectArg = effect.trigger.name;
|
| +return effectArg == path || effectArg.indexOf(path + '.') === 0 || effect.trigger.wildcard && path.indexOf(effectArg) === 0;
|
| +},
|
| +linkPaths: function (to, from) {
|
| +this._boundPaths = this._boundPaths || {};
|
| +if (from) {
|
| +this._boundPaths[to] = from;
|
| +} else {
|
| +this.unbindPath(to);
|
| +}
|
| +},
|
| +unlinkPaths: function (path) {
|
| +if (this._boundPaths) {
|
| +delete this._boundPaths[path];
|
| +}
|
| +},
|
| +_notifyBoundPaths: function (path, value) {
|
| +var from, to;
|
| +for (var a in this._boundPaths) {
|
| +var b = this._boundPaths[a];
|
| +if (path.indexOf(a + '.') == 0) {
|
| +from = a;
|
| +to = b;
|
| +break;
|
| +}
|
| +if (path.indexOf(b + '.') == 0) {
|
| +from = b;
|
| +to = a;
|
| +break;
|
| +}
|
| +}
|
| +if (from && to) {
|
| +var p = this._fixPath(to, from, path);
|
| +this.notifyPath(p, value);
|
| +}
|
| +},
|
| +_fixPath: function (property, root, path) {
|
| +return property + path.slice(root.length);
|
| +},
|
| +_notifyPath: function (path, value) {
|
| +var rootName = this._modelForPath(path);
|
| +var dashCaseName = Polymer.CaseMap.camelToDashCase(rootName);
|
| +var eventName = dashCaseName + this._EVENT_CHANGED;
|
| +this.fire(eventName, {
|
| +path: path,
|
| +value: value
|
| +}, { bubbles: false });
|
| +},
|
| +_modelForPath: function (path) {
|
| +var dot = path.indexOf('.');
|
| +return dot < 0 ? path : path.slice(0, dot);
|
| +},
|
| +_EVENT_CHANGED: '-changed',
|
| +_notifySplice: function (array, path, index, added, removed) {
|
| +var splices = [{
|
| +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 args = Array.prototype.slice.call(arguments, 1);
|
| +var len = array.length;
|
| +var ret = array.push.apply(array, args);
|
| +this._notifySplice(array, path, len, args.length, []);
|
| +return ret;
|
| +},
|
| +pop: function (path) {
|
| +var array = this.get(path);
|
| +var args = Array.prototype.slice.call(arguments, 1);
|
| +var rem = array.slice(-1);
|
| +var ret = array.pop.apply(array, args);
|
| +this._notifySplice(array, path, array.length, 0, rem);
|
| +return ret;
|
| +},
|
| +splice: function (path, start, deleteCount) {
|
| +var array = this.get(path);
|
| +var args = Array.prototype.slice.call(arguments, 1);
|
| +var rem = array.slice(start, start + deleteCount);
|
| +var ret = array.splice.apply(array, args);
|
| +this._notifySplice(array, path, start, args.length - 2, rem);
|
| +return ret;
|
| +},
|
| +shift: function (path) {
|
| +var array = this.get(path);
|
| +var args = Array.prototype.slice.call(arguments, 1);
|
| +var ret = array.shift.apply(array, args);
|
| +this._notifySplice(array, path, 0, 0, [ret]);
|
| +return ret;
|
| +},
|
| +unshift: function (path) {
|
| +var array = this.get(path);
|
| +var args = Array.prototype.slice.call(arguments, 1);
|
| +var ret = array.unshift.apply(array, args);
|
| +this._notifySplice(array, path, 0, args.length, []);
|
| +return ret;
|
| +}
|
| +});
|
| +}());
|
| +Polymer.Base._addFeature({
|
| +resolveUrl: function (url) {
|
| +var module = Polymer.DomModule.import(this.is);
|
| +var root = '';
|
| +if (module) {
|
| +var assetPath = module.getAttribute('assetpath') || '';
|
| +root = Polymer.ResolveUrl.resolveUrl(assetPath, module.ownerDocument.baseURI);
|
| +}
|
| +return Polymer.ResolveUrl.resolveUrl(url, root);
|
| +}
|
| +});
|
| +Polymer.CssParse = function () {
|
| +var api = {
|
| +parse: function (text) {
|
| +text = this._clean(text);
|
| +return this._parseCss(this._lex(text), text);
|
| +},
|
| +_clean: function (cssText) {
|
| +return cssText.replace(rx.comments, '').replace(rx.port, '');
|
| +},
|
| +_lex: function (text) {
|
| +var root = {
|
| +start: 0,
|
| +end: text.length
|
| +};
|
| +var n = root;
|
| +for (var i = 0, s = 0, l = text.length; i < l; i++) {
|
| +switch (text[i]) {
|
| +case this.OPEN_BRACE:
|
| +if (!n.rules) {
|
| +n.rules = [];
|
| +}
|
| +var p = n;
|
| +var previous = p.rules[p.rules.length - 1];
|
| +n = {
|
| +start: i + 1,
|
| +parent: p,
|
| +previous: previous
|
| +};
|
| +p.rules.push(n);
|
| +break;
|
| +case this.CLOSE_BRACE:
|
| +n.end = i + 1;
|
| +n = n.parent || root;
|
| +break;
|
| +}
|
| +}
|
| +return root;
|
| +},
|
| +_parseCss: function (node, text) {
|
| +var t = text.substring(node.start, node.end - 1);
|
| +node.parsedCssText = node.cssText = t.trim();
|
| +if (node.parent) {
|
| +var ss = node.previous ? node.previous.end : node.parent.start;
|
| +t = text.substring(ss, node.start - 1);
|
| +t = t.substring(t.lastIndexOf(';') + 1);
|
| +var s = node.parsedSelector = node.selector = t.trim();
|
| +node.atRule = s.indexOf(AT_START) === 0;
|
| +if (node.atRule) {
|
| +if (s.indexOf(MEDIA_START) === 0) {
|
| +node.type = this.types.MEDIA_RULE;
|
| +} else if (s.match(rx.keyframesRule)) {
|
| +node.type = this.types.KEYFRAMES_RULE;
|
| +}
|
| +} else {
|
| +if (s.indexOf(VAR_START) === 0) {
|
| +node.type = this.types.MIXIN_RULE;
|
| +} else {
|
| +node.type = this.types.STYLE_RULE;
|
| +}
|
| +}
|
| +}
|
| +var r$ = node.rules;
|
| +if (r$) {
|
| +for (var i = 0, l = r$.length, r; i < l && (r = r$[i]); i++) {
|
| +this._parseCss(r, text);
|
| +}
|
| +}
|
| +return node;
|
| +},
|
| +stringify: function (node, preserveProperties, text) {
|
| +text = text || '';
|
| +var cssText = '';
|
| +if (node.cssText || node.rules) {
|
| +var r$ = node.rules;
|
| +if (r$ && (preserveProperties || !hasMixinRules(r$))) {
|
| +for (var i = 0, l = r$.length, r; i < l && (r = r$[i]); i++) {
|
| +cssText = this.stringify(r, preserveProperties, cssText);
|
| +}
|
| +} else {
|
| +cssText = preserveProperties ? node.cssText : removeCustomProps(node.cssText);
|
| +cssText = cssText.trim();
|
| +if (cssText) {
|
| +cssText = ' ' + cssText + '\n';
|
| +}
|
| +}
|
| +}
|
| +if (cssText) {
|
| +if (node.selector) {
|
| +text += node.selector + ' ' + this.OPEN_BRACE + '\n';
|
| +}
|
| +text += cssText;
|
| +if (node.selector) {
|
| +text += this.CLOSE_BRACE + '\n\n';
|
| +}
|
| +}
|
| +return text;
|
| +},
|
| +types: {
|
| +STYLE_RULE: 1,
|
| +KEYFRAMES_RULE: 7,
|
| +MEDIA_RULE: 4,
|
| +MIXIN_RULE: 1000
|
| +},
|
| +OPEN_BRACE: '{',
|
| +CLOSE_BRACE: '}'
|
| +};
|
| +function hasMixinRules(rules) {
|
| +return rules[0].selector.indexOf(VAR_START) >= 0;
|
| +}
|
| +function removeCustomProps(cssText) {
|
| +return cssText.replace(rx.customProp, '').replace(rx.mixinProp, '').replace(rx.mixinApply, '').replace(rx.varApply, '');
|
| +}
|
| +var VAR_START = '--';
|
| +var MEDIA_START = '@media';
|
| +var AT_START = '@';
|
| +var rx = {
|
| +comments: /\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,
|
| +port: /@import[^;]*;/gim,
|
| +customProp: /(?:^|[\s;])--[^;{]*?:[^{};]*?;/gim,
|
| +mixinProp: /(?:^|[\s;])--[^;{]*?:[^{;]*?{[^}]*?};?/gim,
|
| +mixinApply: /@apply[\s]*\([^)]*?\)[\s]*;/gim,
|
| +varApply: /[^;:]*?:[^;]*var[^;]*;/gim,
|
| +keyframesRule: /^@[^\s]*keyframes/
|
| +};
|
| +return api;
|
| +}();
|
| +Polymer.StyleUtil = function () {
|
| +return {
|
| +MODULE_STYLES_SELECTOR: 'style, link[rel=import][type~=css]',
|
| +toCssText: function (rules, callback, preserveProperties) {
|
| +if (typeof rules === 'string') {
|
| +rules = this.parser.parse(rules);
|
| +}
|
| +if (callback) {
|
| +this.forEachStyleRule(rules, callback);
|
| +}
|
| +return this.parser.stringify(rules, preserveProperties);
|
| +},
|
| +forRulesInStyles: function (styles, callback) {
|
| +for (var i = 0, l = styles.length, s; i < l && (s = styles[i]); i++) {
|
| +this.forEachStyleRule(this.rulesForStyle(s), callback);
|
| +}
|
| +},
|
| +rulesForStyle: function (style) {
|
| +if (!style.__cssRules && style.textContent) {
|
| +style.__cssRules = this.parser.parse(style.textContent);
|
| +}
|
| +return style.__cssRules;
|
| +},
|
| +clearStyleRules: function (style) {
|
| +style.__cssRules = null;
|
| +},
|
| +forEachStyleRule: function (node, callback) {
|
| +var s = node.selector;
|
| +var skipRules = false;
|
| +if (node.type === this.ruleTypes.STYLE_RULE) {
|
| +callback(node);
|
| +} else if (node.type === this.ruleTypes.KEYFRAMES_RULE || node.type === this.ruleTypes.MIXIN_RULE) {
|
| +skipRules = true;
|
| +}
|
| +var r$ = node.rules;
|
| +if (r$ && !skipRules) {
|
| +for (var i = 0, l = r$.length, r; i < l && (r = r$[i]); i++) {
|
| +this.forEachStyleRule(r, callback);
|
| +}
|
| +}
|
| +},
|
| +applyCss: function (cssText, moniker, target, afterNode) {
|
| +var style = document.createElement('style');
|
| +if (moniker) {
|
| +style.setAttribute('scope', moniker);
|
| +}
|
| +style.textContent = cssText;
|
| +target = target || document.head;
|
| +if (!afterNode) {
|
| +var n$ = target.querySelectorAll('style[scope]');
|
| +afterNode = n$[n$.length - 1];
|
| +}
|
| +target.insertBefore(style, afterNode && afterNode.nextSibling || target.firstChild);
|
| +return style;
|
| +},
|
| +cssFromModule: function (moduleId) {
|
| +var m = Polymer.DomModule.import(moduleId);
|
| +if (m && !m._cssText) {
|
| +var cssText = '';
|
| +var e$ = Array.prototype.slice.call(m.querySelectorAll(this.MODULE_STYLES_SELECTOR));
|
| +for (var i = 0, e; i < e$.length; i++) {
|
| +e = e$[i];
|
| +if (e.localName === 'style') {
|
| +e = e.__appliedElement || e;
|
| +e.parentNode.removeChild(e);
|
| +} else {
|
| +e = e.import && e.import.body;
|
| +}
|
| +if (e) {
|
| +cssText += Polymer.ResolveUrl.resolveCss(e.textContent, e.ownerDocument);
|
| +}
|
| +}
|
| +m._cssText = cssText;
|
| +}
|
| +return m && m._cssText || '';
|
| +},
|
| +parser: Polymer.CssParse,
|
| +ruleTypes: Polymer.CssParse.types
|
| +};
|
| +}();
|
| +Polymer.StyleTransformer = function () {
|
| +var nativeShadow = Polymer.Settings.useNativeShadow;
|
| +var styleUtil = Polymer.StyleUtil;
|
| +var api = {
|
| +dom: function (node, scope, useAttr, shouldRemoveScope) {
|
| +this._transformDom(node, scope || '', useAttr, shouldRemoveScope);
|
| +},
|
| +_transformDom: function (node, selector, useAttr, shouldRemoveScope) {
|
| +if (node.setAttribute) {
|
| +this.element(node, selector, useAttr, shouldRemoveScope);
|
| +}
|
| +var c$ = Polymer.dom(node).childNodes;
|
| +for (var i = 0; i < c$.length; i++) {
|
| +this._transformDom(c$[i], selector, useAttr, shouldRemoveScope);
|
| +}
|
| +},
|
| +element: function (element, scope, useAttr, shouldRemoveScope) {
|
| +if (useAttr) {
|
| +if (shouldRemoveScope) {
|
| +element.removeAttribute(SCOPE_NAME);
|
| +} else {
|
| +element.setAttribute(SCOPE_NAME, scope);
|
| +}
|
| +} else {
|
| +if (scope) {
|
| +if (element.classList) {
|
| +if (shouldRemoveScope) {
|
| +element.classList.remove(SCOPE_NAME);
|
| +element.classList.remove(scope);
|
| +} else {
|
| +element.classList.add(SCOPE_NAME);
|
| +element.classList.add(scope);
|
| +}
|
| +} else if (element.getAttribute) {
|
| +var c = element.getAttribute(CLASS);
|
| +if (shouldRemoveScope) {
|
| +if (c) {
|
| +element.setAttribute(CLASS, c.replace(SCOPE_NAME, '').replace(scope, ''));
|
| +}
|
| +} else {
|
| +element.setAttribute(CLASS, c + (c ? ' ' : '') + SCOPE_NAME + ' ' + scope);
|
| +}
|
| +}
|
| +}
|
| +}
|
| +},
|
| +elementStyles: function (element, callback) {
|
| +var styles = element._styles;
|
| +var cssText = '';
|
| +for (var i = 0, l = styles.length, s, text; i < l && (s = styles[i]); i++) {
|
| +var rules = styleUtil.rulesForStyle(s);
|
| +cssText += nativeShadow ? styleUtil.toCssText(rules, callback) : this.css(rules, element.is, element.extends, callback, element._scopeCssViaAttr) + '\n\n';
|
| +}
|
| +return cssText.trim();
|
| +},
|
| +css: function (rules, scope, ext, callback, useAttr) {
|
| +var hostScope = this._calcHostScope(scope, ext);
|
| +scope = this._calcElementScope(scope, useAttr);
|
| +var self = this;
|
| +return styleUtil.toCssText(rules, function (rule) {
|
| +if (!rule.isScoped) {
|
| +self.rule(rule, scope, hostScope);
|
| +rule.isScoped = true;
|
| +}
|
| +if (callback) {
|
| +callback(rule, scope, hostScope);
|
| +}
|
| +});
|
| +},
|
| +_calcElementScope: function (scope, useAttr) {
|
| +if (scope) {
|
| +return useAttr ? CSS_ATTR_PREFIX + scope + CSS_ATTR_SUFFIX : CSS_CLASS_PREFIX + scope;
|
| +} else {
|
| +return '';
|
| +}
|
| +},
|
| +_calcHostScope: function (scope, ext) {
|
| +return ext ? '[is=' + scope + ']' : scope;
|
| +},
|
| +rule: function (rule, scope, hostScope) {
|
| +this._transformRule(rule, this._transformComplexSelector, scope, hostScope);
|
| +},
|
| +_transformRule: function (rule, transformer, scope, hostScope) {
|
| +var p$ = rule.selector.split(COMPLEX_SELECTOR_SEP);
|
| +for (var i = 0, l = p$.length, p; i < l && (p = p$[i]); i++) {
|
| +p$[i] = transformer.call(this, p, scope, hostScope);
|
| +}
|
| +rule.selector = p$.join(COMPLEX_SELECTOR_SEP);
|
| +},
|
| +_transformComplexSelector: function (selector, scope, hostScope) {
|
| +var stop = false;
|
| +var self = this;
|
| +selector = selector.replace(SIMPLE_SELECTOR_SEP, function (m, c, s) {
|
| +if (!stop) {
|
| +var o = self._transformCompoundSelector(s, c, scope, hostScope);
|
| +if (o.stop) {
|
| +stop = true;
|
| +}
|
| +c = o.combinator;
|
| +s = o.value;
|
| +} else {
|
| +s = s.replace(SCOPE_JUMP, ' ');
|
| +}
|
| +return c + s;
|
| +});
|
| +return selector;
|
| +},
|
| +_transformCompoundSelector: function (selector, combinator, scope, hostScope) {
|
| +var jumpIndex = selector.search(SCOPE_JUMP);
|
| +if (selector.indexOf(HOST) >= 0) {
|
| +selector = selector.replace(HOST_PAREN, function (m, host, paren) {
|
| +return hostScope + paren;
|
| +});
|
| +selector = selector.replace(HOST, hostScope);
|
| +} else if (jumpIndex !== 0) {
|
| +selector = scope ? this._transformSimpleSelector(selector, scope) : selector;
|
| +}
|
| +if (selector.indexOf(CONTENT) >= 0) {
|
| +combinator = '';
|
| +}
|
| +var stop;
|
| +if (jumpIndex >= 0) {
|
| +selector = selector.replace(SCOPE_JUMP, ' ');
|
| +stop = true;
|
| +}
|
| +return {
|
| +value: selector,
|
| +combinator: combinator,
|
| +stop: stop
|
| +};
|
| +},
|
| +_transformSimpleSelector: function (selector, scope) {
|
| +var p$ = selector.split(PSEUDO_PREFIX);
|
| +p$[0] += scope;
|
| +return p$.join(PSEUDO_PREFIX);
|
| +},
|
| +documentRule: function (rule) {
|
| +rule.selector = rule.parsedSelector;
|
| +this.normalizeRootSelector(rule);
|
| +if (!nativeShadow) {
|
| +this._transformRule(rule, this._transformDocumentSelector);
|
| +}
|
| +},
|
| +normalizeRootSelector: function (rule) {
|
| +if (rule.selector === ROOT) {
|
| +rule.selector = 'body';
|
| +}
|
| +},
|
| +_transformDocumentSelector: function (selector) {
|
| +return selector.match(SCOPE_JUMP) ? this._transformComplexSelector(selector, SCOPE_DOC_SELECTOR) : this._transformSimpleSelector(selector.trim(), SCOPE_DOC_SELECTOR);
|
| +},
|
| +SCOPE_NAME: 'style-scope'
|
| +};
|
| +var SCOPE_NAME = api.SCOPE_NAME;
|
| +var SCOPE_DOC_SELECTOR = ':not([' + SCOPE_NAME + '])' + ':not(.' + SCOPE_NAME + ')';
|
| +var COMPLEX_SELECTOR_SEP = ',';
|
| +var SIMPLE_SELECTOR_SEP = /(^|[\s>+~]+)([^\s>+~]+)/g;
|
| +var HOST = ':host';
|
| +var ROOT = ':root';
|
| +var HOST_PAREN = /(\:host)(?:\(((?:\([^)(]*\)|[^)(]*)+?)\))/g;
|
| +var CONTENT = '::content';
|
| +var SCOPE_JUMP = /\:\:content|\:\:shadow|\/deep\//;
|
| +var CSS_CLASS_PREFIX = '.';
|
| +var CSS_ATTR_PREFIX = '[' + SCOPE_NAME + '~=';
|
| +var CSS_ATTR_SUFFIX = ']';
|
| +var PSEUDO_PREFIX = ':';
|
| +var CLASS = 'class';
|
| +return api;
|
| +}();
|
| +Polymer.StyleExtends = function () {
|
| +var styleUtil = Polymer.StyleUtil;
|
| +return {
|
| +hasExtends: function (cssText) {
|
| +return Boolean(cssText.match(this.rx.EXTEND));
|
| +},
|
| +transform: function (style) {
|
| +var rules = styleUtil.rulesForStyle(style);
|
| +var self = this;
|
| +styleUtil.forEachStyleRule(rules, function (rule) {
|
| +var map = self._mapRule(rule);
|
| +if (rule.parent) {
|
| +var m;
|
| +while (m = self.rx.EXTEND.exec(rule.cssText)) {
|
| +var extend = m[1];
|
| +var extendor = self._findExtendor(extend, rule);
|
| +if (extendor) {
|
| +self._extendRule(rule, extendor);
|
| +}
|
| +}
|
| +}
|
| +rule.cssText = rule.cssText.replace(self.rx.EXTEND, '');
|
| +});
|
| +return styleUtil.toCssText(rules, function (rule) {
|
| +if (rule.selector.match(self.rx.STRIP)) {
|
| +rule.cssText = '';
|
| +}
|
| +}, true);
|
| +},
|
| +_mapRule: function (rule) {
|
| +if (rule.parent) {
|
| +var map = rule.parent.map || (rule.parent.map = {});
|
| +var parts = rule.selector.split(',');
|
| +for (var i = 0, p; i < parts.length; i++) {
|
| +p = parts[i];
|
| +map[p.trim()] = rule;
|
| +}
|
| +return map;
|
| +}
|
| +},
|
| +_findExtendor: function (extend, rule) {
|
| +return rule.parent && rule.parent.map && rule.parent.map[extend] || this._findExtendor(extend, rule.parent);
|
| +},
|
| +_extendRule: function (target, source) {
|
| +if (target.parent !== source.parent) {
|
| +this._cloneAndAddRuleToParent(source, target.parent);
|
| +}
|
| +target.extends = target.extends || (target.extends = []);
|
| +target.extends.push(source);
|
| +source.selector = source.selector.replace(this.rx.STRIP, '');
|
| +source.selector = (source.selector && source.selector + ',\n') + target.selector;
|
| +if (source.extends) {
|
| +source.extends.forEach(function (e) {
|
| +this._extendRule(target, e);
|
| +}, this);
|
| +}
|
| +},
|
| +_cloneAndAddRuleToParent: function (rule, parent) {
|
| +rule = Object.create(rule);
|
| +rule.parent = parent;
|
| +if (rule.extends) {
|
| +rule.extends = rule.extends.slice();
|
| +}
|
| +parent.rules.push(rule);
|
| +},
|
| +rx: {
|
| +EXTEND: /@extends\(([^)]*)\)\s*?;/gim,
|
| +STRIP: /%[^,]*$/
|
| +}
|
| +};
|
| +}();
|
| +(function () {
|
| +var prepElement = Polymer.Base._prepElement;
|
| +var nativeShadow = Polymer.Settings.useNativeShadow;
|
| +var styleUtil = Polymer.StyleUtil;
|
| +var styleTransformer = Polymer.StyleTransformer;
|
| +var styleExtends = Polymer.StyleExtends;
|
| +Polymer.Base._addFeature({
|
| +_prepElement: function (element) {
|
| +if (this._encapsulateStyle) {
|
| +styleTransformer.element(element, this.is, this._scopeCssViaAttr);
|
| +}
|
| +prepElement.call(this, element);
|
| +},
|
| +_prepStyles: function () {
|
| +if (this._encapsulateStyle === undefined) {
|
| +this._encapsulateStyle = !nativeShadow && Boolean(this._template);
|
| +}
|
| +this._styles = this._collectStyles();
|
| +var cssText = styleTransformer.elementStyles(this);
|
| +if (cssText && this._template) {
|
| +var style = styleUtil.applyCss(cssText, this.is, nativeShadow ? this._template.content : null);
|
| +if (!nativeShadow) {
|
| +this._scopeStyle = style;
|
| +}
|
| +}
|
| +},
|
| +_collectStyles: function () {
|
| +var styles = [];
|
| +var cssText = '', m$ = this.styleModules;
|
| +if (m$) {
|
| +for (var i = 0, l = m$.length, m; i < l && (m = m$[i]); i++) {
|
| +cssText += styleUtil.cssFromModule(m);
|
| +}
|
| +}
|
| +cssText += styleUtil.cssFromModule(this.is);
|
| +if (cssText) {
|
| +var style = document.createElement('style');
|
| +style.textContent = cssText;
|
| +if (styleExtends.hasExtends(style.textContent)) {
|
| +cssText = styleExtends.transform(style);
|
| +}
|
| +styles.push(style);
|
| +}
|
| +return styles;
|
| +},
|
| +_elementAdd: function (node) {
|
| +if (this._encapsulateStyle) {
|
| +if (node.__styleScoped) {
|
| +node.__styleScoped = false;
|
| +} else {
|
| +styleTransformer.dom(node, this.is, this._scopeCssViaAttr);
|
| +}
|
| +}
|
| +},
|
| +_elementRemove: function (node) {
|
| +if (this._encapsulateStyle) {
|
| +styleTransformer.dom(node, this.is, this._scopeCssViaAttr, true);
|
| +}
|
| +},
|
| +scopeSubtree: function (container, shouldObserve) {
|
| +if (nativeShadow) {
|
| +return;
|
| +}
|
| +var self = this;
|
| +var scopify = function (node) {
|
| +if (node.nodeType === Node.ELEMENT_NODE) {
|
| +node.className = self._scopeElementClass(node, node.className);
|
| +var n$ = node.querySelectorAll('*');
|
| +Array.prototype.forEach.call(n$, function (n) {
|
| +n.className = self._scopeElementClass(n, n.className);
|
| +});
|
| +}
|
| +};
|
| +scopify(container);
|
| +if (shouldObserve) {
|
| +var mo = new MutationObserver(function (mxns) {
|
| +mxns.forEach(function (m) {
|
| +if (m.addedNodes) {
|
| +for (var i = 0; i < m.addedNodes.length; i++) {
|
| +scopify(m.addedNodes[i]);
|
| +}
|
| +}
|
| +});
|
| +});
|
| +mo.observe(container, {
|
| +childList: true,
|
| +subtree: true
|
| +});
|
| +return mo;
|
| +}
|
| +}
|
| +});
|
| +}());
|
| +Polymer.StyleProperties = function () {
|
| +'use strict';
|
| +var nativeShadow = Polymer.Settings.useNativeShadow;
|
| +var matchesSelector = Polymer.DomApi.matchesSelector;
|
| +var styleUtil = Polymer.StyleUtil;
|
| +var styleTransformer = Polymer.StyleTransformer;
|
| +return {
|
| +decorateStyles: function (styles) {
|
| +var self = this, props = {};
|
| +styleUtil.forRulesInStyles(styles, function (rule) {
|
| +self.decorateRule(rule);
|
| +self.collectPropertiesInCssText(rule.propertyInfo.cssText, props);
|
| +});
|
| +var names = [];
|
| +for (var i in props) {
|
| +names.push(i);
|
| +}
|
| +return names;
|
| +},
|
| +decorateRule: function (rule) {
|
| +if (rule.propertyInfo) {
|
| +return rule.propertyInfo;
|
| +}
|
| +var info = {}, properties = {};
|
| +var hasProperties = this.collectProperties(rule, properties);
|
| +if (hasProperties) {
|
| +info.properties = properties;
|
| +rule.rules = null;
|
| +}
|
| +info.cssText = this.collectCssText(rule);
|
| +rule.propertyInfo = info;
|
| +return info;
|
| +},
|
| +collectProperties: function (rule, properties) {
|
| +var info = rule.propertyInfo;
|
| +if (info) {
|
| +if (info.properties) {
|
| +Polymer.Base.mixin(properties, info.properties);
|
| +return true;
|
| +}
|
| +} else {
|
| +var m, rx = this.rx.VAR_ASSIGN;
|
| +var cssText = rule.parsedCssText;
|
| +var any;
|
| +while (m = rx.exec(cssText)) {
|
| +properties[m[1]] = (m[2] || m[3]).trim();
|
| +any = true;
|
| +}
|
| +return any;
|
| +}
|
| +},
|
| +collectCssText: function (rule) {
|
| +var customCssText = '';
|
| +var cssText = rule.parsedCssText;
|
| +cssText = cssText.replace(this.rx.BRACKETED, '').replace(this.rx.VAR_ASSIGN, '');
|
| +var parts = cssText.split(';');
|
| +for (var i = 0, p; i < parts.length; i++) {
|
| +p = parts[i];
|
| +if (p.match(this.rx.MIXIN_MATCH) || p.match(this.rx.VAR_MATCH)) {
|
| +customCssText += p + ';\n';
|
| +}
|
| +}
|
| +return customCssText;
|
| +},
|
| +collectPropertiesInCssText: function (cssText, props) {
|
| +var m;
|
| +while (m = this.rx.VAR_CAPTURE.exec(cssText)) {
|
| +props[m[1]] = true;
|
| +var def = m[2];
|
| +if (def && def.match(this.rx.IS_VAR)) {
|
| +props[def] = true;
|
| +}
|
| +}
|
| +},
|
| +reify: function (props) {
|
| +var names = Object.getOwnPropertyNames(props);
|
| +for (var i = 0, n; i < names.length; i++) {
|
| +n = names[i];
|
| +props[n] = this.valueForProperty(props[n], props);
|
| +}
|
| +},
|
| +valueForProperty: function (property, props) {
|
| +if (property) {
|
| +if (property.indexOf(';') >= 0) {
|
| +property = this.valueForProperties(property, props);
|
| +} else {
|
| +var self = this;
|
| +var fn = function (all, prefix, value, fallback) {
|
| +var propertyValue = self.valueForProperty(props[value], props) || (props[fallback] ? self.valueForProperty(props[fallback], props) : fallback);
|
| +return prefix + (propertyValue || '');
|
| +};
|
| +property = property.replace(this.rx.VAR_MATCH, fn);
|
| +}
|
| +}
|
| +return property && property.trim() || '';
|
| +},
|
| +valueForProperties: function (property, props) {
|
| +var parts = property.split(';');
|
| +for (var i = 0, p, m; i < parts.length && (p = parts[i]); i++) {
|
| +m = p.match(this.rx.MIXIN_MATCH);
|
| +if (m) {
|
| +p = this.valueForProperty(props[m[1]], props);
|
| +} else {
|
| +var pp = p.split(':');
|
| +if (pp[1]) {
|
| +pp[1] = pp[1].trim();
|
| +pp[1] = this.valueForProperty(pp[1], props) || pp[1];
|
| +}
|
| +p = pp.join(':');
|
| +}
|
| +parts[i] = p && p.lastIndexOf(';') === p.length - 1 ? p.slice(0, -1) : p || '';
|
| +}
|
| +return parts.join(';');
|
| +},
|
| +applyProperties: function (rule, props) {
|
| +var output = '';
|
| +if (!rule.propertyInfo) {
|
| +this.decorateRule(rule);
|
| +}
|
| +if (rule.propertyInfo.cssText) {
|
| +output = this.valueForProperties(rule.propertyInfo.cssText, props);
|
| +}
|
| +rule.cssText = output;
|
| +},
|
| +propertyDataFromStyles: function (styles, element) {
|
| +var props = {}, self = this;
|
| +var o = [], i = 0;
|
| +styleUtil.forRulesInStyles(styles, function (rule) {
|
| +if (!rule.propertyInfo) {
|
| +self.decorateRule(rule);
|
| +}
|
| +if (element && rule.propertyInfo.properties && matchesSelector.call(element, rule.selector)) {
|
| +self.collectProperties(rule, props);
|
| +addToBitMask(i, o);
|
| +}
|
| +i++;
|
| +});
|
| +return {
|
| +properties: props,
|
| +key: o
|
| +};
|
| +},
|
| +scopePropertiesFromStyles: function (styles) {
|
| +if (!styles._scopeStyleProperties) {
|
| +styles._scopeStyleProperties = this.selectedPropertiesFromStyles(styles, this.SCOPE_SELECTORS);
|
| +}
|
| +return styles._scopeStyleProperties;
|
| +},
|
| +hostPropertiesFromStyles: function (styles) {
|
| +if (!styles._hostStyleProperties) {
|
| +styles._hostStyleProperties = this.selectedPropertiesFromStyles(styles, this.HOST_SELECTORS);
|
| +}
|
| +return styles._hostStyleProperties;
|
| +},
|
| +selectedPropertiesFromStyles: function (styles, selectors) {
|
| +var props = {}, self = this;
|
| +styleUtil.forRulesInStyles(styles, function (rule) {
|
| +if (!rule.propertyInfo) {
|
| +self.decorateRule(rule);
|
| +}
|
| +for (var i = 0; i < selectors.length; i++) {
|
| +if (rule.parsedSelector === selectors[i]) {
|
| +self.collectProperties(rule, props);
|
| +return;
|
| +}
|
| +}
|
| +});
|
| +return props;
|
| +},
|
| +transformStyles: function (element, properties, scopeSelector) {
|
| +var self = this;
|
| +var hostSelector = styleTransformer._calcHostScope(element.is, element.extends);
|
| +var rxHostSelector = element.extends ? '\\' + hostSelector.slice(0, -1) + '\\]' : hostSelector;
|
| +var hostRx = new RegExp(this.rx.HOST_PREFIX + rxHostSelector + this.rx.HOST_SUFFIX);
|
| +return styleTransformer.elementStyles(element, function (rule) {
|
| +self.applyProperties(rule, properties);
|
| +if (rule.cssText && !nativeShadow) {
|
| +self._scopeSelector(rule, hostRx, hostSelector, element._scopeCssViaAttr, scopeSelector);
|
| +}
|
| +});
|
| +},
|
| +_scopeSelector: function (rule, hostRx, hostSelector, viaAttr, scopeId) {
|
| +rule.transformedSelector = rule.transformedSelector || rule.selector;
|
| +var selector = rule.transformedSelector;
|
| +var scope = viaAttr ? '[' + styleTransformer.SCOPE_NAME + '~=' + scopeId + ']' : '.' + scopeId;
|
| +var parts = selector.split(',');
|
| +for (var i = 0, l = parts.length, p; i < l && (p = parts[i]); i++) {
|
| +parts[i] = p.match(hostRx) ? p.replace(hostSelector, hostSelector + scope) : scope + ' ' + p;
|
| +}
|
| +rule.selector = parts.join(',');
|
| +},
|
| +applyElementScopeSelector: function (element, selector, old, viaAttr) {
|
| +var c = viaAttr ? element.getAttribute(styleTransformer.SCOPE_NAME) : element.className;
|
| +var v = old ? c.replace(old, selector) : (c ? c + ' ' : '') + this.XSCOPE_NAME + ' ' + selector;
|
| +if (c !== v) {
|
| +if (viaAttr) {
|
| +element.setAttribute(styleTransformer.SCOPE_NAME, v);
|
| +} else {
|
| +element.className = v;
|
| +}
|
| +}
|
| +},
|
| +applyElementStyle: function (element, properties, selector, style) {
|
| +var cssText = style ? style.textContent || '' : this.transformStyles(element, properties, selector);
|
| +var s = element._customStyle;
|
| +if (s && !nativeShadow && s !== style) {
|
| +s._useCount--;
|
| +if (s._useCount <= 0) {
|
| +s.parentNode.removeChild(s);
|
| +}
|
| +}
|
| +if (nativeShadow || (!style || !style.parentNode)) {
|
| +if (nativeShadow && element._customStyle) {
|
| +element._customStyle.textContent = cssText;
|
| +style = element._customStyle;
|
| +} else if (cssText) {
|
| +style = styleUtil.applyCss(cssText, selector, nativeShadow ? element.root : null, element._scopeStyle);
|
| +}
|
| +}
|
| +if (style) {
|
| +style._useCount = style._useCount || 0;
|
| +if (element._customStyle != style) {
|
| +style._useCount++;
|
| +}
|
| +element._customStyle = style;
|
| +}
|
| +return style;
|
| +},
|
| +rx: {
|
| +VAR_ASSIGN: /(?:^|;\s*)(--[^\:;]*?):\s*?(?:([^;{]*?)|{([^}]*)})(?=;)/gim,
|
| +MIXIN_MATCH: /(?:^|\W+)@apply[\s]*\(([^)]*)\);?/im,
|
| +VAR_MATCH: /(^|\W+)var\([\s]*([^,)]*)[\s]*,?[\s]*((?:[^,)]*)|(?:[^;]*\([^;)]*\)))[\s]*?\)/gim,
|
| +VAR_CAPTURE: /\([\s]*(--[^,\s)]*)(?:,[\s]*(--[^,\s)]*))?(?:\)|,)/gim,
|
| +IS_VAR: /^--/,
|
| +BRACKETED: /\{[^}]*\}/g,
|
| +HOST_PREFIX: '(?:^|[^.])',
|
| +HOST_SUFFIX: '($|[.:[\\s>+~])'
|
| +},
|
| +HOST_SELECTORS: [':host'],
|
| +SCOPE_SELECTORS: [':root'],
|
| +XSCOPE_NAME: 'x-scope'
|
| +};
|
| +function addToBitMask(n, bits) {
|
| +var o = parseInt(n / 32);
|
| +var v = 1 << n % 32;
|
| +bits[o] = (bits[o] || 0) | v;
|
| +}
|
| +}();
|
| +Polymer.StyleDefaults = function () {
|
| +var styleProperties = Polymer.StyleProperties;
|
| +var styleUtil = Polymer.StyleUtil;
|
| +var api = {
|
| +_styles: [],
|
| +_properties: null,
|
| +addStyle: function (style) {
|
| +this._styles.push(style);
|
| +this._properties = null;
|
| +},
|
| +get _styleProperties() {
|
| +if (!this._properties) {
|
| +styleProperties.decorateStyles(this._styles);
|
| +this._styles._scopeStyleProperties = null;
|
| +this._properties = styleProperties.scopePropertiesFromStyles(this._styles);
|
| +styleProperties.reify(this._properties);
|
| +}
|
| +return this._properties;
|
| +},
|
| +_needsStyleProperties: function () {
|
| +},
|
| +_computeStyleProperties: function () {
|
| +return this._styleProperties;
|
| +},
|
| +updateStyles: function () {
|
| +this._styleCache.clear();
|
| +for (var i = 0, s; i < this._styles.length; i++) {
|
| +s = this._styles[i];
|
| +s = s.__importElement || s;
|
| +s._apply();
|
| +}
|
| +}
|
| +};
|
| +return api;
|
| +}();
|
| +(function () {
|
| +Polymer.StyleCache = function () {
|
| +this.cache = {};
|
| +};
|
| +Polymer.StyleCache.prototype = {
|
| +MAX: 100,
|
| +store: function (is, data, keyValues, keyStyles) {
|
| +data.keyValues = keyValues;
|
| +data.styles = keyStyles;
|
| +var s$ = this.cache[is] = this.cache[is] || [];
|
| +s$.push(data);
|
| +if (s$.length > this.MAX) {
|
| +s$.shift();
|
| +}
|
| +},
|
| +retrieve: function (is, keyValues, keyStyles) {
|
| +var cache = this.cache[is];
|
| +if (cache) {
|
| +for (var i = cache.length - 1, data; i >= 0; i--) {
|
| +data = cache[i];
|
| +if (keyStyles === data.styles && this._objectsEqual(keyValues, data.keyValues)) {
|
| +return data;
|
| +}
|
| +}
|
| +}
|
| +},
|
| +clear: function () {
|
| +this.cache = {};
|
| +},
|
| +_objectsEqual: function (target, source) {
|
| +for (var i in target) {
|
| +if (target[i] !== source[i]) {
|
| +return false;
|
| +}
|
| +}
|
| +if (Array.isArray(target)) {
|
| +return target.length === source.length;
|
| +}
|
| +return true;
|
| +}
|
| +};
|
| +}());
|
| +(function () {
|
| +'use strict';
|
| +var serializeValueToAttribute = Polymer.Base.serializeValueToAttribute;
|
| +var propertyUtils = Polymer.StyleProperties;
|
| +var styleTransformer = Polymer.StyleTransformer;
|
| +var styleUtil = Polymer.StyleUtil;
|
| +var styleDefaults = Polymer.StyleDefaults;
|
| +var nativeShadow = Polymer.Settings.useNativeShadow;
|
| +Polymer.Base._addFeature({
|
| +_prepStyleProperties: function () {
|
| +this._ownStylePropertyNames = this._styles ? propertyUtils.decorateStyles(this._styles) : [];
|
| +},
|
| +_setupStyleProperties: function () {
|
| +this.customStyle = {};
|
| +},
|
| +_needsStyleProperties: function () {
|
| +return Boolean(this._ownStylePropertyNames && this._ownStylePropertyNames.length);
|
| +},
|
| +_beforeAttached: function () {
|
| +if (!this._scopeSelector && this._needsStyleProperties()) {
|
| +this._updateStyleProperties();
|
| +}
|
| +},
|
| +_updateStyleProperties: function () {
|
| +var info, scope = this.domHost || styleDefaults;
|
| +if (!scope._styleCache) {
|
| +scope._styleCache = new Polymer.StyleCache();
|
| +}
|
| +var scopeData = propertyUtils.propertyDataFromStyles(scope._styles, this);
|
| +info = scope._styleCache.retrieve(this.is, scopeData.key, this._styles);
|
| +var scopeCached = Boolean(info);
|
| +if (scopeCached) {
|
| +this._styleProperties = info._styleProperties;
|
| +} else {
|
| +this._computeStyleProperties(scopeData.properties);
|
| +}
|
| +this._computeOwnStyleProperties();
|
| +if (!scopeCached) {
|
| +info = styleCache.retrieve(this.is, this._ownStyleProperties, this._styles);
|
| +}
|
| +var globalCached = Boolean(info) && !scopeCached;
|
| +var style = this._applyStyleProperties(info);
|
| +if (!scopeCached) {
|
| +var cacheableStyle = style;
|
| +if (nativeShadow) {
|
| +cacheableStyle = style.cloneNode ? style.cloneNode(true) : Object.create(style || null);
|
| +}
|
| +info = {
|
| +style: cacheableStyle,
|
| +_scopeSelector: this._scopeSelector,
|
| +_styleProperties: this._styleProperties
|
| +};
|
| +scope._styleCache.store(this.is, info, scopeData.key, this._styles);
|
| +if (!globalCached) {
|
| +styleCache.store(this.is, Object.create(info), this._ownStyleProperties, this._styles);
|
| +}
|
| +}
|
| +},
|
| +_computeStyleProperties: function (scopeProps) {
|
| +var scope = this.domHost || styleDefaults;
|
| +if (!scope._styleProperties) {
|
| +scope._computeStyleProperties();
|
| +}
|
| +var props = Object.create(scope._styleProperties);
|
| +this.mixin(props, propertyUtils.hostPropertiesFromStyles(this._styles));
|
| +scopeProps = scopeProps || propertyUtils.propertyDataFromStyles(scope._styles, this).properties;
|
| +this.mixin(props, scopeProps);
|
| +this.mixin(props, propertyUtils.scopePropertiesFromStyles(this._styles));
|
| +this.mixin(props, this.customStyle);
|
| +propertyUtils.reify(props);
|
| +this._styleProperties = props;
|
| +},
|
| +_computeOwnStyleProperties: function () {
|
| +var props = {};
|
| +for (var i = 0, n; i < this._ownStylePropertyNames.length; i++) {
|
| +n = this._ownStylePropertyNames[i];
|
| +props[n] = this._styleProperties[n];
|
| +}
|
| +this._ownStyleProperties = props;
|
| +},
|
| +_scopeCount: 0,
|
| +_applyStyleProperties: function (info) {
|
| +var oldScopeSelector = this._scopeSelector;
|
| +this._scopeSelector = info ? info._scopeSelector : this.is + '-' + this.__proto__._scopeCount++;
|
| +var style = propertyUtils.applyElementStyle(this, this._styleProperties, this._scopeSelector, info && info.style);
|
| +if ((style || oldScopeSelector) && !nativeShadow) {
|
| +propertyUtils.applyElementScopeSelector(this, this._scopeSelector, oldScopeSelector, this._scopeCssViaAttr);
|
| +}
|
| +return style || {};
|
| +},
|
| +serializeValueToAttribute: function (value, attribute, node) {
|
| +node = node || this;
|
| +if (attribute === 'class') {
|
| +var host = node === this ? this.domHost || this.dataHost : this;
|
| +if (host) {
|
| +value = host._scopeElementClass(node, value);
|
| +}
|
| +}
|
| +node = Polymer.dom(node);
|
| +serializeValueToAttribute.call(this, value, attribute, node);
|
| +},
|
| +_scopeElementClass: function (element, selector) {
|
| +if (!nativeShadow && !this._scopeCssViaAttr) {
|
| +selector += (selector ? ' ' : '') + SCOPE_NAME + ' ' + this.is + (element._scopeSelector ? ' ' + XSCOPE_NAME + ' ' + element._scopeSelector : '');
|
| +}
|
| +return selector;
|
| +},
|
| +updateStyles: function () {
|
| +if (this.isAttached) {
|
| +if (this._needsStyleProperties()) {
|
| +this._updateStyleProperties();
|
| +} else {
|
| +this._styleProperties = null;
|
| +}
|
| +if (this._styleCache) {
|
| +this._styleCache.clear();
|
| +}
|
| +this._updateRootStyles();
|
| +}
|
| +},
|
| +_updateRootStyles: function (root) {
|
| +root = root || this.root;
|
| +var c$ = Polymer.dom(root)._query(function (e) {
|
| +return e.shadyRoot || e.shadowRoot;
|
| +});
|
| +for (var i = 0, l = c$.length, c; i < l && (c = c$[i]); i++) {
|
| +if (c.updateStyles) {
|
| +c.updateStyles();
|
| +}
|
| +}
|
| +}
|
| +});
|
| +Polymer.updateStyles = function () {
|
| +styleDefaults.updateStyles();
|
| +Polymer.Base._updateRootStyles(document);
|
| +};
|
| +var styleCache = new Polymer.StyleCache();
|
| +Polymer.customStyleCache = styleCache;
|
| +var SCOPE_NAME = styleTransformer.SCOPE_NAME;
|
| +var XSCOPE_NAME = propertyUtils.XSCOPE_NAME;
|
| +}());
|
| +Polymer.Base._addFeature({
|
| +_registerFeatures: function () {
|
| +this._prepIs();
|
| +this._prepAttributes();
|
| +this._prepExtends();
|
| +this._prepConstructor();
|
| +this._prepTemplate();
|
| +this._prepStyles();
|
| +this._prepStyleProperties();
|
| +this._prepAnnotations();
|
| +this._prepEffects();
|
| +this._prepBehaviors();
|
| +this._prepBindings();
|
| +this._prepShady();
|
| +},
|
| +_prepBehavior: function (b) {
|
| +this._addPropertyEffects(b.properties);
|
| +this._addComplexObserverEffects(b.observers);
|
| +this._addHostAttributes(b.hostAttributes);
|
| +},
|
| +_initFeatures: function () {
|
| +this._poolContent();
|
| +this._setupConfigure();
|
| +this._setupStyleProperties();
|
| +this._pushHost();
|
| +this._stampTemplate();
|
| +this._popHost();
|
| +this._marshalAnnotationReferences();
|
| +this._marshalHostAttributes();
|
| +this._setupDebouncers();
|
| +this._marshalInstanceEffects();
|
| +this._marshalBehaviors();
|
| +this._marshalAttributes();
|
| +this._tryReady();
|
| +},
|
| +_marshalBehavior: function (b) {
|
| +this._listenListeners(b.listeners);
|
| +}
|
| +});
|
| +(function () {
|
| +var nativeShadow = Polymer.Settings.useNativeShadow;
|
| +var propertyUtils = Polymer.StyleProperties;
|
| +var styleUtil = Polymer.StyleUtil;
|
| +var styleDefaults = Polymer.StyleDefaults;
|
| +var styleTransformer = Polymer.StyleTransformer;
|
| +Polymer({
|
| +is: 'custom-style',
|
| +extends: 'style',
|
| +created: function () {
|
| +this._tryApply();
|
| +},
|
| +attached: function () {
|
| +this._tryApply();
|
| +},
|
| +_tryApply: function () {
|
| +if (!this._appliesToDocument) {
|
| +if (this.parentNode && this.parentNode.localName !== 'dom-module') {
|
| +this._appliesToDocument = true;
|
| +var e = this.__appliedElement || this;
|
| +styleDefaults.addStyle(e);
|
| +if (e.textContent) {
|
| +this._apply();
|
| +} else {
|
| +var observer = new MutationObserver(function () {
|
| +observer.disconnect();
|
| +this._apply();
|
| +}.bind(this));
|
| +observer.observe(e, { childList: true });
|
| +}
|
| +}
|
| +}
|
| +},
|
| +_apply: function () {
|
| +var e = this.__appliedElement || this;
|
| +this._computeStyleProperties();
|
| +var props = this._styleProperties;
|
| +var self = this;
|
| +e.textContent = styleUtil.toCssText(styleUtil.rulesForStyle(e), function (rule) {
|
| +var css = rule.cssText = rule.parsedCssText;
|
| +if (rule.propertyInfo && rule.propertyInfo.cssText) {
|
| +css = css.replace(propertyUtils.rx.VAR_ASSIGN, '');
|
| +rule.cssText = propertyUtils.valueForProperties(css, props);
|
| +}
|
| +styleTransformer.documentRule(rule);
|
| +});
|
| +}
|
| +});
|
| +}());
|
| +Polymer.Templatizer = {
|
| +properties: { _hideTemplateChildren: { observer: '_showHideChildren' } },
|
| +_templatizerStatic: {
|
| +count: 0,
|
| +callbacks: {},
|
| +debouncer: null
|
| +},
|
| +_instanceProps: Polymer.nob,
|
| +created: function () {
|
| +this._templatizerId = this._templatizerStatic.count++;
|
| +},
|
| +templatize: function (template) {
|
| +if (!template._content) {
|
| +template._content = template.content;
|
| +}
|
| +if (template._content._ctor) {
|
| +this.ctor = template._content._ctor;
|
| +this._prepParentProperties(this.ctor.prototype, template);
|
| +return;
|
| +}
|
| +var archetype = Object.create(Polymer.Base);
|
| +this._customPrepAnnotations(archetype, template);
|
| +archetype._prepEffects();
|
| +this._customPrepEffects(archetype);
|
| +archetype._prepBehaviors();
|
| +archetype._prepBindings();
|
| +this._prepParentProperties(archetype, template);
|
| +archetype._notifyPath = this._notifyPathImpl;
|
| +archetype._scopeElementClass = this._scopeElementClassImpl;
|
| +archetype.listen = this._listenImpl;
|
| +var _constructor = this._constructorImpl;
|
| +var ctor = function TemplateInstance(model, host) {
|
| +_constructor.call(this, model, host);
|
| +};
|
| +ctor.prototype = archetype;
|
| +archetype.constructor = ctor;
|
| +template._content._ctor = ctor;
|
| +this.ctor = ctor;
|
| +},
|
| +_getRootDataHost: function () {
|
| +return this.dataHost && this.dataHost._rootDataHost || this.dataHost;
|
| +},
|
| +_showHideChildren: function (hidden) {
|
| +},
|
| +_debounceTemplate: function (fn) {
|
| +this._templatizerStatic.callbacks[this._templatizerId] = fn.bind(this);
|
| +this._templatizerStatic.debouncer = Polymer.Debounce(this._templatizerStatic.debouncer, this._flushTemplates.bind(this, true));
|
| +},
|
| +_flushTemplates: function (debouncerExpired) {
|
| +var db = this._templatizerStatic.debouncer;
|
| +while (debouncerExpired || db && db.finish) {
|
| +db.stop();
|
| +var cbs = this._templatizerStatic.callbacks;
|
| +this._templatizerStatic.callbacks = {};
|
| +for (var id in cbs) {
|
| +cbs[id]();
|
| +}
|
| +debouncerExpired = false;
|
| +}
|
| +},
|
| +_customPrepEffects: function (archetype) {
|
| +var parentProps = archetype._parentProps;
|
| +for (var prop in parentProps) {
|
| +archetype._addPropertyEffect(prop, 'function', this._createHostPropEffector(prop));
|
| +}
|
| +},
|
| +_customPrepAnnotations: function (archetype, template) {
|
| +archetype._template = template;
|
| +var c = template._content;
|
| +if (!c._notes) {
|
| +var rootDataHost = archetype._rootDataHost;
|
| +if (rootDataHost) {
|
| +Polymer.Annotations.prepElement = rootDataHost._prepElement.bind(rootDataHost);
|
| +}
|
| +c._notes = Polymer.Annotations.parseAnnotations(template);
|
| +Polymer.Annotations.prepElement = null;
|
| +this._processAnnotations(c._notes);
|
| +}
|
| +archetype._notes = c._notes;
|
| +archetype._parentProps = c._parentProps;
|
| +},
|
| +_prepParentProperties: function (archetype, template) {
|
| +var parentProps = this._parentProps = archetype._parentProps;
|
| +if (this._forwardParentProp && parentProps) {
|
| +var proto = archetype._parentPropProto;
|
| +var prop;
|
| +if (!proto) {
|
| +for (prop in this._instanceProps) {
|
| +delete parentProps[prop];
|
| +}
|
| +proto = archetype._parentPropProto = Object.create(null);
|
| +if (template != this) {
|
| +Polymer.Bind.prepareModel(proto);
|
| +}
|
| +for (prop in parentProps) {
|
| +var parentProp = '_parent_' + prop;
|
| +var effects = [
|
| +{
|
| +kind: 'function',
|
| +effect: this._createForwardPropEffector(prop)
|
| +},
|
| +{ kind: 'notify' }
|
| +];
|
| +Polymer.Bind._createAccessors(proto, parentProp, effects);
|
| +}
|
| +}
|
| +if (template != this) {
|
| +Polymer.Bind.prepareInstance(template);
|
| +template._forwardParentProp = this._forwardParentProp.bind(this);
|
| +}
|
| +this._extendTemplate(template, proto);
|
| +}
|
| +},
|
| +_createForwardPropEffector: function (prop) {
|
| +return function (source, value) {
|
| +this._forwardParentProp(prop, value);
|
| +};
|
| +},
|
| +_createHostPropEffector: function (prop) {
|
| +return function (source, value) {
|
| +this.dataHost['_parent_' + prop] = value;
|
| +};
|
| +},
|
| +_extendTemplate: function (template, proto) {
|
| +Object.getOwnPropertyNames(proto).forEach(function (n) {
|
| +var val = template[n];
|
| +var pd = Object.getOwnPropertyDescriptor(proto, n);
|
| +Object.defineProperty(template, n, pd);
|
| +if (val !== undefined) {
|
| +template._propertySet(n, val);
|
| +}
|
| +});
|
| +},
|
| +_forwardInstancePath: function (inst, path, value) {
|
| +},
|
| +_notifyPathImpl: function (path, value) {
|
| +var dataHost = this.dataHost;
|
| +var dot = path.indexOf('.');
|
| +var root = dot < 0 ? path : path.slice(0, dot);
|
| +dataHost._forwardInstancePath.call(dataHost, this, path, value);
|
| +if (root in dataHost._parentProps) {
|
| +dataHost.notifyPath('_parent_' + path, value);
|
| +}
|
| +},
|
| +_pathEffector: function (path, value, fromAbove) {
|
| +if (this._forwardParentPath) {
|
| +if (path.indexOf('_parent_') === 0) {
|
| +this._forwardParentPath(path.substring(8), value);
|
| +}
|
| +}
|
| +Polymer.Base._pathEffector.apply(this, arguments);
|
| +},
|
| +_constructorImpl: function (model, host) {
|
| +this._rootDataHost = host._getRootDataHost();
|
| +this._setupConfigure(model);
|
| +this._pushHost(host);
|
| +this.root = this.instanceTemplate(this._template);
|
| +this.root.__styleScoped = true;
|
| +this._popHost();
|
| +this._marshalAnnotatedNodes();
|
| +this._marshalInstanceEffects();
|
| +this._marshalAnnotatedListeners();
|
| +var children = [];
|
| +for (var n = this.root.firstChild; n; n = n.nextSibling) {
|
| +children.push(n);
|
| +n._templateInstance = this;
|
| +}
|
| +this._children = children;
|
| +this._tryReady();
|
| +},
|
| +_listenImpl: function (node, eventName, methodName) {
|
| +var model = this;
|
| +var host = this._rootDataHost;
|
| +var handler = host._createEventHandler(node, eventName, methodName);
|
| +var decorated = function (e) {
|
| +e.model = model;
|
| +handler(e);
|
| +};
|
| +host._listen(node, eventName, decorated);
|
| +},
|
| +_scopeElementClassImpl: function (node, value) {
|
| +var host = this._rootDataHost;
|
| +if (host) {
|
| +return host._scopeElementClass(node, value);
|
| +}
|
| +},
|
| +stamp: function (model) {
|
| +model = model || {};
|
| +if (this._parentProps) {
|
| +for (var prop in this._parentProps) {
|
| +model[prop] = this['_parent_' + prop];
|
| +}
|
| +}
|
| +return new this.ctor(model, this);
|
| +}
|
| +};
|
| +Polymer({
|
| +is: 'dom-template',
|
| +extends: 'template',
|
| +behaviors: [Polymer.Templatizer],
|
| +ready: function () {
|
| +this.templatize(this);
|
| +}
|
| +});
|
| +Polymer._collections = new WeakMap();
|
| +Polymer.Collection = function (userArray) {
|
| +Polymer._collections.set(userArray, this);
|
| +this.userArray = userArray;
|
| +this.store = userArray.slice();
|
| +this.initMap();
|
| +};
|
| +Polymer.Collection.prototype = {
|
| +constructor: Polymer.Collection,
|
| +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);
|
| +} else {
|
| +pmap[item] = i;
|
| +}
|
| +}
|
| +},
|
| +add: function (item) {
|
| +var key = this.store.push(item) - 1;
|
| +if (item && typeof item == 'object') {
|
| +this.omap.set(item, key);
|
| +} else {
|
| +this.pmap[item] = key;
|
| +}
|
| +return key;
|
| +},
|
| +removeKey: function (key) {
|
| +this._removeFromMap(this.store[key]);
|
| +delete this.store[key];
|
| +},
|
| +_removeFromMap: function (item) {
|
| +if (typeof item == 'object') {
|
| +this.omap.delete(item);
|
| +} else {
|
| +delete this.pmap[item];
|
| +}
|
| +},
|
| +remove: function (item) {
|
| +var key = this.getKey(item);
|
| +this.removeKey(key);
|
| +return key;
|
| +},
|
| +getKey: function (item) {
|
| +if (typeof item == 'object') {
|
| +return this.omap.get(item);
|
| +} else {
|
| +return this.pmap[item];
|
| +}
|
| +},
|
| +getKeys: function () {
|
| +return Object.keys(this.store);
|
| +},
|
| +setItem: function (key, value) {
|
| +this.store[key] = value;
|
| +},
|
| +getItem: function (key) {
|
| +return this.store[key];
|
| +},
|
| +getItems: function () {
|
| +var items = [], store = this.store;
|
| +for (var key in store) {
|
| +items.push(store[key]);
|
| +}
|
| +return items;
|
| +},
|
| +_applySplices: function (splices) {
|
| +var keySplices = [];
|
| +for (var i = 0; i < splices.length; i++) {
|
| +var j, o, key, s = splices[i];
|
| +var removed = [];
|
| +for (j = 0; j < s.removed.length; j++) {
|
| +o = s.removed[j];
|
| +key = this.remove(o);
|
| +removed.push(key);
|
| +}
|
| +var added = [];
|
| +for (j = 0; j < s.addedCount; j++) {
|
| +o = this.userArray[s.index + j];
|
| +key = this.add(o);
|
| +added.push(key);
|
| +}
|
| +keySplices.push({
|
| +index: s.index,
|
| +removed: removed,
|
| +removedItems: s.removed,
|
| +added: added
|
| +});
|
| +}
|
| +return keySplices;
|
| +}
|
| +};
|
| +Polymer.Collection.get = function (userArray) {
|
| +return Polymer._collections.get(userArray) || new Polymer.Collection(userArray);
|
| +};
|
| +Polymer.Collection.applySplices = function (userArray, splices) {
|
| +var coll = Polymer._collections.get(userArray);
|
| +return coll ? coll._applySplices(splices) : null;
|
| +};
|
| +Polymer({
|
| +is: 'dom-repeat',
|
| +extends: 'template',
|
| +properties: {
|
| +items: { type: Array },
|
| +as: {
|
| +type: String,
|
| +value: 'item'
|
| +},
|
| +indexAs: {
|
| +type: String,
|
| +value: 'index'
|
| +},
|
| +sort: {
|
| +type: Function,
|
| +observer: '_sortChanged'
|
| +},
|
| +filter: {
|
| +type: Function,
|
| +observer: '_filterChanged'
|
| +},
|
| +observe: {
|
| +type: String,
|
| +observer: '_observeChanged'
|
| +},
|
| +delay: Number
|
| +},
|
| +behaviors: [Polymer.Templatizer],
|
| +observers: ['_itemsChanged(items.*)'],
|
| +detached: function () {
|
| +if (this.rows) {
|
| +for (var i = 0; i < this.rows.length; i++) {
|
| +this._detachRow(i);
|
| +}
|
| +}
|
| +},
|
| +attached: function () {
|
| +if (this.rows) {
|
| +var parentNode = Polymer.dom(this).parentNode;
|
| +for (var i = 0; i < this.rows.length; i++) {
|
| +Polymer.dom(parentNode).insertBefore(this.rows[i].root, this);
|
| +}
|
| +}
|
| +},
|
| +ready: function () {
|
| +this._instanceProps = { __key__: true };
|
| +this._instanceProps[this.as] = true;
|
| +this._instanceProps[this.indexAs] = true;
|
| +if (!this.ctor) {
|
| +this.templatize(this);
|
| +}
|
| +},
|
| +_sortChanged: function () {
|
| +var dataHost = this._getRootDataHost();
|
| +var sort = this.sort;
|
| +this._sortFn = sort && (typeof sort == 'function' ? sort : function () {
|
| +return dataHost[sort].apply(dataHost, arguments);
|
| +});
|
| +this._fullRefresh = true;
|
| +if (this.items) {
|
| +this._debounceTemplate(this._render);
|
| +}
|
| +},
|
| +_filterChanged: function () {
|
| +var dataHost = this._getRootDataHost();
|
| +var filter = this.filter;
|
| +this._filterFn = filter && (typeof filter == 'function' ? filter : function () {
|
| +return dataHost[filter].apply(dataHost, arguments);
|
| +});
|
| +this._fullRefresh = true;
|
| +if (this.items) {
|
| +this._debounceTemplate(this._render);
|
| +}
|
| +},
|
| +_observeChanged: function () {
|
| +this._observePaths = this.observe && this.observe.replace('.*', '.').split(' ');
|
| +},
|
| +_itemsChanged: function (change) {
|
| +if (change.path == 'items') {
|
| +if (Array.isArray(this.items)) {
|
| +this.collection = Polymer.Collection.get(this.items);
|
| +} else if (!this.items) {
|
| +this.collection = null;
|
| +} else {
|
| +this._error(this._logf('dom-repeat', 'expected array for `items`,' + ' found', this.items));
|
| +}
|
| +this._splices = [];
|
| +this._fullRefresh = true;
|
| +this._debounceTemplate(this._render);
|
| +} else if (change.path == 'items.splices') {
|
| +this._splices = this._splices.concat(change.value.keySplices);
|
| +this._debounceTemplate(this._render);
|
| +} else {
|
| +var subpath = change.path.slice(6);
|
| +this._forwardItemPath(subpath, change.value);
|
| +this._checkObservedPaths(subpath);
|
| +}
|
| +},
|
| +_checkObservedPaths: function (path) {
|
| +if (this._observePaths) {
|
| +path = path.substring(path.indexOf('.') + 1);
|
| +var paths = this._observePaths;
|
| +for (var i = 0; i < paths.length; i++) {
|
| +if (path.indexOf(paths[i]) === 0) {
|
| +this._fullRefresh = true;
|
| +if (this.delay) {
|
| +this.debounce('render', this._render, this.delay);
|
| +} else {
|
| +this._debounceTemplate(this._render);
|
| +}
|
| +return;
|
| +}
|
| +}
|
| +}
|
| +},
|
| +render: function () {
|
| +this._fullRefresh = true;
|
| +this.debounce('render', this._render);
|
| +this._flushTemplates();
|
| +},
|
| +_render: function () {
|
| +var c = this.collection;
|
| +if (!this._fullRefresh) {
|
| +if (this._sortFn) {
|
| +this._applySplicesViewSort(this._splices);
|
| +} else {
|
| +if (this._filterFn) {
|
| +this._fullRefresh = true;
|
| +} else {
|
| +this._applySplicesArraySort(this._splices);
|
| +}
|
| +}
|
| +}
|
| +if (this._fullRefresh) {
|
| +this._sortAndFilter();
|
| +this._fullRefresh = false;
|
| +}
|
| +this._splices = [];
|
| +var rowForKey = this._rowForKey = {};
|
| +var keys = this._orderedKeys;
|
| +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];
|
| +rowForKey[key] = i;
|
| +if (!row) {
|
| +this.rows.push(row = this._insertRow(i, null, item));
|
| +}
|
| +row[this.as] = item;
|
| +row.__key__ = key;
|
| +row[this.indexAs] = i;
|
| +}
|
| +for (; i < this.rows.length; i++) {
|
| +this._detachRow(i);
|
| +}
|
| +this.rows.splice(keys.length, this.rows.length - keys.length);
|
| +this.fire('dom-change');
|
| +},
|
| +_sortAndFilter: function () {
|
| +var c = this.collection;
|
| +if (!this._sortFn) {
|
| +this._orderedKeys = [];
|
| +var items = this.items;
|
| +if (items) {
|
| +for (var i = 0; i < items.length; i++) {
|
| +this._orderedKeys.push(c.getKey(items[i]));
|
| +}
|
| +}
|
| +} else {
|
| +this._orderedKeys = c ? c.getKeys() : [];
|
| +}
|
| +if (this._filterFn) {
|
| +this._orderedKeys = this._orderedKeys.filter(function (a) {
|
| +return this._filterFn(c.getItem(a));
|
| +}, this);
|
| +}
|
| +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) {
|
| +for (var i = 0; i < s.removed.length; i++) {
|
| +var idx = this._rowForKey[s.removed[i]];
|
| +if (idx != null) {
|
| +removedRows.push(idx);
|
| +}
|
| +}
|
| +for (var i = 0; i < s.added.length; i++) {
|
| +addedKeys.push(s.added[i]);
|
| +}
|
| +}, this);
|
| +if (removedRows.length) {
|
| +removedRows.sort();
|
| +for (var 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) {
|
| +if (this._filterFn) {
|
| +addedKeys = addedKeys.filter(function (a) {
|
| +return this._filterFn(c.getItem(a));
|
| +}, this);
|
| +}
|
| +addedKeys.sort(function (a, b) {
|
| +return this._sortFn(c.getItem(a), c.getItem(b));
|
| +}.bind(this));
|
| +var start = 0;
|
| +for (var 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);
|
| +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;
|
| +}
|
| +this._orderedKeys.splice(idx, 0, key);
|
| +this.rows.splice(idx, 0, this._insertRow(idx, pool, c.getItem(key)));
|
| +return idx;
|
| +},
|
| +_applySplicesArraySort: function (splices) {
|
| +var keys = this._orderedKeys;
|
| +var pool = [];
|
| +splices.forEach(function (s) {
|
| +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;
|
| +splices.forEach(function (s) {
|
| +var args = [
|
| +s.index,
|
| +s.removed.length
|
| +].concat(s.added);
|
| +keys.splice.apply(keys, args);
|
| +for (var i = 0; i < s.added.length; i++) {
|
| +var item = c.getItem(s.added[i]);
|
| +var row = this._insertRow(s.index + i, pool, item);
|
| +this.rows.splice(s.index + i, 0, row);
|
| +}
|
| +}, 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;
|
| +Polymer.dom(parentNode).insertBefore(row.root, beforeNode);
|
| +return row;
|
| +},
|
| +_generateRow: function (idx, item) {
|
| +var model = { __key__: this.collection.getKey(item) };
|
| +model[this.as] = item;
|
| +model[this.indexAs] = idx;
|
| +var row = this.stamp(model);
|
| +return row;
|
| +},
|
| +_showHideChildren: function (hidden) {
|
| +if (this.rows) {
|
| +for (var i = 0; i < this.rows.length; i++) {
|
| +var c$ = this.rows[i]._children;
|
| +for (var j = 0; j < c$.length; j++) {
|
| +var c = c$[j];
|
| +if (c.style) {
|
| +c.style.display = hidden ? 'none' : '';
|
| +}
|
| +c._hideTemplateChildren = hidden;
|
| +}
|
| +}
|
| +}
|
| +},
|
| +_forwardInstancePath: function (row, path, value) {
|
| +if (path.indexOf(this.as + '.') === 0) {
|
| +this.notifyPath('items.' + row.__key__ + '.' + path.slice(this.as.length + 1), value);
|
| +return true;
|
| +}
|
| +},
|
| +_forwardParentProp: function (prop, value) {
|
| +if (this.rows) {
|
| +this.rows.forEach(function (row) {
|
| +row[prop] = value;
|
| +}, this);
|
| +}
|
| +},
|
| +_forwardParentPath: function (path, value) {
|
| +if (this.rows) {
|
| +this.rows.forEach(function (row) {
|
| +row.notifyPath(path, value, true);
|
| +}, this);
|
| +}
|
| +},
|
| +_forwardItemPath: function (path, value) {
|
| +if (this._rowForKey) {
|
| +var dot = path.indexOf('.');
|
| +var key = path.substring(0, dot < 0 ? path.length : dot);
|
| +var idx = this._rowForKey[key];
|
| +var row = this.rows[idx];
|
| +if (row) {
|
| +if (dot >= 0) {
|
| +path = this.as + '.' + path.substring(dot + 1);
|
| +row.notifyPath(path, value, true);
|
| +} else {
|
| +row[this.as] = value;
|
| +}
|
| +}
|
| +}
|
| +},
|
| +modelForElement: function (el) {
|
| +var model;
|
| +while (el) {
|
| +if (model = el._templateInstance) {
|
| +if (model.dataHost != this) {
|
| +el = model.dataHost;
|
| +} else {
|
| +return model;
|
| +}
|
| +} else {
|
| +el = el.parentNode;
|
| +}
|
| +}
|
| +},
|
| +itemForElement: function (el) {
|
| +var instance = this.modelForElement(el);
|
| +return instance && instance[this.as];
|
| +},
|
| +keyForElement: function (el) {
|
| +var instance = this.modelForElement(el);
|
| +return instance && instance.__key__;
|
| +},
|
| +indexForElement: function (el) {
|
| +var instance = this.modelForElement(el);
|
| +return instance && instance[this.indexAs];
|
| +}
|
| +});
|
| +Polymer({
|
| +is: 'array-selector',
|
| +properties: {
|
| +items: {
|
| +type: Array,
|
| +observer: '_itemsChanged'
|
| +},
|
| +selected: {
|
| +type: Object,
|
| +notify: true
|
| +},
|
| +toggle: Boolean,
|
| +multi: Boolean
|
| +},
|
| +_itemsChanged: function () {
|
| +if (Array.isArray(this.selected)) {
|
| +for (var i = 0; i < this.selected.length; i++) {
|
| +this.unlinkPaths('selected.' + i);
|
| +}
|
| +} else {
|
| +this.unlinkPaths('selected');
|
| +}
|
| +if (this.multi) {
|
| +this.selected = [];
|
| +} else {
|
| +this.selected = null;
|
| +}
|
| +},
|
| +deselect: function (item) {
|
| +if (this.multi) {
|
| +var scol = Polymer.Collection.get(this.selected);
|
| +var sidx = this.selected.indexOf(item);
|
| +if (sidx >= 0) {
|
| +var skey = scol.getKey(item);
|
| +this.splice('selected', sidx, 1);
|
| +this.unlinkPaths('selected.' + skey);
|
| +return true;
|
| +}
|
| +} else {
|
| +this.selected = null;
|
| +this.unlinkPaths('selected');
|
| +}
|
| +},
|
| +select: function (item) {
|
| +var icol = Polymer.Collection.get(this.items);
|
| +var key = icol.getKey(item);
|
| +if (this.multi) {
|
| +var scol = Polymer.Collection.get(this.selected);
|
| +var skey = scol.getKey(item);
|
| +if (skey >= 0) {
|
| +if (this.toggle) {
|
| +this.deselect(item);
|
| +}
|
| +} else {
|
| +this.push('selected', item);
|
| +this.async(function () {
|
| +skey = scol.getKey(item);
|
| +this.linkPaths('selected.' + skey, 'items.' + key);
|
| +});
|
| +}
|
| +} else {
|
| +if (this.toggle && item == this.selected) {
|
| +this.deselect();
|
| +} else {
|
| +this.linkPaths('selected', 'items.' + key);
|
| +this.selected = item;
|
| +}
|
| +}
|
| +}
|
| +});
|
| +Polymer({
|
| +is: 'dom-if',
|
| +extends: 'template',
|
| +properties: {
|
| +'if': {
|
| +type: Boolean,
|
| +value: false
|
| +},
|
| +restamp: {
|
| +type: Boolean,
|
| +value: false
|
| +}
|
| +},
|
| +behaviors: [Polymer.Templatizer],
|
| +observers: ['_queueRender(if, restamp)'],
|
| +_queueRender: function () {
|
| +this._debounceTemplate(this._render);
|
| +},
|
| +detached: function () {
|
| +this._teardownInstance();
|
| +},
|
| +attached: function () {
|
| +if (this.if && this.ctor) {
|
| +this.async(this._ensureInstance);
|
| +}
|
| +},
|
| +render: function () {
|
| +this._flushTemplates();
|
| +},
|
| +_render: function () {
|
| +if (this.if) {
|
| +if (!this.ctor) {
|
| +this._wrapTextNodes(this._content || this.content);
|
| +this.templatize(this);
|
| +}
|
| +this._ensureInstance();
|
| +this._showHideChildren();
|
| +} else if (this.restamp) {
|
| +this._teardownInstance();
|
| +}
|
| +if (!this.restamp && this._instance) {
|
| +this._showHideChildren();
|
| +}
|
| +if (this.if != this._lastIf) {
|
| +this.fire('dom-change');
|
| +this._lastIf = this.if;
|
| +}
|
| +},
|
| +_ensureInstance: function () {
|
| +if (!this._instance) {
|
| +this._instance = this.stamp();
|
| +var root = this._instance.root;
|
| +var parent = Polymer.dom(Polymer.dom(this).parentNode);
|
| +parent.insertBefore(root, this);
|
| +}
|
| +},
|
| +_teardownInstance: function () {
|
| +if (this._instance) {
|
| +var c = this._instance._children;
|
| +if (c) {
|
| +var parent = Polymer.dom(Polymer.dom(c[0]).parentNode);
|
| +c.forEach(function (n) {
|
| +parent.removeChild(n);
|
| +});
|
| +}
|
| +this._instance = null;
|
| +}
|
| +},
|
| +_wrapTextNodes: function (root) {
|
| +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;
|
| +}
|
| +}
|
| +},
|
| +_showHideChildren: function () {
|
| +var hidden = this._hideTemplateChildren || !this.if;
|
| +if (this._instance) {
|
| +var c$ = this._instance._children;
|
| +for (var i = 0; i < c$.length; i++) {
|
| +var c = c$[i];
|
| +c.style.display = hidden ? 'none' : '';
|
| +c._hideTemplateChildren = hidden;
|
| +}
|
| +}
|
| +},
|
| +_forwardParentProp: function (prop, value) {
|
| +if (this._instance) {
|
| +this._instance[prop] = value;
|
| +}
|
| +},
|
| +_forwardParentPath: function (path, value) {
|
| +if (this._instance) {
|
| +this._instance.notifyPath(path, value, true);
|
| +}
|
| +}
|
| +});
|
| +Polymer.ImportStatus = {
|
| +_ready: false,
|
| +_callbacks: [],
|
| +whenLoaded: function (cb) {
|
| +if (this._ready) {
|
| +cb();
|
| +} else {
|
| +this._callbacks.push(cb);
|
| +}
|
| +},
|
| +_importsLoaded: function () {
|
| +this._ready = true;
|
| +this._callbacks.forEach(function (cb) {
|
| +cb();
|
| +});
|
| +this._callbacks = [];
|
| +}
|
| +};
|
| +window.addEventListener('load', function () {
|
| +Polymer.ImportStatus._importsLoaded();
|
| +});
|
| +if (window.HTMLImports) {
|
| +HTMLImports.whenReady(function () {
|
| +Polymer.ImportStatus._importsLoaded();
|
| +});
|
| +}
|
| +Polymer({
|
| +is: 'dom-bind',
|
| +extends: 'template',
|
| +created: function () {
|
| +Polymer.ImportStatus.whenLoaded(this._readySelf.bind(this));
|
| +},
|
| +_registerFeatures: function () {
|
| +this._prepExtends();
|
| +this._prepConstructor();
|
| +},
|
| +_insertChildren: function () {
|
| +var parentDom = Polymer.dom(Polymer.dom(this).parentNode);
|
| +parentDom.insertBefore(this.root, this);
|
| +},
|
| +_removeChildren: function () {
|
| +if (this._children) {
|
| +for (var i = 0; i < this._children.length; i++) {
|
| +this.root.appendChild(this._children[i]);
|
| +}
|
| +}
|
| +},
|
| +_initFeatures: function () {
|
| +},
|
| +_scopeElementClass: function (element, selector) {
|
| +if (this.dataHost) {
|
| +return this.dataHost._scopeElementClass(element, selector);
|
| +} else {
|
| +return selector;
|
| +}
|
| +},
|
| +_prepConfigure: function () {
|
| +var config = {};
|
| +for (var prop in this._propertyEffects) {
|
| +config[prop] = this[prop];
|
| +}
|
| +this._setupConfigure = this._setupConfigure.bind(this, config);
|
| +},
|
| +attached: function () {
|
| +if (!this._children) {
|
| +this._template = this;
|
| +this._prepAnnotations();
|
| +this._prepEffects();
|
| +this._prepBehaviors();
|
| +this._prepConfigure();
|
| +this._prepBindings();
|
| +Polymer.Base._initFeatures.call(this);
|
| +this._children = Array.prototype.slice.call(this.root.childNodes);
|
| +}
|
| +this._insertChildren();
|
| +this.fire('dom-change');
|
| +},
|
| +detached: function () {
|
| +this._removeChildren();
|
| +}
|
| +});</script>
|
|
|
Chromium Code Reviews
Issue 1205703007:
Add polymer 1.0 to npm_modules (Closed)
Base URL: https://chromium.googlesource.com/infra/third_party/npm_modules.git@master