| Index: runtime/bin/vmservice/observatory/deployed/web/packages/shadow_dom/shadow_dom.debug.js
|
| diff --git a/runtime/bin/vmservice/observatory/deployed/web/packages/shadow_dom/shadow_dom.debug.js b/runtime/bin/vmservice/observatory/deployed/web/packages/shadow_dom/shadow_dom.debug.js
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..f411852d5eb1aea73001f3be60b3f21a61691b76
|
| --- /dev/null
|
| +++ b/runtime/bin/vmservice/observatory/deployed/web/packages/shadow_dom/shadow_dom.debug.js
|
| @@ -0,0 +1,7551 @@
|
| +if (!HTMLElement.prototype.createShadowRoot
|
| + || window.__forceShadowDomPolyfill) {
|
| +
|
| +/*
|
| + * Copyright 2013 The Polymer Authors. All rights reserved.
|
| + * Use of this source code is governed by a BSD-style
|
| + * license that can be found in the LICENSE file.
|
| + */
|
| +(function() {
|
| + // TODO(jmesserly): fix dart:html to use unprefixed name
|
| + if (Element.prototype.webkitCreateShadowRoot) {
|
| + Element.prototype.webkitCreateShadowRoot = function() {
|
| + return window.ShadowDOMPolyfill.wrapIfNeeded(this).createShadowRoot();
|
| + };
|
| + }
|
| +})();
|
| +
|
| +// Copyright 2012 Google Inc.
|
| +//
|
| +// Licensed under the Apache License, Version 2.0 (the "License");
|
| +// you may not use this file except in compliance with the License.
|
| +// You may obtain a copy of the License at
|
| +//
|
| +// http://www.apache.org/licenses/LICENSE-2.0
|
| +//
|
| +// Unless required by applicable law or agreed to in writing, software
|
| +// distributed under the License is distributed on an "AS IS" BASIS,
|
| +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
| +// See the License for the specific language governing permissions and
|
| +// limitations under the License.
|
| +
|
| +(function(global) {
|
| + 'use strict';
|
| +
|
| + var PROP_ADD_TYPE = 'add';
|
| + var PROP_UPDATE_TYPE = 'update';
|
| + var PROP_RECONFIGURE_TYPE = 'reconfigure';
|
| + var PROP_DELETE_TYPE = 'delete';
|
| + var ARRAY_SPLICE_TYPE = 'splice';
|
| +
|
| + // Detect and do basic sanity checking on Object/Array.observe.
|
| + function detectObjectObserve() {
|
| + if (typeof Object.observe !== 'function' ||
|
| + typeof Array.observe !== 'function') {
|
| + return false;
|
| + }
|
| +
|
| + var records = [];
|
| +
|
| + function callback(recs) {
|
| + records = recs;
|
| + }
|
| +
|
| + var test = {};
|
| + Object.observe(test, callback);
|
| + test.id = 1;
|
| + test.id = 2;
|
| + delete test.id;
|
| + Object.deliverChangeRecords(callback);
|
| + if (records.length !== 3)
|
| + return false;
|
| +
|
| + // TODO(rafaelw): Remove this when new change record type names make it to
|
| + // chrome release.
|
| + if (records[0].type == 'new' &&
|
| + records[1].type == 'updated' &&
|
| + records[2].type == 'deleted') {
|
| + PROP_ADD_TYPE = 'new';
|
| + PROP_UPDATE_TYPE = 'updated';
|
| + PROP_RECONFIGURE_TYPE = 'reconfigured';
|
| + PROP_DELETE_TYPE = 'deleted';
|
| + } else if (records[0].type != 'add' ||
|
| + records[1].type != 'update' ||
|
| + records[2].type != 'delete') {
|
| + console.error('Unexpected change record names for Object.observe. ' +
|
| + 'Using dirty-checking instead');
|
| + return false;
|
| + }
|
| + Object.unobserve(test, callback);
|
| +
|
| + test = [0];
|
| + Array.observe(test, callback);
|
| + test[1] = 1;
|
| + test.length = 0;
|
| + Object.deliverChangeRecords(callback);
|
| + if (records.length != 2)
|
| + return false;
|
| + if (records[0].type != ARRAY_SPLICE_TYPE ||
|
| + records[1].type != ARRAY_SPLICE_TYPE) {
|
| + return false;
|
| + }
|
| + Array.unobserve(test, callback);
|
| +
|
| + return true;
|
| + }
|
| +
|
| + var hasObserve = detectObjectObserve();
|
| +
|
| + function detectEval() {
|
| + // don't test for eval if document has CSP securityPolicy object and we can see that
|
| + // eval is not supported. This avoids an error message in console even when the exception
|
| + // is caught
|
| + if (global.document &&
|
| + 'securityPolicy' in global.document &&
|
| + !global.document.securityPolicy.allowsEval) {
|
| + return false;
|
| + }
|
| +
|
| + try {
|
| + var f = new Function('', 'return true;');
|
| + return f();
|
| + } catch (ex) {
|
| + return false;
|
| + }
|
| + }
|
| +
|
| + var hasEval = detectEval();
|
| +
|
| + function isIndex(s) {
|
| + return +s === s >>> 0;
|
| + }
|
| +
|
| + function toNumber(s) {
|
| + return +s;
|
| + }
|
| +
|
| + function isObject(obj) {
|
| + return obj === Object(obj);
|
| + }
|
| +
|
| + var numberIsNaN = global.Number.isNaN || function isNaN(value) {
|
| + return typeof value === 'number' && global.isNaN(value);
|
| + }
|
| +
|
| + function areSameValue(left, right) {
|
| + if (left === right)
|
| + return left !== 0 || 1 / left === 1 / right;
|
| + if (numberIsNaN(left) && numberIsNaN(right))
|
| + return true;
|
| +
|
| + return left !== left && right !== right;
|
| + }
|
| +
|
| + var createObject = ('__proto__' in {}) ?
|
| + function(obj) { return obj; } :
|
| + function(obj) {
|
| + var proto = obj.__proto__;
|
| + if (!proto)
|
| + return obj;
|
| + var newObject = Object.create(proto);
|
| + Object.getOwnPropertyNames(obj).forEach(function(name) {
|
| + Object.defineProperty(newObject, name,
|
| + Object.getOwnPropertyDescriptor(obj, name));
|
| + });
|
| + return newObject;
|
| + };
|
| +
|
| + var identStart = '[\$_a-zA-Z]';
|
| + var identPart = '[\$_a-zA-Z0-9]';
|
| + var ident = identStart + '+' + identPart + '*';
|
| + var elementIndex = '(?:[0-9]|[1-9]+[0-9]+)';
|
| + var identOrElementIndex = '(?:' + ident + '|' + elementIndex + ')';
|
| + var path = '(?:' + identOrElementIndex + ')(?:\\s*\\.\\s*' + identOrElementIndex + ')*';
|
| + var pathRegExp = new RegExp('^' + path + '$');
|
| +
|
| + function isPathValid(s) {
|
| + if (typeof s != 'string')
|
| + return false;
|
| + s = s.trim();
|
| +
|
| + if (s == '')
|
| + return true;
|
| +
|
| + if (s[0] == '.')
|
| + return false;
|
| +
|
| + return pathRegExp.test(s);
|
| + }
|
| +
|
| + var constructorIsPrivate = {};
|
| +
|
| + function Path(s, privateToken) {
|
| + if (privateToken !== constructorIsPrivate)
|
| + throw Error('Use Path.get to retrieve path objects');
|
| +
|
| + if (s.trim() == '')
|
| + return this;
|
| +
|
| + if (isIndex(s)) {
|
| + this.push(s);
|
| + return this;
|
| + }
|
| +
|
| + s.split(/\s*\.\s*/).filter(function(part) {
|
| + return part;
|
| + }).forEach(function(part) {
|
| + this.push(part);
|
| + }, this);
|
| +
|
| + if (hasEval && this.length) {
|
| + this.getValueFrom = this.compiledGetValueFromFn();
|
| + }
|
| + }
|
| +
|
| + // TODO(rafaelw): Make simple LRU cache
|
| + var pathCache = {};
|
| +
|
| + function getPath(pathString) {
|
| + if (pathString instanceof Path)
|
| + return pathString;
|
| +
|
| + if (pathString == null)
|
| + pathString = '';
|
| +
|
| + if (typeof pathString !== 'string')
|
| + pathString = String(pathString);
|
| +
|
| + var path = pathCache[pathString];
|
| + if (path)
|
| + return path;
|
| + if (!isPathValid(pathString))
|
| + return invalidPath;
|
| + var path = new Path(pathString, constructorIsPrivate);
|
| + pathCache[pathString] = path;
|
| + return path;
|
| + }
|
| +
|
| + Path.get = getPath;
|
| +
|
| + Path.prototype = createObject({
|
| + __proto__: [],
|
| + valid: true,
|
| +
|
| + toString: function() {
|
| + return this.join('.');
|
| + },
|
| +
|
| + getValueFrom: function(obj, directObserver) {
|
| + for (var i = 0; i < this.length; i++) {
|
| + if (obj == null)
|
| + return;
|
| + obj = obj[this[i]];
|
| + }
|
| + return obj;
|
| + },
|
| +
|
| + iterateObjects: function(obj, observe) {
|
| + for (var i = 0; i < this.length; i++) {
|
| + if (i)
|
| + obj = obj[this[i - 1]];
|
| + if (!obj)
|
| + return;
|
| + observe(obj);
|
| + }
|
| + },
|
| +
|
| + compiledGetValueFromFn: function() {
|
| + var accessors = this.map(function(ident) {
|
| + return isIndex(ident) ? '["' + ident + '"]' : '.' + ident;
|
| + });
|
| +
|
| + var str = '';
|
| + var pathString = 'obj';
|
| + str += 'if (obj != null';
|
| + var i = 0;
|
| + for (; i < (this.length - 1); i++) {
|
| + var ident = this[i];
|
| + pathString += accessors[i];
|
| + str += ' &&\n ' + pathString + ' != null';
|
| + }
|
| + str += ')\n';
|
| +
|
| + pathString += accessors[i];
|
| +
|
| + str += ' return ' + pathString + ';\nelse\n return undefined;';
|
| + return new Function('obj', str);
|
| + },
|
| +
|
| + setValueFrom: function(obj, value) {
|
| + if (!this.length)
|
| + return false;
|
| +
|
| + for (var i = 0; i < this.length - 1; i++) {
|
| + if (!isObject(obj))
|
| + return false;
|
| + obj = obj[this[i]];
|
| + }
|
| +
|
| + if (!isObject(obj))
|
| + return false;
|
| +
|
| + obj[this[i]] = value;
|
| + return true;
|
| + }
|
| + });
|
| +
|
| + var invalidPath = new Path('', constructorIsPrivate);
|
| + invalidPath.valid = false;
|
| + invalidPath.getValueFrom = invalidPath.setValueFrom = function() {};
|
| +
|
| + var MAX_DIRTY_CHECK_CYCLES = 1000;
|
| +
|
| + function dirtyCheck(observer) {
|
| + var cycles = 0;
|
| + while (cycles < MAX_DIRTY_CHECK_CYCLES && observer.check_()) {
|
| + cycles++;
|
| + }
|
| + if (global.testingExposeCycleCount)
|
| + global.dirtyCheckCycleCount = cycles;
|
| +
|
| + return cycles > 0;
|
| + }
|
| +
|
| + function objectIsEmpty(object) {
|
| + for (var prop in object)
|
| + return false;
|
| + return true;
|
| + }
|
| +
|
| + function diffIsEmpty(diff) {
|
| + return objectIsEmpty(diff.added) &&
|
| + objectIsEmpty(diff.removed) &&
|
| + objectIsEmpty(diff.changed);
|
| + }
|
| +
|
| + function diffObjectFromOldObject(object, oldObject) {
|
| + var added = {};
|
| + var removed = {};
|
| + var changed = {};
|
| + var oldObjectHas = {};
|
| +
|
| + for (var prop in oldObject) {
|
| + var newValue = object[prop];
|
| +
|
| + if (newValue !== undefined && newValue === oldObject[prop])
|
| + continue;
|
| +
|
| + if (!(prop in object)) {
|
| + removed[prop] = undefined;
|
| + continue;
|
| + }
|
| +
|
| + if (newValue !== oldObject[prop])
|
| + changed[prop] = newValue;
|
| + }
|
| +
|
| + for (var prop in object) {
|
| + if (prop in oldObject)
|
| + continue;
|
| +
|
| + added[prop] = object[prop];
|
| + }
|
| +
|
| + if (Array.isArray(object) && object.length !== oldObject.length)
|
| + changed.length = object.length;
|
| +
|
| + return {
|
| + added: added,
|
| + removed: removed,
|
| + changed: changed
|
| + };
|
| + }
|
| +
|
| + var eomTasks = [];
|
| + function runEOMTasks() {
|
| + if (!eomTasks.length)
|
| + return false;
|
| +
|
| + for (var i = 0; i < eomTasks.length; i++) {
|
| + eomTasks[i]();
|
| + }
|
| + eomTasks.length = 0;
|
| + return true;
|
| + }
|
| +
|
| + var runEOM = hasObserve ? (function(){
|
| + var eomObj = { pingPong: true };
|
| + var eomRunScheduled = false;
|
| +
|
| + Object.observe(eomObj, function() {
|
| + runEOMTasks();
|
| + eomRunScheduled = false;
|
| + });
|
| +
|
| + return function(fn) {
|
| + eomTasks.push(fn);
|
| + if (!eomRunScheduled) {
|
| + eomRunScheduled = true;
|
| + eomObj.pingPong = !eomObj.pingPong;
|
| + }
|
| + };
|
| + })() :
|
| + (function() {
|
| + return function(fn) {
|
| + eomTasks.push(fn);
|
| + };
|
| + })();
|
| +
|
| + var observedObjectCache = [];
|
| +
|
| + function newObservedObject() {
|
| + var observer;
|
| + var object;
|
| + var discardRecords = false;
|
| + var first = true;
|
| +
|
| + function callback(records) {
|
| + if (observer && observer.state_ === OPENED && !discardRecords)
|
| + observer.check_(records);
|
| + }
|
| +
|
| + return {
|
| + open: function(obs) {
|
| + if (observer)
|
| + throw Error('ObservedObject in use');
|
| +
|
| + if (!first)
|
| + Object.deliverChangeRecords(callback);
|
| +
|
| + observer = obs;
|
| + first = false;
|
| + },
|
| + observe: function(obj, arrayObserve) {
|
| + object = obj;
|
| + if (arrayObserve)
|
| + Array.observe(object, callback);
|
| + else
|
| + Object.observe(object, callback);
|
| + },
|
| + deliver: function(discard) {
|
| + discardRecords = discard;
|
| + Object.deliverChangeRecords(callback);
|
| + discardRecords = false;
|
| + },
|
| + close: function() {
|
| + observer = undefined;
|
| + Object.unobserve(object, callback);
|
| + observedObjectCache.push(this);
|
| + }
|
| + };
|
| + }
|
| +
|
| + function getObservedObject(observer, object, arrayObserve) {
|
| + var dir = observedObjectCache.pop() || newObservedObject();
|
| + dir.open(observer);
|
| + dir.observe(object, arrayObserve);
|
| + return dir;
|
| + }
|
| +
|
| + var emptyArray = [];
|
| + var observedSetCache = [];
|
| +
|
| + function newObservedSet() {
|
| + var observers = [];
|
| + var observerCount = 0;
|
| + var objects = [];
|
| + var toRemove = emptyArray;
|
| + var resetNeeded = false;
|
| + var resetScheduled = false;
|
| +
|
| + function observe(obj) {
|
| + if (!isObject(obj))
|
| + return;
|
| +
|
| + var index = toRemove.indexOf(obj);
|
| + if (index >= 0) {
|
| + toRemove[index] = undefined;
|
| + objects.push(obj);
|
| + } else if (objects.indexOf(obj) < 0) {
|
| + objects.push(obj);
|
| + Object.observe(obj, callback);
|
| + }
|
| +
|
| + observe(Object.getPrototypeOf(obj));
|
| + }
|
| +
|
| + function reset() {
|
| + resetScheduled = false;
|
| + if (!resetNeeded)
|
| + return;
|
| +
|
| + var objs = toRemove === emptyArray ? [] : toRemove;
|
| + toRemove = objects;
|
| + objects = objs;
|
| +
|
| + var observer;
|
| + for (var id in observers) {
|
| + observer = observers[id];
|
| + if (!observer || observer.state_ != OPENED)
|
| + continue;
|
| +
|
| + observer.iterateObjects_(observe);
|
| + }
|
| +
|
| + for (var i = 0; i < toRemove.length; i++) {
|
| + var obj = toRemove[i];
|
| + if (obj)
|
| + Object.unobserve(obj, callback);
|
| + }
|
| +
|
| + toRemove.length = 0;
|
| + }
|
| +
|
| + function scheduleReset() {
|
| + if (resetScheduled)
|
| + return;
|
| +
|
| + resetNeeded = true;
|
| + resetScheduled = true;
|
| + runEOM(reset);
|
| + }
|
| +
|
| + function callback() {
|
| + var observer;
|
| +
|
| + for (var id in observers) {
|
| + observer = observers[id];
|
| + if (!observer || observer.state_ != OPENED)
|
| + continue;
|
| +
|
| + observer.check_();
|
| + }
|
| +
|
| + scheduleReset();
|
| + }
|
| +
|
| + var record = {
|
| + object: undefined,
|
| + objects: objects,
|
| + open: function(obs) {
|
| + observers[obs.id_] = obs;
|
| + observerCount++;
|
| + obs.iterateObjects_(observe);
|
| + },
|
| + close: function(obs) {
|
| + var anyLeft = false;
|
| +
|
| + observers[obs.id_] = undefined;
|
| + observerCount--;
|
| +
|
| + if (observerCount) {
|
| + scheduleReset();
|
| + return;
|
| + }
|
| + resetNeeded = false;
|
| +
|
| + for (var i = 0; i < objects.length; i++) {
|
| + Object.unobserve(objects[i], callback);
|
| + Observer.unobservedCount++;
|
| + }
|
| +
|
| + observers.length = 0;
|
| + objects.length = 0;
|
| + observedSetCache.push(this);
|
| + },
|
| + reset: scheduleReset
|
| + };
|
| +
|
| + return record;
|
| + }
|
| +
|
| + var lastObservedSet;
|
| +
|
| + function getObservedSet(observer, obj) {
|
| + if (!lastObservedSet || lastObservedSet.object !== obj) {
|
| + lastObservedSet = observedSetCache.pop() || newObservedSet();
|
| + lastObservedSet.object = obj;
|
| + }
|
| + lastObservedSet.open(observer);
|
| + return lastObservedSet;
|
| + }
|
| +
|
| + var UNOPENED = 0;
|
| + var OPENED = 1;
|
| + var CLOSED = 2;
|
| + var RESETTING = 3;
|
| +
|
| + var nextObserverId = 1;
|
| +
|
| + function Observer() {
|
| + this.state_ = UNOPENED;
|
| + this.callback_ = undefined;
|
| + this.target_ = undefined; // TODO(rafaelw): Should be WeakRef
|
| + this.directObserver_ = undefined;
|
| + this.value_ = undefined;
|
| + this.id_ = nextObserverId++;
|
| + }
|
| +
|
| + Observer.prototype = {
|
| + open: function(callback, target) {
|
| + if (this.state_ != UNOPENED)
|
| + throw Error('Observer has already been opened.');
|
| +
|
| + addToAll(this);
|
| + this.callback_ = callback;
|
| + this.target_ = target;
|
| + this.state_ = OPENED;
|
| + this.connect_();
|
| + return this.value_;
|
| + },
|
| +
|
| + close: function() {
|
| + if (this.state_ != OPENED)
|
| + return;
|
| +
|
| + removeFromAll(this);
|
| + this.state_ = CLOSED;
|
| + this.disconnect_();
|
| + this.value_ = undefined;
|
| + this.callback_ = undefined;
|
| + this.target_ = undefined;
|
| + },
|
| +
|
| + deliver: function() {
|
| + if (this.state_ != OPENED)
|
| + return;
|
| +
|
| + dirtyCheck(this);
|
| + },
|
| +
|
| + report_: function(changes) {
|
| + try {
|
| + this.callback_.apply(this.target_, changes);
|
| + } catch (ex) {
|
| + Observer._errorThrownDuringCallback = true;
|
| + console.error('Exception caught during observer callback: ' +
|
| + (ex.stack || ex));
|
| + }
|
| + },
|
| +
|
| + discardChanges: function() {
|
| + this.check_(undefined, true);
|
| + return this.value_;
|
| + }
|
| + }
|
| +
|
| + var collectObservers = !hasObserve;
|
| + var allObservers;
|
| + Observer._allObserversCount = 0;
|
| +
|
| + if (collectObservers) {
|
| + allObservers = [];
|
| + }
|
| +
|
| + function addToAll(observer) {
|
| + Observer._allObserversCount++;
|
| + if (!collectObservers)
|
| + return;
|
| +
|
| + allObservers.push(observer);
|
| + }
|
| +
|
| + function removeFromAll(observer) {
|
| + Observer._allObserversCount--;
|
| + }
|
| +
|
| + var runningMicrotaskCheckpoint = false;
|
| +
|
| + var hasDebugForceFullDelivery = typeof Object.deliverAllChangeRecords == 'function';
|
| +
|
| + global.Platform = global.Platform || {};
|
| +
|
| + global.Platform.performMicrotaskCheckpoint = function() {
|
| + if (runningMicrotaskCheckpoint)
|
| + return;
|
| +
|
| + if (hasDebugForceFullDelivery) {
|
| + Object.deliverAllChangeRecords();
|
| + return;
|
| + }
|
| +
|
| + if (!collectObservers)
|
| + return;
|
| +
|
| + runningMicrotaskCheckpoint = true;
|
| +
|
| + var cycles = 0;
|
| + var anyChanged, toCheck;
|
| +
|
| + do {
|
| + cycles++;
|
| + toCheck = allObservers;
|
| + allObservers = [];
|
| + anyChanged = false;
|
| +
|
| + for (var i = 0; i < toCheck.length; i++) {
|
| + var observer = toCheck[i];
|
| + if (observer.state_ != OPENED)
|
| + continue;
|
| +
|
| + if (observer.check_())
|
| + anyChanged = true;
|
| +
|
| + allObservers.push(observer);
|
| + }
|
| + if (runEOMTasks())
|
| + anyChanged = true;
|
| + } while (cycles < MAX_DIRTY_CHECK_CYCLES && anyChanged);
|
| +
|
| + if (global.testingExposeCycleCount)
|
| + global.dirtyCheckCycleCount = cycles;
|
| +
|
| + runningMicrotaskCheckpoint = false;
|
| + };
|
| +
|
| + if (collectObservers) {
|
| + global.Platform.clearObservers = function() {
|
| + allObservers = [];
|
| + };
|
| + }
|
| +
|
| + function ObjectObserver(object) {
|
| + Observer.call(this);
|
| + this.value_ = object;
|
| + this.oldObject_ = undefined;
|
| + }
|
| +
|
| + ObjectObserver.prototype = createObject({
|
| + __proto__: Observer.prototype,
|
| +
|
| + arrayObserve: false,
|
| +
|
| + connect_: function(callback, target) {
|
| + if (hasObserve) {
|
| + this.directObserver_ = getObservedObject(this, this.value_,
|
| + this.arrayObserve);
|
| + } else {
|
| + this.oldObject_ = this.copyObject(this.value_);
|
| + }
|
| +
|
| + },
|
| +
|
| + copyObject: function(object) {
|
| + var copy = Array.isArray(object) ? [] : {};
|
| + for (var prop in object) {
|
| + copy[prop] = object[prop];
|
| + };
|
| + if (Array.isArray(object))
|
| + copy.length = object.length;
|
| + return copy;
|
| + },
|
| +
|
| + check_: function(changeRecords, skipChanges) {
|
| + var diff;
|
| + var oldValues;
|
| + if (hasObserve) {
|
| + if (!changeRecords)
|
| + return false;
|
| +
|
| + oldValues = {};
|
| + diff = diffObjectFromChangeRecords(this.value_, changeRecords,
|
| + oldValues);
|
| + } else {
|
| + oldValues = this.oldObject_;
|
| + diff = diffObjectFromOldObject(this.value_, this.oldObject_);
|
| + }
|
| +
|
| + if (diffIsEmpty(diff))
|
| + return false;
|
| +
|
| + if (!hasObserve)
|
| + this.oldObject_ = this.copyObject(this.value_);
|
| +
|
| + this.report_([
|
| + diff.added || {},
|
| + diff.removed || {},
|
| + diff.changed || {},
|
| + function(property) {
|
| + return oldValues[property];
|
| + }
|
| + ]);
|
| +
|
| + return true;
|
| + },
|
| +
|
| + disconnect_: function() {
|
| + if (hasObserve) {
|
| + this.directObserver_.close();
|
| + this.directObserver_ = undefined;
|
| + } else {
|
| + this.oldObject_ = undefined;
|
| + }
|
| + },
|
| +
|
| + deliver: function() {
|
| + if (this.state_ != OPENED)
|
| + return;
|
| +
|
| + if (hasObserve)
|
| + this.directObserver_.deliver(false);
|
| + else
|
| + dirtyCheck(this);
|
| + },
|
| +
|
| + discardChanges: function() {
|
| + if (this.directObserver_)
|
| + this.directObserver_.deliver(true);
|
| + else
|
| + this.oldObject_ = this.copyObject(this.value_);
|
| +
|
| + return this.value_;
|
| + }
|
| + });
|
| +
|
| + function ArrayObserver(array) {
|
| + if (!Array.isArray(array))
|
| + throw Error('Provided object is not an Array');
|
| + ObjectObserver.call(this, array);
|
| + }
|
| +
|
| + ArrayObserver.prototype = createObject({
|
| +
|
| + __proto__: ObjectObserver.prototype,
|
| +
|
| + arrayObserve: true,
|
| +
|
| + copyObject: function(arr) {
|
| + return arr.slice();
|
| + },
|
| +
|
| + check_: function(changeRecords) {
|
| + var splices;
|
| + if (hasObserve) {
|
| + if (!changeRecords)
|
| + return false;
|
| + splices = projectArraySplices(this.value_, changeRecords);
|
| + } else {
|
| + splices = calcSplices(this.value_, 0, this.value_.length,
|
| + this.oldObject_, 0, this.oldObject_.length);
|
| + }
|
| +
|
| + if (!splices || !splices.length)
|
| + return false;
|
| +
|
| + if (!hasObserve)
|
| + this.oldObject_ = this.copyObject(this.value_);
|
| +
|
| + this.report_([splices]);
|
| + return true;
|
| + }
|
| + });
|
| +
|
| + ArrayObserver.applySplices = function(previous, current, splices) {
|
| + splices.forEach(function(splice) {
|
| + var spliceArgs = [splice.index, splice.removed.length];
|
| + var addIndex = splice.index;
|
| + while (addIndex < splice.index + splice.addedCount) {
|
| + spliceArgs.push(current[addIndex]);
|
| + addIndex++;
|
| + }
|
| +
|
| + Array.prototype.splice.apply(previous, spliceArgs);
|
| + });
|
| + };
|
| +
|
| + function PathObserver(object, path) {
|
| + Observer.call(this);
|
| +
|
| + this.object_ = object;
|
| + this.path_ = path instanceof Path ? path : getPath(path);
|
| + this.directObserver_ = undefined;
|
| + }
|
| +
|
| + PathObserver.prototype = createObject({
|
| + __proto__: Observer.prototype,
|
| +
|
| + connect_: function() {
|
| + if (hasObserve)
|
| + this.directObserver_ = getObservedSet(this, this.object_);
|
| +
|
| + this.check_(undefined, true);
|
| + },
|
| +
|
| + disconnect_: function() {
|
| + this.value_ = undefined;
|
| +
|
| + if (this.directObserver_) {
|
| + this.directObserver_.close(this);
|
| + this.directObserver_ = undefined;
|
| + }
|
| + },
|
| +
|
| + iterateObjects_: function(observe) {
|
| + this.path_.iterateObjects(this.object_, observe);
|
| + },
|
| +
|
| + check_: function(changeRecords, skipChanges) {
|
| + var oldValue = this.value_;
|
| + this.value_ = this.path_.getValueFrom(this.object_);
|
| + if (skipChanges || areSameValue(this.value_, oldValue))
|
| + return false;
|
| +
|
| + this.report_([this.value_, oldValue]);
|
| + return true;
|
| + },
|
| +
|
| + setValue: function(newValue) {
|
| + if (this.path_)
|
| + this.path_.setValueFrom(this.object_, newValue);
|
| + }
|
| + });
|
| +
|
| + function CompoundObserver() {
|
| + Observer.call(this);
|
| +
|
| + this.value_ = [];
|
| + this.directObserver_ = undefined;
|
| + this.observed_ = [];
|
| + }
|
| +
|
| + var observerSentinel = {};
|
| +
|
| + CompoundObserver.prototype = createObject({
|
| + __proto__: Observer.prototype,
|
| +
|
| + connect_: function() {
|
| + this.check_(undefined, true);
|
| +
|
| + if (!hasObserve)
|
| + return;
|
| +
|
| + var object;
|
| + var needsDirectObserver = false;
|
| + for (var i = 0; i < this.observed_.length; i += 2) {
|
| + object = this.observed_[i]
|
| + if (object !== observerSentinel) {
|
| + needsDirectObserver = true;
|
| + break;
|
| + }
|
| + }
|
| +
|
| + if (this.directObserver_) {
|
| + if (needsDirectObserver) {
|
| + this.directObserver_.reset();
|
| + return;
|
| + }
|
| + this.directObserver_.close();
|
| + this.directObserver_ = undefined;
|
| + return;
|
| + }
|
| +
|
| + if (needsDirectObserver)
|
| + this.directObserver_ = getObservedSet(this, object);
|
| + },
|
| +
|
| + closeObservers_: function() {
|
| + for (var i = 0; i < this.observed_.length; i += 2) {
|
| + if (this.observed_[i] === observerSentinel)
|
| + this.observed_[i + 1].close();
|
| + }
|
| + this.observed_.length = 0;
|
| + },
|
| +
|
| + disconnect_: function() {
|
| + this.value_ = undefined;
|
| +
|
| + if (this.directObserver_) {
|
| + this.directObserver_.close(this);
|
| + this.directObserver_ = undefined;
|
| + }
|
| +
|
| + this.closeObservers_();
|
| + },
|
| +
|
| + addPath: function(object, path) {
|
| + if (this.state_ != UNOPENED && this.state_ != RESETTING)
|
| + throw Error('Cannot add paths once started.');
|
| +
|
| + this.observed_.push(object, path instanceof Path ? path : getPath(path));
|
| + },
|
| +
|
| + addObserver: function(observer) {
|
| + if (this.state_ != UNOPENED && this.state_ != RESETTING)
|
| + throw Error('Cannot add observers once started.');
|
| +
|
| + observer.open(this.deliver, this);
|
| + this.observed_.push(observerSentinel, observer);
|
| + },
|
| +
|
| + startReset: function() {
|
| + if (this.state_ != OPENED)
|
| + throw Error('Can only reset while open');
|
| +
|
| + this.state_ = RESETTING;
|
| + this.closeObservers_();
|
| + },
|
| +
|
| + finishReset: function() {
|
| + if (this.state_ != RESETTING)
|
| + throw Error('Can only finishReset after startReset');
|
| + this.state_ = OPENED;
|
| + this.connect_();
|
| +
|
| + return this.value_;
|
| + },
|
| +
|
| + iterateObjects_: function(observe) {
|
| + var object;
|
| + for (var i = 0; i < this.observed_.length; i += 2) {
|
| + object = this.observed_[i]
|
| + if (object !== observerSentinel)
|
| + this.observed_[i + 1].iterateObjects(object, observe)
|
| + }
|
| + },
|
| +
|
| + check_: function(changeRecords, skipChanges) {
|
| + var oldValues;
|
| + for (var i = 0; i < this.observed_.length; i += 2) {
|
| + var pathOrObserver = this.observed_[i+1];
|
| + var object = this.observed_[i];
|
| + var value = object === observerSentinel ?
|
| + pathOrObserver.discardChanges() :
|
| + pathOrObserver.getValueFrom(object)
|
| +
|
| + if (skipChanges) {
|
| + this.value_[i / 2] = value;
|
| + continue;
|
| + }
|
| +
|
| + if (areSameValue(value, this.value_[i / 2]))
|
| + continue;
|
| +
|
| + oldValues = oldValues || [];
|
| + oldValues[i / 2] = this.value_[i / 2];
|
| + this.value_[i / 2] = value;
|
| + }
|
| +
|
| + if (!oldValues)
|
| + return false;
|
| +
|
| + // TODO(rafaelw): Having observed_ as the third callback arg here is
|
| + // pretty lame API. Fix.
|
| + this.report_([this.value_, oldValues, this.observed_]);
|
| + return true;
|
| + }
|
| + });
|
| +
|
| + function identFn(value) { return value; }
|
| +
|
| + function ObserverTransform(observable, getValueFn, setValueFn,
|
| + dontPassThroughSet) {
|
| + this.callback_ = undefined;
|
| + this.target_ = undefined;
|
| + this.value_ = undefined;
|
| + this.observable_ = observable;
|
| + this.getValueFn_ = getValueFn || identFn;
|
| + this.setValueFn_ = setValueFn || identFn;
|
| + // TODO(rafaelw): This is a temporary hack. PolymerExpressions needs this
|
| + // at the moment because of a bug in it's dependency tracking.
|
| + this.dontPassThroughSet_ = dontPassThroughSet;
|
| + }
|
| +
|
| + ObserverTransform.prototype = {
|
| + open: function(callback, target) {
|
| + this.callback_ = callback;
|
| + this.target_ = target;
|
| + this.value_ =
|
| + this.getValueFn_(this.observable_.open(this.observedCallback_, this));
|
| + return this.value_;
|
| + },
|
| +
|
| + observedCallback_: function(value) {
|
| + value = this.getValueFn_(value);
|
| + if (areSameValue(value, this.value_))
|
| + return;
|
| + var oldValue = this.value_;
|
| + this.value_ = value;
|
| + this.callback_.call(this.target_, this.value_, oldValue);
|
| + },
|
| +
|
| + discardChanges: function() {
|
| + this.value_ = this.getValueFn_(this.observable_.discardChanges());
|
| + return this.value_;
|
| + },
|
| +
|
| + deliver: function() {
|
| + return this.observable_.deliver();
|
| + },
|
| +
|
| + setValue: function(value) {
|
| + value = this.setValueFn_(value);
|
| + if (!this.dontPassThroughSet_ && this.observable_.setValue)
|
| + return this.observable_.setValue(value);
|
| + },
|
| +
|
| + close: function() {
|
| + if (this.observable_)
|
| + this.observable_.close();
|
| + this.callback_ = undefined;
|
| + this.target_ = undefined;
|
| + this.observable_ = undefined;
|
| + this.value_ = undefined;
|
| + this.getValueFn_ = undefined;
|
| + this.setValueFn_ = undefined;
|
| + }
|
| + }
|
| +
|
| + var expectedRecordTypes = {};
|
| + expectedRecordTypes[PROP_ADD_TYPE] = true;
|
| + expectedRecordTypes[PROP_UPDATE_TYPE] = true;
|
| + expectedRecordTypes[PROP_DELETE_TYPE] = true;
|
| +
|
| + function notifyFunction(object, name) {
|
| + if (typeof Object.observe !== 'function')
|
| + return;
|
| +
|
| + var notifier = Object.getNotifier(object);
|
| + return function(type, oldValue) {
|
| + var changeRecord = {
|
| + object: object,
|
| + type: type,
|
| + name: name
|
| + };
|
| + if (arguments.length === 2)
|
| + changeRecord.oldValue = oldValue;
|
| + notifier.notify(changeRecord);
|
| + }
|
| + }
|
| +
|
| + Observer.defineComputedProperty = function(target, name, observable) {
|
| + var notify = notifyFunction(target, name);
|
| + var value = observable.open(function(newValue, oldValue) {
|
| + value = newValue;
|
| + if (notify)
|
| + notify(PROP_UPDATE_TYPE, oldValue);
|
| + });
|
| +
|
| + Object.defineProperty(target, name, {
|
| + get: function() {
|
| + observable.deliver();
|
| + return value;
|
| + },
|
| + set: function(newValue) {
|
| + observable.setValue(newValue);
|
| + return newValue;
|
| + },
|
| + configurable: true
|
| + });
|
| +
|
| + return {
|
| + close: function() {
|
| + observable.close();
|
| + Object.defineProperty(target, name, {
|
| + value: value,
|
| + writable: true,
|
| + configurable: true
|
| + });
|
| + }
|
| + };
|
| + }
|
| +
|
| + function diffObjectFromChangeRecords(object, changeRecords, oldValues) {
|
| + var added = {};
|
| + var removed = {};
|
| +
|
| + for (var i = 0; i < changeRecords.length; i++) {
|
| + var record = changeRecords[i];
|
| + if (!expectedRecordTypes[record.type]) {
|
| + console.error('Unknown changeRecord type: ' + record.type);
|
| + console.error(record);
|
| + continue;
|
| + }
|
| +
|
| + if (!(record.name in oldValues))
|
| + oldValues[record.name] = record.oldValue;
|
| +
|
| + if (record.type == PROP_UPDATE_TYPE)
|
| + continue;
|
| +
|
| + if (record.type == PROP_ADD_TYPE) {
|
| + if (record.name in removed)
|
| + delete removed[record.name];
|
| + else
|
| + added[record.name] = true;
|
| +
|
| + continue;
|
| + }
|
| +
|
| + // type = 'delete'
|
| + if (record.name in added) {
|
| + delete added[record.name];
|
| + delete oldValues[record.name];
|
| + } else {
|
| + removed[record.name] = true;
|
| + }
|
| + }
|
| +
|
| + for (var prop in added)
|
| + added[prop] = object[prop];
|
| +
|
| + for (var prop in removed)
|
| + removed[prop] = undefined;
|
| +
|
| + var changed = {};
|
| + for (var prop in oldValues) {
|
| + if (prop in added || prop in removed)
|
| + continue;
|
| +
|
| + var newValue = object[prop];
|
| + if (oldValues[prop] !== newValue)
|
| + changed[prop] = newValue;
|
| + }
|
| +
|
| + return {
|
| + added: added,
|
| + removed: removed,
|
| + changed: changed
|
| + };
|
| + }
|
| +
|
| + function newSplice(index, removed, addedCount) {
|
| + return {
|
| + index: index,
|
| + removed: removed,
|
| + addedCount: addedCount
|
| + };
|
| + }
|
| +
|
| + var EDIT_LEAVE = 0;
|
| + var EDIT_UPDATE = 1;
|
| + var EDIT_ADD = 2;
|
| + var EDIT_DELETE = 3;
|
| +
|
| + function ArraySplice() {}
|
| +
|
| + ArraySplice.prototype = {
|
| +
|
| + // Note: This function is *based* on the computation of the Levenshtein
|
| + // "edit" distance. The one change is that "updates" are treated as two
|
| + // edits - not one. With Array splices, an update is really a delete
|
| + // followed by an add. By retaining this, we optimize for "keeping" the
|
| + // maximum array items in the original array. For example:
|
| + //
|
| + // 'xxxx123' -> '123yyyy'
|
| + //
|
| + // With 1-edit updates, the shortest path would be just to update all seven
|
| + // characters. With 2-edit updates, we delete 4, leave 3, and add 4. This
|
| + // leaves the substring '123' intact.
|
| + calcEditDistances: function(current, currentStart, currentEnd,
|
| + old, oldStart, oldEnd) {
|
| + // "Deletion" columns
|
| + var rowCount = oldEnd - oldStart + 1;
|
| + var columnCount = currentEnd - currentStart + 1;
|
| + var distances = new Array(rowCount);
|
| +
|
| + // "Addition" rows. Initialize null column.
|
| + for (var i = 0; i < rowCount; i++) {
|
| + distances[i] = new Array(columnCount);
|
| + distances[i][0] = i;
|
| + }
|
| +
|
| + // Initialize null row
|
| + for (var j = 0; j < columnCount; j++)
|
| + distances[0][j] = j;
|
| +
|
| + for (var i = 1; i < rowCount; i++) {
|
| + for (var j = 1; j < columnCount; j++) {
|
| + if (this.equals(current[currentStart + j - 1], old[oldStart + i - 1]))
|
| + distances[i][j] = distances[i - 1][j - 1];
|
| + else {
|
| + var north = distances[i - 1][j] + 1;
|
| + var west = distances[i][j - 1] + 1;
|
| + distances[i][j] = north < west ? north : west;
|
| + }
|
| + }
|
| + }
|
| +
|
| + return distances;
|
| + },
|
| +
|
| + // This starts at the final weight, and walks "backward" by finding
|
| + // the minimum previous weight recursively until the origin of the weight
|
| + // matrix.
|
| + spliceOperationsFromEditDistances: function(distances) {
|
| + var i = distances.length - 1;
|
| + var j = distances[0].length - 1;
|
| + var current = distances[i][j];
|
| + var edits = [];
|
| + while (i > 0 || j > 0) {
|
| + if (i == 0) {
|
| + edits.push(EDIT_ADD);
|
| + j--;
|
| + continue;
|
| + }
|
| + if (j == 0) {
|
| + edits.push(EDIT_DELETE);
|
| + i--;
|
| + continue;
|
| + }
|
| + var northWest = distances[i - 1][j - 1];
|
| + var west = distances[i - 1][j];
|
| + var north = distances[i][j - 1];
|
| +
|
| + var min;
|
| + if (west < north)
|
| + min = west < northWest ? west : northWest;
|
| + else
|
| + min = north < northWest ? north : northWest;
|
| +
|
| + if (min == northWest) {
|
| + if (northWest == current) {
|
| + edits.push(EDIT_LEAVE);
|
| + } else {
|
| + edits.push(EDIT_UPDATE);
|
| + current = northWest;
|
| + }
|
| + i--;
|
| + j--;
|
| + } else if (min == west) {
|
| + edits.push(EDIT_DELETE);
|
| + i--;
|
| + current = west;
|
| + } else {
|
| + edits.push(EDIT_ADD);
|
| + j--;
|
| + current = north;
|
| + }
|
| + }
|
| +
|
| + edits.reverse();
|
| + return edits;
|
| + },
|
| +
|
| + /**
|
| + * Splice Projection functions:
|
| + *
|
| + * A splice map is a representation of how a previous array of items
|
| + * was transformed into a new array of items. Conceptually it is a list of
|
| + * tuples of
|
| + *
|
| + * <index, removed, addedCount>
|
| + *
|
| + * which are kept in ascending index order of. The tuple represents that at
|
| + * the |index|, |removed| sequence of items were removed, and counting forward
|
| + * from |index|, |addedCount| items were added.
|
| + */
|
| +
|
| + /**
|
| + * Lacking individual splice mutation information, the minimal set of
|
| + * splices can be synthesized given the previous state and final state of an
|
| + * array. The basic approach is to calculate the edit distance matrix and
|
| + * choose the shortest path through it.
|
| + *
|
| + * Complexity: O(l * p)
|
| + * l: The length of the current array
|
| + * p: The length of the old array
|
| + */
|
| + calcSplices: function(current, currentStart, currentEnd,
|
| + old, oldStart, oldEnd) {
|
| + var prefixCount = 0;
|
| + var suffixCount = 0;
|
| +
|
| + var minLength = Math.min(currentEnd - currentStart, oldEnd - oldStart);
|
| + if (currentStart == 0 && oldStart == 0)
|
| + prefixCount = this.sharedPrefix(current, old, minLength);
|
| +
|
| + if (currentEnd == current.length && oldEnd == old.length)
|
| + suffixCount = this.sharedSuffix(current, old, minLength - prefixCount);
|
| +
|
| + currentStart += prefixCount;
|
| + oldStart += prefixCount;
|
| + currentEnd -= suffixCount;
|
| + oldEnd -= suffixCount;
|
| +
|
| + if (currentEnd - currentStart == 0 && oldEnd - oldStart == 0)
|
| + return [];
|
| +
|
| + if (currentStart == currentEnd) {
|
| + var splice = newSplice(currentStart, [], 0);
|
| + while (oldStart < oldEnd)
|
| + splice.removed.push(old[oldStart++]);
|
| +
|
| + return [ splice ];
|
| + } else if (oldStart == oldEnd)
|
| + return [ newSplice(currentStart, [], currentEnd - currentStart) ];
|
| +
|
| + var ops = this.spliceOperationsFromEditDistances(
|
| + this.calcEditDistances(current, currentStart, currentEnd,
|
| + old, oldStart, oldEnd));
|
| +
|
| + var splice = undefined;
|
| + var splices = [];
|
| + var index = currentStart;
|
| + var oldIndex = oldStart;
|
| + for (var i = 0; i < ops.length; i++) {
|
| + switch(ops[i]) {
|
| + case EDIT_LEAVE:
|
| + if (splice) {
|
| + splices.push(splice);
|
| + splice = undefined;
|
| + }
|
| +
|
| + index++;
|
| + oldIndex++;
|
| + break;
|
| + case EDIT_UPDATE:
|
| + if (!splice)
|
| + splice = newSplice(index, [], 0);
|
| +
|
| + splice.addedCount++;
|
| + index++;
|
| +
|
| + splice.removed.push(old[oldIndex]);
|
| + oldIndex++;
|
| + break;
|
| + case EDIT_ADD:
|
| + if (!splice)
|
| + splice = newSplice(index, [], 0);
|
| +
|
| + splice.addedCount++;
|
| + index++;
|
| + break;
|
| + case EDIT_DELETE:
|
| + if (!splice)
|
| + splice = newSplice(index, [], 0);
|
| +
|
| + splice.removed.push(old[oldIndex]);
|
| + oldIndex++;
|
| + break;
|
| + }
|
| + }
|
| +
|
| + if (splice) {
|
| + splices.push(splice);
|
| + }
|
| + return splices;
|
| + },
|
| +
|
| + sharedPrefix: function(current, old, searchLength) {
|
| + for (var i = 0; i < searchLength; i++)
|
| + if (!this.equals(current[i], old[i]))
|
| + return i;
|
| + return searchLength;
|
| + },
|
| +
|
| + sharedSuffix: function(current, old, searchLength) {
|
| + var index1 = current.length;
|
| + var index2 = old.length;
|
| + var count = 0;
|
| + while (count < searchLength && this.equals(current[--index1], old[--index2]))
|
| + count++;
|
| +
|
| + return count;
|
| + },
|
| +
|
| + calculateSplices: function(current, previous) {
|
| + return this.calcSplices(current, 0, current.length, previous, 0,
|
| + previous.length);
|
| + },
|
| +
|
| + equals: function(currentValue, previousValue) {
|
| + return currentValue === previousValue;
|
| + }
|
| + };
|
| +
|
| + var arraySplice = new ArraySplice();
|
| +
|
| + function calcSplices(current, currentStart, currentEnd,
|
| + old, oldStart, oldEnd) {
|
| + return arraySplice.calcSplices(current, currentStart, currentEnd,
|
| + old, oldStart, oldEnd);
|
| + }
|
| +
|
| + function intersect(start1, end1, start2, end2) {
|
| + // Disjoint
|
| + if (end1 < start2 || end2 < start1)
|
| + return -1;
|
| +
|
| + // Adjacent
|
| + if (end1 == start2 || end2 == start1)
|
| + return 0;
|
| +
|
| + // Non-zero intersect, span1 first
|
| + if (start1 < start2) {
|
| + if (end1 < end2)
|
| + return end1 - start2; // Overlap
|
| + else
|
| + return end2 - start2; // Contained
|
| + } else {
|
| + // Non-zero intersect, span2 first
|
| + if (end2 < end1)
|
| + return end2 - start1; // Overlap
|
| + else
|
| + return end1 - start1; // Contained
|
| + }
|
| + }
|
| +
|
| + function mergeSplice(splices, index, removed, addedCount) {
|
| +
|
| + var splice = newSplice(index, removed, addedCount);
|
| +
|
| + var inserted = false;
|
| + var insertionOffset = 0;
|
| +
|
| + for (var i = 0; i < splices.length; i++) {
|
| + var current = splices[i];
|
| + current.index += insertionOffset;
|
| +
|
| + if (inserted)
|
| + continue;
|
| +
|
| + var intersectCount = intersect(splice.index,
|
| + splice.index + splice.removed.length,
|
| + current.index,
|
| + current.index + current.addedCount);
|
| +
|
| + if (intersectCount >= 0) {
|
| + // Merge the two splices
|
| +
|
| + splices.splice(i, 1);
|
| + i--;
|
| +
|
| + insertionOffset -= current.addedCount - current.removed.length;
|
| +
|
| + splice.addedCount += current.addedCount - intersectCount;
|
| + var deleteCount = splice.removed.length +
|
| + current.removed.length - intersectCount;
|
| +
|
| + if (!splice.addedCount && !deleteCount) {
|
| + // merged splice is a noop. discard.
|
| + inserted = true;
|
| + } else {
|
| + var removed = current.removed;
|
| +
|
| + if (splice.index < current.index) {
|
| + // some prefix of splice.removed is prepended to current.removed.
|
| + var prepend = splice.removed.slice(0, current.index - splice.index);
|
| + Array.prototype.push.apply(prepend, removed);
|
| + removed = prepend;
|
| + }
|
| +
|
| + if (splice.index + splice.removed.length > current.index + current.addedCount) {
|
| + // some suffix of splice.removed is appended to current.removed.
|
| + var append = splice.removed.slice(current.index + current.addedCount - splice.index);
|
| + Array.prototype.push.apply(removed, append);
|
| + }
|
| +
|
| + splice.removed = removed;
|
| + if (current.index < splice.index) {
|
| + splice.index = current.index;
|
| + }
|
| + }
|
| + } else if (splice.index < current.index) {
|
| + // Insert splice here.
|
| +
|
| + inserted = true;
|
| +
|
| + splices.splice(i, 0, splice);
|
| + i++;
|
| +
|
| + var offset = splice.addedCount - splice.removed.length
|
| + current.index += offset;
|
| + insertionOffset += offset;
|
| + }
|
| + }
|
| +
|
| + if (!inserted)
|
| + splices.push(splice);
|
| + }
|
| +
|
| + function createInitialSplices(array, changeRecords) {
|
| + var splices = [];
|
| +
|
| + for (var i = 0; i < changeRecords.length; i++) {
|
| + var record = changeRecords[i];
|
| + switch(record.type) {
|
| + case ARRAY_SPLICE_TYPE:
|
| + mergeSplice(splices, record.index, record.removed.slice(), record.addedCount);
|
| + break;
|
| + case PROP_ADD_TYPE:
|
| + case PROP_UPDATE_TYPE:
|
| + case PROP_DELETE_TYPE:
|
| + if (!isIndex(record.name))
|
| + continue;
|
| + var index = toNumber(record.name);
|
| + if (index < 0)
|
| + continue;
|
| + mergeSplice(splices, index, [record.oldValue], 1);
|
| + break;
|
| + default:
|
| + console.error('Unexpected record type: ' + JSON.stringify(record));
|
| + break;
|
| + }
|
| + }
|
| +
|
| + return splices;
|
| + }
|
| +
|
| + function projectArraySplices(array, changeRecords) {
|
| + var splices = [];
|
| +
|
| + createInitialSplices(array, changeRecords).forEach(function(splice) {
|
| + if (splice.addedCount == 1 && splice.removed.length == 1) {
|
| + if (splice.removed[0] !== array[splice.index])
|
| + splices.push(splice);
|
| +
|
| + return
|
| + };
|
| +
|
| + splices = splices.concat(calcSplices(array, splice.index, splice.index + splice.addedCount,
|
| + splice.removed, 0, splice.removed.length));
|
| + });
|
| +
|
| + return splices;
|
| + }
|
| +
|
| + global.Observer = Observer;
|
| + global.Observer.runEOM_ = runEOM;
|
| + global.Observer.hasObjectObserve = hasObserve;
|
| + global.ArrayObserver = ArrayObserver;
|
| + global.ArrayObserver.calculateSplices = function(current, previous) {
|
| + return arraySplice.calculateSplices(current, previous);
|
| + };
|
| +
|
| + global.ArraySplice = ArraySplice;
|
| + global.ObjectObserver = ObjectObserver;
|
| + global.PathObserver = PathObserver;
|
| + global.CompoundObserver = CompoundObserver;
|
| + global.Path = Path;
|
| + global.ObserverTransform = ObserverTransform;
|
| +
|
| + // TODO(rafaelw): Only needed for testing until new change record names
|
| + // make it to release.
|
| + global.Observer.changeRecordTypes = {
|
| + add: PROP_ADD_TYPE,
|
| + update: PROP_UPDATE_TYPE,
|
| + reconfigure: PROP_RECONFIGURE_TYPE,
|
| + 'delete': PROP_DELETE_TYPE,
|
| + splice: ARRAY_SPLICE_TYPE
|
| + };
|
| +})(typeof global !== 'undefined' && global && typeof module !== 'undefined' && module ? global : this || window);
|
| +
|
| +/*
|
| + * Copyright 2012 The Polymer Authors. All rights reserved.
|
| + * Use of this source code is governed by a BSD-style
|
| + * license that can be found in the LICENSE file.
|
| + */
|
| +
|
| +if (typeof WeakMap === 'undefined') {
|
| + (function() {
|
| + var defineProperty = Object.defineProperty;
|
| + var counter = Date.now() % 1e9;
|
| +
|
| + var WeakMap = function() {
|
| + this.name = '__st' + (Math.random() * 1e9 >>> 0) + (counter++ + '__');
|
| + };
|
| +
|
| + WeakMap.prototype = {
|
| + set: function(key, value) {
|
| + var entry = key[this.name];
|
| + if (entry && entry[0] === key)
|
| + entry[1] = value;
|
| + else
|
| + defineProperty(key, this.name, {value: [key, value], writable: true});
|
| + },
|
| + get: function(key) {
|
| + var entry;
|
| + return (entry = key[this.name]) && entry[0] === key ?
|
| + entry[1] : undefined;
|
| + },
|
| + delete: function(key) {
|
| + this.set(key, undefined);
|
| + }
|
| + };
|
| +
|
| + window.WeakMap = WeakMap;
|
| + })();
|
| +}
|
| +
|
| +// Copyright 2012 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +window.ShadowDOMPolyfill = {};
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var constructorTable = new WeakMap();
|
| + var nativePrototypeTable = new WeakMap();
|
| + var wrappers = Object.create(null);
|
| +
|
| + // Don't test for eval if document has CSP securityPolicy object and we can
|
| + // see that eval is not supported. This avoids an error message in console
|
| + // even when the exception is caught
|
| + var hasEval = !('securityPolicy' in document) ||
|
| + document.securityPolicy.allowsEval;
|
| + if (hasEval) {
|
| + try {
|
| + var f = new Function('', 'return true;');
|
| + hasEval = f();
|
| + } catch (ex) {
|
| + hasEval = false;
|
| + }
|
| + }
|
| +
|
| + function assert(b) {
|
| + if (!b)
|
| + throw new Error('Assertion failed');
|
| + };
|
| +
|
| + var defineProperty = Object.defineProperty;
|
| + var getOwnPropertyNames = Object.getOwnPropertyNames;
|
| + var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
| +
|
| + function mixin(to, from) {
|
| + getOwnPropertyNames(from).forEach(function(name) {
|
| + defineProperty(to, name, getOwnPropertyDescriptor(from, name));
|
| + });
|
| + return to;
|
| + };
|
| +
|
| + function mixinStatics(to, from) {
|
| + getOwnPropertyNames(from).forEach(function(name) {
|
| + switch (name) {
|
| + case 'arguments':
|
| + case 'caller':
|
| + case 'length':
|
| + case 'name':
|
| + case 'prototype':
|
| + case 'toString':
|
| + return;
|
| + }
|
| + defineProperty(to, name, getOwnPropertyDescriptor(from, name));
|
| + });
|
| + return to;
|
| + };
|
| +
|
| + function oneOf(object, propertyNames) {
|
| + for (var i = 0; i < propertyNames.length; i++) {
|
| + if (propertyNames[i] in object)
|
| + return propertyNames[i];
|
| + }
|
| + }
|
| +
|
| + // Mozilla's old DOM bindings are bretty busted:
|
| + // https://bugzilla.mozilla.org/show_bug.cgi?id=855844
|
| + // Make sure they are create before we start modifying things.
|
| + getOwnPropertyNames(window);
|
| +
|
| + function getWrapperConstructor(node) {
|
| + var nativePrototype = node.__proto__ || Object.getPrototypeOf(node);
|
| + var wrapperConstructor = constructorTable.get(nativePrototype);
|
| + if (wrapperConstructor)
|
| + return wrapperConstructor;
|
| +
|
| + var parentWrapperConstructor = getWrapperConstructor(nativePrototype);
|
| +
|
| + var GeneratedWrapper = createWrapperConstructor(parentWrapperConstructor);
|
| + registerInternal(nativePrototype, GeneratedWrapper, node);
|
| +
|
| + return GeneratedWrapper;
|
| + }
|
| +
|
| + function addForwardingProperties(nativePrototype, wrapperPrototype) {
|
| + installProperty(nativePrototype, wrapperPrototype, true);
|
| + }
|
| +
|
| + function registerInstanceProperties(wrapperPrototype, instanceObject) {
|
| + installProperty(instanceObject, wrapperPrototype, false);
|
| + }
|
| +
|
| + var isFirefox = /Firefox/.test(navigator.userAgent);
|
| +
|
| + // This is used as a fallback when getting the descriptor fails in
|
| + // installProperty.
|
| + var dummyDescriptor = {
|
| + get: function() {},
|
| + set: function(v) {},
|
| + configurable: true,
|
| + enumerable: true
|
| + };
|
| +
|
| + function isEventHandlerName(name) {
|
| + return /^on[a-z]+$/.test(name);
|
| + }
|
| +
|
| + function isIdentifierName(name) {
|
| + return /^\w[a-zA-Z_0-9]*$/.test(name);
|
| + }
|
| +
|
| + function getGetter(name) {
|
| + return hasEval && isIdentifierName(name) ?
|
| + new Function('return this.impl.' + name) :
|
| + function() { return this.impl[name]; };
|
| + }
|
| +
|
| + function getSetter(name) {
|
| + return hasEval && isIdentifierName(name) ?
|
| + new Function('v', 'this.impl.' + name + ' = v') :
|
| + function(v) { this.impl[name] = v; };
|
| + }
|
| +
|
| + function getMethod(name) {
|
| + return hasEval && isIdentifierName(name) ?
|
| + new Function('return this.impl.' + name +
|
| + '.apply(this.impl, arguments)') :
|
| + function() { return this.impl[name].apply(this.impl, arguments); };
|
| + }
|
| +
|
| + function getDescriptor(source, name) {
|
| + try {
|
| + return Object.getOwnPropertyDescriptor(source, name);
|
| + } catch (ex) {
|
| + // JSC and V8 both use data properties instead of accessors which can
|
| + // cause getting the property desciptor to throw an exception.
|
| + // https://bugs.webkit.org/show_bug.cgi?id=49739
|
| + return dummyDescriptor;
|
| + }
|
| + }
|
| +
|
| + function installProperty(source, target, allowMethod, opt_blacklist) {
|
| + var names = getOwnPropertyNames(source);
|
| + for (var i = 0; i < names.length; i++) {
|
| + var name = names[i];
|
| + if (name === 'polymerBlackList_')
|
| + continue;
|
| +
|
| + if (name in target)
|
| + continue;
|
| +
|
| + if (source.polymerBlackList_ && source.polymerBlackList_[name])
|
| + continue;
|
| +
|
| + if (isFirefox) {
|
| + // Tickle Firefox's old bindings.
|
| + source.__lookupGetter__(name);
|
| + }
|
| + var descriptor = getDescriptor(source, name);
|
| + var getter, setter;
|
| + if (allowMethod && typeof descriptor.value === 'function') {
|
| + target[name] = getMethod(name);
|
| + continue;
|
| + }
|
| +
|
| + var isEvent = isEventHandlerName(name);
|
| + if (isEvent)
|
| + getter = scope.getEventHandlerGetter(name);
|
| + else
|
| + getter = getGetter(name);
|
| +
|
| + if (descriptor.writable || descriptor.set) {
|
| + if (isEvent)
|
| + setter = scope.getEventHandlerSetter(name);
|
| + else
|
| + setter = getSetter(name);
|
| + }
|
| +
|
| + defineProperty(target, name, {
|
| + get: getter,
|
| + set: setter,
|
| + configurable: descriptor.configurable,
|
| + enumerable: descriptor.enumerable
|
| + });
|
| + }
|
| + }
|
| +
|
| + /**
|
| + * @param {Function} nativeConstructor
|
| + * @param {Function} wrapperConstructor
|
| + * @param {Object=} opt_instance If present, this is used to extract
|
| + * properties from an instance object.
|
| + */
|
| + function register(nativeConstructor, wrapperConstructor, opt_instance) {
|
| + var nativePrototype = nativeConstructor.prototype;
|
| + registerInternal(nativePrototype, wrapperConstructor, opt_instance);
|
| + mixinStatics(wrapperConstructor, nativeConstructor);
|
| + }
|
| +
|
| + function registerInternal(nativePrototype, wrapperConstructor, opt_instance) {
|
| + var wrapperPrototype = wrapperConstructor.prototype;
|
| + assert(constructorTable.get(nativePrototype) === undefined);
|
| +
|
| + constructorTable.set(nativePrototype, wrapperConstructor);
|
| + nativePrototypeTable.set(wrapperPrototype, nativePrototype);
|
| +
|
| + addForwardingProperties(nativePrototype, wrapperPrototype);
|
| + if (opt_instance)
|
| + registerInstanceProperties(wrapperPrototype, opt_instance);
|
| + defineProperty(wrapperPrototype, 'constructor', {
|
| + value: wrapperConstructor,
|
| + configurable: true,
|
| + enumerable: false,
|
| + writable: true
|
| + });
|
| + }
|
| +
|
| + function isWrapperFor(wrapperConstructor, nativeConstructor) {
|
| + return constructorTable.get(nativeConstructor.prototype) ===
|
| + wrapperConstructor;
|
| + }
|
| +
|
| + /**
|
| + * Creates a generic wrapper constructor based on |object| and its
|
| + * constructor.
|
| + * @param {Node} object
|
| + * @return {Function} The generated constructor.
|
| + */
|
| + function registerObject(object) {
|
| + var nativePrototype = Object.getPrototypeOf(object);
|
| +
|
| + var superWrapperConstructor = getWrapperConstructor(nativePrototype);
|
| + var GeneratedWrapper = createWrapperConstructor(superWrapperConstructor);
|
| + registerInternal(nativePrototype, GeneratedWrapper, object);
|
| +
|
| + return GeneratedWrapper;
|
| + }
|
| +
|
| + function createWrapperConstructor(superWrapperConstructor) {
|
| + function GeneratedWrapper(node) {
|
| + superWrapperConstructor.call(this, node);
|
| + }
|
| + GeneratedWrapper.prototype =
|
| + Object.create(superWrapperConstructor.prototype);
|
| + GeneratedWrapper.prototype.constructor = GeneratedWrapper;
|
| +
|
| + return GeneratedWrapper;
|
| + }
|
| +
|
| + var OriginalDOMImplementation = window.DOMImplementation;
|
| + var OriginalEventTarget = window.EventTarget;
|
| + var OriginalEvent = window.Event;
|
| + var OriginalNode = window.Node;
|
| + var OriginalWindow = window.Window;
|
| + var OriginalRange = window.Range;
|
| + var OriginalCanvasRenderingContext2D = window.CanvasRenderingContext2D;
|
| + var OriginalWebGLRenderingContext = window.WebGLRenderingContext;
|
| + var OriginalSVGElementInstance = window.SVGElementInstance;
|
| +
|
| + function isWrapper(object) {
|
| + return object instanceof wrappers.EventTarget ||
|
| + object instanceof wrappers.Event ||
|
| + object instanceof wrappers.Range ||
|
| + object instanceof wrappers.DOMImplementation ||
|
| + object instanceof wrappers.CanvasRenderingContext2D ||
|
| + wrappers.WebGLRenderingContext &&
|
| + object instanceof wrappers.WebGLRenderingContext;
|
| + }
|
| +
|
| + function isNative(object) {
|
| + return OriginalEventTarget && object instanceof OriginalEventTarget ||
|
| + object instanceof OriginalNode ||
|
| + object instanceof OriginalEvent ||
|
| + object instanceof OriginalWindow ||
|
| + object instanceof OriginalRange ||
|
| + object instanceof OriginalDOMImplementation ||
|
| + object instanceof OriginalCanvasRenderingContext2D ||
|
| + OriginalWebGLRenderingContext &&
|
| + object instanceof OriginalWebGLRenderingContext ||
|
| + OriginalSVGElementInstance &&
|
| + object instanceof OriginalSVGElementInstance;
|
| + }
|
| +
|
| + /**
|
| + * Wraps a node in a WrapperNode. If there already exists a wrapper for the
|
| + * |node| that wrapper is returned instead.
|
| + * @param {Node} node
|
| + * @return {WrapperNode}
|
| + */
|
| + function wrap(impl) {
|
| + if (impl === null)
|
| + return null;
|
| +
|
| + assert(isNative(impl));
|
| + return impl.polymerWrapper_ ||
|
| + (impl.polymerWrapper_ = new (getWrapperConstructor(impl))(impl));
|
| + }
|
| +
|
| + /**
|
| + * Unwraps a wrapper and returns the node it is wrapping.
|
| + * @param {WrapperNode} wrapper
|
| + * @return {Node}
|
| + */
|
| + function unwrap(wrapper) {
|
| + if (wrapper === null)
|
| + return null;
|
| + assert(isWrapper(wrapper));
|
| + return wrapper.impl;
|
| + }
|
| +
|
| + /**
|
| + * Unwraps object if it is a wrapper.
|
| + * @param {Object} object
|
| + * @return {Object} The native implementation object.
|
| + */
|
| + function unwrapIfNeeded(object) {
|
| + return object && isWrapper(object) ? unwrap(object) : object;
|
| + }
|
| +
|
| + /**
|
| + * Wraps object if it is not a wrapper.
|
| + * @param {Object} object
|
| + * @return {Object} The wrapper for object.
|
| + */
|
| + function wrapIfNeeded(object) {
|
| + return object && !isWrapper(object) ? wrap(object) : object;
|
| + }
|
| +
|
| + /**
|
| + * Overrides the current wrapper (if any) for node.
|
| + * @param {Node} node
|
| + * @param {WrapperNode=} wrapper If left out the wrapper will be created as
|
| + * needed next time someone wraps the node.
|
| + */
|
| + function rewrap(node, wrapper) {
|
| + if (wrapper === null)
|
| + return;
|
| + assert(isNative(node));
|
| + assert(wrapper === undefined || isWrapper(wrapper));
|
| + node.polymerWrapper_ = wrapper;
|
| + }
|
| +
|
| + function defineGetter(constructor, name, getter) {
|
| + defineProperty(constructor.prototype, name, {
|
| + get: getter,
|
| + configurable: true,
|
| + enumerable: true
|
| + });
|
| + }
|
| +
|
| + function defineWrapGetter(constructor, name) {
|
| + defineGetter(constructor, name, function() {
|
| + return wrap(this.impl[name]);
|
| + });
|
| + }
|
| +
|
| + /**
|
| + * Forwards existing methods on the native object to the wrapper methods.
|
| + * This does not wrap any of the arguments or the return value since the
|
| + * wrapper implementation already takes care of that.
|
| + * @param {Array.<Function>} constructors
|
| + * @parem {Array.<string>} names
|
| + */
|
| + function forwardMethodsToWrapper(constructors, names) {
|
| + constructors.forEach(function(constructor) {
|
| + names.forEach(function(name) {
|
| + constructor.prototype[name] = function() {
|
| + var w = wrapIfNeeded(this);
|
| + return w[name].apply(w, arguments);
|
| + };
|
| + });
|
| + });
|
| + }
|
| +
|
| + scope.assert = assert;
|
| + scope.constructorTable = constructorTable;
|
| + scope.defineGetter = defineGetter;
|
| + scope.defineWrapGetter = defineWrapGetter;
|
| + scope.forwardMethodsToWrapper = forwardMethodsToWrapper;
|
| + scope.isWrapper = isWrapper;
|
| + scope.isWrapperFor = isWrapperFor;
|
| + scope.mixin = mixin;
|
| + scope.nativePrototypeTable = nativePrototypeTable;
|
| + scope.oneOf = oneOf;
|
| + scope.registerObject = registerObject;
|
| + scope.registerWrapper = register;
|
| + scope.rewrap = rewrap;
|
| + scope.unwrap = unwrap;
|
| + scope.unwrapIfNeeded = unwrapIfNeeded;
|
| + scope.wrap = wrap;
|
| + scope.wrapIfNeeded = wrapIfNeeded;
|
| + scope.wrappers = wrappers;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +/*
|
| + * Copyright 2013 The Polymer Authors. All rights reserved.
|
| + * Use of this source code is goverened by a BSD-style
|
| + * license that can be found in the LICENSE file.
|
| + */
|
| +
|
| +(function(context) {
|
| + 'use strict';
|
| +
|
| + var OriginalMutationObserver = window.MutationObserver;
|
| + var callbacks = [];
|
| + var pending = false;
|
| + var timerFunc;
|
| +
|
| + function handle() {
|
| + pending = false;
|
| + var copies = callbacks.slice(0);
|
| + callbacks = [];
|
| + for (var i = 0; i < copies.length; i++) {
|
| + (0, copies[i])();
|
| + }
|
| + }
|
| +
|
| + if (OriginalMutationObserver) {
|
| + var counter = 1;
|
| + var observer = new OriginalMutationObserver(handle);
|
| + var textNode = document.createTextNode(counter);
|
| + observer.observe(textNode, {characterData: true});
|
| +
|
| + timerFunc = function() {
|
| + counter = (counter + 1) % 2;
|
| + textNode.data = counter;
|
| + };
|
| +
|
| + } else {
|
| + timerFunc = window.setImmediate || window.setTimeout;
|
| + }
|
| +
|
| + function setEndOfMicrotask(func) {
|
| + callbacks.push(func);
|
| + if (pending)
|
| + return;
|
| + pending = true;
|
| + timerFunc(handle, 0);
|
| + }
|
| +
|
| + context.setEndOfMicrotask = setEndOfMicrotask;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +/*
|
| + * Copyright 2013 The Polymer Authors. All rights reserved.
|
| + * Use of this source code is goverened by a BSD-style
|
| + * license that can be found in the LICENSE file.
|
| + */
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var setEndOfMicrotask = scope.setEndOfMicrotask
|
| + var wrapIfNeeded = scope.wrapIfNeeded
|
| + var wrappers = scope.wrappers;
|
| +
|
| + var registrationsTable = new WeakMap();
|
| + var globalMutationObservers = [];
|
| + var isScheduled = false;
|
| +
|
| + function scheduleCallback(observer) {
|
| + if (isScheduled)
|
| + return;
|
| + setEndOfMicrotask(notifyObservers);
|
| + isScheduled = true;
|
| + }
|
| +
|
| + // http://dom.spec.whatwg.org/#mutation-observers
|
| + function notifyObservers() {
|
| + isScheduled = false;
|
| +
|
| + do {
|
| + var notifyList = globalMutationObservers.slice();
|
| + var anyNonEmpty = false;
|
| + for (var i = 0; i < notifyList.length; i++) {
|
| + var mo = notifyList[i];
|
| + var queue = mo.takeRecords();
|
| + removeTransientObserversFor(mo);
|
| + if (queue.length) {
|
| + mo.callback_(queue, mo);
|
| + anyNonEmpty = true;
|
| + }
|
| + }
|
| + } while (anyNonEmpty);
|
| + }
|
| +
|
| + /**
|
| + * @param {string} type
|
| + * @param {Node} target
|
| + * @constructor
|
| + */
|
| + function MutationRecord(type, target) {
|
| + this.type = type;
|
| + this.target = target;
|
| + this.addedNodes = new wrappers.NodeList();
|
| + this.removedNodes = new wrappers.NodeList();
|
| + this.previousSibling = null;
|
| + this.nextSibling = null;
|
| + this.attributeName = null;
|
| + this.attributeNamespace = null;
|
| + this.oldValue = null;
|
| + }
|
| +
|
| + /**
|
| + * Registers transient observers to ancestor and its ancesors for the node
|
| + * which was removed.
|
| + * @param {!Node} ancestor
|
| + * @param {!Node} node
|
| + */
|
| + function registerTransientObservers(ancestor, node) {
|
| + for (; ancestor; ancestor = ancestor.parentNode) {
|
| + var registrations = registrationsTable.get(ancestor);
|
| + if (!registrations)
|
| + continue;
|
| + for (var i = 0; i < registrations.length; i++) {
|
| + var registration = registrations[i];
|
| + if (registration.options.subtree)
|
| + registration.addTransientObserver(node);
|
| + }
|
| + }
|
| + }
|
| +
|
| + function removeTransientObserversFor(observer) {
|
| + for (var i = 0; i < observer.nodes_.length; i++) {
|
| + var node = observer.nodes_[i];
|
| + var registrations = registrationsTable.get(node);
|
| + if (!registrations)
|
| + return;
|
| + for (var j = 0; j < registrations.length; j++) {
|
| + var registration = registrations[j];
|
| + if (registration.observer === observer)
|
| + registration.removeTransientObservers();
|
| + }
|
| + }
|
| + }
|
| +
|
| + // http://dom.spec.whatwg.org/#queue-a-mutation-record
|
| + function enqueueMutation(target, type, data) {
|
| + // 1.
|
| + var interestedObservers = Object.create(null);
|
| + var associatedStrings = Object.create(null);
|
| +
|
| + // 2.
|
| + for (var node = target; node; node = node.parentNode) {
|
| + // 3.
|
| + var registrations = registrationsTable.get(node);
|
| + if (!registrations)
|
| + continue;
|
| + for (var j = 0; j < registrations.length; j++) {
|
| + var registration = registrations[j];
|
| + var options = registration.options;
|
| + // 1.
|
| + if (node !== target && !options.subtree)
|
| + continue;
|
| +
|
| + // 2.
|
| + if (type === 'attributes' && !options.attributes)
|
| + continue;
|
| +
|
| + // 3. If type is "attributes", options's attributeFilter is present, and
|
| + // either options's attributeFilter does not contain name or namespace
|
| + // is non-null, continue.
|
| + if (type === 'attributes' && options.attributeFilter &&
|
| + (data.namespace !== null ||
|
| + options.attributeFilter.indexOf(data.name) === -1)) {
|
| + continue;
|
| + }
|
| +
|
| + // 4.
|
| + if (type === 'characterData' && !options.characterData)
|
| + continue;
|
| +
|
| + // 5.
|
| + if (type === 'childList' && !options.childList)
|
| + continue;
|
| +
|
| + // 6.
|
| + var observer = registration.observer;
|
| + interestedObservers[observer.uid_] = observer;
|
| +
|
| + // 7. If either type is "attributes" and options's attributeOldValue is
|
| + // true, or type is "characterData" and options's characterDataOldValue
|
| + // is true, set the paired string of registered observer's observer in
|
| + // interested observers to oldValue.
|
| + if (type === 'attributes' && options.attributeOldValue ||
|
| + type === 'characterData' && options.characterDataOldValue) {
|
| + associatedStrings[observer.uid_] = data.oldValue;
|
| + }
|
| + }
|
| + }
|
| +
|
| + var anyRecordsEnqueued = false;
|
| +
|
| + // 4.
|
| + for (var uid in interestedObservers) {
|
| + var observer = interestedObservers[uid];
|
| + var record = new MutationRecord(type, target);
|
| +
|
| + // 2.
|
| + if ('name' in data && 'namespace' in data) {
|
| + record.attributeName = data.name;
|
| + record.attributeNamespace = data.namespace;
|
| + }
|
| +
|
| + // 3.
|
| + if (data.addedNodes)
|
| + record.addedNodes = data.addedNodes;
|
| +
|
| + // 4.
|
| + if (data.removedNodes)
|
| + record.removedNodes = data.removedNodes;
|
| +
|
| + // 5.
|
| + if (data.previousSibling)
|
| + record.previousSibling = data.previousSibling;
|
| +
|
| + // 6.
|
| + if (data.nextSibling)
|
| + record.nextSibling = data.nextSibling;
|
| +
|
| + // 7.
|
| + if (associatedStrings[uid] !== undefined)
|
| + record.oldValue = associatedStrings[uid];
|
| +
|
| + // 8.
|
| + observer.records_.push(record);
|
| +
|
| + anyRecordsEnqueued = true;
|
| + }
|
| +
|
| + if (anyRecordsEnqueued)
|
| + scheduleCallback();
|
| + }
|
| +
|
| + var slice = Array.prototype.slice;
|
| +
|
| + /**
|
| + * @param {!Object} options
|
| + * @constructor
|
| + */
|
| + function MutationObserverOptions(options) {
|
| + this.childList = !!options.childList;
|
| + this.subtree = !!options.subtree;
|
| +
|
| + // 1. If either options' attributeOldValue or attributeFilter is present
|
| + // and options' attributes is omitted, set options' attributes to true.
|
| + if (!('attributes' in options) &&
|
| + ('attributeOldValue' in options || 'attributeFilter' in options)) {
|
| + this.attributes = true;
|
| + } else {
|
| + this.attributes = !!options.attributes;
|
| + }
|
| +
|
| + // 2. If options' characterDataOldValue is present and options'
|
| + // characterData is omitted, set options' characterData to true.
|
| + if ('characterDataOldValue' in options && !('characterData' in options))
|
| + this.characterData = true;
|
| + else
|
| + this.characterData = !!options.characterData;
|
| +
|
| + // 3. & 4.
|
| + if (!this.attributes &&
|
| + (options.attributeOldValue || 'attributeFilter' in options) ||
|
| + // 5.
|
| + !this.characterData && options.characterDataOldValue) {
|
| + throw new TypeError();
|
| + }
|
| +
|
| + this.characterData = !!options.characterData;
|
| + this.attributeOldValue = !!options.attributeOldValue;
|
| + this.characterDataOldValue = !!options.characterDataOldValue;
|
| + if ('attributeFilter' in options) {
|
| + if (options.attributeFilter == null ||
|
| + typeof options.attributeFilter !== 'object') {
|
| + throw new TypeError();
|
| + }
|
| + this.attributeFilter = slice.call(options.attributeFilter);
|
| + } else {
|
| + this.attributeFilter = null;
|
| + }
|
| + }
|
| +
|
| + var uidCounter = 0;
|
| +
|
| + /**
|
| + * The class that maps to the DOM MutationObserver interface.
|
| + * @param {Function} callback.
|
| + * @constructor
|
| + */
|
| + function MutationObserver(callback) {
|
| + this.callback_ = callback;
|
| + this.nodes_ = [];
|
| + this.records_ = [];
|
| + this.uid_ = ++uidCounter;
|
| +
|
| + // This will leak. There is no way to implement this without WeakRefs :'(
|
| + globalMutationObservers.push(this);
|
| + }
|
| +
|
| + MutationObserver.prototype = {
|
| + // http://dom.spec.whatwg.org/#dom-mutationobserver-observe
|
| + observe: function(target, options) {
|
| + target = wrapIfNeeded(target);
|
| +
|
| + var newOptions = new MutationObserverOptions(options);
|
| +
|
| + // 6.
|
| + var registration;
|
| + var registrations = registrationsTable.get(target);
|
| + if (!registrations)
|
| + registrationsTable.set(target, registrations = []);
|
| +
|
| + for (var i = 0; i < registrations.length; i++) {
|
| + if (registrations[i].observer === this) {
|
| + registration = registrations[i];
|
| + // 6.1.
|
| + registration.removeTransientObservers();
|
| + // 6.2.
|
| + registration.options = newOptions;
|
| + }
|
| + }
|
| +
|
| + // 7.
|
| + if (!registration) {
|
| + registration = new Registration(this, target, newOptions);
|
| + registrations.push(registration);
|
| + this.nodes_.push(target);
|
| + }
|
| + },
|
| +
|
| + // http://dom.spec.whatwg.org/#dom-mutationobserver-disconnect
|
| + disconnect: function() {
|
| + this.nodes_.forEach(function(node) {
|
| + var registrations = registrationsTable.get(node);
|
| + for (var i = 0; i < registrations.length; i++) {
|
| + var registration = registrations[i];
|
| + if (registration.observer === this) {
|
| + registrations.splice(i, 1);
|
| + // Each node can only have one registered observer associated with
|
| + // this observer.
|
| + break;
|
| + }
|
| + }
|
| + }, this);
|
| + this.records_ = [];
|
| + },
|
| +
|
| + takeRecords: function() {
|
| + var copyOfRecords = this.records_;
|
| + this.records_ = [];
|
| + return copyOfRecords;
|
| + }
|
| + };
|
| +
|
| + /**
|
| + * Class used to represent a registered observer.
|
| + * @param {MutationObserver} observer
|
| + * @param {Node} target
|
| + * @param {MutationObserverOptions} options
|
| + * @constructor
|
| + */
|
| + function Registration(observer, target, options) {
|
| + this.observer = observer;
|
| + this.target = target;
|
| + this.options = options;
|
| + this.transientObservedNodes = [];
|
| + }
|
| +
|
| + Registration.prototype = {
|
| + /**
|
| + * Adds a transient observer on node. The transient observer gets removed
|
| + * next time we deliver the change records.
|
| + * @param {Node} node
|
| + */
|
| + addTransientObserver: function(node) {
|
| + // Don't add transient observers on the target itself. We already have all
|
| + // the required listeners set up on the target.
|
| + if (node === this.target)
|
| + return;
|
| +
|
| + this.transientObservedNodes.push(node);
|
| + var registrations = registrationsTable.get(node);
|
| + if (!registrations)
|
| + registrationsTable.set(node, registrations = []);
|
| +
|
| + // We know that registrations does not contain this because we already
|
| + // checked if node === this.target.
|
| + registrations.push(this);
|
| + },
|
| +
|
| + removeTransientObservers: function() {
|
| + var transientObservedNodes = this.transientObservedNodes;
|
| + this.transientObservedNodes = [];
|
| +
|
| + for (var i = 0; i < transientObservedNodes.length; i++) {
|
| + var node = transientObservedNodes[i];
|
| + var registrations = registrationsTable.get(node);
|
| + for (var j = 0; j < registrations.length; j++) {
|
| + if (registrations[j] === this) {
|
| + registrations.splice(j, 1);
|
| + // Each node can only have one registered observer associated with
|
| + // this observer.
|
| + break;
|
| + }
|
| + }
|
| + }
|
| + }
|
| + };
|
| +
|
| + scope.enqueueMutation = enqueueMutation;
|
| + scope.registerTransientObservers = registerTransientObservers;
|
| + scope.wrappers.MutationObserver = MutationObserver;
|
| + scope.wrappers.MutationRecord = MutationRecord;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var forwardMethodsToWrapper = scope.forwardMethodsToWrapper;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var unwrap = scope.unwrap;
|
| + var wrap = scope.wrap;
|
| + var wrappers = scope.wrappers;
|
| +
|
| + var wrappedFuns = new WeakMap();
|
| + var listenersTable = new WeakMap();
|
| + var handledEventsTable = new WeakMap();
|
| + var currentlyDispatchingEvents = new WeakMap();
|
| + var targetTable = new WeakMap();
|
| + var currentTargetTable = new WeakMap();
|
| + var relatedTargetTable = new WeakMap();
|
| + var eventPhaseTable = new WeakMap();
|
| + var stopPropagationTable = new WeakMap();
|
| + var stopImmediatePropagationTable = new WeakMap();
|
| + var eventHandlersTable = new WeakMap();
|
| + var eventPathTable = new WeakMap();
|
| +
|
| + function isShadowRoot(node) {
|
| + return node instanceof wrappers.ShadowRoot;
|
| + }
|
| +
|
| + function isInsertionPoint(node) {
|
| + var localName = node.localName;
|
| + return localName === 'content' || localName === 'shadow';
|
| + }
|
| +
|
| + function isShadowHost(node) {
|
| + return !!node.shadowRoot;
|
| + }
|
| +
|
| + function getEventParent(node) {
|
| + var dv;
|
| + return node.parentNode || (dv = node.defaultView) && wrap(dv) || null;
|
| + }
|
| +
|
| + // https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#dfn-adjusted-parent
|
| + function calculateParents(node, context, ancestors) {
|
| + if (ancestors.length)
|
| + return ancestors.shift();
|
| +
|
| + // 1.
|
| + if (isShadowRoot(node))
|
| + return getInsertionParent(node) || node.host;
|
| +
|
| + // 2.
|
| + var eventParents = scope.eventParentsTable.get(node);
|
| + if (eventParents) {
|
| + // Copy over the remaining event parents for next iteration.
|
| + for (var i = 1; i < eventParents.length; i++) {
|
| + ancestors[i - 1] = eventParents[i];
|
| + }
|
| + return eventParents[0];
|
| + }
|
| +
|
| + // 3.
|
| + if (context && isInsertionPoint(node)) {
|
| + var parentNode = node.parentNode;
|
| + if (parentNode && isShadowHost(parentNode)) {
|
| + var trees = scope.getShadowTrees(parentNode);
|
| + var p = getInsertionParent(context);
|
| + for (var i = 0; i < trees.length; i++) {
|
| + if (trees[i].contains(p))
|
| + return p;
|
| + }
|
| + }
|
| + }
|
| +
|
| + return getEventParent(node);
|
| + }
|
| +
|
| + // https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#event-retargeting
|
| + function retarget(node) {
|
| + var stack = []; // 1.
|
| + var ancestor = node; // 2.
|
| + var targets = [];
|
| + var ancestors = [];
|
| + while (ancestor) { // 3.
|
| + var context = null; // 3.2.
|
| + // TODO(arv): Change order of these. If the stack is empty we always end
|
| + // up pushing ancestor, no matter what.
|
| + if (isInsertionPoint(ancestor)) { // 3.1.
|
| + context = topMostNotInsertionPoint(stack); // 3.1.1.
|
| + var top = stack[stack.length - 1] || ancestor; // 3.1.2.
|
| + stack.push(top);
|
| + } else if (!stack.length) {
|
| + stack.push(ancestor); // 3.3.
|
| + }
|
| + var target = stack[stack.length - 1]; // 3.4.
|
| + targets.push({target: target, currentTarget: ancestor}); // 3.5.
|
| + if (isShadowRoot(ancestor)) // 3.6.
|
| + stack.pop(); // 3.6.1.
|
| +
|
| + ancestor = calculateParents(ancestor, context, ancestors); // 3.7.
|
| + }
|
| + return targets;
|
| + }
|
| +
|
| + function topMostNotInsertionPoint(stack) {
|
| + for (var i = stack.length - 1; i >= 0; i--) {
|
| + if (!isInsertionPoint(stack[i]))
|
| + return stack[i];
|
| + }
|
| + return null;
|
| + }
|
| +
|
| + // https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#dfn-adjusted-related-target
|
| + function adjustRelatedTarget(target, related) {
|
| + var ancestors = [];
|
| + while (target) { // 3.
|
| + var stack = []; // 3.1.
|
| + var ancestor = related; // 3.2.
|
| + var last = undefined; // 3.3. Needs to be reset every iteration.
|
| + while (ancestor) {
|
| + var context = null;
|
| + if (!stack.length) {
|
| + stack.push(ancestor);
|
| + } else {
|
| + if (isInsertionPoint(ancestor)) { // 3.4.3.
|
| + context = topMostNotInsertionPoint(stack);
|
| + // isDistributed is more general than checking whether last is
|
| + // assigned into ancestor.
|
| + if (isDistributed(last)) { // 3.4.3.2.
|
| + var head = stack[stack.length - 1];
|
| + stack.push(head);
|
| + }
|
| + }
|
| + }
|
| +
|
| + if (inSameTree(ancestor, target)) // 3.4.4.
|
| + return stack[stack.length - 1];
|
| +
|
| + if (isShadowRoot(ancestor)) // 3.4.5.
|
| + stack.pop();
|
| +
|
| + last = ancestor; // 3.4.6.
|
| + ancestor = calculateParents(ancestor, context, ancestors); // 3.4.7.
|
| + }
|
| + if (isShadowRoot(target)) // 3.5.
|
| + target = target.host;
|
| + else
|
| + target = target.parentNode; // 3.6.
|
| + }
|
| + }
|
| +
|
| + function getInsertionParent(node) {
|
| + return scope.insertionParentTable.get(node);
|
| + }
|
| +
|
| + function isDistributed(node) {
|
| + return getInsertionParent(node);
|
| + }
|
| +
|
| + function rootOfNode(node) {
|
| + var p;
|
| + while (p = node.parentNode) {
|
| + node = p;
|
| + }
|
| + return node;
|
| + }
|
| +
|
| + function inSameTree(a, b) {
|
| + return rootOfNode(a) === rootOfNode(b);
|
| + }
|
| +
|
| + function enclosedBy(a, b) {
|
| + if (a === b)
|
| + return true;
|
| + if (a instanceof wrappers.ShadowRoot)
|
| + return enclosedBy(rootOfNode(a.host), b);
|
| + return false;
|
| + }
|
| +
|
| +
|
| + function dispatchOriginalEvent(originalEvent) {
|
| + // Make sure this event is only dispatched once.
|
| + if (handledEventsTable.get(originalEvent))
|
| + return;
|
| + handledEventsTable.set(originalEvent, true);
|
| +
|
| + return dispatchEvent(wrap(originalEvent), wrap(originalEvent.target));
|
| + }
|
| +
|
| + function dispatchEvent(event, originalWrapperTarget) {
|
| + if (currentlyDispatchingEvents.get(event))
|
| + throw new Error('InvalidStateError')
|
| + currentlyDispatchingEvents.set(event, true);
|
| +
|
| + // Render to ensure that the event path is correct.
|
| + scope.renderAllPending();
|
| + var eventPath = retarget(originalWrapperTarget);
|
| +
|
| + // For window load events the load event is dispatched at the window but
|
| + // the target is set to the document.
|
| + //
|
| + // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#the-end
|
| + //
|
| + // TODO(arv): Find a less hacky way to do this.
|
| + if (event.type === 'load' &&
|
| + eventPath.length === 2 &&
|
| + eventPath[0].target instanceof wrappers.Document) {
|
| + eventPath.shift();
|
| + }
|
| +
|
| + eventPathTable.set(event, eventPath);
|
| +
|
| + if (dispatchCapturing(event, eventPath)) {
|
| + if (dispatchAtTarget(event, eventPath)) {
|
| + dispatchBubbling(event, eventPath);
|
| + }
|
| + }
|
| +
|
| + eventPhaseTable.set(event, Event.NONE);
|
| + currentTargetTable.delete(event, null);
|
| + currentlyDispatchingEvents.delete(event);
|
| +
|
| + return event.defaultPrevented;
|
| + }
|
| +
|
| + function dispatchCapturing(event, eventPath) {
|
| + var phase;
|
| +
|
| + for (var i = eventPath.length - 1; i > 0; i--) {
|
| + var target = eventPath[i].target;
|
| + var currentTarget = eventPath[i].currentTarget;
|
| + if (target === currentTarget)
|
| + continue;
|
| +
|
| + phase = Event.CAPTURING_PHASE;
|
| + if (!invoke(eventPath[i], event, phase))
|
| + return false;
|
| + }
|
| +
|
| + return true;
|
| + }
|
| +
|
| + function dispatchAtTarget(event, eventPath) {
|
| + var phase = Event.AT_TARGET;
|
| + return invoke(eventPath[0], event, phase);
|
| + }
|
| +
|
| + function dispatchBubbling(event, eventPath) {
|
| + var bubbles = event.bubbles;
|
| + var phase;
|
| +
|
| + for (var i = 1; i < eventPath.length; i++) {
|
| + var target = eventPath[i].target;
|
| + var currentTarget = eventPath[i].currentTarget;
|
| + if (target === currentTarget)
|
| + phase = Event.AT_TARGET;
|
| + else if (bubbles && !stopImmediatePropagationTable.get(event))
|
| + phase = Event.BUBBLING_PHASE;
|
| + else
|
| + continue;
|
| +
|
| + if (!invoke(eventPath[i], event, phase))
|
| + return;
|
| + }
|
| + }
|
| +
|
| + function invoke(tuple, event, phase) {
|
| + var target = tuple.target;
|
| + var currentTarget = tuple.currentTarget;
|
| +
|
| + var listeners = listenersTable.get(currentTarget);
|
| + if (!listeners)
|
| + return true;
|
| +
|
| + if ('relatedTarget' in event) {
|
| + var originalEvent = unwrap(event);
|
| + // X-Tag sets relatedTarget on a CustomEvent. If they do that there is no
|
| + // way to have relatedTarget return the adjusted target but worse is that
|
| + // the originalEvent might not have a relatedTarget so we hit an assert
|
| + // when we try to wrap it.
|
| + if (originalEvent.relatedTarget) {
|
| + var relatedTarget = wrap(originalEvent.relatedTarget);
|
| +
|
| + var adjusted = adjustRelatedTarget(currentTarget, relatedTarget);
|
| + if (adjusted === target)
|
| + return true;
|
| +
|
| + relatedTargetTable.set(event, adjusted);
|
| + }
|
| + }
|
| +
|
| + eventPhaseTable.set(event, phase);
|
| + var type = event.type;
|
| +
|
| + var anyRemoved = false;
|
| + targetTable.set(event, target);
|
| + currentTargetTable.set(event, currentTarget);
|
| +
|
| + for (var i = 0; i < listeners.length; i++) {
|
| + var listener = listeners[i];
|
| + if (listener.removed) {
|
| + anyRemoved = true;
|
| + continue;
|
| + }
|
| +
|
| + if (listener.type !== type ||
|
| + !listener.capture && phase === Event.CAPTURING_PHASE ||
|
| + listener.capture && phase === Event.BUBBLING_PHASE) {
|
| + continue;
|
| + }
|
| +
|
| + try {
|
| + if (typeof listener.handler === 'function')
|
| + listener.handler.call(currentTarget, event);
|
| + else
|
| + listener.handler.handleEvent(event);
|
| +
|
| + if (stopImmediatePropagationTable.get(event))
|
| + return false;
|
| +
|
| + } catch (ex) {
|
| + if (window.onerror)
|
| + window.onerror(ex.message);
|
| + else
|
| + console.error(ex, ex.stack);
|
| + }
|
| + }
|
| +
|
| + if (anyRemoved) {
|
| + var copy = listeners.slice();
|
| + listeners.length = 0;
|
| + for (var i = 0; i < copy.length; i++) {
|
| + if (!copy[i].removed)
|
| + listeners.push(copy[i]);
|
| + }
|
| + }
|
| +
|
| + return !stopPropagationTable.get(event);
|
| + }
|
| +
|
| + function Listener(type, handler, capture) {
|
| + this.type = type;
|
| + this.handler = handler;
|
| + this.capture = Boolean(capture);
|
| + }
|
| + Listener.prototype = {
|
| + equals: function(that) {
|
| + return this.handler === that.handler && this.type === that.type &&
|
| + this.capture === that.capture;
|
| + },
|
| + get removed() {
|
| + return this.handler === null;
|
| + },
|
| + remove: function() {
|
| + this.handler = null;
|
| + }
|
| + };
|
| +
|
| + var OriginalEvent = window.Event;
|
| + OriginalEvent.prototype.polymerBlackList_ = {
|
| + returnValue: true,
|
| + // TODO(arv): keyLocation is part of KeyboardEvent but Firefox does not
|
| + // support constructable KeyboardEvent so we keep it here for now.
|
| + keyLocation: true
|
| + };
|
| +
|
| + /**
|
| + * Creates a new Event wrapper or wraps an existin native Event object.
|
| + * @param {string|Event} type
|
| + * @param {Object=} options
|
| + * @constructor
|
| + */
|
| + function Event(type, options) {
|
| + if (type instanceof OriginalEvent)
|
| + this.impl = type;
|
| + else
|
| + return wrap(constructEvent(OriginalEvent, 'Event', type, options));
|
| + }
|
| + Event.prototype = {
|
| + get target() {
|
| + return targetTable.get(this);
|
| + },
|
| + get currentTarget() {
|
| + return currentTargetTable.get(this);
|
| + },
|
| + get eventPhase() {
|
| + return eventPhaseTable.get(this);
|
| + },
|
| + get path() {
|
| + var nodeList = new wrappers.NodeList();
|
| + var eventPath = eventPathTable.get(this);
|
| + if (eventPath) {
|
| + var index = 0;
|
| + var lastIndex = eventPath.length - 1;
|
| + var baseRoot = rootOfNode(currentTargetTable.get(this));
|
| +
|
| + for (var i = 0; i <= lastIndex; i++) {
|
| + var currentTarget = eventPath[i].currentTarget;
|
| + var currentRoot = rootOfNode(currentTarget);
|
| + if (enclosedBy(baseRoot, currentRoot) &&
|
| + // Make sure we do not add Window to the path.
|
| + (i !== lastIndex || currentTarget instanceof wrappers.Node)) {
|
| + nodeList[index++] = currentTarget;
|
| + }
|
| + }
|
| + nodeList.length = index;
|
| + }
|
| + return nodeList;
|
| + },
|
| + stopPropagation: function() {
|
| + stopPropagationTable.set(this, true);
|
| + },
|
| + stopImmediatePropagation: function() {
|
| + stopPropagationTable.set(this, true);
|
| + stopImmediatePropagationTable.set(this, true);
|
| + }
|
| + };
|
| + registerWrapper(OriginalEvent, Event, document.createEvent('Event'));
|
| +
|
| + function unwrapOptions(options) {
|
| + if (!options || !options.relatedTarget)
|
| + return options;
|
| + return Object.create(options, {
|
| + relatedTarget: {value: unwrap(options.relatedTarget)}
|
| + });
|
| + }
|
| +
|
| + function registerGenericEvent(name, SuperEvent, prototype) {
|
| + var OriginalEvent = window[name];
|
| + var GenericEvent = function(type, options) {
|
| + if (type instanceof OriginalEvent)
|
| + this.impl = type;
|
| + else
|
| + return wrap(constructEvent(OriginalEvent, name, type, options));
|
| + };
|
| + GenericEvent.prototype = Object.create(SuperEvent.prototype);
|
| + if (prototype)
|
| + mixin(GenericEvent.prototype, prototype);
|
| + if (OriginalEvent) {
|
| + // - Old versions of Safari fails on new FocusEvent (and others?).
|
| + // - IE does not support event constructors.
|
| + // - createEvent('FocusEvent') throws in Firefox.
|
| + // => Try the best practice solution first and fallback to the old way
|
| + // if needed.
|
| + try {
|
| + registerWrapper(OriginalEvent, GenericEvent, new OriginalEvent('temp'));
|
| + } catch (ex) {
|
| + registerWrapper(OriginalEvent, GenericEvent,
|
| + document.createEvent(name));
|
| + }
|
| + }
|
| + return GenericEvent;
|
| + }
|
| +
|
| + var UIEvent = registerGenericEvent('UIEvent', Event);
|
| + var CustomEvent = registerGenericEvent('CustomEvent', Event);
|
| +
|
| + var relatedTargetProto = {
|
| + get relatedTarget() {
|
| + return relatedTargetTable.get(this) || wrap(unwrap(this).relatedTarget);
|
| + }
|
| + };
|
| +
|
| + function getInitFunction(name, relatedTargetIndex) {
|
| + return function() {
|
| + arguments[relatedTargetIndex] = unwrap(arguments[relatedTargetIndex]);
|
| + var impl = unwrap(this);
|
| + impl[name].apply(impl, arguments);
|
| + };
|
| + }
|
| +
|
| + var mouseEventProto = mixin({
|
| + initMouseEvent: getInitFunction('initMouseEvent', 14)
|
| + }, relatedTargetProto);
|
| +
|
| + var focusEventProto = mixin({
|
| + initFocusEvent: getInitFunction('initFocusEvent', 5)
|
| + }, relatedTargetProto);
|
| +
|
| + var MouseEvent = registerGenericEvent('MouseEvent', UIEvent, mouseEventProto);
|
| + var FocusEvent = registerGenericEvent('FocusEvent', UIEvent, focusEventProto);
|
| +
|
| + // In case the browser does not support event constructors we polyfill that
|
| + // by calling `createEvent('Foo')` and `initFooEvent` where the arguments to
|
| + // `initFooEvent` are derived from the registered default event init dict.
|
| + var defaultInitDicts = Object.create(null);
|
| +
|
| + var supportsEventConstructors = (function() {
|
| + try {
|
| + new window.FocusEvent('focus');
|
| + } catch (ex) {
|
| + return false;
|
| + }
|
| + return true;
|
| + })();
|
| +
|
| + /**
|
| + * Constructs a new native event.
|
| + */
|
| + function constructEvent(OriginalEvent, name, type, options) {
|
| + if (supportsEventConstructors)
|
| + return new OriginalEvent(type, unwrapOptions(options));
|
| +
|
| + // Create the arguments from the default dictionary.
|
| + var event = unwrap(document.createEvent(name));
|
| + var defaultDict = defaultInitDicts[name];
|
| + var args = [type];
|
| + Object.keys(defaultDict).forEach(function(key) {
|
| + var v = options != null && key in options ?
|
| + options[key] : defaultDict[key];
|
| + if (key === 'relatedTarget')
|
| + v = unwrap(v);
|
| + args.push(v);
|
| + });
|
| + event['init' + name].apply(event, args);
|
| + return event;
|
| + }
|
| +
|
| + if (!supportsEventConstructors) {
|
| + var configureEventConstructor = function(name, initDict, superName) {
|
| + if (superName) {
|
| + var superDict = defaultInitDicts[superName];
|
| + initDict = mixin(mixin({}, superDict), initDict);
|
| + }
|
| +
|
| + defaultInitDicts[name] = initDict;
|
| + };
|
| +
|
| + // The order of the default event init dictionary keys is important, the
|
| + // arguments to initFooEvent is derived from that.
|
| + configureEventConstructor('Event', {bubbles: false, cancelable: false});
|
| + configureEventConstructor('CustomEvent', {detail: null}, 'Event');
|
| + configureEventConstructor('UIEvent', {view: null, detail: 0}, 'Event');
|
| + configureEventConstructor('MouseEvent', {
|
| + screenX: 0,
|
| + screenY: 0,
|
| + clientX: 0,
|
| + clientY: 0,
|
| + ctrlKey: false,
|
| + altKey: false,
|
| + shiftKey: false,
|
| + metaKey: false,
|
| + button: 0,
|
| + relatedTarget: null
|
| + }, 'UIEvent');
|
| + configureEventConstructor('FocusEvent', {relatedTarget: null}, 'UIEvent');
|
| + }
|
| +
|
| + function BeforeUnloadEvent(impl) {
|
| + Event.call(this);
|
| + }
|
| + BeforeUnloadEvent.prototype = Object.create(Event.prototype);
|
| + mixin(BeforeUnloadEvent.prototype, {
|
| + get returnValue() {
|
| + return this.impl.returnValue;
|
| + },
|
| + set returnValue(v) {
|
| + this.impl.returnValue = v;
|
| + }
|
| + });
|
| +
|
| + function isValidListener(fun) {
|
| + if (typeof fun === 'function')
|
| + return true;
|
| + return fun && fun.handleEvent;
|
| + }
|
| +
|
| + function isMutationEvent(type) {
|
| + switch (type) {
|
| + case 'DOMAttrModified':
|
| + case 'DOMAttributeNameChanged':
|
| + case 'DOMCharacterDataModified':
|
| + case 'DOMElementNameChanged':
|
| + case 'DOMNodeInserted':
|
| + case 'DOMNodeInsertedIntoDocument':
|
| + case 'DOMNodeRemoved':
|
| + case 'DOMNodeRemovedFromDocument':
|
| + case 'DOMSubtreeModified':
|
| + return true;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + var OriginalEventTarget = window.EventTarget;
|
| +
|
| + /**
|
| + * This represents a wrapper for an EventTarget.
|
| + * @param {!EventTarget} impl The original event target.
|
| + * @constructor
|
| + */
|
| + function EventTarget(impl) {
|
| + this.impl = impl;
|
| + }
|
| +
|
| + // Node and Window have different internal type checks in WebKit so we cannot
|
| + // use the same method as the original function.
|
| + var methodNames = [
|
| + 'addEventListener',
|
| + 'removeEventListener',
|
| + 'dispatchEvent'
|
| + ];
|
| +
|
| + [Node, Window].forEach(function(constructor) {
|
| + var p = constructor.prototype;
|
| + methodNames.forEach(function(name) {
|
| + Object.defineProperty(p, name + '_', {value: p[name]});
|
| + });
|
| + });
|
| +
|
| + function getTargetToListenAt(wrapper) {
|
| + if (wrapper instanceof wrappers.ShadowRoot)
|
| + wrapper = wrapper.host;
|
| + return unwrap(wrapper);
|
| + }
|
| +
|
| + EventTarget.prototype = {
|
| + addEventListener: function(type, fun, capture) {
|
| + if (!isValidListener(fun) || isMutationEvent(type))
|
| + return;
|
| +
|
| + var listener = new Listener(type, fun, capture);
|
| + var listeners = listenersTable.get(this);
|
| + if (!listeners) {
|
| + listeners = [];
|
| + listenersTable.set(this, listeners);
|
| + } else {
|
| + // Might have a duplicate.
|
| + for (var i = 0; i < listeners.length; i++) {
|
| + if (listener.equals(listeners[i]))
|
| + return;
|
| + }
|
| + }
|
| +
|
| + listeners.push(listener);
|
| +
|
| + var target = getTargetToListenAt(this);
|
| + target.addEventListener_(type, dispatchOriginalEvent, true);
|
| + },
|
| + removeEventListener: function(type, fun, capture) {
|
| + capture = Boolean(capture);
|
| + var listeners = listenersTable.get(this);
|
| + if (!listeners)
|
| + return;
|
| + var count = 0, found = false;
|
| + for (var i = 0; i < listeners.length; i++) {
|
| + if (listeners[i].type === type && listeners[i].capture === capture) {
|
| + count++;
|
| + if (listeners[i].handler === fun) {
|
| + found = true;
|
| + listeners[i].remove();
|
| + }
|
| + }
|
| + }
|
| +
|
| + if (found && count === 1) {
|
| + var target = getTargetToListenAt(this);
|
| + target.removeEventListener_(type, dispatchOriginalEvent, true);
|
| + }
|
| + },
|
| + dispatchEvent: function(event) {
|
| + // We want to use the native dispatchEvent because it triggers the default
|
| + // actions (like checking a checkbox). However, if there are no listeners
|
| + // in the composed tree then there are no events that will trigger and
|
| + // listeners in the non composed tree that are part of the event path are
|
| + // not notified.
|
| + //
|
| + // If we find out that there are no listeners in the composed tree we add
|
| + // a temporary listener to the target which makes us get called back even
|
| + // in that case.
|
| +
|
| + var nativeEvent = unwrap(event);
|
| + var eventType = nativeEvent.type;
|
| +
|
| + // Allow dispatching the same event again. This is safe because if user
|
| + // code calls this during an existing dispatch of the same event the
|
| + // native dispatchEvent throws (that is required by the spec).
|
| + handledEventsTable.set(nativeEvent, false);
|
| +
|
| + // Force rendering since we prefer native dispatch and that works on the
|
| + // composed tree.
|
| + scope.renderAllPending();
|
| +
|
| + var tempListener;
|
| + if (!hasListenerInAncestors(this, eventType)) {
|
| + tempListener = function() {};
|
| + this.addEventListener(eventType, tempListener, true);
|
| + }
|
| +
|
| + try {
|
| + return unwrap(this).dispatchEvent_(nativeEvent);
|
| + } finally {
|
| + if (tempListener)
|
| + this.removeEventListener(eventType, tempListener, true);
|
| + }
|
| + }
|
| + };
|
| +
|
| + function hasListener(node, type) {
|
| + var listeners = listenersTable.get(node);
|
| + if (listeners) {
|
| + for (var i = 0; i < listeners.length; i++) {
|
| + if (!listeners[i].removed && listeners[i].type === type)
|
| + return true;
|
| + }
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + function hasListenerInAncestors(target, type) {
|
| + for (var node = unwrap(target); node; node = node.parentNode) {
|
| + if (hasListener(wrap(node), type))
|
| + return true;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + if (OriginalEventTarget)
|
| + registerWrapper(OriginalEventTarget, EventTarget);
|
| +
|
| + function wrapEventTargetMethods(constructors) {
|
| + forwardMethodsToWrapper(constructors, methodNames);
|
| + }
|
| +
|
| + var originalElementFromPoint = document.elementFromPoint;
|
| +
|
| + function elementFromPoint(self, document, x, y) {
|
| + scope.renderAllPending();
|
| +
|
| + var element = wrap(originalElementFromPoint.call(document.impl, x, y));
|
| + var targets = retarget(element, this)
|
| + for (var i = 0; i < targets.length; i++) {
|
| + var target = targets[i];
|
| + if (target.currentTarget === self)
|
| + return target.target;
|
| + }
|
| + return null;
|
| + }
|
| +
|
| + /**
|
| + * Returns a function that is to be used as a getter for `onfoo` properties.
|
| + * @param {string} name
|
| + * @return {Function}
|
| + */
|
| + function getEventHandlerGetter(name) {
|
| + return function() {
|
| + var inlineEventHandlers = eventHandlersTable.get(this);
|
| + return inlineEventHandlers && inlineEventHandlers[name] &&
|
| + inlineEventHandlers[name].value || null;
|
| + };
|
| + }
|
| +
|
| + /**
|
| + * Returns a function that is to be used as a setter for `onfoo` properties.
|
| + * @param {string} name
|
| + * @return {Function}
|
| + */
|
| + function getEventHandlerSetter(name) {
|
| + var eventType = name.slice(2);
|
| + return function(value) {
|
| + var inlineEventHandlers = eventHandlersTable.get(this);
|
| + if (!inlineEventHandlers) {
|
| + inlineEventHandlers = Object.create(null);
|
| + eventHandlersTable.set(this, inlineEventHandlers);
|
| + }
|
| +
|
| + var old = inlineEventHandlers[name];
|
| + if (old)
|
| + this.removeEventListener(eventType, old.wrapped, false);
|
| +
|
| + if (typeof value === 'function') {
|
| + var wrapped = function(e) {
|
| + var rv = value.call(this, e);
|
| + if (rv === false)
|
| + e.preventDefault();
|
| + else if (name === 'onbeforeunload' && typeof rv === 'string')
|
| + e.returnValue = rv;
|
| + // mouseover uses true for preventDefault but preventDefault for
|
| + // mouseover is ignored by browsers these day.
|
| + };
|
| +
|
| + this.addEventListener(eventType, wrapped, false);
|
| + inlineEventHandlers[name] = {
|
| + value: value,
|
| + wrapped: wrapped
|
| + };
|
| + }
|
| + };
|
| + }
|
| +
|
| + scope.adjustRelatedTarget = adjustRelatedTarget;
|
| + scope.elementFromPoint = elementFromPoint;
|
| + scope.getEventHandlerGetter = getEventHandlerGetter;
|
| + scope.getEventHandlerSetter = getEventHandlerSetter;
|
| + scope.wrapEventTargetMethods = wrapEventTargetMethods;
|
| + scope.wrappers.BeforeUnloadEvent = BeforeUnloadEvent;
|
| + scope.wrappers.CustomEvent = CustomEvent;
|
| + scope.wrappers.Event = Event;
|
| + scope.wrappers.EventTarget = EventTarget;
|
| + scope.wrappers.FocusEvent = FocusEvent;
|
| + scope.wrappers.MouseEvent = MouseEvent;
|
| + scope.wrappers.UIEvent = UIEvent;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2012 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var wrap = scope.wrap;
|
| +
|
| + function nonEnum(obj, prop) {
|
| + Object.defineProperty(obj, prop, {enumerable: false});
|
| + }
|
| +
|
| + function NodeList() {
|
| + this.length = 0;
|
| + nonEnum(this, 'length');
|
| + }
|
| + NodeList.prototype = {
|
| + item: function(index) {
|
| + return this[index];
|
| + }
|
| + };
|
| + nonEnum(NodeList.prototype, 'item');
|
| +
|
| + function wrapNodeList(list) {
|
| + if (list == null)
|
| + return list;
|
| + var wrapperList = new NodeList();
|
| + for (var i = 0, length = list.length; i < length; i++) {
|
| + wrapperList[i] = wrap(list[i]);
|
| + }
|
| + wrapperList.length = length;
|
| + return wrapperList;
|
| + }
|
| +
|
| + function addWrapNodeListMethod(wrapperConstructor, name) {
|
| + wrapperConstructor.prototype[name] = function() {
|
| + return wrapNodeList(this.impl[name].apply(this.impl, arguments));
|
| + };
|
| + }
|
| +
|
| + scope.wrappers.NodeList = NodeList;
|
| + scope.addWrapNodeListMethod = addWrapNodeListMethod;
|
| + scope.wrapNodeList = wrapNodeList;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2012 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var EventTarget = scope.wrappers.EventTarget;
|
| + var NodeList = scope.wrappers.NodeList;
|
| + var assert = scope.assert;
|
| + var defineWrapGetter = scope.defineWrapGetter;
|
| + var enqueueMutation = scope.enqueueMutation;
|
| + var isWrapper = scope.isWrapper;
|
| + var mixin = scope.mixin;
|
| + var registerTransientObservers = scope.registerTransientObservers;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var unwrap = scope.unwrap;
|
| + var wrap = scope.wrap;
|
| + var wrapIfNeeded = scope.wrapIfNeeded;
|
| +
|
| + function assertIsNodeWrapper(node) {
|
| + assert(node instanceof Node);
|
| + }
|
| +
|
| + function createOneElementNodeList(node) {
|
| + var nodes = new NodeList();
|
| + nodes[0] = node;
|
| + nodes.length = 1;
|
| + return nodes;
|
| + }
|
| +
|
| + var surpressMutations = false;
|
| +
|
| + /**
|
| + * Called before node is inserted into a node to enqueue its removal from its
|
| + * old parent.
|
| + * @param {!Node} node The node that is about to be removed.
|
| + * @param {!Node} parent The parent node that the node is being removed from.
|
| + * @param {!NodeList} nodes The collected nodes.
|
| + */
|
| + function enqueueRemovalForInsertedNodes(node, parent, nodes) {
|
| + enqueueMutation(parent, 'childList', {
|
| + removedNodes: nodes,
|
| + previousSibling: node.previousSibling,
|
| + nextSibling: node.nextSibling
|
| + });
|
| + }
|
| +
|
| + function enqueueRemovalForInsertedDocumentFragment(df, nodes) {
|
| + enqueueMutation(df, 'childList', {
|
| + removedNodes: nodes
|
| + });
|
| + }
|
| +
|
| + /**
|
| + * Collects nodes from a DocumentFragment or a Node for removal followed
|
| + * by an insertion.
|
| + *
|
| + * This updates the internal pointers for node, previousNode and nextNode.
|
| + */
|
| + function collectNodes(node, parentNode, previousNode, nextNode) {
|
| + if (node instanceof DocumentFragment) {
|
| + var nodes = collectNodesForDocumentFragment(node);
|
| +
|
| + // The extra loop is to work around bugs with DocumentFragments in IE.
|
| + surpressMutations = true;
|
| + for (var i = nodes.length - 1; i >= 0; i--) {
|
| + node.removeChild(nodes[i]);
|
| + nodes[i].parentNode_ = parentNode;
|
| + }
|
| + surpressMutations = false;
|
| +
|
| + for (var i = 0; i < nodes.length; i++) {
|
| + nodes[i].previousSibling_ = nodes[i - 1] || previousNode;
|
| + nodes[i].nextSibling_ = nodes[i + 1] || nextNode;
|
| + }
|
| +
|
| + if (previousNode)
|
| + previousNode.nextSibling_ = nodes[0];
|
| + if (nextNode)
|
| + nextNode.previousSibling_ = nodes[nodes.length - 1];
|
| +
|
| + return nodes;
|
| + }
|
| +
|
| + var nodes = createOneElementNodeList(node);
|
| + var oldParent = node.parentNode;
|
| + if (oldParent) {
|
| + // This will enqueue the mutation record for the removal as needed.
|
| + oldParent.removeChild(node);
|
| + }
|
| +
|
| + node.parentNode_ = parentNode;
|
| + node.previousSibling_ = previousNode;
|
| + node.nextSibling_ = nextNode;
|
| + if (previousNode)
|
| + previousNode.nextSibling_ = node;
|
| + if (nextNode)
|
| + nextNode.previousSibling_ = node;
|
| +
|
| + return nodes;
|
| + }
|
| +
|
| + function collectNodesNative(node) {
|
| + if (node instanceof DocumentFragment)
|
| + return collectNodesForDocumentFragment(node);
|
| +
|
| + var nodes = createOneElementNodeList(node);
|
| + var oldParent = node.parentNode;
|
| + if (oldParent)
|
| + enqueueRemovalForInsertedNodes(node, oldParent, nodes);
|
| + return nodes;
|
| + }
|
| +
|
| + function collectNodesForDocumentFragment(node) {
|
| + var nodes = new NodeList();
|
| + var i = 0;
|
| + for (var child = node.firstChild; child; child = child.nextSibling) {
|
| + nodes[i++] = child;
|
| + }
|
| + nodes.length = i;
|
| + enqueueRemovalForInsertedDocumentFragment(node, nodes);
|
| + return nodes;
|
| + }
|
| +
|
| + function snapshotNodeList(nodeList) {
|
| + // NodeLists are not live at the moment so just return the same object.
|
| + return nodeList;
|
| + }
|
| +
|
| + // http://dom.spec.whatwg.org/#node-is-inserted
|
| + function nodeWasAdded(node) {
|
| + node.nodeIsInserted_();
|
| + }
|
| +
|
| + function nodesWereAdded(nodes) {
|
| + for (var i = 0; i < nodes.length; i++) {
|
| + nodeWasAdded(nodes[i]);
|
| + }
|
| + }
|
| +
|
| + // http://dom.spec.whatwg.org/#node-is-removed
|
| + function nodeWasRemoved(node) {
|
| + // Nothing at this point in time.
|
| + }
|
| +
|
| + function nodesWereRemoved(nodes) {
|
| + // Nothing at this point in time.
|
| + }
|
| +
|
| + function ensureSameOwnerDocument(parent, child) {
|
| + var ownerDoc = parent.nodeType === Node.DOCUMENT_NODE ?
|
| + parent : parent.ownerDocument;
|
| + if (ownerDoc !== child.ownerDocument)
|
| + ownerDoc.adoptNode(child);
|
| + }
|
| +
|
| + function adoptNodesIfNeeded(owner, nodes) {
|
| + if (!nodes.length)
|
| + return;
|
| +
|
| + var ownerDoc = owner.ownerDocument;
|
| +
|
| + // All nodes have the same ownerDocument when we get here.
|
| + if (ownerDoc === nodes[0].ownerDocument)
|
| + return;
|
| +
|
| + for (var i = 0; i < nodes.length; i++) {
|
| + scope.adoptNodeNoRemove(nodes[i], ownerDoc);
|
| + }
|
| + }
|
| +
|
| + function unwrapNodesForInsertion(owner, nodes) {
|
| + adoptNodesIfNeeded(owner, nodes);
|
| + var length = nodes.length;
|
| +
|
| + if (length === 1)
|
| + return unwrap(nodes[0]);
|
| +
|
| + var df = unwrap(owner.ownerDocument.createDocumentFragment());
|
| + for (var i = 0; i < length; i++) {
|
| + df.appendChild(unwrap(nodes[i]));
|
| + }
|
| + return df;
|
| + }
|
| +
|
| + function clearChildNodes(wrapper) {
|
| + if (wrapper.firstChild_ !== undefined) {
|
| + var child = wrapper.firstChild_;
|
| + while (child) {
|
| + var tmp = child;
|
| + child = child.nextSibling_;
|
| + tmp.parentNode_ = tmp.previousSibling_ = tmp.nextSibling_ = undefined;
|
| + }
|
| + }
|
| + wrapper.firstChild_ = wrapper.lastChild_ = undefined;
|
| + }
|
| +
|
| + function removeAllChildNodes(wrapper) {
|
| + if (wrapper.invalidateShadowRenderer()) {
|
| + var childWrapper = wrapper.firstChild;
|
| + while (childWrapper) {
|
| + assert(childWrapper.parentNode === wrapper);
|
| + var nextSibling = childWrapper.nextSibling;
|
| + var childNode = unwrap(childWrapper);
|
| + var parentNode = childNode.parentNode;
|
| + if (parentNode)
|
| + originalRemoveChild.call(parentNode, childNode);
|
| + childWrapper.previousSibling_ = childWrapper.nextSibling_ =
|
| + childWrapper.parentNode_ = null;
|
| + childWrapper = nextSibling;
|
| + }
|
| + wrapper.firstChild_ = wrapper.lastChild_ = null;
|
| + } else {
|
| + var node = unwrap(wrapper);
|
| + var child = node.firstChild;
|
| + var nextSibling;
|
| + while (child) {
|
| + nextSibling = child.nextSibling;
|
| + originalRemoveChild.call(node, child);
|
| + child = nextSibling;
|
| + }
|
| + }
|
| + }
|
| +
|
| + function invalidateParent(node) {
|
| + var p = node.parentNode;
|
| + return p && p.invalidateShadowRenderer();
|
| + }
|
| +
|
| + function cleanupNodes(nodes) {
|
| + for (var i = 0, n; i < nodes.length; i++) {
|
| + n = nodes[i];
|
| + n.parentNode.removeChild(n);
|
| + }
|
| + }
|
| +
|
| + var OriginalNode = window.Node;
|
| +
|
| + /**
|
| + * This represents a wrapper of a native DOM node.
|
| + * @param {!Node} original The original DOM node, aka, the visual DOM node.
|
| + * @constructor
|
| + * @extends {EventTarget}
|
| + */
|
| + function Node(original) {
|
| + assert(original instanceof OriginalNode);
|
| +
|
| + EventTarget.call(this, original);
|
| +
|
| + // These properties are used to override the visual references with the
|
| + // logical ones. If the value is undefined it means that the logical is the
|
| + // same as the visual.
|
| +
|
| + /**
|
| + * @type {Node|undefined}
|
| + * @private
|
| + */
|
| + this.parentNode_ = undefined;
|
| +
|
| + /**
|
| + * @type {Node|undefined}
|
| + * @private
|
| + */
|
| + this.firstChild_ = undefined;
|
| +
|
| + /**
|
| + * @type {Node|undefined}
|
| + * @private
|
| + */
|
| + this.lastChild_ = undefined;
|
| +
|
| + /**
|
| + * @type {Node|undefined}
|
| + * @private
|
| + */
|
| + this.nextSibling_ = undefined;
|
| +
|
| + /**
|
| + * @type {Node|undefined}
|
| + * @private
|
| + */
|
| + this.previousSibling_ = undefined;
|
| + }
|
| +
|
| + var OriginalDocumentFragment = window.DocumentFragment;
|
| + var originalAppendChild = OriginalNode.prototype.appendChild;
|
| + var originalCompareDocumentPosition =
|
| + OriginalNode.prototype.compareDocumentPosition;
|
| + var originalInsertBefore = OriginalNode.prototype.insertBefore;
|
| + var originalRemoveChild = OriginalNode.prototype.removeChild;
|
| + var originalReplaceChild = OriginalNode.prototype.replaceChild;
|
| +
|
| + var isIe = /Trident/.test(navigator.userAgent);
|
| +
|
| + var removeChildOriginalHelper = isIe ?
|
| + function(parent, child) {
|
| + try {
|
| + originalRemoveChild.call(parent, child);
|
| + } catch (ex) {
|
| + if (!(parent instanceof OriginalDocumentFragment))
|
| + throw ex;
|
| + }
|
| + } :
|
| + function(parent, child) {
|
| + originalRemoveChild.call(parent, child);
|
| + };
|
| +
|
| + Node.prototype = Object.create(EventTarget.prototype);
|
| + mixin(Node.prototype, {
|
| + appendChild: function(childWrapper) {
|
| + return this.insertBefore(childWrapper, null);
|
| + },
|
| +
|
| + insertBefore: function(childWrapper, refWrapper) {
|
| + assertIsNodeWrapper(childWrapper);
|
| +
|
| + var refNode;
|
| + if (refWrapper) {
|
| + if (isWrapper(refWrapper)) {
|
| + refNode = unwrap(refWrapper);
|
| + } else {
|
| + refNode = refWrapper;
|
| + refWrapper = wrap(refNode);
|
| + }
|
| + } else {
|
| + refWrapper = null;
|
| + refNode = null;
|
| + }
|
| +
|
| + refWrapper && assert(refWrapper.parentNode === this);
|
| +
|
| + var nodes;
|
| + var previousNode =
|
| + refWrapper ? refWrapper.previousSibling : this.lastChild;
|
| +
|
| + var useNative = !this.invalidateShadowRenderer() &&
|
| + !invalidateParent(childWrapper);
|
| +
|
| + if (useNative)
|
| + nodes = collectNodesNative(childWrapper);
|
| + else
|
| + nodes = collectNodes(childWrapper, this, previousNode, refWrapper);
|
| +
|
| + if (useNative) {
|
| + ensureSameOwnerDocument(this, childWrapper);
|
| + clearChildNodes(this);
|
| + originalInsertBefore.call(this.impl, unwrap(childWrapper), refNode);
|
| + } else {
|
| + if (!previousNode)
|
| + this.firstChild_ = nodes[0];
|
| + if (!refWrapper)
|
| + this.lastChild_ = nodes[nodes.length - 1];
|
| +
|
| + var parentNode = refNode ? refNode.parentNode : this.impl;
|
| +
|
| + // insertBefore refWrapper no matter what the parent is?
|
| + if (parentNode) {
|
| + originalInsertBefore.call(parentNode,
|
| + unwrapNodesForInsertion(this, nodes), refNode);
|
| + } else {
|
| + adoptNodesIfNeeded(this, nodes);
|
| + }
|
| + }
|
| +
|
| + enqueueMutation(this, 'childList', {
|
| + addedNodes: nodes,
|
| + nextSibling: refWrapper,
|
| + previousSibling: previousNode
|
| + });
|
| +
|
| + nodesWereAdded(nodes);
|
| +
|
| + return childWrapper;
|
| + },
|
| +
|
| + removeChild: function(childWrapper) {
|
| + assertIsNodeWrapper(childWrapper);
|
| + if (childWrapper.parentNode !== this) {
|
| + // IE has invalid DOM trees at times.
|
| + var found = false;
|
| + var childNodes = this.childNodes;
|
| + for (var ieChild = this.firstChild; ieChild;
|
| + ieChild = ieChild.nextSibling) {
|
| + if (ieChild === childWrapper) {
|
| + found = true;
|
| + break;
|
| + }
|
| + }
|
| + if (!found) {
|
| + // TODO(arv): DOMException
|
| + throw new Error('NotFoundError');
|
| + }
|
| + }
|
| +
|
| + var childNode = unwrap(childWrapper);
|
| + var childWrapperNextSibling = childWrapper.nextSibling;
|
| + var childWrapperPreviousSibling = childWrapper.previousSibling;
|
| +
|
| + if (this.invalidateShadowRenderer()) {
|
| + // We need to remove the real node from the DOM before updating the
|
| + // pointers. This is so that that mutation event is dispatched before
|
| + // the pointers have changed.
|
| + var thisFirstChild = this.firstChild;
|
| + var thisLastChild = this.lastChild;
|
| +
|
| + var parentNode = childNode.parentNode;
|
| + if (parentNode)
|
| + removeChildOriginalHelper(parentNode, childNode);
|
| +
|
| + if (thisFirstChild === childWrapper)
|
| + this.firstChild_ = childWrapperNextSibling;
|
| + if (thisLastChild === childWrapper)
|
| + this.lastChild_ = childWrapperPreviousSibling;
|
| + if (childWrapperPreviousSibling)
|
| + childWrapperPreviousSibling.nextSibling_ = childWrapperNextSibling;
|
| + if (childWrapperNextSibling) {
|
| + childWrapperNextSibling.previousSibling_ =
|
| + childWrapperPreviousSibling;
|
| + }
|
| +
|
| + childWrapper.previousSibling_ = childWrapper.nextSibling_ =
|
| + childWrapper.parentNode_ = undefined;
|
| + } else {
|
| + clearChildNodes(this);
|
| + removeChildOriginalHelper(this.impl, childNode);
|
| + }
|
| +
|
| + if (!surpressMutations) {
|
| + enqueueMutation(this, 'childList', {
|
| + removedNodes: createOneElementNodeList(childWrapper),
|
| + nextSibling: childWrapperNextSibling,
|
| + previousSibling: childWrapperPreviousSibling
|
| + });
|
| + }
|
| +
|
| + registerTransientObservers(this, childWrapper);
|
| +
|
| + return childWrapper;
|
| + },
|
| +
|
| + replaceChild: function(newChildWrapper, oldChildWrapper) {
|
| + assertIsNodeWrapper(newChildWrapper);
|
| +
|
| + var oldChildNode;
|
| + if (isWrapper(oldChildWrapper)) {
|
| + oldChildNode = unwrap(oldChildWrapper);
|
| + } else {
|
| + oldChildNode = oldChildWrapper;
|
| + oldChildWrapper = wrap(oldChildNode);
|
| + }
|
| +
|
| + if (oldChildWrapper.parentNode !== this) {
|
| + // TODO(arv): DOMException
|
| + throw new Error('NotFoundError');
|
| + }
|
| +
|
| + var nextNode = oldChildWrapper.nextSibling;
|
| + var previousNode = oldChildWrapper.previousSibling;
|
| + var nodes;
|
| +
|
| + var useNative = !this.invalidateShadowRenderer() &&
|
| + !invalidateParent(newChildWrapper);
|
| +
|
| + if (useNative) {
|
| + nodes = collectNodesNative(newChildWrapper);
|
| + } else {
|
| + if (nextNode === newChildWrapper)
|
| + nextNode = newChildWrapper.nextSibling;
|
| + nodes = collectNodes(newChildWrapper, this, previousNode, nextNode);
|
| + }
|
| +
|
| + if (!useNative) {
|
| + if (this.firstChild === oldChildWrapper)
|
| + this.firstChild_ = nodes[0];
|
| + if (this.lastChild === oldChildWrapper)
|
| + this.lastChild_ = nodes[nodes.length - 1];
|
| +
|
| + oldChildWrapper.previousSibling_ = oldChildWrapper.nextSibling_ =
|
| + oldChildWrapper.parentNode_ = undefined;
|
| +
|
| + // replaceChild no matter what the parent is?
|
| + if (oldChildNode.parentNode) {
|
| + originalReplaceChild.call(
|
| + oldChildNode.parentNode,
|
| + unwrapNodesForInsertion(this, nodes),
|
| + oldChildNode);
|
| + }
|
| + } else {
|
| + ensureSameOwnerDocument(this, newChildWrapper);
|
| + clearChildNodes(this);
|
| + originalReplaceChild.call(this.impl, unwrap(newChildWrapper),
|
| + oldChildNode);
|
| + }
|
| +
|
| + enqueueMutation(this, 'childList', {
|
| + addedNodes: nodes,
|
| + removedNodes: createOneElementNodeList(oldChildWrapper),
|
| + nextSibling: nextNode,
|
| + previousSibling: previousNode
|
| + });
|
| +
|
| + nodeWasRemoved(oldChildWrapper);
|
| + nodesWereAdded(nodes);
|
| +
|
| + return oldChildWrapper;
|
| + },
|
| +
|
| + /**
|
| + * Called after a node was inserted. Subclasses override this to invalidate
|
| + * the renderer as needed.
|
| + * @private
|
| + */
|
| + nodeIsInserted_: function() {
|
| + for (var child = this.firstChild; child; child = child.nextSibling) {
|
| + child.nodeIsInserted_();
|
| + }
|
| + },
|
| +
|
| + hasChildNodes: function() {
|
| + return this.firstChild !== null;
|
| + },
|
| +
|
| + /** @type {Node} */
|
| + get parentNode() {
|
| + // If the parentNode has not been overridden, use the original parentNode.
|
| + return this.parentNode_ !== undefined ?
|
| + this.parentNode_ : wrap(this.impl.parentNode);
|
| + },
|
| +
|
| + /** @type {Node} */
|
| + get firstChild() {
|
| + return this.firstChild_ !== undefined ?
|
| + this.firstChild_ : wrap(this.impl.firstChild);
|
| + },
|
| +
|
| + /** @type {Node} */
|
| + get lastChild() {
|
| + return this.lastChild_ !== undefined ?
|
| + this.lastChild_ : wrap(this.impl.lastChild);
|
| + },
|
| +
|
| + /** @type {Node} */
|
| + get nextSibling() {
|
| + return this.nextSibling_ !== undefined ?
|
| + this.nextSibling_ : wrap(this.impl.nextSibling);
|
| + },
|
| +
|
| + /** @type {Node} */
|
| + get previousSibling() {
|
| + return this.previousSibling_ !== undefined ?
|
| + this.previousSibling_ : wrap(this.impl.previousSibling);
|
| + },
|
| +
|
| + get parentElement() {
|
| + var p = this.parentNode;
|
| + while (p && p.nodeType !== Node.ELEMENT_NODE) {
|
| + p = p.parentNode;
|
| + }
|
| + return p;
|
| + },
|
| +
|
| + get textContent() {
|
| + // TODO(arv): This should fallback to this.impl.textContent if there
|
| + // are no shadow trees below or above the context node.
|
| + var s = '';
|
| + for (var child = this.firstChild; child; child = child.nextSibling) {
|
| + if (child.nodeType != Node.COMMENT_NODE) {
|
| + s += child.textContent;
|
| + }
|
| + }
|
| + return s;
|
| + },
|
| + set textContent(textContent) {
|
| + var removedNodes = snapshotNodeList(this.childNodes);
|
| +
|
| + if (this.invalidateShadowRenderer()) {
|
| + removeAllChildNodes(this);
|
| + if (textContent !== '') {
|
| + var textNode = this.impl.ownerDocument.createTextNode(textContent);
|
| + this.appendChild(textNode);
|
| + }
|
| + } else {
|
| + clearChildNodes(this);
|
| + this.impl.textContent = textContent;
|
| + }
|
| +
|
| + var addedNodes = snapshotNodeList(this.childNodes);
|
| +
|
| + enqueueMutation(this, 'childList', {
|
| + addedNodes: addedNodes,
|
| + removedNodes: removedNodes
|
| + });
|
| +
|
| + nodesWereRemoved(removedNodes);
|
| + nodesWereAdded(addedNodes);
|
| + },
|
| +
|
| + get childNodes() {
|
| + var wrapperList = new NodeList();
|
| + var i = 0;
|
| + for (var child = this.firstChild; child; child = child.nextSibling) {
|
| + wrapperList[i++] = child;
|
| + }
|
| + wrapperList.length = i;
|
| + return wrapperList;
|
| + },
|
| +
|
| + cloneNode: function(deep) {
|
| + var clone = wrap(this.impl.cloneNode(false));
|
| + if (deep) {
|
| + for (var child = this.firstChild; child; child = child.nextSibling) {
|
| + clone.appendChild(child.cloneNode(true));
|
| + }
|
| + }
|
| + // TODO(arv): Some HTML elements also clone other data like value.
|
| + return clone;
|
| + },
|
| +
|
| + contains: function(child) {
|
| + if (!child)
|
| + return false;
|
| +
|
| + child = wrapIfNeeded(child);
|
| +
|
| + // TODO(arv): Optimize using ownerDocument etc.
|
| + if (child === this)
|
| + return true;
|
| + var parentNode = child.parentNode;
|
| + if (!parentNode)
|
| + return false;
|
| + return this.contains(parentNode);
|
| + },
|
| +
|
| + compareDocumentPosition: function(otherNode) {
|
| + // This only wraps, it therefore only operates on the composed DOM and not
|
| + // the logical DOM.
|
| + return originalCompareDocumentPosition.call(this.impl, unwrap(otherNode));
|
| + },
|
| +
|
| + normalize: function() {
|
| + var nodes = snapshotNodeList(this.childNodes);
|
| + var remNodes = [];
|
| + var s = '';
|
| + var modNode;
|
| +
|
| + for (var i = 0, n; i < nodes.length; i++) {
|
| + n = nodes[i];
|
| + if (n.nodeType === Node.TEXT_NODE) {
|
| + if (!modNode && !n.data.length)
|
| + this.removeNode(n);
|
| + else if (!modNode)
|
| + modNode = n;
|
| + else {
|
| + s += n.data;
|
| + remNodes.push(n);
|
| + }
|
| + } else {
|
| + if (modNode && remNodes.length) {
|
| + modNode.data += s;
|
| + cleanUpNodes(remNodes);
|
| + }
|
| + remNodes = [];
|
| + s = '';
|
| + modNode = null;
|
| + if (n.childNodes.length)
|
| + n.normalize();
|
| + }
|
| + }
|
| +
|
| + // handle case where >1 text nodes are the last children
|
| + if (modNode && remNodes.length) {
|
| + modNode.data += s;
|
| + cleanupNodes(remNodes);
|
| + }
|
| + }
|
| + });
|
| +
|
| + defineWrapGetter(Node, 'ownerDocument');
|
| +
|
| + // We use a DocumentFragment as a base and then delete the properties of
|
| + // DocumentFragment.prototype from the wrapper Node. Since delete makes
|
| + // objects slow in some JS engines we recreate the prototype object.
|
| + registerWrapper(OriginalNode, Node, document.createDocumentFragment());
|
| + delete Node.prototype.querySelector;
|
| + delete Node.prototype.querySelectorAll;
|
| + Node.prototype = mixin(Object.create(EventTarget.prototype), Node.prototype);
|
| +
|
| + scope.nodeWasAdded = nodeWasAdded;
|
| + scope.nodeWasRemoved = nodeWasRemoved;
|
| + scope.nodesWereAdded = nodesWereAdded;
|
| + scope.nodesWereRemoved = nodesWereRemoved;
|
| + scope.snapshotNodeList = snapshotNodeList;
|
| + scope.wrappers.Node = Node;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is governed by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + function findOne(node, selector) {
|
| + var m, el = node.firstElementChild;
|
| + while (el) {
|
| + if (el.matches(selector))
|
| + return el;
|
| + m = findOne(el, selector);
|
| + if (m)
|
| + return m;
|
| + el = el.nextElementSibling;
|
| + }
|
| + return null;
|
| + }
|
| +
|
| + function findAll(node, selector, results) {
|
| + var el = node.firstElementChild;
|
| + while (el) {
|
| + if (el.matches(selector))
|
| + results[results.length++] = el;
|
| + findAll(el, selector, results);
|
| + el = el.nextElementSibling;
|
| + }
|
| + return results;
|
| + }
|
| +
|
| + // find and findAll will only match Simple Selectors,
|
| + // Structural Pseudo Classes are not guarenteed to be correct
|
| + // http://www.w3.org/TR/css3-selectors/#simple-selectors
|
| +
|
| + var SelectorsInterface = {
|
| + querySelector: function(selector) {
|
| + return findOne(this, selector);
|
| + },
|
| + querySelectorAll: function(selector) {
|
| + return findAll(this, selector, new NodeList())
|
| + }
|
| + };
|
| +
|
| + var GetElementsByInterface = {
|
| + getElementsByTagName: function(tagName) {
|
| + // TODO(arv): Check tagName?
|
| + return this.querySelectorAll(tagName);
|
| + },
|
| + getElementsByClassName: function(className) {
|
| + // TODO(arv): Check className?
|
| + return this.querySelectorAll('.' + className);
|
| + },
|
| + getElementsByTagNameNS: function(ns, tagName) {
|
| + if (ns === '*')
|
| + return this.getElementsByTagName(tagName);
|
| +
|
| + // TODO(arv): Check tagName?
|
| + var result = new NodeList;
|
| + var els = this.getElementsByTagName(tagName);
|
| + for (var i = 0, j = 0; i < els.length; i++) {
|
| + if (els[i].namespaceURI === ns)
|
| + result[j++] = els[i];
|
| + }
|
| + result.length = j;
|
| + return result;
|
| + }
|
| + };
|
| +
|
| + scope.GetElementsByInterface = GetElementsByInterface;
|
| + scope.SelectorsInterface = SelectorsInterface;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var NodeList = scope.wrappers.NodeList;
|
| +
|
| + function forwardElement(node) {
|
| + while (node && node.nodeType !== Node.ELEMENT_NODE) {
|
| + node = node.nextSibling;
|
| + }
|
| + return node;
|
| + }
|
| +
|
| + function backwardsElement(node) {
|
| + while (node && node.nodeType !== Node.ELEMENT_NODE) {
|
| + node = node.previousSibling;
|
| + }
|
| + return node;
|
| + }
|
| +
|
| + var ParentNodeInterface = {
|
| + get firstElementChild() {
|
| + return forwardElement(this.firstChild);
|
| + },
|
| +
|
| + get lastElementChild() {
|
| + return backwardsElement(this.lastChild);
|
| + },
|
| +
|
| + get childElementCount() {
|
| + var count = 0;
|
| + for (var child = this.firstElementChild;
|
| + child;
|
| + child = child.nextElementSibling) {
|
| + count++;
|
| + }
|
| + return count;
|
| + },
|
| +
|
| + get children() {
|
| + var wrapperList = new NodeList();
|
| + var i = 0;
|
| + for (var child = this.firstElementChild;
|
| + child;
|
| + child = child.nextElementSibling) {
|
| + wrapperList[i++] = child;
|
| + }
|
| + wrapperList.length = i;
|
| + return wrapperList;
|
| + }
|
| + };
|
| +
|
| + var ChildNodeInterface = {
|
| + get nextElementSibling() {
|
| + return forwardElement(this.nextSibling);
|
| + },
|
| +
|
| + get previousElementSibling() {
|
| + return backwardsElement(this.previousSibling);
|
| + }
|
| + };
|
| +
|
| + scope.ChildNodeInterface = ChildNodeInterface;
|
| + scope.ParentNodeInterface = ParentNodeInterface;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var ChildNodeInterface = scope.ChildNodeInterface;
|
| + var Node = scope.wrappers.Node;
|
| + var enqueueMutation = scope.enqueueMutation;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| +
|
| + var OriginalCharacterData = window.CharacterData;
|
| +
|
| + function CharacterData(node) {
|
| + Node.call(this, node);
|
| + }
|
| + CharacterData.prototype = Object.create(Node.prototype);
|
| + mixin(CharacterData.prototype, {
|
| + get textContent() {
|
| + return this.data;
|
| + },
|
| + set textContent(value) {
|
| + this.data = value;
|
| + },
|
| + get data() {
|
| + return this.impl.data;
|
| + },
|
| + set data(value) {
|
| + var oldValue = this.impl.data;
|
| + enqueueMutation(this, 'characterData', {
|
| + oldValue: oldValue
|
| + });
|
| + this.impl.data = value;
|
| + }
|
| + });
|
| +
|
| + mixin(CharacterData.prototype, ChildNodeInterface);
|
| +
|
| + registerWrapper(OriginalCharacterData, CharacterData,
|
| + document.createTextNode(''));
|
| +
|
| + scope.wrappers.CharacterData = CharacterData;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2014 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var CharacterData = scope.wrappers.CharacterData;
|
| + var enqueueMutation = scope.enqueueMutation;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| +
|
| + function toUInt32(x) {
|
| + return x >>> 0;
|
| + }
|
| +
|
| + var OriginalText = window.Text;
|
| +
|
| + function Text(node) {
|
| + CharacterData.call(this, node);
|
| + }
|
| + Text.prototype = Object.create(CharacterData.prototype);
|
| + mixin(Text.prototype, {
|
| + splitText: function(offset) {
|
| + offset = toUInt32(offset);
|
| + var s = this.data;
|
| + if (offset > s.length)
|
| + throw new Error('IndexSizeError');
|
| + var head = s.slice(0, offset);
|
| + var tail = s.slice(offset);
|
| + this.data = head;
|
| + var newTextNode = this.ownerDocument.createTextNode(tail);
|
| + if (this.parentNode)
|
| + this.parentNode.insertBefore(newTextNode, this.nextSibling);
|
| + return newTextNode;
|
| + }
|
| + });
|
| +
|
| + registerWrapper(OriginalText, Text, document.createTextNode(''));
|
| +
|
| + scope.wrappers.Text = Text;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var ChildNodeInterface = scope.ChildNodeInterface;
|
| + var GetElementsByInterface = scope.GetElementsByInterface;
|
| + var Node = scope.wrappers.Node;
|
| + var ParentNodeInterface = scope.ParentNodeInterface;
|
| + var SelectorsInterface = scope.SelectorsInterface;
|
| + var addWrapNodeListMethod = scope.addWrapNodeListMethod;
|
| + var enqueueMutation = scope.enqueueMutation;
|
| + var mixin = scope.mixin;
|
| + var oneOf = scope.oneOf;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var wrappers = scope.wrappers;
|
| +
|
| + var OriginalElement = window.Element;
|
| +
|
| + var matchesNames = [
|
| + 'matches', // needs to come first.
|
| + 'mozMatchesSelector',
|
| + 'msMatchesSelector',
|
| + 'webkitMatchesSelector',
|
| + ].filter(function(name) {
|
| + return OriginalElement.prototype[name];
|
| + });
|
| +
|
| + var matchesName = matchesNames[0];
|
| +
|
| + var originalMatches = OriginalElement.prototype[matchesName];
|
| +
|
| + function invalidateRendererBasedOnAttribute(element, name) {
|
| + // Only invalidate if parent node is a shadow host.
|
| + var p = element.parentNode;
|
| + if (!p || !p.shadowRoot)
|
| + return;
|
| +
|
| + var renderer = scope.getRendererForHost(p);
|
| + if (renderer.dependsOnAttribute(name))
|
| + renderer.invalidate();
|
| + }
|
| +
|
| + function enqueAttributeChange(element, name, oldValue) {
|
| + // This is not fully spec compliant. We should use localName (which might
|
| + // have a different case than name) and the namespace (which requires us
|
| + // to get the Attr object).
|
| + enqueueMutation(element, 'attributes', {
|
| + name: name,
|
| + namespace: null,
|
| + oldValue: oldValue
|
| + });
|
| + }
|
| +
|
| + function Element(node) {
|
| + Node.call(this, node);
|
| + }
|
| + Element.prototype = Object.create(Node.prototype);
|
| + mixin(Element.prototype, {
|
| + createShadowRoot: function() {
|
| + var newShadowRoot = new wrappers.ShadowRoot(this);
|
| + this.impl.polymerShadowRoot_ = newShadowRoot;
|
| +
|
| + var renderer = scope.getRendererForHost(this);
|
| + renderer.invalidate();
|
| +
|
| + return newShadowRoot;
|
| + },
|
| +
|
| + get shadowRoot() {
|
| + return this.impl.polymerShadowRoot_ || null;
|
| + },
|
| +
|
| + setAttribute: function(name, value) {
|
| + var oldValue = this.impl.getAttribute(name);
|
| + this.impl.setAttribute(name, value);
|
| + enqueAttributeChange(this, name, oldValue);
|
| + invalidateRendererBasedOnAttribute(this, name);
|
| + },
|
| +
|
| + removeAttribute: function(name) {
|
| + var oldValue = this.impl.getAttribute(name);
|
| + this.impl.removeAttribute(name);
|
| + enqueAttributeChange(this, name, oldValue);
|
| + invalidateRendererBasedOnAttribute(this, name);
|
| + },
|
| +
|
| + matches: function(selector) {
|
| + return originalMatches.call(this.impl, selector);
|
| + }
|
| + });
|
| +
|
| + matchesNames.forEach(function(name) {
|
| + if (name !== 'matches') {
|
| + Element.prototype[name] = function(selector) {
|
| + return this.matches(selector);
|
| + };
|
| + }
|
| + });
|
| +
|
| + if (OriginalElement.prototype.webkitCreateShadowRoot) {
|
| + Element.prototype.webkitCreateShadowRoot =
|
| + Element.prototype.createShadowRoot;
|
| + }
|
| +
|
| + /**
|
| + * Useful for generating the accessor pair for a property that reflects an
|
| + * attribute.
|
| + */
|
| + function setterDirtiesAttribute(prototype, propertyName, opt_attrName) {
|
| + var attrName = opt_attrName || propertyName;
|
| + Object.defineProperty(prototype, propertyName, {
|
| + get: function() {
|
| + return this.impl[propertyName];
|
| + },
|
| + set: function(v) {
|
| + this.impl[propertyName] = v;
|
| + invalidateRendererBasedOnAttribute(this, attrName);
|
| + },
|
| + configurable: true,
|
| + enumerable: true
|
| + });
|
| + }
|
| +
|
| + setterDirtiesAttribute(Element.prototype, 'id');
|
| + setterDirtiesAttribute(Element.prototype, 'className', 'class');
|
| +
|
| + mixin(Element.prototype, ChildNodeInterface);
|
| + mixin(Element.prototype, GetElementsByInterface);
|
| + mixin(Element.prototype, ParentNodeInterface);
|
| + mixin(Element.prototype, SelectorsInterface);
|
| +
|
| + registerWrapper(OriginalElement, Element,
|
| + document.createElementNS(null, 'x'));
|
| +
|
| + // TODO(arv): Export setterDirtiesAttribute and apply it to more bindings
|
| + // that reflect attributes.
|
| + scope.matchesNames = matchesNames;
|
| + scope.wrappers.Element = Element;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var Element = scope.wrappers.Element;
|
| + var defineGetter = scope.defineGetter;
|
| + var enqueueMutation = scope.enqueueMutation;
|
| + var mixin = scope.mixin;
|
| + var nodesWereAdded = scope.nodesWereAdded;
|
| + var nodesWereRemoved = scope.nodesWereRemoved;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var snapshotNodeList = scope.snapshotNodeList;
|
| + var unwrap = scope.unwrap;
|
| + var wrap = scope.wrap;
|
| +
|
| + /////////////////////////////////////////////////////////////////////////////
|
| + // innerHTML and outerHTML
|
| +
|
| + // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#escapingString
|
| + var escapeAttrRegExp = /[&\u00A0"]/g;
|
| + var escapeDataRegExp = /[&\u00A0<>]/g;
|
| +
|
| + function escapeReplace(c) {
|
| + switch (c) {
|
| + case '&':
|
| + return '&';
|
| + case '<':
|
| + return '<';
|
| + case '>':
|
| + return '>';
|
| + case '"':
|
| + return '"'
|
| + case '\u00A0':
|
| + return ' ';
|
| + }
|
| + }
|
| +
|
| + function escapeAttr(s) {
|
| + return s.replace(escapeAttrRegExp, escapeReplace);
|
| + }
|
| +
|
| + function escapeData(s) {
|
| + return s.replace(escapeDataRegExp, escapeReplace);
|
| + }
|
| +
|
| + function makeSet(arr) {
|
| + var set = {};
|
| + for (var i = 0; i < arr.length; i++) {
|
| + set[arr[i]] = true;
|
| + }
|
| + return set;
|
| + }
|
| +
|
| + // http://www.whatwg.org/specs/web-apps/current-work/#void-elements
|
| + var voidElements = makeSet([
|
| + 'area',
|
| + 'base',
|
| + 'br',
|
| + 'col',
|
| + 'command',
|
| + 'embed',
|
| + 'hr',
|
| + 'img',
|
| + 'input',
|
| + 'keygen',
|
| + 'link',
|
| + 'meta',
|
| + 'param',
|
| + 'source',
|
| + 'track',
|
| + 'wbr'
|
| + ]);
|
| +
|
| + var plaintextParents = makeSet([
|
| + 'style',
|
| + 'script',
|
| + 'xmp',
|
| + 'iframe',
|
| + 'noembed',
|
| + 'noframes',
|
| + 'plaintext',
|
| + 'noscript'
|
| + ]);
|
| +
|
| + function getOuterHTML(node, parentNode) {
|
| + switch (node.nodeType) {
|
| + case Node.ELEMENT_NODE:
|
| + var tagName = node.tagName.toLowerCase();
|
| + var s = '<' + tagName;
|
| + var attrs = node.attributes;
|
| + for (var i = 0, attr; attr = attrs[i]; i++) {
|
| + s += ' ' + attr.name + '="' + escapeAttr(attr.value) + '"';
|
| + }
|
| + s += '>';
|
| + if (voidElements[tagName])
|
| + return s;
|
| +
|
| + return s + getInnerHTML(node) + '</' + tagName + '>';
|
| +
|
| + case Node.TEXT_NODE:
|
| + var data = node.data;
|
| + if (parentNode && plaintextParents[parentNode.localName])
|
| + return data;
|
| + return escapeData(data);
|
| +
|
| + case Node.COMMENT_NODE:
|
| + return '<!--' + node.data + '-->';
|
| +
|
| + default:
|
| + console.error(node);
|
| + throw new Error('not implemented');
|
| + }
|
| + }
|
| +
|
| + function getInnerHTML(node) {
|
| + var s = '';
|
| + for (var child = node.firstChild; child; child = child.nextSibling) {
|
| + s += getOuterHTML(child, node);
|
| + }
|
| + return s;
|
| + }
|
| +
|
| + function setInnerHTML(node, value, opt_tagName) {
|
| + var tagName = opt_tagName || 'div';
|
| + node.textContent = '';
|
| + var tempElement = unwrap(node.ownerDocument.createElement(tagName));
|
| + tempElement.innerHTML = value;
|
| + var firstChild;
|
| + while (firstChild = tempElement.firstChild) {
|
| + node.appendChild(wrap(firstChild));
|
| + }
|
| + }
|
| +
|
| + // IE11 does not have MSIE in the user agent string.
|
| + var oldIe = /MSIE/.test(navigator.userAgent);
|
| +
|
| + var OriginalHTMLElement = window.HTMLElement;
|
| +
|
| + function HTMLElement(node) {
|
| + Element.call(this, node);
|
| + }
|
| + HTMLElement.prototype = Object.create(Element.prototype);
|
| + mixin(HTMLElement.prototype, {
|
| + get innerHTML() {
|
| + // TODO(arv): This should fallback to this.impl.innerHTML if there
|
| + // are no shadow trees below or above the context node.
|
| + return getInnerHTML(this);
|
| + },
|
| + set innerHTML(value) {
|
| + // IE9 does not handle set innerHTML correctly on plaintextParents. It
|
| + // creates element children. For example
|
| + //
|
| + // scriptElement.innerHTML = '<a>test</a>'
|
| + //
|
| + // Creates a single HTMLAnchorElement child.
|
| + if (oldIe && plaintextParents[this.localName]) {
|
| + this.textContent = value;
|
| + return;
|
| + }
|
| +
|
| + var removedNodes = snapshotNodeList(this.childNodes);
|
| +
|
| + if (this.invalidateShadowRenderer())
|
| + setInnerHTML(this, value, this.tagName);
|
| + else
|
| + this.impl.innerHTML = value;
|
| + var addedNodes = snapshotNodeList(this.childNodes);
|
| +
|
| + enqueueMutation(this, 'childList', {
|
| + addedNodes: addedNodes,
|
| + removedNodes: removedNodes
|
| + });
|
| +
|
| + nodesWereRemoved(removedNodes);
|
| + nodesWereAdded(addedNodes);
|
| + },
|
| +
|
| + get outerHTML() {
|
| + return getOuterHTML(this, this.parentNode);
|
| + },
|
| + set outerHTML(value) {
|
| + var p = this.parentNode;
|
| + if (p) {
|
| + p.invalidateShadowRenderer();
|
| + var df = frag(p, value);
|
| + p.replaceChild(df, this);
|
| + }
|
| + },
|
| +
|
| + insertAdjacentHTML: function(position, text) {
|
| + var contextElement, refNode;
|
| + switch (String(position).toLowerCase()) {
|
| + case 'beforebegin':
|
| + contextElement = this.parentNode;
|
| + refNode = this;
|
| + break;
|
| + case 'afterend':
|
| + contextElement = this.parentNode;
|
| + refNode = this.nextSibling;
|
| + break;
|
| + case 'afterbegin':
|
| + contextElement = this;
|
| + refNode = this.firstChild;
|
| + break;
|
| + case 'beforeend':
|
| + contextElement = this;
|
| + refNode = null;
|
| + break;
|
| + default:
|
| + return;
|
| + }
|
| +
|
| + var df = frag(contextElement, text);
|
| + contextElement.insertBefore(df, refNode);
|
| + }
|
| + });
|
| +
|
| + function frag(contextElement, html) {
|
| + // TODO(arv): This does not work with SVG and other non HTML elements.
|
| + var p = unwrap(contextElement.cloneNode(false));
|
| + p.innerHTML = html;
|
| + var df = unwrap(document.createDocumentFragment());
|
| + var c;
|
| + while (c = p.firstChild) {
|
| + df.appendChild(c);
|
| + }
|
| + return wrap(df);
|
| + }
|
| +
|
| + function getter(name) {
|
| + return function() {
|
| + scope.renderAllPending();
|
| + return this.impl[name];
|
| + };
|
| + }
|
| +
|
| + function getterRequiresRendering(name) {
|
| + defineGetter(HTMLElement, name, getter(name));
|
| + }
|
| +
|
| + [
|
| + 'clientHeight',
|
| + 'clientLeft',
|
| + 'clientTop',
|
| + 'clientWidth',
|
| + 'offsetHeight',
|
| + 'offsetLeft',
|
| + 'offsetTop',
|
| + 'offsetWidth',
|
| + 'scrollHeight',
|
| + 'scrollWidth',
|
| + ].forEach(getterRequiresRendering);
|
| +
|
| + function getterAndSetterRequiresRendering(name) {
|
| + Object.defineProperty(HTMLElement.prototype, name, {
|
| + get: getter(name),
|
| + set: function(v) {
|
| + scope.renderAllPending();
|
| + this.impl[name] = v;
|
| + },
|
| + configurable: true,
|
| + enumerable: true
|
| + });
|
| + }
|
| +
|
| + [
|
| + 'scrollLeft',
|
| + 'scrollTop',
|
| + ].forEach(getterAndSetterRequiresRendering);
|
| +
|
| + function methodRequiresRendering(name) {
|
| + Object.defineProperty(HTMLElement.prototype, name, {
|
| + value: function() {
|
| + scope.renderAllPending();
|
| + return this.impl[name].apply(this.impl, arguments);
|
| + },
|
| + configurable: true,
|
| + enumerable: true
|
| + });
|
| + }
|
| +
|
| + [
|
| + 'getBoundingClientRect',
|
| + 'getClientRects',
|
| + 'scrollIntoView'
|
| + ].forEach(methodRequiresRendering);
|
| +
|
| + // HTMLElement is abstract so we use a subclass that has no members.
|
| + registerWrapper(OriginalHTMLElement, HTMLElement,
|
| + document.createElement('b'));
|
| +
|
| + scope.wrappers.HTMLElement = HTMLElement;
|
| +
|
| + // TODO: Find a better way to share these two with WrapperShadowRoot.
|
| + scope.getInnerHTML = getInnerHTML;
|
| + scope.setInnerHTML = setInnerHTML
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var HTMLElement = scope.wrappers.HTMLElement;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var wrap = scope.wrap;
|
| +
|
| + var OriginalHTMLCanvasElement = window.HTMLCanvasElement;
|
| +
|
| + function HTMLCanvasElement(node) {
|
| + HTMLElement.call(this, node);
|
| + }
|
| + HTMLCanvasElement.prototype = Object.create(HTMLElement.prototype);
|
| +
|
| + mixin(HTMLCanvasElement.prototype, {
|
| + getContext: function() {
|
| + var context = this.impl.getContext.apply(this.impl, arguments);
|
| + return context && wrap(context);
|
| + }
|
| + });
|
| +
|
| + registerWrapper(OriginalHTMLCanvasElement, HTMLCanvasElement,
|
| + document.createElement('canvas'));
|
| +
|
| + scope.wrappers.HTMLCanvasElement = HTMLCanvasElement;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var HTMLElement = scope.wrappers.HTMLElement;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| +
|
| + var OriginalHTMLContentElement = window.HTMLContentElement;
|
| +
|
| + function HTMLContentElement(node) {
|
| + HTMLElement.call(this, node);
|
| + }
|
| + HTMLContentElement.prototype = Object.create(HTMLElement.prototype);
|
| + mixin(HTMLContentElement.prototype, {
|
| + get select() {
|
| + return this.getAttribute('select');
|
| + },
|
| + set select(value) {
|
| + this.setAttribute('select', value);
|
| + },
|
| +
|
| + setAttribute: function(n, v) {
|
| + HTMLElement.prototype.setAttribute.call(this, n, v);
|
| + if (String(n).toLowerCase() === 'select')
|
| + this.invalidateShadowRenderer(true);
|
| + }
|
| +
|
| + // getDistributedNodes is added in ShadowRenderer
|
| +
|
| + // TODO: attribute boolean resetStyleInheritance;
|
| + });
|
| +
|
| + if (OriginalHTMLContentElement)
|
| + registerWrapper(OriginalHTMLContentElement, HTMLContentElement);
|
| +
|
| + scope.wrappers.HTMLContentElement = HTMLContentElement;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var HTMLElement = scope.wrappers.HTMLElement;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var unwrap = scope.unwrap;
|
| + var rewrap = scope.rewrap;
|
| +
|
| + var OriginalHTMLImageElement = window.HTMLImageElement;
|
| +
|
| + function HTMLImageElement(node) {
|
| + HTMLElement.call(this, node);
|
| + }
|
| + HTMLImageElement.prototype = Object.create(HTMLElement.prototype);
|
| +
|
| + registerWrapper(OriginalHTMLImageElement, HTMLImageElement,
|
| + document.createElement('img'));
|
| +
|
| + function Image(width, height) {
|
| + if (!(this instanceof Image)) {
|
| + throw new TypeError(
|
| + 'DOM object constructor cannot be called as a function.');
|
| + }
|
| +
|
| + var node = unwrap(document.createElement('img'));
|
| + HTMLElement.call(this, node);
|
| + rewrap(node, this);
|
| +
|
| + if (width !== undefined)
|
| + node.width = width;
|
| + if (height !== undefined)
|
| + node.height = height;
|
| + }
|
| +
|
| + Image.prototype = HTMLImageElement.prototype;
|
| +
|
| + scope.wrappers.HTMLImageElement = HTMLImageElement;
|
| + scope.wrappers.Image = Image;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var HTMLElement = scope.wrappers.HTMLElement;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| +
|
| + var OriginalHTMLShadowElement = window.HTMLShadowElement;
|
| +
|
| + function HTMLShadowElement(node) {
|
| + HTMLElement.call(this, node);
|
| + }
|
| + HTMLShadowElement.prototype = Object.create(HTMLElement.prototype);
|
| + mixin(HTMLShadowElement.prototype, {
|
| + // TODO: attribute boolean resetStyleInheritance;
|
| + });
|
| +
|
| + if (OriginalHTMLShadowElement)
|
| + registerWrapper(OriginalHTMLShadowElement, HTMLShadowElement);
|
| +
|
| + scope.wrappers.HTMLShadowElement = HTMLShadowElement;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var HTMLElement = scope.wrappers.HTMLElement;
|
| + var getInnerHTML = scope.getInnerHTML;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var setInnerHTML = scope.setInnerHTML;
|
| + var unwrap = scope.unwrap;
|
| + var wrap = scope.wrap;
|
| +
|
| + var contentTable = new WeakMap();
|
| + var templateContentsOwnerTable = new WeakMap();
|
| +
|
| + // http://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/templates/index.html#dfn-template-contents-owner
|
| + function getTemplateContentsOwner(doc) {
|
| + if (!doc.defaultView)
|
| + return doc;
|
| + var d = templateContentsOwnerTable.get(doc);
|
| + if (!d) {
|
| + // TODO(arv): This should either be a Document or HTMLDocument depending
|
| + // on doc.
|
| + d = doc.implementation.createHTMLDocument('');
|
| + while (d.lastChild) {
|
| + d.removeChild(d.lastChild);
|
| + }
|
| + templateContentsOwnerTable.set(doc, d);
|
| + }
|
| + return d;
|
| + }
|
| +
|
| + function extractContent(templateElement) {
|
| + // templateElement is not a wrapper here.
|
| + var doc = getTemplateContentsOwner(templateElement.ownerDocument);
|
| + var df = unwrap(doc.createDocumentFragment());
|
| + var child;
|
| + while (child = templateElement.firstChild) {
|
| + df.appendChild(child);
|
| + }
|
| + return df;
|
| + }
|
| +
|
| + var OriginalHTMLTemplateElement = window.HTMLTemplateElement;
|
| +
|
| + function HTMLTemplateElement(node) {
|
| + HTMLElement.call(this, node);
|
| + if (!OriginalHTMLTemplateElement) {
|
| + var content = extractContent(node);
|
| + contentTable.set(this, wrap(content));
|
| + }
|
| + }
|
| + HTMLTemplateElement.prototype = Object.create(HTMLElement.prototype);
|
| +
|
| + mixin(HTMLTemplateElement.prototype, {
|
| + get content() {
|
| + if (OriginalHTMLTemplateElement)
|
| + return wrap(this.impl.content);
|
| + return contentTable.get(this);
|
| + },
|
| +
|
| + get innerHTML() {
|
| + return getInnerHTML(this.content);
|
| + },
|
| + set innerHTML(value) {
|
| + setInnerHTML(this.content, value);
|
| + }
|
| +
|
| + // TODO(arv): cloneNode needs to clone content.
|
| +
|
| + });
|
| +
|
| + if (OriginalHTMLTemplateElement)
|
| + registerWrapper(OriginalHTMLTemplateElement, HTMLTemplateElement);
|
| +
|
| + scope.wrappers.HTMLTemplateElement = HTMLTemplateElement;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var HTMLElement = scope.wrappers.HTMLElement;
|
| + var registerWrapper = scope.registerWrapper;
|
| +
|
| + var OriginalHTMLMediaElement = window.HTMLMediaElement;
|
| +
|
| + function HTMLMediaElement(node) {
|
| + HTMLElement.call(this, node);
|
| + }
|
| + HTMLMediaElement.prototype = Object.create(HTMLElement.prototype);
|
| +
|
| + registerWrapper(OriginalHTMLMediaElement, HTMLMediaElement,
|
| + document.createElement('audio'));
|
| +
|
| + scope.wrappers.HTMLMediaElement = HTMLMediaElement;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var HTMLMediaElement = scope.wrappers.HTMLMediaElement;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var unwrap = scope.unwrap;
|
| + var rewrap = scope.rewrap;
|
| +
|
| + var OriginalHTMLAudioElement = window.HTMLAudioElement;
|
| +
|
| + function HTMLAudioElement(node) {
|
| + HTMLMediaElement.call(this, node);
|
| + }
|
| + HTMLAudioElement.prototype = Object.create(HTMLMediaElement.prototype);
|
| +
|
| + registerWrapper(OriginalHTMLAudioElement, HTMLAudioElement,
|
| + document.createElement('audio'));
|
| +
|
| + function Audio(src) {
|
| + if (!(this instanceof Audio)) {
|
| + throw new TypeError(
|
| + 'DOM object constructor cannot be called as a function.');
|
| + }
|
| +
|
| + var node = unwrap(document.createElement('audio'));
|
| + HTMLMediaElement.call(this, node);
|
| + rewrap(node, this);
|
| +
|
| + node.setAttribute('preload', 'auto');
|
| + if (src !== undefined)
|
| + node.setAttribute('src', src);
|
| + }
|
| +
|
| + Audio.prototype = HTMLAudioElement.prototype;
|
| +
|
| + scope.wrappers.HTMLAudioElement = HTMLAudioElement;
|
| + scope.wrappers.Audio = Audio;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var HTMLElement = scope.wrappers.HTMLElement;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var rewrap = scope.rewrap;
|
| + var unwrap = scope.unwrap;
|
| + var wrap = scope.wrap;
|
| +
|
| + var OriginalHTMLOptionElement = window.HTMLOptionElement;
|
| +
|
| + function trimText(s) {
|
| + return s.replace(/\s+/g, ' ').trim();
|
| + }
|
| +
|
| + function HTMLOptionElement(node) {
|
| + HTMLElement.call(this, node);
|
| + }
|
| + HTMLOptionElement.prototype = Object.create(HTMLElement.prototype);
|
| + mixin(HTMLOptionElement.prototype, {
|
| + get text() {
|
| + return trimText(this.textContent);
|
| + },
|
| + set text(value) {
|
| + this.textContent = trimText(String(value));
|
| + },
|
| + get form() {
|
| + return wrap(unwrap(this).form);
|
| + }
|
| + });
|
| +
|
| + registerWrapper(OriginalHTMLOptionElement, HTMLOptionElement,
|
| + document.createElement('option'));
|
| +
|
| + function Option(text, value, defaultSelected, selected) {
|
| + if (!(this instanceof Option)) {
|
| + throw new TypeError(
|
| + 'DOM object constructor cannot be called as a function.');
|
| + }
|
| +
|
| + var node = unwrap(document.createElement('option'));
|
| + HTMLElement.call(this, node);
|
| + rewrap(node, this);
|
| +
|
| + if (text !== undefined)
|
| + node.text = text;
|
| + if (value !== undefined)
|
| + node.setAttribute('value', value);
|
| + if (defaultSelected === true)
|
| + node.setAttribute('selected', '');
|
| + node.selected = selected === true;
|
| + }
|
| +
|
| + Option.prototype = HTMLOptionElement.prototype;
|
| +
|
| + scope.wrappers.HTMLOptionElement = HTMLOptionElement;
|
| + scope.wrappers.Option = Option;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var HTMLContentElement = scope.wrappers.HTMLContentElement;
|
| + var HTMLElement = scope.wrappers.HTMLElement;
|
| + var HTMLShadowElement = scope.wrappers.HTMLShadowElement;
|
| + var HTMLTemplateElement = scope.wrappers.HTMLTemplateElement;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| +
|
| + var OriginalHTMLUnknownElement = window.HTMLUnknownElement;
|
| +
|
| + function HTMLUnknownElement(node) {
|
| + switch (node.localName) {
|
| + case 'content':
|
| + return new HTMLContentElement(node);
|
| + case 'shadow':
|
| + return new HTMLShadowElement(node);
|
| + case 'template':
|
| + return new HTMLTemplateElement(node);
|
| + }
|
| + HTMLElement.call(this, node);
|
| + }
|
| + HTMLUnknownElement.prototype = Object.create(HTMLElement.prototype);
|
| + registerWrapper(OriginalHTMLUnknownElement, HTMLUnknownElement);
|
| + scope.wrappers.HTMLUnknownElement = HTMLUnknownElement;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2014 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var registerObject = scope.registerObject;
|
| +
|
| + var SVG_NS = 'http://www.w3.org/2000/svg';
|
| + var svgTitleElement = document.createElementNS(SVG_NS, 'title');
|
| + var SVGTitleElement = registerObject(svgTitleElement);
|
| + var SVGElement = Object.getPrototypeOf(SVGTitleElement.prototype).constructor;
|
| +
|
| + scope.wrappers.SVGElement = SVGElement;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2014 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var unwrap = scope.unwrap;
|
| + var wrap = scope.wrap;
|
| +
|
| + var OriginalSVGUseElement = window.SVGUseElement;
|
| +
|
| + // IE uses SVGElement as parent interface, SVG2 (Blink & Gecko) uses
|
| + // SVGGraphicsElement. Use the <g> element to get the right prototype.
|
| +
|
| + var SVG_NS = 'http://www.w3.org/2000/svg';
|
| + var gWrapper = wrap(document.createElementNS(SVG_NS, 'g'));
|
| + var useElement = document.createElementNS(SVG_NS, 'use');
|
| + var SVGGElement = gWrapper.constructor;
|
| + var parentInterfacePrototype = Object.getPrototypeOf(SVGGElement.prototype);
|
| + var parentInterface = parentInterfacePrototype.constructor;
|
| +
|
| + function SVGUseElement(impl) {
|
| + parentInterface.call(this, impl);
|
| + }
|
| +
|
| + SVGUseElement.prototype = Object.create(parentInterfacePrototype);
|
| +
|
| + // Firefox does not expose instanceRoot.
|
| + if ('instanceRoot' in useElement) {
|
| + mixin(SVGUseElement.prototype, {
|
| + get instanceRoot() {
|
| + return wrap(unwrap(this).instanceRoot);
|
| + },
|
| + get animatedInstanceRoot() {
|
| + return wrap(unwrap(this).animatedInstanceRoot);
|
| + },
|
| + });
|
| + }
|
| +
|
| + registerWrapper(OriginalSVGUseElement, SVGUseElement, useElement);
|
| +
|
| + scope.wrappers.SVGUseElement = SVGUseElement;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2014 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var EventTarget = scope.wrappers.EventTarget;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var wrap = scope.wrap;
|
| +
|
| + var OriginalSVGElementInstance = window.SVGElementInstance;
|
| + if (!OriginalSVGElementInstance)
|
| + return;
|
| +
|
| + function SVGElementInstance(impl) {
|
| + EventTarget.call(this, impl);
|
| + }
|
| +
|
| + SVGElementInstance.prototype = Object.create(EventTarget.prototype);
|
| + mixin(SVGElementInstance.prototype, {
|
| + /** @type {SVGElement} */
|
| + get correspondingElement() {
|
| + return wrap(this.impl.correspondingElement);
|
| + },
|
| +
|
| + /** @type {SVGUseElement} */
|
| + get correspondingUseElement() {
|
| + return wrap(this.impl.correspondingUseElement);
|
| + },
|
| +
|
| + /** @type {SVGElementInstance} */
|
| + get parentNode() {
|
| + return wrap(this.impl.parentNode);
|
| + },
|
| +
|
| + /** @type {SVGElementInstanceList} */
|
| + get childNodes() {
|
| + throw new Error('Not implemented');
|
| + },
|
| +
|
| + /** @type {SVGElementInstance} */
|
| + get firstChild() {
|
| + return wrap(this.impl.firstChild);
|
| + },
|
| +
|
| + /** @type {SVGElementInstance} */
|
| + get lastChild() {
|
| + return wrap(this.impl.lastChild);
|
| + },
|
| +
|
| + /** @type {SVGElementInstance} */
|
| + get previousSibling() {
|
| + return wrap(this.impl.previousSibling);
|
| + },
|
| +
|
| + /** @type {SVGElementInstance} */
|
| + get nextSibling() {
|
| + return wrap(this.impl.nextSibling);
|
| + }
|
| + });
|
| +
|
| + registerWrapper(OriginalSVGElementInstance, SVGElementInstance);
|
| +
|
| + scope.wrappers.SVGElementInstance = SVGElementInstance;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var unwrap = scope.unwrap;
|
| + var unwrapIfNeeded = scope.unwrapIfNeeded;
|
| + var wrap = scope.wrap;
|
| +
|
| + var OriginalCanvasRenderingContext2D = window.CanvasRenderingContext2D;
|
| +
|
| + function CanvasRenderingContext2D(impl) {
|
| + this.impl = impl;
|
| + }
|
| +
|
| + mixin(CanvasRenderingContext2D.prototype, {
|
| + get canvas() {
|
| + return wrap(this.impl.canvas);
|
| + },
|
| +
|
| + drawImage: function() {
|
| + arguments[0] = unwrapIfNeeded(arguments[0]);
|
| + this.impl.drawImage.apply(this.impl, arguments);
|
| + },
|
| +
|
| + createPattern: function() {
|
| + arguments[0] = unwrap(arguments[0]);
|
| + return this.impl.createPattern.apply(this.impl, arguments);
|
| + }
|
| + });
|
| +
|
| + registerWrapper(OriginalCanvasRenderingContext2D, CanvasRenderingContext2D,
|
| + document.createElement('canvas').getContext('2d'));
|
| +
|
| + scope.wrappers.CanvasRenderingContext2D = CanvasRenderingContext2D;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var unwrapIfNeeded = scope.unwrapIfNeeded;
|
| + var wrap = scope.wrap;
|
| +
|
| + var OriginalWebGLRenderingContext = window.WebGLRenderingContext;
|
| +
|
| + // IE10 does not have WebGL.
|
| + if (!OriginalWebGLRenderingContext)
|
| + return;
|
| +
|
| + function WebGLRenderingContext(impl) {
|
| + this.impl = impl;
|
| + }
|
| +
|
| + mixin(WebGLRenderingContext.prototype, {
|
| + get canvas() {
|
| + return wrap(this.impl.canvas);
|
| + },
|
| +
|
| + texImage2D: function() {
|
| + arguments[5] = unwrapIfNeeded(arguments[5]);
|
| + this.impl.texImage2D.apply(this.impl, arguments);
|
| + },
|
| +
|
| + texSubImage2D: function() {
|
| + arguments[6] = unwrapIfNeeded(arguments[6]);
|
| + this.impl.texSubImage2D.apply(this.impl, arguments);
|
| + }
|
| + });
|
| +
|
| + // Blink/WebKit has broken DOM bindings. Usually we would create an instance
|
| + // of the object and pass it into registerWrapper as a "blueprint" but
|
| + // creating WebGL contexts is expensive and might fail so we use a dummy
|
| + // object with dummy instance properties for these broken browsers.
|
| + var instanceProperties = /WebKit/.test(navigator.userAgent) ?
|
| + {drawingBufferHeight: null, drawingBufferWidth: null} : {};
|
| +
|
| + registerWrapper(OriginalWebGLRenderingContext, WebGLRenderingContext,
|
| + instanceProperties);
|
| +
|
| + scope.wrappers.WebGLRenderingContext = WebGLRenderingContext;
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var registerWrapper = scope.registerWrapper;
|
| + var unwrap = scope.unwrap;
|
| + var unwrapIfNeeded = scope.unwrapIfNeeded;
|
| + var wrap = scope.wrap;
|
| +
|
| + var OriginalRange = window.Range;
|
| +
|
| + function Range(impl) {
|
| + this.impl = impl;
|
| + }
|
| + Range.prototype = {
|
| + get startContainer() {
|
| + return wrap(this.impl.startContainer);
|
| + },
|
| + get endContainer() {
|
| + return wrap(this.impl.endContainer);
|
| + },
|
| + get commonAncestorContainer() {
|
| + return wrap(this.impl.commonAncestorContainer);
|
| + },
|
| + setStart: function(refNode,offset) {
|
| + this.impl.setStart(unwrapIfNeeded(refNode), offset);
|
| + },
|
| + setEnd: function(refNode,offset) {
|
| + this.impl.setEnd(unwrapIfNeeded(refNode), offset);
|
| + },
|
| + setStartBefore: function(refNode) {
|
| + this.impl.setStartBefore(unwrapIfNeeded(refNode));
|
| + },
|
| + setStartAfter: function(refNode) {
|
| + this.impl.setStartAfter(unwrapIfNeeded(refNode));
|
| + },
|
| + setEndBefore: function(refNode) {
|
| + this.impl.setEndBefore(unwrapIfNeeded(refNode));
|
| + },
|
| + setEndAfter: function(refNode) {
|
| + this.impl.setEndAfter(unwrapIfNeeded(refNode));
|
| + },
|
| + selectNode: function(refNode) {
|
| + this.impl.selectNode(unwrapIfNeeded(refNode));
|
| + },
|
| + selectNodeContents: function(refNode) {
|
| + this.impl.selectNodeContents(unwrapIfNeeded(refNode));
|
| + },
|
| + compareBoundaryPoints: function(how, sourceRange) {
|
| + return this.impl.compareBoundaryPoints(how, unwrap(sourceRange));
|
| + },
|
| + extractContents: function() {
|
| + return wrap(this.impl.extractContents());
|
| + },
|
| + cloneContents: function() {
|
| + return wrap(this.impl.cloneContents());
|
| + },
|
| + insertNode: function(node) {
|
| + this.impl.insertNode(unwrapIfNeeded(node));
|
| + },
|
| + surroundContents: function(newParent) {
|
| + this.impl.surroundContents(unwrapIfNeeded(newParent));
|
| + },
|
| + cloneRange: function() {
|
| + return wrap(this.impl.cloneRange());
|
| + },
|
| + isPointInRange: function(node, offset) {
|
| + return this.impl.isPointInRange(unwrapIfNeeded(node), offset);
|
| + },
|
| + comparePoint: function(node, offset) {
|
| + return this.impl.comparePoint(unwrapIfNeeded(node), offset);
|
| + },
|
| + intersectsNode: function(node) {
|
| + return this.impl.intersectsNode(unwrapIfNeeded(node));
|
| + },
|
| + toString: function() {
|
| + return this.impl.toString();
|
| + }
|
| + };
|
| +
|
| + // IE9 does not have createContextualFragment.
|
| + if (OriginalRange.prototype.createContextualFragment) {
|
| + Range.prototype.createContextualFragment = function(html) {
|
| + return wrap(this.impl.createContextualFragment(html));
|
| + };
|
| + }
|
| +
|
| + registerWrapper(window.Range, Range, document.createRange());
|
| +
|
| + scope.wrappers.Range = Range;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var GetElementsByInterface = scope.GetElementsByInterface;
|
| + var ParentNodeInterface = scope.ParentNodeInterface;
|
| + var SelectorsInterface = scope.SelectorsInterface;
|
| + var mixin = scope.mixin;
|
| + var registerObject = scope.registerObject;
|
| +
|
| + var DocumentFragment = registerObject(document.createDocumentFragment());
|
| + mixin(DocumentFragment.prototype, ParentNodeInterface);
|
| + mixin(DocumentFragment.prototype, SelectorsInterface);
|
| + mixin(DocumentFragment.prototype, GetElementsByInterface);
|
| +
|
| + var Comment = registerObject(document.createComment(''));
|
| +
|
| + scope.wrappers.Comment = Comment;
|
| + scope.wrappers.DocumentFragment = DocumentFragment;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var DocumentFragment = scope.wrappers.DocumentFragment;
|
| + var elementFromPoint = scope.elementFromPoint;
|
| + var getInnerHTML = scope.getInnerHTML;
|
| + var mixin = scope.mixin;
|
| + var rewrap = scope.rewrap;
|
| + var setInnerHTML = scope.setInnerHTML;
|
| + var unwrap = scope.unwrap;
|
| +
|
| + var shadowHostTable = new WeakMap();
|
| + var nextOlderShadowTreeTable = new WeakMap();
|
| +
|
| + var spaceCharRe = /[ \t\n\r\f]/;
|
| +
|
| + function ShadowRoot(hostWrapper) {
|
| + var node = unwrap(hostWrapper.impl.ownerDocument.createDocumentFragment());
|
| + DocumentFragment.call(this, node);
|
| +
|
| + // createDocumentFragment associates the node with a wrapper
|
| + // DocumentFragment instance. Override that.
|
| + rewrap(node, this);
|
| +
|
| + var oldShadowRoot = hostWrapper.shadowRoot;
|
| + nextOlderShadowTreeTable.set(this, oldShadowRoot);
|
| +
|
| + shadowHostTable.set(this, hostWrapper);
|
| + }
|
| + ShadowRoot.prototype = Object.create(DocumentFragment.prototype);
|
| + mixin(ShadowRoot.prototype, {
|
| + get innerHTML() {
|
| + return getInnerHTML(this);
|
| + },
|
| + set innerHTML(value) {
|
| + setInnerHTML(this, value);
|
| + this.invalidateShadowRenderer();
|
| + },
|
| +
|
| + get olderShadowRoot() {
|
| + return nextOlderShadowTreeTable.get(this) || null;
|
| + },
|
| +
|
| + get host() {
|
| + return shadowHostTable.get(this) || null;
|
| + },
|
| +
|
| + invalidateShadowRenderer: function() {
|
| + return shadowHostTable.get(this).invalidateShadowRenderer();
|
| + },
|
| +
|
| + elementFromPoint: function(x, y) {
|
| + return elementFromPoint(this, this.ownerDocument, x, y);
|
| + },
|
| +
|
| + getElementById: function(id) {
|
| + if (spaceCharRe.test(id))
|
| + return null;
|
| + return this.querySelector('[id="' + id + '"]');
|
| + }
|
| + });
|
| +
|
| + scope.wrappers.ShadowRoot = ShadowRoot;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is governed by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var Element = scope.wrappers.Element;
|
| + var HTMLContentElement = scope.wrappers.HTMLContentElement;
|
| + var HTMLShadowElement = scope.wrappers.HTMLShadowElement;
|
| + var Node = scope.wrappers.Node;
|
| + var ShadowRoot = scope.wrappers.ShadowRoot;
|
| + var assert = scope.assert;
|
| + var mixin = scope.mixin;
|
| + var oneOf = scope.oneOf;
|
| + var unwrap = scope.unwrap;
|
| + var wrap = scope.wrap;
|
| +
|
| + /**
|
| + * Updates the fields of a wrapper to a snapshot of the logical DOM as needed.
|
| + * Up means parentNode
|
| + * Sideways means previous and next sibling.
|
| + * @param {!Node} wrapper
|
| + */
|
| + function updateWrapperUpAndSideways(wrapper) {
|
| + wrapper.previousSibling_ = wrapper.previousSibling;
|
| + wrapper.nextSibling_ = wrapper.nextSibling;
|
| + wrapper.parentNode_ = wrapper.parentNode;
|
| + }
|
| +
|
| + /**
|
| + * Updates the fields of a wrapper to a snapshot of the logical DOM as needed.
|
| + * Down means first and last child
|
| + * @param {!Node} wrapper
|
| + */
|
| + function updateWrapperDown(wrapper) {
|
| + wrapper.firstChild_ = wrapper.firstChild;
|
| + wrapper.lastChild_ = wrapper.lastChild;
|
| + }
|
| +
|
| + function updateAllChildNodes(parentNodeWrapper) {
|
| + assert(parentNodeWrapper instanceof Node);
|
| + for (var childWrapper = parentNodeWrapper.firstChild;
|
| + childWrapper;
|
| + childWrapper = childWrapper.nextSibling) {
|
| + updateWrapperUpAndSideways(childWrapper);
|
| + }
|
| + updateWrapperDown(parentNodeWrapper);
|
| + }
|
| +
|
| + function insertBefore(parentNodeWrapper, newChildWrapper, refChildWrapper) {
|
| + var parentNode = unwrap(parentNodeWrapper);
|
| + var newChild = unwrap(newChildWrapper);
|
| + var refChild = refChildWrapper ? unwrap(refChildWrapper) : null;
|
| +
|
| + remove(newChildWrapper);
|
| + updateWrapperUpAndSideways(newChildWrapper);
|
| +
|
| + if (!refChildWrapper) {
|
| + parentNodeWrapper.lastChild_ = parentNodeWrapper.lastChild;
|
| + if (parentNodeWrapper.lastChild === parentNodeWrapper.firstChild)
|
| + parentNodeWrapper.firstChild_ = parentNodeWrapper.firstChild;
|
| +
|
| + var lastChildWrapper = wrap(parentNode.lastChild);
|
| + if (lastChildWrapper)
|
| + lastChildWrapper.nextSibling_ = lastChildWrapper.nextSibling;
|
| + } else {
|
| + if (parentNodeWrapper.firstChild === refChildWrapper)
|
| + parentNodeWrapper.firstChild_ = refChildWrapper;
|
| +
|
| + refChildWrapper.previousSibling_ = refChildWrapper.previousSibling;
|
| + }
|
| +
|
| + parentNode.insertBefore(newChild, refChild);
|
| + }
|
| +
|
| + function remove(nodeWrapper) {
|
| + var node = unwrap(nodeWrapper)
|
| + var parentNode = node.parentNode;
|
| + if (!parentNode)
|
| + return;
|
| +
|
| + var parentNodeWrapper = wrap(parentNode);
|
| + updateWrapperUpAndSideways(nodeWrapper);
|
| +
|
| + if (nodeWrapper.previousSibling)
|
| + nodeWrapper.previousSibling.nextSibling_ = nodeWrapper;
|
| + if (nodeWrapper.nextSibling)
|
| + nodeWrapper.nextSibling.previousSibling_ = nodeWrapper;
|
| +
|
| + if (parentNodeWrapper.lastChild === nodeWrapper)
|
| + parentNodeWrapper.lastChild_ = nodeWrapper;
|
| + if (parentNodeWrapper.firstChild === nodeWrapper)
|
| + parentNodeWrapper.firstChild_ = nodeWrapper;
|
| +
|
| + parentNode.removeChild(node);
|
| + }
|
| +
|
| + var distributedChildNodesTable = new WeakMap();
|
| + var eventParentsTable = new WeakMap();
|
| + var insertionParentTable = new WeakMap();
|
| + var rendererForHostTable = new WeakMap();
|
| +
|
| + function distributeChildToInsertionPoint(child, insertionPoint) {
|
| + getDistributedChildNodes(insertionPoint).push(child);
|
| + assignToInsertionPoint(child, insertionPoint);
|
| +
|
| + var eventParents = eventParentsTable.get(child);
|
| + if (!eventParents)
|
| + eventParentsTable.set(child, eventParents = []);
|
| + eventParents.push(insertionPoint);
|
| + }
|
| +
|
| + function resetDistributedChildNodes(insertionPoint) {
|
| + distributedChildNodesTable.set(insertionPoint, []);
|
| + }
|
| +
|
| + function getDistributedChildNodes(insertionPoint) {
|
| + return distributedChildNodesTable.get(insertionPoint);
|
| + }
|
| +
|
| + function getChildNodesSnapshot(node) {
|
| + var result = [], i = 0;
|
| + for (var child = node.firstChild; child; child = child.nextSibling) {
|
| + result[i++] = child;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + /**
|
| + * Visits all nodes in the tree that fulfils the |predicate|. If the |visitor|
|
| + * function returns |false| the traversal is aborted.
|
| + * @param {!Node} tree
|
| + * @param {function(!Node) : boolean} predicate
|
| + * @param {function(!Node) : *} visitor
|
| + */
|
| + function visit(tree, predicate, visitor) {
|
| + // This operates on logical DOM.
|
| + for (var node = tree.firstChild; node; node = node.nextSibling) {
|
| + if (predicate(node)) {
|
| + if (visitor(node) === false)
|
| + return;
|
| + } else {
|
| + visit(node, predicate, visitor);
|
| + }
|
| + }
|
| + }
|
| +
|
| + // Matching Insertion Points
|
| + // http://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#matching-insertion-points
|
| +
|
| + // TODO(arv): Verify this... I don't remember why I picked this regexp.
|
| + var selectorMatchRegExp = /^[*.:#[a-zA-Z_|]/;
|
| +
|
| + var allowedPseudoRegExp = new RegExp('^:(' + [
|
| + 'link',
|
| + 'visited',
|
| + 'target',
|
| + 'enabled',
|
| + 'disabled',
|
| + 'checked',
|
| + 'indeterminate',
|
| + 'nth-child',
|
| + 'nth-last-child',
|
| + 'nth-of-type',
|
| + 'nth-last-of-type',
|
| + 'first-child',
|
| + 'last-child',
|
| + 'first-of-type',
|
| + 'last-of-type',
|
| + 'only-of-type',
|
| + ].join('|') + ')');
|
| +
|
| +
|
| + /**
|
| + * @param {Element} node
|
| + * @oaram {Element} point The insertion point element.
|
| + * @return {boolean} Whether the node matches the insertion point.
|
| + */
|
| + function matchesCriteria(node, point) {
|
| + var select = point.getAttribute('select');
|
| + if (!select)
|
| + return true;
|
| +
|
| + // Here we know the select attribute is a non empty string.
|
| + select = select.trim();
|
| + if (!select)
|
| + return true;
|
| +
|
| + if (!(node instanceof Element))
|
| + return false;
|
| +
|
| + // The native matches function in IE9 does not correctly work with elements
|
| + // that are not in the document.
|
| + // TODO(arv): Implement matching in JS.
|
| + // https://github.com/Polymer/ShadowDOM/issues/361
|
| + if (select === '*' || select === node.localName)
|
| + return true;
|
| +
|
| + // TODO(arv): This does not seem right. Need to check for a simple selector.
|
| + if (!selectorMatchRegExp.test(select))
|
| + return false;
|
| +
|
| + // TODO(arv): This no longer matches the spec.
|
| + if (select[0] === ':' && !allowedPseudoRegExp.test(select))
|
| + return false;
|
| +
|
| + try {
|
| + return node.matches(select);
|
| + } catch (ex) {
|
| + // Invalid selector.
|
| + return false;
|
| + }
|
| + }
|
| +
|
| + var request = oneOf(window, [
|
| + 'requestAnimationFrame',
|
| + 'mozRequestAnimationFrame',
|
| + 'webkitRequestAnimationFrame',
|
| + 'setTimeout'
|
| + ]);
|
| +
|
| + var pendingDirtyRenderers = [];
|
| + var renderTimer;
|
| +
|
| + function renderAllPending() {
|
| + for (var i = 0; i < pendingDirtyRenderers.length; i++) {
|
| + pendingDirtyRenderers[i].render();
|
| + }
|
| + pendingDirtyRenderers = [];
|
| + }
|
| +
|
| + function handleRequestAnimationFrame() {
|
| + renderTimer = null;
|
| + renderAllPending();
|
| + }
|
| +
|
| + /**
|
| + * Returns existing shadow renderer for a host or creates it if it is needed.
|
| + * @params {!Element} host
|
| + * @return {!ShadowRenderer}
|
| + */
|
| + function getRendererForHost(host) {
|
| + var renderer = rendererForHostTable.get(host);
|
| + if (!renderer) {
|
| + renderer = new ShadowRenderer(host);
|
| + rendererForHostTable.set(host, renderer);
|
| + }
|
| + return renderer;
|
| + }
|
| +
|
| + function getShadowRootAncestor(node) {
|
| + for (; node; node = node.parentNode) {
|
| + if (node instanceof ShadowRoot)
|
| + return node;
|
| + }
|
| + return null;
|
| + }
|
| +
|
| + function getRendererForShadowRoot(shadowRoot) {
|
| + return getRendererForHost(shadowRoot.host);
|
| + }
|
| +
|
| + var spliceDiff = new ArraySplice();
|
| + spliceDiff.equals = function(renderNode, rawNode) {
|
| + return unwrap(renderNode.node) === rawNode;
|
| + };
|
| +
|
| + /**
|
| + * RenderNode is used as an in memory "render tree". When we render the
|
| + * composed tree we create a tree of RenderNodes, then we diff this against
|
| + * the real DOM tree and make minimal changes as needed.
|
| + */
|
| + function RenderNode(node) {
|
| + this.skip = false;
|
| + this.node = node;
|
| + this.childNodes = [];
|
| + }
|
| +
|
| + RenderNode.prototype = {
|
| + append: function(node) {
|
| + var rv = new RenderNode(node);
|
| + this.childNodes.push(rv);
|
| + return rv;
|
| + },
|
| +
|
| + sync: function(opt_added) {
|
| + if (this.skip)
|
| + return;
|
| +
|
| + var nodeWrapper = this.node;
|
| + // plain array of RenderNodes
|
| + var newChildren = this.childNodes;
|
| + // plain array of real nodes.
|
| + var oldChildren = getChildNodesSnapshot(unwrap(nodeWrapper));
|
| + var added = opt_added || new WeakMap();
|
| +
|
| + var splices = spliceDiff.calculateSplices(newChildren, oldChildren);
|
| +
|
| + var newIndex = 0, oldIndex = 0;
|
| + var lastIndex = 0;
|
| + for (var i = 0; i < splices.length; i++) {
|
| + var splice = splices[i];
|
| + for (; lastIndex < splice.index; lastIndex++) {
|
| + oldIndex++;
|
| + newChildren[newIndex++].sync(added);
|
| + }
|
| +
|
| + var removedCount = splice.removed.length;
|
| + for (var j = 0; j < removedCount; j++) {
|
| + var wrapper = wrap(oldChildren[oldIndex++]);
|
| + if (!added.get(wrapper))
|
| + remove(wrapper);
|
| + }
|
| +
|
| + var addedCount = splice.addedCount;
|
| + var refNode = oldChildren[oldIndex] && wrap(oldChildren[oldIndex]);
|
| + for (var j = 0; j < addedCount; j++) {
|
| + var newChildRenderNode = newChildren[newIndex++];
|
| + var newChildWrapper = newChildRenderNode.node;
|
| + insertBefore(nodeWrapper, newChildWrapper, refNode);
|
| +
|
| + // Keep track of added so that we do not remove the node after it
|
| + // has been added.
|
| + added.set(newChildWrapper, true);
|
| +
|
| + newChildRenderNode.sync(added);
|
| + }
|
| +
|
| + lastIndex += addedCount;
|
| + }
|
| +
|
| + for (var i = lastIndex; i < newChildren.length; i++) {
|
| + newChildren[i].sync(added);
|
| + }
|
| + }
|
| + };
|
| +
|
| + function ShadowRenderer(host) {
|
| + this.host = host;
|
| + this.dirty = false;
|
| + this.invalidateAttributes();
|
| + this.associateNode(host);
|
| + }
|
| +
|
| + ShadowRenderer.prototype = {
|
| +
|
| + // http://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#rendering-shadow-trees
|
| + render: function(opt_renderNode) {
|
| + if (!this.dirty)
|
| + return;
|
| +
|
| + this.invalidateAttributes();
|
| + this.treeComposition();
|
| +
|
| + var host = this.host;
|
| + var shadowRoot = host.shadowRoot;
|
| +
|
| + this.associateNode(host);
|
| + var topMostRenderer = !renderNode;
|
| + var renderNode = opt_renderNode || new RenderNode(host);
|
| +
|
| + for (var node = shadowRoot.firstChild; node; node = node.nextSibling) {
|
| + this.renderNode(shadowRoot, renderNode, node, false);
|
| + }
|
| +
|
| + if (topMostRenderer)
|
| + renderNode.sync();
|
| +
|
| + this.dirty = false;
|
| + },
|
| +
|
| + invalidate: function() {
|
| + if (!this.dirty) {
|
| + this.dirty = true;
|
| + pendingDirtyRenderers.push(this);
|
| + if (renderTimer)
|
| + return;
|
| + renderTimer = window[request](handleRequestAnimationFrame, 0);
|
| + }
|
| + },
|
| +
|
| + renderNode: function(shadowRoot, renderNode, node, isNested) {
|
| + if (isShadowHost(node)) {
|
| + renderNode = renderNode.append(node);
|
| + var renderer = getRendererForHost(node);
|
| + renderer.dirty = true; // Need to rerender due to reprojection.
|
| + renderer.render(renderNode);
|
| + } else if (isInsertionPoint(node)) {
|
| + this.renderInsertionPoint(shadowRoot, renderNode, node, isNested);
|
| + } else if (isShadowInsertionPoint(node)) {
|
| + this.renderShadowInsertionPoint(shadowRoot, renderNode, node);
|
| + } else {
|
| + this.renderAsAnyDomTree(shadowRoot, renderNode, node, isNested);
|
| + }
|
| + },
|
| +
|
| + renderAsAnyDomTree: function(shadowRoot, renderNode, node, isNested) {
|
| + renderNode = renderNode.append(node);
|
| +
|
| + if (isShadowHost(node)) {
|
| + var renderer = getRendererForHost(node);
|
| + renderNode.skip = !renderer.dirty;
|
| + renderer.render(renderNode);
|
| + } else {
|
| + for (var child = node.firstChild; child; child = child.nextSibling) {
|
| + this.renderNode(shadowRoot, renderNode, child, isNested);
|
| + }
|
| + }
|
| + },
|
| +
|
| + renderInsertionPoint: function(shadowRoot, renderNode, insertionPoint,
|
| + isNested) {
|
| + var distributedChildNodes = getDistributedChildNodes(insertionPoint);
|
| + if (distributedChildNodes.length) {
|
| + this.associateNode(insertionPoint);
|
| +
|
| + for (var i = 0; i < distributedChildNodes.length; i++) {
|
| + var child = distributedChildNodes[i];
|
| + if (isInsertionPoint(child) && isNested)
|
| + this.renderInsertionPoint(shadowRoot, renderNode, child, isNested);
|
| + else
|
| + this.renderAsAnyDomTree(shadowRoot, renderNode, child, isNested);
|
| + }
|
| + } else {
|
| + this.renderFallbackContent(shadowRoot, renderNode, insertionPoint);
|
| + }
|
| + this.associateNode(insertionPoint.parentNode);
|
| + },
|
| +
|
| + renderShadowInsertionPoint: function(shadowRoot, renderNode,
|
| + shadowInsertionPoint) {
|
| + var nextOlderTree = shadowRoot.olderShadowRoot;
|
| + if (nextOlderTree) {
|
| + assignToInsertionPoint(nextOlderTree, shadowInsertionPoint);
|
| + this.associateNode(shadowInsertionPoint.parentNode);
|
| + for (var node = nextOlderTree.firstChild;
|
| + node;
|
| + node = node.nextSibling) {
|
| + this.renderNode(nextOlderTree, renderNode, node, true);
|
| + }
|
| + } else {
|
| + this.renderFallbackContent(shadowRoot, renderNode,
|
| + shadowInsertionPoint);
|
| + }
|
| + },
|
| +
|
| + renderFallbackContent: function(shadowRoot, renderNode, fallbackHost) {
|
| + this.associateNode(fallbackHost);
|
| + this.associateNode(fallbackHost.parentNode);
|
| + for (var node = fallbackHost.firstChild; node; node = node.nextSibling) {
|
| + this.renderAsAnyDomTree(shadowRoot, renderNode, node, false);
|
| + }
|
| + },
|
| +
|
| + /**
|
| + * Invalidates the attributes used to keep track of which attributes may
|
| + * cause the renderer to be invalidated.
|
| + */
|
| + invalidateAttributes: function() {
|
| + this.attributes = Object.create(null);
|
| + },
|
| +
|
| + /**
|
| + * Parses the selector and makes this renderer dependent on the attribute
|
| + * being used in the selector.
|
| + * @param {string} selector
|
| + */
|
| + updateDependentAttributes: function(selector) {
|
| + if (!selector)
|
| + return;
|
| +
|
| + var attributes = this.attributes;
|
| +
|
| + // .class
|
| + if (/\.\w+/.test(selector))
|
| + attributes['class'] = true;
|
| +
|
| + // #id
|
| + if (/#\w+/.test(selector))
|
| + attributes['id'] = true;
|
| +
|
| + selector.replace(/\[\s*([^\s=\|~\]]+)/g, function(_, name) {
|
| + attributes[name] = true;
|
| + });
|
| +
|
| + // Pseudo selectors have been removed from the spec.
|
| + },
|
| +
|
| + dependsOnAttribute: function(name) {
|
| + return this.attributes[name];
|
| + },
|
| +
|
| + // http://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#dfn-distribution-algorithm
|
| + distribute: function(tree, pool) {
|
| + var self = this;
|
| +
|
| + visit(tree, isActiveInsertionPoint,
|
| + function(insertionPoint) {
|
| + resetDistributedChildNodes(insertionPoint);
|
| + self.updateDependentAttributes(
|
| + insertionPoint.getAttribute('select'));
|
| +
|
| + for (var i = 0; i < pool.length; i++) { // 1.2
|
| + var node = pool[i]; // 1.2.1
|
| + if (node === undefined) // removed
|
| + continue;
|
| + if (matchesCriteria(node, insertionPoint)) { // 1.2.2
|
| + distributeChildToInsertionPoint(node, insertionPoint); // 1.2.2.1
|
| + pool[i] = undefined; // 1.2.2.2
|
| + }
|
| + }
|
| + });
|
| + },
|
| +
|
| + // http://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#dfn-tree-composition
|
| + treeComposition: function () {
|
| + var shadowHost = this.host;
|
| + var tree = shadowHost.shadowRoot; // 1.
|
| + var pool = []; // 2.
|
| +
|
| + for (var child = shadowHost.firstChild;
|
| + child;
|
| + child = child.nextSibling) { // 3.
|
| + if (isInsertionPoint(child)) { // 3.2.
|
| + var reprojected = getDistributedChildNodes(child); // 3.2.1.
|
| + // if reprojected is undef... reset it?
|
| + if (!reprojected || !reprojected.length) // 3.2.2.
|
| + reprojected = getChildNodesSnapshot(child);
|
| + pool.push.apply(pool, reprojected); // 3.2.3.
|
| + } else {
|
| + pool.push(child); // 3.3.
|
| + }
|
| + }
|
| +
|
| + var shadowInsertionPoint, point;
|
| + while (tree) { // 4.
|
| + // 4.1.
|
| + shadowInsertionPoint = undefined; // Reset every iteration.
|
| + visit(tree, isActiveShadowInsertionPoint, function(point) {
|
| + shadowInsertionPoint = point;
|
| + return false;
|
| + });
|
| + point = shadowInsertionPoint;
|
| +
|
| + this.distribute(tree, pool); // 4.2.
|
| + if (point) { // 4.3.
|
| + var nextOlderTree = tree.olderShadowRoot; // 4.3.1.
|
| + if (!nextOlderTree) {
|
| + break; // 4.3.1.1.
|
| + } else {
|
| + tree = nextOlderTree; // 4.3.2.2.
|
| + assignToInsertionPoint(tree, point); // 4.3.2.2.
|
| + continue; // 4.3.2.3.
|
| + }
|
| + } else {
|
| + break; // 4.4.
|
| + }
|
| + }
|
| + },
|
| +
|
| + associateNode: function(node) {
|
| + node.impl.polymerShadowRenderer_ = this;
|
| + }
|
| + };
|
| +
|
| + function isInsertionPoint(node) {
|
| + // Should this include <shadow>?
|
| + return node instanceof HTMLContentElement;
|
| + }
|
| +
|
| + function isActiveInsertionPoint(node) {
|
| + // <content> inside another <content> or <shadow> is considered inactive.
|
| + return node instanceof HTMLContentElement;
|
| + }
|
| +
|
| + function isShadowInsertionPoint(node) {
|
| + return node instanceof HTMLShadowElement;
|
| + }
|
| +
|
| + function isActiveShadowInsertionPoint(node) {
|
| + // <shadow> inside another <content> or <shadow> is considered inactive.
|
| + return node instanceof HTMLShadowElement;
|
| + }
|
| +
|
| + function isShadowHost(shadowHost) {
|
| + return shadowHost.shadowRoot;
|
| + }
|
| +
|
| + function getShadowTrees(host) {
|
| + var trees = [];
|
| +
|
| + for (var tree = host.shadowRoot; tree; tree = tree.olderShadowRoot) {
|
| + trees.push(tree);
|
| + }
|
| + return trees;
|
| + }
|
| +
|
| + function assignToInsertionPoint(tree, point) {
|
| + insertionParentTable.set(tree, point);
|
| + }
|
| +
|
| + // http://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#rendering-shadow-trees
|
| + function render(host) {
|
| + new ShadowRenderer(host).render();
|
| + };
|
| +
|
| + // Need to rerender shadow host when:
|
| + //
|
| + // - a direct child to the ShadowRoot is added or removed
|
| + // - a direct child to the host is added or removed
|
| + // - a new shadow root is created
|
| + // - a direct child to a content/shadow element is added or removed
|
| + // - a sibling to a content/shadow element is added or removed
|
| + // - content[select] is changed
|
| + // - an attribute in a direct child to a host is modified
|
| +
|
| + /**
|
| + * This gets called when a node was added or removed to it.
|
| + */
|
| + Node.prototype.invalidateShadowRenderer = function(force) {
|
| + var renderer = this.impl.polymerShadowRenderer_;
|
| + if (renderer) {
|
| + renderer.invalidate();
|
| + return true;
|
| + }
|
| +
|
| + return false;
|
| + };
|
| +
|
| + HTMLContentElement.prototype.getDistributedNodes = function() {
|
| + // TODO(arv): We should only rerender the dirty ancestor renderers (from
|
| + // the root and down).
|
| + renderAllPending();
|
| + return getDistributedChildNodes(this);
|
| + };
|
| +
|
| + HTMLShadowElement.prototype.nodeIsInserted_ =
|
| + HTMLContentElement.prototype.nodeIsInserted_ = function() {
|
| + // Invalidate old renderer if any.
|
| + this.invalidateShadowRenderer();
|
| +
|
| + var shadowRoot = getShadowRootAncestor(this);
|
| + var renderer;
|
| + if (shadowRoot)
|
| + renderer = getRendererForShadowRoot(shadowRoot);
|
| + this.impl.polymerShadowRenderer_ = renderer;
|
| + if (renderer)
|
| + renderer.invalidate();
|
| + };
|
| +
|
| + scope.eventParentsTable = eventParentsTable;
|
| + scope.getRendererForHost = getRendererForHost;
|
| + scope.getShadowTrees = getShadowTrees;
|
| + scope.insertionParentTable = insertionParentTable;
|
| + scope.renderAllPending = renderAllPending;
|
| +
|
| + // Exposed for testing
|
| + scope.visual = {
|
| + insertBefore: insertBefore,
|
| + remove: remove,
|
| + };
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var HTMLElement = scope.wrappers.HTMLElement;
|
| + var assert = scope.assert;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var unwrap = scope.unwrap;
|
| + var wrap = scope.wrap;
|
| +
|
| + var elementsWithFormProperty = [
|
| + 'HTMLButtonElement',
|
| + 'HTMLFieldSetElement',
|
| + 'HTMLInputElement',
|
| + 'HTMLKeygenElement',
|
| + 'HTMLLabelElement',
|
| + 'HTMLLegendElement',
|
| + 'HTMLObjectElement',
|
| + // HTMLOptionElement is handled in HTMLOptionElement.js
|
| + 'HTMLOutputElement',
|
| + 'HTMLSelectElement',
|
| + 'HTMLTextAreaElement',
|
| + ];
|
| +
|
| + function createWrapperConstructor(name) {
|
| + if (!window[name])
|
| + return;
|
| +
|
| + // Ensure we are not overriding an already existing constructor.
|
| + assert(!scope.wrappers[name]);
|
| +
|
| + var GeneratedWrapper = function(node) {
|
| + // At this point all of them extend HTMLElement.
|
| + HTMLElement.call(this, node);
|
| + }
|
| + GeneratedWrapper.prototype = Object.create(HTMLElement.prototype);
|
| + mixin(GeneratedWrapper.prototype, {
|
| + get form() {
|
| + return wrap(unwrap(this).form);
|
| + },
|
| + });
|
| +
|
| + registerWrapper(window[name], GeneratedWrapper,
|
| + document.createElement(name.slice(4, -7)));
|
| + scope.wrappers[name] = GeneratedWrapper;
|
| + }
|
| +
|
| + elementsWithFormProperty.forEach(createWrapperConstructor);
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2014 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var registerWrapper = scope.registerWrapper;
|
| + var unwrap = scope.unwrap;
|
| + var unwrapIfNeeded = scope.unwrapIfNeeded;
|
| + var wrap = scope.wrap;
|
| +
|
| + var OriginalSelection = window.Selection;
|
| +
|
| + function Selection(impl) {
|
| + this.impl = impl;
|
| + }
|
| + Selection.prototype = {
|
| + get anchorNode() {
|
| + return wrap(this.impl.anchorNode);
|
| + },
|
| + get focusNode() {
|
| + return wrap(this.impl.focusNode);
|
| + },
|
| + addRange: function(range) {
|
| + this.impl.addRange(unwrap(range));
|
| + },
|
| + collapse: function(node, index) {
|
| + this.impl.collapse(unwrapIfNeeded(node), index);
|
| + },
|
| + containsNode: function(node, allowPartial) {
|
| + return this.impl.containsNode(unwrapIfNeeded(node), allowPartial);
|
| + },
|
| + extend: function(node, offset) {
|
| + this.impl.extend(unwrapIfNeeded(node), offset);
|
| + },
|
| + getRangeAt: function(index) {
|
| + return wrap(this.impl.getRangeAt(index));
|
| + },
|
| + removeRange: function(range) {
|
| + this.impl.removeRange(unwrap(range));
|
| + },
|
| + selectAllChildren: function(node) {
|
| + this.impl.selectAllChildren(unwrapIfNeeded(node));
|
| + },
|
| + toString: function() {
|
| + return this.impl.toString();
|
| + }
|
| + };
|
| +
|
| + // WebKit extensions. Not implemented.
|
| + // readonly attribute Node baseNode;
|
| + // readonly attribute long baseOffset;
|
| + // readonly attribute Node extentNode;
|
| + // readonly attribute long extentOffset;
|
| + // [RaisesException] void setBaseAndExtent([Default=Undefined] optional Node baseNode,
|
| + // [Default=Undefined] optional long baseOffset,
|
| + // [Default=Undefined] optional Node extentNode,
|
| + // [Default=Undefined] optional long extentOffset);
|
| + // [RaisesException, ImplementedAs=collapse] void setPosition([Default=Undefined] optional Node node,
|
| + // [Default=Undefined] optional long offset);
|
| +
|
| + registerWrapper(window.Selection, Selection, window.getSelection());
|
| +
|
| + scope.wrappers.Selection = Selection;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var GetElementsByInterface = scope.GetElementsByInterface;
|
| + var Node = scope.wrappers.Node;
|
| + var ParentNodeInterface = scope.ParentNodeInterface;
|
| + var Selection = scope.wrappers.Selection;
|
| + var SelectorsInterface = scope.SelectorsInterface;
|
| + var ShadowRoot = scope.wrappers.ShadowRoot;
|
| + var defineWrapGetter = scope.defineWrapGetter;
|
| + var elementFromPoint = scope.elementFromPoint;
|
| + var forwardMethodsToWrapper = scope.forwardMethodsToWrapper;
|
| + var matchesNames = scope.matchesNames;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var renderAllPending = scope.renderAllPending;
|
| + var rewrap = scope.rewrap;
|
| + var unwrap = scope.unwrap;
|
| + var wrap = scope.wrap;
|
| + var wrapEventTargetMethods = scope.wrapEventTargetMethods;
|
| + var wrapNodeList = scope.wrapNodeList;
|
| +
|
| + var implementationTable = new WeakMap();
|
| +
|
| + function Document(node) {
|
| + Node.call(this, node);
|
| + }
|
| + Document.prototype = Object.create(Node.prototype);
|
| +
|
| + defineWrapGetter(Document, 'documentElement');
|
| +
|
| + // Conceptually both body and head can be in a shadow but suporting that seems
|
| + // overkill at this point.
|
| + defineWrapGetter(Document, 'body');
|
| + defineWrapGetter(Document, 'head');
|
| +
|
| + // document cannot be overridden so we override a bunch of its methods
|
| + // directly on the instance.
|
| +
|
| + function wrapMethod(name) {
|
| + var original = document[name];
|
| + Document.prototype[name] = function() {
|
| + return wrap(original.apply(this.impl, arguments));
|
| + };
|
| + }
|
| +
|
| + [
|
| + 'createComment',
|
| + 'createDocumentFragment',
|
| + 'createElement',
|
| + 'createElementNS',
|
| + 'createEvent',
|
| + 'createEventNS',
|
| + 'createRange',
|
| + 'createTextNode',
|
| + 'getElementById'
|
| + ].forEach(wrapMethod);
|
| +
|
| + var originalAdoptNode = document.adoptNode;
|
| +
|
| + function adoptNodeNoRemove(node, doc) {
|
| + originalAdoptNode.call(doc.impl, unwrap(node));
|
| + adoptSubtree(node, doc);
|
| + }
|
| +
|
| + function adoptSubtree(node, doc) {
|
| + if (node.shadowRoot)
|
| + doc.adoptNode(node.shadowRoot);
|
| + if (node instanceof ShadowRoot)
|
| + adoptOlderShadowRoots(node, doc);
|
| + for (var child = node.firstChild; child; child = child.nextSibling) {
|
| + adoptSubtree(child, doc);
|
| + }
|
| + }
|
| +
|
| + function adoptOlderShadowRoots(shadowRoot, doc) {
|
| + var oldShadowRoot = shadowRoot.olderShadowRoot;
|
| + if (oldShadowRoot)
|
| + doc.adoptNode(oldShadowRoot);
|
| + }
|
| +
|
| + var originalImportNode = document.importNode;
|
| + var originalGetSelection = document.getSelection;
|
| +
|
| + mixin(Document.prototype, {
|
| + adoptNode: function(node) {
|
| + if (node.parentNode)
|
| + node.parentNode.removeChild(node);
|
| + adoptNodeNoRemove(node, this);
|
| + return node;
|
| + },
|
| + elementFromPoint: function(x, y) {
|
| + return elementFromPoint(this, this, x, y);
|
| + },
|
| + importNode: function(node, deep) {
|
| + // We need to manually walk the tree to ensure we do not include rendered
|
| + // shadow trees.
|
| + var clone = wrap(originalImportNode.call(this.impl, unwrap(node), false));
|
| + if (deep) {
|
| + for (var child = node.firstChild; child; child = child.nextSibling) {
|
| + clone.appendChild(this.importNode(child, true));
|
| + }
|
| + }
|
| + return clone;
|
| + },
|
| + getSelection: function() {
|
| + renderAllPending();
|
| + return new Selection(originalGetSelection.call(unwrap(this)));
|
| + }
|
| + });
|
| +
|
| + if (document.registerElement) {
|
| + var originalRegisterElement = document.registerElement;
|
| + Document.prototype.registerElement = function(tagName, object) {
|
| + var prototype = object.prototype;
|
| +
|
| + // If we already used the object as a prototype for another custom
|
| + // element.
|
| + if (scope.nativePrototypeTable.get(prototype)) {
|
| + // TODO(arv): DOMException
|
| + throw new Error('NotSupportedError');
|
| + }
|
| +
|
| + // Find first object on the prototype chain that already have a native
|
| + // prototype. Keep track of all the objects before that so we can create
|
| + // a similar structure for the native case.
|
| + var proto = Object.getPrototypeOf(prototype);
|
| + var nativePrototype;
|
| + var prototypes = [];
|
| + while (proto) {
|
| + nativePrototype = scope.nativePrototypeTable.get(proto);
|
| + if (nativePrototype)
|
| + break;
|
| + prototypes.push(proto);
|
| + proto = Object.getPrototypeOf(proto);
|
| + }
|
| +
|
| + if (!nativePrototype) {
|
| + // TODO(arv): DOMException
|
| + throw new Error('NotSupportedError');
|
| + }
|
| +
|
| + // This works by creating a new prototype object that is empty, but has
|
| + // the native prototype as its proto. The original prototype object
|
| + // passed into register is used as the wrapper prototype.
|
| +
|
| + var newPrototype = Object.create(nativePrototype);
|
| + for (var i = prototypes.length - 1; i >= 0; i--) {
|
| + newPrototype = Object.create(newPrototype);
|
| + }
|
| +
|
| + // Add callbacks if present.
|
| + // Names are taken from:
|
| + // https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit/Source/bindings/v8/CustomElementConstructorBuilder.cpp&sq=package:chromium&type=cs&l=156
|
| + // and not from the spec since the spec is out of date.
|
| + [
|
| + 'createdCallback',
|
| + 'attachedCallback',
|
| + 'detachedCallback',
|
| + 'attributeChangedCallback',
|
| + ].forEach(function(name) {
|
| + var f = prototype[name];
|
| + if (!f)
|
| + return;
|
| + newPrototype[name] = function() {
|
| + // if this element has been wrapped prior to registration,
|
| + // the wrapper is stale; in this case rewrap
|
| + if (!(wrap(this) instanceof CustomElementConstructor)) {
|
| + rewrap(this);
|
| + }
|
| + f.apply(wrap(this), arguments);
|
| + };
|
| + });
|
| +
|
| + var p = {prototype: newPrototype};
|
| + if (object.extends)
|
| + p.extends = object.extends;
|
| +
|
| + function CustomElementConstructor(node) {
|
| + if (!node) {
|
| + if (object.extends) {
|
| + return document.createElement(object.extends, tagName);
|
| + } else {
|
| + return document.createElement(tagName);
|
| + }
|
| + }
|
| + this.impl = node;
|
| + }
|
| + CustomElementConstructor.prototype = prototype;
|
| + CustomElementConstructor.prototype.constructor = CustomElementConstructor;
|
| +
|
| + scope.constructorTable.set(newPrototype, CustomElementConstructor);
|
| + scope.nativePrototypeTable.set(prototype, newPrototype);
|
| +
|
| + // registration is synchronous so do it last
|
| + var nativeConstructor = originalRegisterElement.call(unwrap(this),
|
| + tagName, p);
|
| + return CustomElementConstructor;
|
| + };
|
| +
|
| + forwardMethodsToWrapper([
|
| + window.HTMLDocument || window.Document, // Gecko adds these to HTMLDocument
|
| + ], [
|
| + 'registerElement',
|
| + ]);
|
| + }
|
| +
|
| + // We also override some of the methods on document.body and document.head
|
| + // for convenience.
|
| + forwardMethodsToWrapper([
|
| + window.HTMLBodyElement,
|
| + window.HTMLDocument || window.Document, // Gecko adds these to HTMLDocument
|
| + window.HTMLHeadElement,
|
| + window.HTMLHtmlElement,
|
| + ], [
|
| + 'appendChild',
|
| + 'compareDocumentPosition',
|
| + 'contains',
|
| + 'getElementsByClassName',
|
| + 'getElementsByTagName',
|
| + 'getElementsByTagNameNS',
|
| + 'insertBefore',
|
| + 'querySelector',
|
| + 'querySelectorAll',
|
| + 'removeChild',
|
| + 'replaceChild',
|
| + ].concat(matchesNames));
|
| +
|
| + forwardMethodsToWrapper([
|
| + window.HTMLDocument || window.Document, // Gecko adds these to HTMLDocument
|
| + ], [
|
| + 'adoptNode',
|
| + 'importNode',
|
| + 'contains',
|
| + 'createComment',
|
| + 'createDocumentFragment',
|
| + 'createElement',
|
| + 'createElementNS',
|
| + 'createEvent',
|
| + 'createEventNS',
|
| + 'createRange',
|
| + 'createTextNode',
|
| + 'elementFromPoint',
|
| + 'getElementById',
|
| + 'getSelection',
|
| + ]);
|
| +
|
| + mixin(Document.prototype, GetElementsByInterface);
|
| + mixin(Document.prototype, ParentNodeInterface);
|
| + mixin(Document.prototype, SelectorsInterface);
|
| +
|
| + mixin(Document.prototype, {
|
| + get implementation() {
|
| + var implementation = implementationTable.get(this);
|
| + if (implementation)
|
| + return implementation;
|
| + implementation =
|
| + new DOMImplementation(unwrap(this).implementation);
|
| + implementationTable.set(this, implementation);
|
| + return implementation;
|
| + }
|
| + });
|
| +
|
| + registerWrapper(window.Document, Document,
|
| + document.implementation.createHTMLDocument(''));
|
| +
|
| + // Both WebKit and Gecko uses HTMLDocument for document. HTML5/DOM only has
|
| + // one Document interface and IE implements the standard correctly.
|
| + if (window.HTMLDocument)
|
| + registerWrapper(window.HTMLDocument, Document);
|
| +
|
| + wrapEventTargetMethods([
|
| + window.HTMLBodyElement,
|
| + window.HTMLDocument || window.Document, // Gecko adds these to HTMLDocument
|
| + window.HTMLHeadElement,
|
| + ]);
|
| +
|
| + function DOMImplementation(impl) {
|
| + this.impl = impl;
|
| + }
|
| +
|
| + function wrapImplMethod(constructor, name) {
|
| + var original = document.implementation[name];
|
| + constructor.prototype[name] = function() {
|
| + return wrap(original.apply(this.impl, arguments));
|
| + };
|
| + }
|
| +
|
| + function forwardImplMethod(constructor, name) {
|
| + var original = document.implementation[name];
|
| + constructor.prototype[name] = function() {
|
| + return original.apply(this.impl, arguments);
|
| + };
|
| + }
|
| +
|
| + wrapImplMethod(DOMImplementation, 'createDocumentType');
|
| + wrapImplMethod(DOMImplementation, 'createDocument');
|
| + wrapImplMethod(DOMImplementation, 'createHTMLDocument');
|
| + forwardImplMethod(DOMImplementation, 'hasFeature');
|
| +
|
| + registerWrapper(window.DOMImplementation, DOMImplementation);
|
| +
|
| + forwardMethodsToWrapper([
|
| + window.DOMImplementation,
|
| + ], [
|
| + 'createDocumentType',
|
| + 'createDocument',
|
| + 'createHTMLDocument',
|
| + 'hasFeature',
|
| + ]);
|
| +
|
| + scope.adoptNodeNoRemove = adoptNodeNoRemove;
|
| + scope.wrappers.DOMImplementation = DOMImplementation;
|
| + scope.wrappers.Document = Document;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var EventTarget = scope.wrappers.EventTarget;
|
| + var Selection = scope.wrappers.Selection;
|
| + var mixin = scope.mixin;
|
| + var registerWrapper = scope.registerWrapper;
|
| + var renderAllPending = scope.renderAllPending;
|
| + var unwrap = scope.unwrap;
|
| + var unwrapIfNeeded = scope.unwrapIfNeeded;
|
| + var wrap = scope.wrap;
|
| +
|
| + var OriginalWindow = window.Window;
|
| + var originalGetComputedStyle = window.getComputedStyle;
|
| + var originalGetSelection = window.getSelection;
|
| +
|
| + function Window(impl) {
|
| + EventTarget.call(this, impl);
|
| + }
|
| + Window.prototype = Object.create(EventTarget.prototype);
|
| +
|
| + OriginalWindow.prototype.getComputedStyle = function(el, pseudo) {
|
| + return wrap(this || window).getComputedStyle(unwrapIfNeeded(el), pseudo);
|
| + };
|
| +
|
| + OriginalWindow.prototype.getSelection = function() {
|
| + return wrap(this || window).getSelection();
|
| + };
|
| +
|
| + // Work around for https://bugzilla.mozilla.org/show_bug.cgi?id=943065
|
| + delete window.getComputedStyle;
|
| + delete window.getSelection;
|
| +
|
| + ['addEventListener', 'removeEventListener', 'dispatchEvent'].forEach(
|
| + function(name) {
|
| + OriginalWindow.prototype[name] = function() {
|
| + var w = wrap(this || window);
|
| + return w[name].apply(w, arguments);
|
| + };
|
| +
|
| + // Work around for https://bugzilla.mozilla.org/show_bug.cgi?id=943065
|
| + delete window[name];
|
| + });
|
| +
|
| + mixin(Window.prototype, {
|
| + getComputedStyle: function(el, pseudo) {
|
| + renderAllPending();
|
| + return originalGetComputedStyle.call(unwrap(this), unwrapIfNeeded(el),
|
| + pseudo);
|
| + },
|
| + getSelection: function() {
|
| + renderAllPending();
|
| + return new Selection(originalGetSelection.call(unwrap(this)));
|
| + },
|
| + });
|
| +
|
| + registerWrapper(OriginalWindow, Window);
|
| +
|
| + scope.wrappers.Window = Window;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +// Copyright 2013 The Polymer Authors. All rights reserved.
|
| +// Use of this source code is goverened by a BSD-style
|
| +// license that can be found in the LICENSE file.
|
| +
|
| +(function(scope) {
|
| + 'use strict';
|
| +
|
| + var isWrapperFor = scope.isWrapperFor;
|
| +
|
| + // This is a list of the elements we currently override the global constructor
|
| + // for.
|
| + var elements = {
|
| + 'a': 'HTMLAnchorElement',
|
| +
|
| + // Do not create an applet element by default since it shows a warning in
|
| + // IE.
|
| + // https://github.com/Polymer/polymer/issues/217
|
| + // 'applet': 'HTMLAppletElement',
|
| +
|
| + 'area': 'HTMLAreaElement',
|
| + 'br': 'HTMLBRElement',
|
| + 'base': 'HTMLBaseElement',
|
| + 'body': 'HTMLBodyElement',
|
| + 'button': 'HTMLButtonElement',
|
| + // 'command': 'HTMLCommandElement', // Not fully implemented in Gecko.
|
| + 'dl': 'HTMLDListElement',
|
| + 'datalist': 'HTMLDataListElement',
|
| + 'data': 'HTMLDataElement',
|
| + 'dir': 'HTMLDirectoryElement',
|
| + 'div': 'HTMLDivElement',
|
| + 'embed': 'HTMLEmbedElement',
|
| + 'fieldset': 'HTMLFieldSetElement',
|
| + 'font': 'HTMLFontElement',
|
| + 'form': 'HTMLFormElement',
|
| + 'frame': 'HTMLFrameElement',
|
| + 'frameset': 'HTMLFrameSetElement',
|
| + 'hr': 'HTMLHRElement',
|
| + 'head': 'HTMLHeadElement',
|
| + 'h1': 'HTMLHeadingElement',
|
| + 'html': 'HTMLHtmlElement',
|
| + 'iframe': 'HTMLIFrameElement',
|
| + 'input': 'HTMLInputElement',
|
| + 'li': 'HTMLLIElement',
|
| + 'label': 'HTMLLabelElement',
|
| + 'legend': 'HTMLLegendElement',
|
| + 'link': 'HTMLLinkElement',
|
| + 'map': 'HTMLMapElement',
|
| + 'marquee': 'HTMLMarqueeElement',
|
| + 'menu': 'HTMLMenuElement',
|
| + 'menuitem': 'HTMLMenuItemElement',
|
| + 'meta': 'HTMLMetaElement',
|
| + 'meter': 'HTMLMeterElement',
|
| + 'del': 'HTMLModElement',
|
| + 'ol': 'HTMLOListElement',
|
| + 'object': 'HTMLObjectElement',
|
| + 'optgroup': 'HTMLOptGroupElement',
|
| + 'option': 'HTMLOptionElement',
|
| + 'output': 'HTMLOutputElement',
|
| + 'p': 'HTMLParagraphElement',
|
| + 'param': 'HTMLParamElement',
|
| + 'pre': 'HTMLPreElement',
|
| + 'progress': 'HTMLProgressElement',
|
| + 'q': 'HTMLQuoteElement',
|
| + 'script': 'HTMLScriptElement',
|
| + 'select': 'HTMLSelectElement',
|
| + 'source': 'HTMLSourceElement',
|
| + 'span': 'HTMLSpanElement',
|
| + 'style': 'HTMLStyleElement',
|
| + 'time': 'HTMLTimeElement',
|
| + 'caption': 'HTMLTableCaptionElement',
|
| + // WebKit and Moz are wrong:
|
| + // https://bugs.webkit.org/show_bug.cgi?id=111469
|
| + // https://bugzilla.mozilla.org/show_bug.cgi?id=848096
|
| + // 'td': 'HTMLTableCellElement',
|
| + 'col': 'HTMLTableColElement',
|
| + 'table': 'HTMLTableElement',
|
| + 'tr': 'HTMLTableRowElement',
|
| + 'thead': 'HTMLTableSectionElement',
|
| + 'tbody': 'HTMLTableSectionElement',
|
| + 'textarea': 'HTMLTextAreaElement',
|
| + 'track': 'HTMLTrackElement',
|
| + 'title': 'HTMLTitleElement',
|
| + 'ul': 'HTMLUListElement',
|
| + 'video': 'HTMLVideoElement',
|
| + };
|
| +
|
| + function overrideConstructor(tagName) {
|
| + var nativeConstructorName = elements[tagName];
|
| + var nativeConstructor = window[nativeConstructorName];
|
| + if (!nativeConstructor)
|
| + return;
|
| + var element = document.createElement(tagName);
|
| + var wrapperConstructor = element.constructor;
|
| + window[nativeConstructorName] = wrapperConstructor;
|
| + }
|
| +
|
| + Object.keys(elements).forEach(overrideConstructor);
|
| +
|
| + Object.getOwnPropertyNames(scope.wrappers).forEach(function(name) {
|
| + window[name] = scope.wrappers[name]
|
| + });
|
| +
|
| + // Export for testing.
|
| + scope.knownElements = elements;
|
| +
|
| +})(window.ShadowDOMPolyfill);
|
| +
|
| +/*
|
| + * Copyright 2013 The Polymer Authors. All rights reserved.
|
| + * Use of this source code is governed by a BSD-style
|
| + * license that can be found in the LICENSE file.
|
| + */
|
| +(function() {
|
| + var ShadowDOMPolyfill = window.ShadowDOMPolyfill;
|
| + var wrap = ShadowDOMPolyfill.wrap;
|
| +
|
| + // patch in prefixed name
|
| + Object.defineProperties(HTMLElement.prototype, {
|
| + //TODO(sjmiles): review accessor alias with Arv
|
| + webkitShadowRoot: {
|
| + get: function() {
|
| + return this.shadowRoot;
|
| + }
|
| + }
|
| + });
|
| +
|
| + // ShadowCSS needs this:
|
| + window.wrap = window.ShadowDOMPolyfill.wrap;
|
| + window.unwrap = window.ShadowDOMPolyfill.unwrap;
|
| +
|
| + //TODO(sjmiles): review method alias with Arv
|
| + HTMLElement.prototype.webkitCreateShadowRoot =
|
| + HTMLElement.prototype.createShadowRoot;
|
| +
|
| + // TODO(jmesserly): we need to wrap document somehow (a dart:html hook?)
|
| + window.dartExperimentalFixupGetTag = function(originalGetTag) {
|
| + var NodeList = ShadowDOMPolyfill.wrappers.NodeList;
|
| + var ShadowRoot = ShadowDOMPolyfill.wrappers.ShadowRoot;
|
| + var unwrapIfNeeded = ShadowDOMPolyfill.unwrapIfNeeded;
|
| + function getTag(obj) {
|
| + // TODO(jmesserly): do we still need these?
|
| + if (obj instanceof NodeList) return 'NodeList';
|
| + if (obj instanceof ShadowRoot) return 'ShadowRoot';
|
| + if (window.MutationRecord && (obj instanceof MutationRecord))
|
| + return 'MutationRecord';
|
| + if (window.MutationObserver && (obj instanceof MutationObserver))
|
| + return 'MutationObserver';
|
| +
|
| + // TODO(jmesserly): this prevents incorrect interaction between ShadowDOM
|
| + // and dart:html's <template> polyfill. Essentially, ShadowDOM is
|
| + // polyfilling native template, but our Dart polyfill fails to detect this
|
| + // because the unwrapped node is an HTMLUnknownElement, leading it to
|
| + // think the node has no content.
|
| + if (obj instanceof HTMLTemplateElement) return 'HTMLTemplateElement';
|
| +
|
| + var unwrapped = unwrapIfNeeded(obj);
|
| + if (obj !== unwrapped) {
|
| + // Fix up class names for Firefox.
|
| + // For some of them (like HTMLFormElement and HTMLInputElement),
|
| + // the "constructor" property of the unwrapped nodes points at the
|
| + // same constructor as the wrapper.
|
| + var ctor = obj.constructor
|
| + if (ctor === unwrapped.constructor) {
|
| + var name = ctor._ShadowDOMPolyfill$cacheTag_;
|
| + if (!name) {
|
| + name = Object.prototype.toString.call(unwrapped);
|
| + name = name.substring(8, name.length - 1);
|
| + ctor._ShadowDOMPolyfill$cacheTag_ = name;
|
| + }
|
| + return name;
|
| + }
|
| +
|
| + obj = unwrapped;
|
| + }
|
| + return originalGetTag(obj);
|
| + }
|
| +
|
| + return getTag;
|
| + };
|
| +})();
|
| +
|
| +// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
|
| +// for details. All rights reserved. Use of this source code is governed by a
|
| +// BSD-style license that can be found in the LICENSE file.
|
| +
|
| +var Platform = {};
|
| +
|
| +/*
|
| + * Copyright 2012 The Polymer Authors. All rights reserved.
|
| + * Use of this source code is governed by a BSD-style
|
| + * license that can be found in the LICENSE file.
|
| + */
|
| +
|
| +/*
|
| + This is a limited shim for ShadowDOM css styling.
|
| + https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles
|
| +
|
| + The intention here is to support only the styling features which can be
|
| + relatively simply implemented. The goal is to allow users to avoid the
|
| + most obvious pitfalls and do so without compromising performance significantly.
|
| + For ShadowDOM styling that's not covered here, a set of best practices
|
| + can be provided that should allow users to accomplish more complex styling.
|
| +
|
| + The following is a list of specific ShadowDOM styling features and a brief
|
| + discussion of the approach used to shim.
|
| +
|
| + Shimmed features:
|
| +
|
| + * @host: ShadowDOM allows styling of the shadowRoot's host element using the
|
| + @host rule. To shim this feature, the @host styles are reformatted and
|
| + prefixed with a given scope name and promoted to a document level stylesheet.
|
| + For example, given a scope name of .foo, a rule like this:
|
| +
|
| + @host {
|
| + * {
|
| + background: red;
|
| + }
|
| + }
|
| +
|
| + becomes:
|
| +
|
| + .foo {
|
| + background: red;
|
| + }
|
| +
|
| + * encapsultion: Styles defined within ShadowDOM, apply only to
|
| + dom inside the ShadowDOM. Polymer uses one of two techniques to imlement
|
| + this feature.
|
| +
|
| + By default, rules are prefixed with the host element tag name
|
| + as a descendant selector. This ensures styling does not leak out of the 'top'
|
| + of the element's ShadowDOM. For example,
|
| +
|
| + div {
|
| + font-weight: bold;
|
| + }
|
| +
|
| + becomes:
|
| +
|
| + x-foo div {
|
| + font-weight: bold;
|
| + }
|
| +
|
| + becomes:
|
| +
|
| +
|
| + Alternatively, if Platform.ShadowCSS.strictStyling is set to true then
|
| + selectors are scoped by adding an attribute selector suffix to each
|
| + simple selector that contains the host element tag name. Each element
|
| + in the element's ShadowDOM template is also given the scope attribute.
|
| + Thus, these rules match only elements that have the scope attribute.
|
| + For example, given a scope name of x-foo, a rule like this:
|
| +
|
| + div {
|
| + font-weight: bold;
|
| + }
|
| +
|
| + becomes:
|
| +
|
| + div[x-foo] {
|
| + font-weight: bold;
|
| + }
|
| +
|
| + Note that elements that are dynamically added to a scope must have the scope
|
| + selector added to them manually.
|
| +
|
| + * ::pseudo: These rules are converted to rules that take advantage of the
|
| + pseudo attribute. For example, a shadowRoot like this inside an x-foo
|
| +
|
| + <div pseudo="x-special">Special</div>
|
| +
|
| + with a rule like this:
|
| +
|
| + x-foo::x-special { ... }
|
| +
|
| + becomes:
|
| +
|
| + x-foo [pseudo=x-special] { ... }
|
| +
|
| + * ::part(): These rules are converted to rules that take advantage of the
|
| + part attribute. For example, a shadowRoot like this inside an x-foo
|
| +
|
| + <div part="special">Special</div>
|
| +
|
| + with a rule like this:
|
| +
|
| + x-foo::part(special) { ... }
|
| +
|
| + becomes:
|
| +
|
| + x-foo [part=special] { ... }
|
| +
|
| + Unaddressed ShadowDOM styling features:
|
| +
|
| + * upper/lower bound encapsulation: Styles which are defined outside a
|
| + shadowRoot should not cross the ShadowDOM boundary and should not apply
|
| + inside a shadowRoot.
|
| +
|
| + This styling behavior is not emulated. Some possible ways to do this that
|
| + were rejected due to complexity and/or performance concerns include: (1) reset
|
| + every possible property for every possible selector for a given scope name;
|
| + (2) re-implement css in javascript.
|
| +
|
| + As an alternative, users should make sure to use selectors
|
| + specific to the scope in which they are working.
|
| +
|
| + * ::distributed: This behavior is not emulated. It's often not necessary
|
| + to style the contents of a specific insertion point and instead, descendants
|
| + of the host element can be styled selectively. Users can also create an
|
| + extra node around an insertion point and style that node's contents
|
| + via descendent selectors. For example, with a shadowRoot like this:
|
| +
|
| + <style>
|
| + content::-webkit-distributed(div) {
|
| + background: red;
|
| + }
|
| + </style>
|
| + <content></content>
|
| +
|
| + could become:
|
| +
|
| + <style>
|
| + / *@polyfill .content-container div * /
|
| + content::-webkit-distributed(div) {
|
| + background: red;
|
| + }
|
| + </style>
|
| + <div class="content-container">
|
| + <content></content>
|
| + </div>
|
| +
|
| + Note the use of @polyfill in the comment above a ShadowDOM specific style
|
| + declaration. This is a directive to the styling shim to use the selector
|
| + in comments in lieu of the next selector when running under polyfill.
|
| +*/
|
| +(function(scope) {
|
| +
|
| +var loader = scope.loader;
|
| +
|
| +var ShadowCSS = {
|
| + strictStyling: false,
|
| + registry: {},
|
| + // Shim styles for a given root associated with a name and extendsName
|
| + // 1. cache root styles by name
|
| + // 2. optionally tag root nodes with scope name
|
| + // 3. shim polyfill directives /* @polyfill */ and /* @polyfill-rule */
|
| + // 4. shim @host and scoping
|
| + shimStyling: function(root, name, extendsName) {
|
| + var typeExtension = this.isTypeExtension(extendsName);
|
| + // use caching to make working with styles nodes easier and to facilitate
|
| + // lookup of extendee
|
| + var def = this.registerDefinition(root, name, extendsName);
|
| + // find styles and apply shimming...
|
| + if (this.strictStyling) {
|
| + this.applyScopeToContent(root, name);
|
| + }
|
| + var cssText = this.stylesToShimmedCssText(def.rootStyles, def.scopeStyles,
|
| + name, typeExtension);
|
| + // provide shimmedStyle for user extensibility
|
| + def.shimmedStyle = cssTextToStyle(cssText);
|
| + if (root) {
|
| + root.shimmedStyle = def.shimmedStyle;
|
| + }
|
| + // remove existing style elements
|
| + for (var i=0, l=def.rootStyles.length, s; (i<l) && (s=def.rootStyles[i]);
|
| + i++) {
|
| + s.parentNode.removeChild(s);
|
| + }
|
| + // add style to document
|
| + addCssToDocument(cssText);
|
| + },
|
| + // apply @polyfill rules + @host and scope shimming
|
| + stylesToShimmedCssText: function(rootStyles, scopeStyles, name,
|
| + typeExtension) {
|
| + name = name || '';
|
| + // insert @polyfill and @polyfill-rule rules into style elements
|
| + // scoping process takes care of shimming these
|
| + this.insertPolyfillDirectives(rootStyles);
|
| + this.insertPolyfillRules(rootStyles);
|
| + var cssText = this.shimAtHost(scopeStyles, name, typeExtension) +
|
| + this.shimScoping(scopeStyles, name, typeExtension);
|
| + // note: we only need to do rootStyles since these are unscoped.
|
| + cssText += this.extractPolyfillUnscopedRules(rootStyles);
|
| + return cssText;
|
| + },
|
| + registerDefinition: function(root, name, extendsName) {
|
| + var def = this.registry[name] = {
|
| + root: root,
|
| + name: name,
|
| + extendsName: extendsName
|
| + }
|
| + var styles = root ? root.querySelectorAll('style') : [];
|
| + styles = styles ? Array.prototype.slice.call(styles, 0) : [];
|
| + def.rootStyles = styles;
|
| + def.scopeStyles = def.rootStyles;
|
| + var extendee = this.registry[def.extendsName];
|
| + if (extendee && (!root || root.querySelector('shadow'))) {
|
| + def.scopeStyles = extendee.scopeStyles.concat(def.scopeStyles);
|
| + }
|
| + return def;
|
| + },
|
| + isTypeExtension: function(extendsName) {
|
| + return extendsName && extendsName.indexOf('-') < 0;
|
| + },
|
| + applyScopeToContent: function(root, name) {
|
| + if (root) {
|
| + // add the name attribute to each node in root.
|
| + Array.prototype.forEach.call(root.querySelectorAll('*'),
|
| + function(node) {
|
| + node.setAttribute(name, '');
|
| + });
|
| + // and template contents too
|
| + Array.prototype.forEach.call(root.querySelectorAll('template'),
|
| + function(template) {
|
| + this.applyScopeToContent(template.content, name);
|
| + },
|
| + this);
|
| + }
|
| + },
|
| + /*
|
| + * Process styles to convert native ShadowDOM rules that will trip
|
| + * up the css parser; we rely on decorating the stylesheet with comments.
|
| + *
|
| + * For example, we convert this rule:
|
| + *
|
| + * (comment start) @polyfill :host menu-item (comment end)
|
| + * shadow::-webkit-distributed(menu-item) {
|
| + *
|
| + * to this:
|
| + *
|
| + * scopeName menu-item {
|
| + *
|
| + **/
|
| + insertPolyfillDirectives: function(styles) {
|
| + if (styles) {
|
| + Array.prototype.forEach.call(styles, function(s) {
|
| + s.textContent = this.insertPolyfillDirectivesInCssText(s.textContent);
|
| + }, this);
|
| + }
|
| + },
|
| + insertPolyfillDirectivesInCssText: function(cssText) {
|
| + return cssText.replace(cssPolyfillCommentRe, function(match, p1) {
|
| + // remove end comment delimiter and add block start
|
| + return p1.slice(0, -2) + '{';
|
| + });
|
| + },
|
| + /*
|
| + * Process styles to add rules which will only apply under the polyfill
|
| + *
|
| + * For example, we convert this rule:
|
| + *
|
| + * (comment start) @polyfill-rule :host menu-item {
|
| + * ... } (comment end)
|
| + *
|
| + * to this:
|
| + *
|
| + * scopeName menu-item {...}
|
| + *
|
| + **/
|
| + insertPolyfillRules: function(styles) {
|
| + if (styles) {
|
| + Array.prototype.forEach.call(styles, function(s) {
|
| + s.textContent = this.insertPolyfillRulesInCssText(s.textContent);
|
| + }, this);
|
| + }
|
| + },
|
| + insertPolyfillRulesInCssText: function(cssText) {
|
| + return cssText.replace(cssPolyfillRuleCommentRe, function(match, p1) {
|
| + // remove end comment delimiter
|
| + return p1.slice(0, -1);
|
| + });
|
| + },
|
| + /*
|
| + * Process styles to add rules which will only apply under the polyfill
|
| + * and do not process via CSSOM. (CSSOM is destructive to rules on rare
|
| + * occasions, e.g. -webkit-calc on Safari.)
|
| + * For example, we convert this rule:
|
| + *
|
| + * (comment start) @polyfill-unscoped-rule menu-item {
|
| + * ... } (comment end)
|
| + *
|
| + * to this:
|
| + *
|
| + * menu-item {...}
|
| + *
|
| + **/
|
| + extractPolyfillUnscopedRules: function(styles) {
|
| + var cssText = '';
|
| + if (styles) {
|
| + Array.prototype.forEach.call(styles, function(s) {
|
| + cssText += this.extractPolyfillUnscopedRulesFromCssText(
|
| + s.textContent) + '\n\n';
|
| + }, this);
|
| + }
|
| + return cssText;
|
| + },
|
| + extractPolyfillUnscopedRulesFromCssText: function(cssText) {
|
| + var r = '', matches;
|
| + while (matches = cssPolyfillUnscopedRuleCommentRe.exec(cssText)) {
|
| + r += matches[1].slice(0, -1) + '\n\n';
|
| + }
|
| + return r;
|
| + },
|
| + // form: @host { .foo { declarations } }
|
| + // becomes: scopeName.foo { declarations }
|
| + shimAtHost: function(styles, name, typeExtension) {
|
| + if (styles) {
|
| + return this.convertAtHostStyles(styles, name, typeExtension);
|
| + }
|
| + },
|
| + convertAtHostStyles: function(styles, name, typeExtension) {
|
| + var cssText = stylesToCssText(styles), self = this;
|
| + cssText = cssText.replace(hostRuleRe, function(m, p1) {
|
| + return self.scopeHostCss(p1, name, typeExtension);
|
| + });
|
| + cssText = rulesToCss(this.findAtHostRules(cssToRules(cssText),
|
| + this.makeScopeMatcher(name, typeExtension)));
|
| + return cssText;
|
| + },
|
| + scopeHostCss: function(cssText, name, typeExtension) {
|
| + var self = this;
|
| + return cssText.replace(selectorRe, function(m, p1, p2) {
|
| + return self.scopeHostSelector(p1, name, typeExtension) + ' ' + p2 + '\n\t';
|
| + });
|
| + },
|
| + // supports scopig by name and [is=name] syntax
|
| + scopeHostSelector: function(selector, name, typeExtension) {
|
| + var r = [], parts = selector.split(','), is = '[is=' + name + ']';
|
| + parts.forEach(function(p) {
|
| + p = p.trim();
|
| + // selector: *|:scope -> name
|
| + if (p.match(hostElementRe)) {
|
| + p = p.replace(hostElementRe, typeExtension ? is + '$1$3' :
|
| + name + '$1$3');
|
| + // selector: .foo -> name.foo (OR) [bar] -> name[bar]
|
| + } else if (p.match(hostFixableRe)) {
|
| + p = typeExtension ? is + p : name + p;
|
| + }
|
| + r.push(p);
|
| + }, this);
|
| + return r.join(', ');
|
| + },
|
| + // consider styles that do not include component name in the selector to be
|
| + // unscoped and in need of promotion;
|
| + // for convenience, also consider keyframe rules this way.
|
| + findAtHostRules: function(cssRules, matcher) {
|
| + return Array.prototype.filter.call(cssRules,
|
| + this.isHostRule.bind(this, matcher));
|
| + },
|
| + isHostRule: function(matcher, cssRule) {
|
| + return (cssRule.selectorText && cssRule.selectorText.match(matcher)) ||
|
| + (cssRule.cssRules && this.findAtHostRules(cssRule.cssRules, matcher).length) ||
|
| + (cssRule.type == CSSRule.WEBKIT_KEYFRAMES_RULE);
|
| + },
|
| + /* Ensure styles are scoped. Pseudo-scoping takes a rule like:
|
| + *
|
| + * .foo {... }
|
| + *
|
| + * and converts this to
|
| + *
|
| + * scopeName .foo { ... }
|
| + */
|
| + shimScoping: function(styles, name, typeExtension) {
|
| + if (styles) {
|
| + return this.convertScopedStyles(styles, name, typeExtension);
|
| + }
|
| + },
|
| + convertScopedStyles: function(styles, name, typeExtension) {
|
| + var cssText = stylesToCssText(styles).replace(hostRuleRe, '');
|
| + cssText = this.insertPolyfillHostInCssText(cssText);
|
| + cssText = this.convertColonHost(cssText);
|
| + cssText = this.convertColonAncestor(cssText);
|
| + // TODO(sorvell): deprecated, remove
|
| + cssText = this.convertPseudos(cssText);
|
| + // TODO(sorvell): deprecated, remove
|
| + cssText = this.convertParts(cssText);
|
| + cssText = this.convertCombinators(cssText);
|
| + var rules = cssToRules(cssText);
|
| + if (name) {
|
| + cssText = this.scopeRules(rules, name, typeExtension);
|
| + }
|
| + return cssText;
|
| + },
|
| + convertPseudos: function(cssText) {
|
| + return cssText.replace(cssPseudoRe, ' [pseudo=$1]');
|
| + },
|
| + convertParts: function(cssText) {
|
| + return cssText.replace(cssPartRe, ' [part=$1]');
|
| + },
|
| + /*
|
| + * convert a rule like :host(.foo) > .bar { }
|
| + *
|
| + * to
|
| + *
|
| + * scopeName.foo > .bar
|
| + */
|
| + convertColonHost: function(cssText) {
|
| + return this.convertColonRule(cssText, cssColonHostRe,
|
| + this.colonHostPartReplacer);
|
| + },
|
| + /*
|
| + * convert a rule like :ancestor(.foo) > .bar { }
|
| + *
|
| + * to
|
| + *
|
| + * scopeName.foo > .bar, .foo scopeName > .bar { }
|
| + *
|
| + * and
|
| + *
|
| + * :ancestor(.foo:host) .bar { ... }
|
| + *
|
| + * to
|
| + *
|
| + * scopeName.foo .bar { ... }
|
| + */
|
| + convertColonAncestor: function(cssText) {
|
| + return this.convertColonRule(cssText, cssColonAncestorRe,
|
| + this.colonAncestorPartReplacer);
|
| + },
|
| + convertColonRule: function(cssText, regExp, partReplacer) {
|
| + // p1 = :host, p2 = contents of (), p3 rest of rule
|
| + return cssText.replace(regExp, function(m, p1, p2, p3) {
|
| + p1 = polyfillHostNoCombinator;
|
| + if (p2) {
|
| + var parts = p2.split(','), r = [];
|
| + for (var i=0, l=parts.length, p; (i<l) && (p=parts[i]); i++) {
|
| + p = p.trim();
|
| + r.push(partReplacer(p1, p, p3));
|
| + }
|
| + return r.join(',');
|
| + } else {
|
| + return p1 + p3;
|
| + }
|
| + });
|
| + },
|
| + colonAncestorPartReplacer: function(host, part, suffix) {
|
| + if (part.match(polyfillHost)) {
|
| + return this.colonHostPartReplacer(host, part, suffix);
|
| + } else {
|
| + return host + part + suffix + ', ' + part + ' ' + host + suffix;
|
| + }
|
| + },
|
| + colonHostPartReplacer: function(host, part, suffix) {
|
| + return host + part.replace(polyfillHost, '') + suffix;
|
| + },
|
| + /*
|
| + * Convert ^ and ^^ combinators by replacing with space.
|
| + */
|
| + convertCombinators: function(cssText) {
|
| + return cssText.replace(/\^\^/g, ' ').replace(/\^/g, ' ');
|
| + },
|
| + // change a selector like 'div' to 'name div'
|
| + scopeRules: function(cssRules, name, typeExtension) {
|
| + var cssText = '';
|
| + Array.prototype.forEach.call(cssRules, function(rule) {
|
| + if (rule.selectorText && (rule.style && rule.style.cssText)) {
|
| + cssText += this.scopeSelector(rule.selectorText, name, typeExtension,
|
| + this.strictStyling) + ' {\n\t';
|
| + cssText += this.propertiesFromRule(rule) + '\n}\n\n';
|
| + } else if (rule.media) {
|
| + cssText += '@media ' + rule.media.mediaText + ' {\n';
|
| + cssText += this.scopeRules(rule.cssRules, name, typeExtension);
|
| + cssText += '\n}\n\n';
|
| + } else if (rule.cssText) {
|
| + cssText += rule.cssText + '\n\n';
|
| + }
|
| + }, this);
|
| + return cssText;
|
| + },
|
| + scopeSelector: function(selector, name, typeExtension, strict) {
|
| + var r = [], parts = selector.split(',');
|
| + parts.forEach(function(p) {
|
| + p = p.trim();
|
| + if (this.selectorNeedsScoping(p, name, typeExtension)) {
|
| + p = (strict && !p.match(polyfillHostNoCombinator)) ?
|
| + this.applyStrictSelectorScope(p, name) :
|
| + this.applySimpleSelectorScope(p, name, typeExtension);
|
| + }
|
| + r.push(p);
|
| + }, this);
|
| + return r.join(', ');
|
| + },
|
| + selectorNeedsScoping: function(selector, name, typeExtension) {
|
| + var re = this.makeScopeMatcher(name, typeExtension);
|
| + return !selector.match(re);
|
| + },
|
| + makeScopeMatcher: function(name, typeExtension) {
|
| + var matchScope = typeExtension ? '\\[is=[\'"]?' + name + '[\'"]?\\]' : name;
|
| + return new RegExp('^(' + matchScope + ')' + selectorReSuffix, 'm');
|
| + },
|
| + // scope via name and [is=name]
|
| + applySimpleSelectorScope: function(selector, name, typeExtension) {
|
| + var scoper = typeExtension ? '[is=' + name + ']' : name;
|
| + if (selector.match(polyfillHostRe)) {
|
| + selector = selector.replace(polyfillHostNoCombinator, scoper);
|
| + return selector.replace(polyfillHostRe, scoper + ' ');
|
| + } else {
|
| + return scoper + ' ' + selector;
|
| + }
|
| + },
|
| + // return a selector with [name] suffix on each simple selector
|
| + // e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name]
|
| + applyStrictSelectorScope: function(selector, name) {
|
| + var splits = [' ', '>', '+', '~'],
|
| + scoped = selector,
|
| + attrName = '[' + name + ']';
|
| + splits.forEach(function(sep) {
|
| + var parts = scoped.split(sep);
|
| + scoped = parts.map(function(p) {
|
| + // remove :host since it should be unnecessary
|
| + var t = p.trim().replace(polyfillHostRe, '');
|
| + if (t && (splits.indexOf(t) < 0) && (t.indexOf(attrName) < 0)) {
|
| + p = t.replace(/([^:]*)(:*)(.*)/, '$1' + attrName + '$2$3')
|
| + }
|
| + return p;
|
| + }).join(sep);
|
| + });
|
| + return scoped;
|
| + },
|
| + insertPolyfillHostInCssText: function(selector) {
|
| + return selector.replace(hostRe, polyfillHost).replace(colonHostRe,
|
| + polyfillHost).replace(colonAncestorRe, polyfillAncestor);
|
| + },
|
| + propertiesFromRule: function(rule) {
|
| + // TODO(sorvell): Safari cssom incorrectly removes quotes from the content
|
| + // property. (https://bugs.webkit.org/show_bug.cgi?id=118045)
|
| + if (rule.style.content && !rule.style.content.match(/['"]+/)) {
|
| + return rule.style.cssText.replace(/content:[^;]*;/g, 'content: \'' +
|
| + rule.style.content + '\';');
|
| + }
|
| + return rule.style.cssText;
|
| + }
|
| +};
|
| +
|
| +var hostRuleRe = /@host[^{]*{(([^}]*?{[^{]*?}[\s\S]*?)+)}/gim,
|
| + selectorRe = /([^{]*)({[\s\S]*?})/gim,
|
| + hostElementRe = /(.*)((?:\*)|(?:\:scope))(.*)/,
|
| + hostFixableRe = /^[.\[:]/,
|
| + cssCommentRe = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//gim,
|
| + cssPolyfillCommentRe = /\/\*\s*@polyfill ([^*]*\*+([^/*][^*]*\*+)*\/)([^{]*?){/gim,
|
| + cssPolyfillRuleCommentRe = /\/\*\s@polyfill-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
|
| + cssPolyfillUnscopedRuleCommentRe = /\/\*\s@polyfill-unscoped-rule([^*]*\*+([^/*][^*]*\*+)*)\//gim,
|
| + cssPseudoRe = /::(x-[^\s{,(]*)/gim,
|
| + cssPartRe = /::part\(([^)]*)\)/gim,
|
| + // note: :host pre-processed to -shadowcsshost.
|
| + polyfillHost = '-shadowcsshost',
|
| + // note: :ancestor pre-processed to -shadowcssancestor.
|
| + polyfillAncestor = '-shadowcssancestor',
|
| + parenSuffix = ')(?:\\((' +
|
| + '(?:\\([^)(]*\\)|[^)(]*)+?' +
|
| + ')\\))?([^,{]*)';
|
| + cssColonHostRe = new RegExp('(' + polyfillHost + parenSuffix, 'gim'),
|
| + cssColonAncestorRe = new RegExp('(' + polyfillAncestor + parenSuffix, 'gim'),
|
| + selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$',
|
| + hostRe = /@host/gim,
|
| + colonHostRe = /\:host/gim,
|
| + colonAncestorRe = /\:ancestor/gim,
|
| + /* host name without combinator */
|
| + polyfillHostNoCombinator = polyfillHost + '-no-combinator',
|
| + polyfillHostRe = new RegExp(polyfillHost, 'gim');
|
| + polyfillAncestorRe = new RegExp(polyfillAncestor, 'gim');
|
| +
|
| +function stylesToCssText(styles, preserveComments) {
|
| + var cssText = '';
|
| + Array.prototype.forEach.call(styles, function(s) {
|
| + cssText += s.textContent + '\n\n';
|
| + });
|
| + // strip comments for easier processing
|
| + if (!preserveComments) {
|
| + cssText = cssText.replace(cssCommentRe, '');
|
| + }
|
| + return cssText;
|
| +}
|
| +
|
| +function cssTextToStyle(cssText) {
|
| + var style = document.createElement('style');
|
| + style.textContent = cssText;
|
| + return style;
|
| +}
|
| +
|
| +function cssToRules(cssText) {
|
| + var style = cssTextToStyle(cssText);
|
| + document.head.appendChild(style);
|
| + var rules = style.sheet.cssRules;
|
| + style.parentNode.removeChild(style);
|
| + return rules;
|
| +}
|
| +
|
| +function rulesToCss(cssRules) {
|
| + for (var i=0, css=[]; i < cssRules.length; i++) {
|
| + css.push(cssRules[i].cssText);
|
| + }
|
| + return css.join('\n\n');
|
| +}
|
| +
|
| +function addCssToDocument(cssText) {
|
| + if (cssText) {
|
| + getSheet().appendChild(document.createTextNode(cssText));
|
| + }
|
| +}
|
| +
|
| +var sheet;
|
| +function getSheet() {
|
| + if (!sheet) {
|
| + sheet = document.createElement("style");
|
| + sheet.setAttribute('ShadowCSSShim', '');
|
| + sheet.shadowCssShim = true;
|
| + }
|
| + return sheet;
|
| +}
|
| +
|
| +// add polyfill stylesheet to document
|
| +if (window.ShadowDOMPolyfill) {
|
| + addCssToDocument('style { display: none !important; }\n');
|
| + var doc = wrap(document);
|
| + var head = doc.querySelector('head');
|
| + head.insertBefore(getSheet(), head.childNodes[0]);
|
| +
|
| + document.addEventListener('DOMContentLoaded', function() {
|
| + if (window.HTMLImports && !HTMLImports.useNative) {
|
| + HTMLImports.importer.preloadSelectors +=
|
| + ', link[rel=stylesheet]:not([nopolyfill])';
|
| + HTMLImports.parser.parseGeneric = function(elt) {
|
| + if (elt.shadowCssShim) {
|
| + return;
|
| + }
|
| + var style = elt;
|
| + if (!elt.hasAttribute('nopolyfill')) {
|
| + if (elt.__resource) {
|
| + style = elt.ownerDocument.createElement('style');
|
| + style.textContent = Platform.loader.resolveUrlsInCssText(
|
| + elt.__resource, elt.href);
|
| + // remove links from main document
|
| + if (elt.ownerDocument === doc) {
|
| + elt.parentNode.removeChild(elt);
|
| + }
|
| + } else {
|
| + Platform.loader.resolveUrlsInStyle(style);
|
| + }
|
| + var styles = [style];
|
| + style.textContent = ShadowCSS.stylesToShimmedCssText(styles, styles);
|
| + style.shadowCssShim = true;
|
| + }
|
| + // place in document
|
| + if (style.parentNode !== head) {
|
| + head.appendChild(style);
|
| + }
|
| + }
|
| + }
|
| + });
|
| +}
|
| +
|
| +// exports
|
| +scope.ShadowCSS = ShadowCSS;
|
| +
|
| +})(window.Platform);
|
| +}
|
|
|
Chromium Code Reviews
Issue 839543002:
Revert "Build Observatory with runtime" (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart