polymer-micro.html

<!--
@license
Copyright (c) 2014 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
--><script>(function() {
function resolve() {
document.body.removeAttribute("unresolved");
}
if (window.WebComponents) {
addEventListener("WebComponentsReady", resolve);
} else {
resolve();
}
})();

Polymer = {
Settings: function() {
var user = window.Polymer || {};
location.search.slice(1).split("&").forEach(function(o) {
o = o.split("=");
o[0] && (user[o[0]] = o[1] || true);
});
var wantShadow = user.dom === "shadow";
var hasShadow = Boolean(Element.prototype.createShadowRoot);
var nativeShadow = hasShadow && !window.ShadowDOMPolyfill;
var useShadow = wantShadow && hasShadow;
var hasNativeImports = Boolean("import" in document.createElement("link"));
var useNativeImports = hasNativeImports;
var useNativeCustomElements = !window.CustomElements || window.CustomElements.useNative;
return {
wantShadow: wantShadow,
hasShadow: hasShadow,
nativeShadow: nativeShadow,
useShadow: useShadow,
useNativeShadow: useShadow && nativeShadow,
useNativeImports: useNativeImports,
useNativeCustomElements: useNativeCustomElements
};
}()
};

(function() {
var userPolymer = window.Polymer;
window.Polymer = function(prototype) {
var ctor = desugar(prototype);
prototype = ctor.prototype;
var options = {
prototype: prototype
};
if (prototype.extends) {
options.extends = prototype.extends;
}
Polymer.telemetry._registrate(prototype);
document.registerElement(prototype.is, options);
return ctor;
};
var desugar = function(prototype) {
prototype = Polymer.Base.chainObject(prototype, Polymer.Base);
prototype.registerCallback();
return prototype.constructor;
};
window.Polymer = Polymer;
if (userPolymer) {
for (var i in userPolymer) {
Polymer[i] = userPolymer[i];
}
}
Polymer.Class = desugar;
})();

Polymer.telemetry = {
registrations: [],
_regLog: function(prototype) {
console.log("[" + prototype.is + "]: registered");
},
_registrate: function(prototype) {
this.registrations.push(prototype);
Polymer.log && this._regLog(prototype);
},
dumpRegistrations: function() {
this.registrations.forEach(this._regLog);
}
};

Object.defineProperty(window, "currentImport", {
enumerable: true,
configurable: true,
get: function() {
return (document._currentScript || document.currentScript).ownerDocument;
}
});

Polymer.Base = {
_addFeature: function(feature) {
this.extend(this, feature);
},
registerCallback: function() {
this._registerFeatures();
this._doBehavior("registered");
},
createdCallback: function() {
Polymer.telemetry.instanceCount++;
this.root = this;
this._doBehavior("created");
this._initFeatures();
},
attachedCallback: function() {
this.isAttached = true;
this._doBehavior("attached");
},
detachedCallback: function() {
this.isAttached = false;
this._doBehavior("detached");
},
attributeChangedCallback: function(name) {
this._setAttributeToProperty(this, name);
this._doBehavior("attributeChanged", arguments);
},
extend: function(prototype, api) {
if (prototype && api) {
Object.getOwnPropertyNames(api).forEach(function(n) {
this.copyOwnProperty(n, api, prototype);
}, this);
}
return prototype || api;
},
copyOwnProperty: function(name, source, target) {
var pd = Object.getOwnPropertyDescriptor(source, name);
if (pd) {
Object.defineProperty(target, name, pd);
}
},
_log: console.log.apply.bind(console.log, console),
_warn: console.warn.apply.bind(console.warn, console),
_error: console.error.apply.bind(console.error, console),
_logf: function() {
return this._logPrefix.concat([ this.is ]).concat(Array.prototype.slice.call(arguments, 0));
}
};

Polymer.Base._logPrefix = function() {
var color = window.chrome || /firefox/i.test(navigator.userAgent);
return color ? [ "%c[%s::%s]:", "font-weight: bold; background-color:#EEEE00;" ] : [ "[%s::%s]:" ];
}();

Polymer.Base.chainObject = function(object, inherited) {
if (object && inherited && object !== inherited) {
if (!Object.__proto__) {
object = Polymer.Base.extend(Object.create(inherited), object);
}
object.__proto__ = inherited;
}
return object;
};

Polymer.Base = Polymer.Base.chainObject(Polymer.Base, HTMLElement.prototype);

Polymer.telemetry.instanceCount = 0;

(function() {
var modules = {};
var DomModule = function() {
return document.createElement("dom-module");
};
DomModule.prototype = Object.create(HTMLElement.prototype);
DomModule.prototype.constructor = DomModule;
DomModule.prototype.createdCallback = function() {
var id = this.id || this.getAttribute("name") || this.getAttribute("is");
if (id) {
this.id = id;
modules[id] = this;
}
};
DomModule.prototype.import = function(id, slctr) {
var m = modules[id];
if (!m) {
forceDocumentUpgrade();
m = modules[id];
}
if (m && slctr) {
m = m.querySelector(slctr);
}
return m;
};
var cePolyfill = window.CustomElements && !CustomElements.useNative;
if (cePolyfill) {
var ready = CustomElements.ready;
CustomElements.ready = true;
}
document.registerElement("dom-module", DomModule);
if (cePolyfill) {
CustomElements.ready = ready;
}
function forceDocumentUpgrade() {
if (cePolyfill) {
var script = document._currentScript || document.currentScript;
if (script) {
CustomElements.upgradeAll(script.ownerDocument);
}
}
}
})();

Polymer.Base._addFeature({
_prepIs: function() {
if (!this.is) {
var module = (document._currentScript || document.currentScript).parentNode;
if (module.localName === "dom-module") {
var id = module.id || module.getAttribute("name") || module.getAttribute("is");
this.is = id;
}
}
}
});

Polymer.Base._addFeature({
behaviors: [],
_prepBehaviors: function() {
if (this.behaviors.length) {
this.behaviors = this._flattenBehaviorsList(this.behaviors);
}
this._prepAllBehaviors(this.behaviors);
},
_flattenBehaviorsList: function(behaviors) {
var flat = [];
behaviors.forEach(function(b) {
if (b instanceof Array) {
flat = flat.concat(this._flattenBehaviorsList(b));
} else if (b) {
flat.push(b);
} else {
this._warn(this._logf("_flattenBehaviorsList", "behavior is null, check for missing or 404 import"));
}
}, this);
return flat;
},
_prepAllBehaviors: function(behaviors) {
for (var i = behaviors.length - 1; i >= 0; i--) {
this._mixinBehavior(behaviors[i]);
}
for (var i = 0, l = behaviors.length; i < l; i++) {
this._prepBehavior(behaviors[i]);
}
this._prepBehavior(this);
},
_mixinBehavior: function(b) {
Object.getOwnPropertyNames(b).forEach(function(n) {
switch (n) {
case "hostAttributes":
case "registered":
case "properties":
case "observers":
case "listeners":
case "created":
case "attached":
case "detached":
case "attributeChanged":
case "configure":
case "ready":
break;

default:
if (!this.hasOwnProperty(n)) {
this.copyOwnProperty(n, b, this);
}
break;
}
}, this);
},
_doBehavior: function(name, args) {
this.behaviors.forEach(function(b) {
this._invokeBehavior(b, name, args);
}, this);
this._invokeBehavior(this, name, args);
},
_invokeBehavior: function(b, name, args) {
var fn = b[name];
if (fn) {
fn.apply(this, args || Polymer.nar);
}
},
_marshalBehaviors: function() {
this.behaviors.forEach(function(b) {
this._marshalBehavior(b);
}, this);
this._marshalBehavior(this);
}
});

Polymer.Base._addFeature({
_prepExtends: function() {
if (this.extends) {
this.__proto__ = this._getExtendedPrototype(this.extends);
}
},
_getExtendedPrototype: function(tag) {
return this._getExtendedNativePrototype(tag);
},
_nativePrototypes: {},
_getExtendedNativePrototype: function(tag) {
var p = this._nativePrototypes[tag];
if (!p) {
var np = this.getNativePrototype(tag);
p = this.extend(Object.create(np), Polymer.Base);
this._nativePrototypes[tag] = p;
}
return p;
},
getNativePrototype: function(tag) {
return Object.getPrototypeOf(document.createElement(tag));
}
});

Polymer.Base._addFeature({
_prepConstructor: function() {
this._factoryArgs = this.extends ? [ this.extends, this.is ] : [ this.is ];
var ctor = function() {
return this._factory(arguments);
};
if (this.hasOwnProperty("extends")) {
ctor.extends = this.extends;
}
Object.defineProperty(this, "constructor", {
value: ctor,
writable: true,
configurable: true
});
ctor.prototype = this;
},
_factory: function(args) {
var elt = document.createElement.apply(document, this._factoryArgs);
if (this.factoryImpl) {
this.factoryImpl.apply(elt, args);
}
return elt;
}
});

Polymer.nob = Object.create(null);

Polymer.Base._addFeature({
properties: {},
getPropertyInfo: function(property) {
var info = this._getPropertyInfo(property, this.properties);
if (!info) {
this.behaviors.some(function(b) {
return info = this._getPropertyInfo(property, b.properties);
}, this);
}
return info || Polymer.nob;
},
_getPropertyInfo: function(property, properties) {
var p = properties && properties[property];
if (typeof p === "function") {
p = properties[property] = {
type: p
};
}
if (p) {
p.defined = true;
}
return p;
}
});

Polymer.CaseMap = {
_caseMap: {},
dashToCamelCase: function(dash) {
var mapped = Polymer.CaseMap._caseMap[dash];
if (mapped) {
return mapped;
}
if (dash.indexOf("-") < 0) {
return Polymer.CaseMap._caseMap[dash] = dash;
}
return Polymer.CaseMap._caseMap[dash] = dash.replace(/-([a-z])/g, function(m) {
return m[1].toUpperCase();
});
},
camelToDashCase: function(camel) {
var mapped = Polymer.CaseMap._caseMap[camel];
if (mapped) {
return mapped;
}
return Polymer.CaseMap._caseMap[camel] = camel.replace(/([a-z][A-Z])/g, function(g) {
return g[0] + "-" + g[1].toLowerCase();
});
}
};

Polymer.Base._addFeature({
_prepAttributes: function() {
this._aggregatedAttributes = {};
},
_addHostAttributes: function(attributes) {
if (attributes) {
this.mixin(this._aggregatedAttributes, attributes);
}
},
_marshalHostAttributes: function() {
this._applyAttributes(this, this._aggregatedAttributes);
},
_applyAttributes: function(node, attr$) {
for (var n in attr$) {
if (!this.hasAttribute(n) && n !== "class") {
this.serializeValueToAttribute(attr$[n], n, this);
}
}
},
_marshalAttributes: function() {
this._takeAttributesToModel(this);
},
_takeAttributesToModel: function(model) {
for (var i = 0, l = this.attributes.length; i < l; i++) {
this._setAttributeToProperty(model, this.attributes[i].name);
}
},
_setAttributeToProperty: function(model, attrName) {
if (!this._serializing) {
var propName = Polymer.CaseMap.dashToCamelCase(attrName);
var info = this.getPropertyInfo(propName);
if (info.defined || this._propertyEffects && this._propertyEffects[propName]) {
var val = this.getAttribute(attrName);
model[propName] = this.deserialize(val, info.type);
}
}
},
_serializing: false,
reflectPropertyToAttribute: function(name) {
this._serializing = true;
this.serializeValueToAttribute(this[name], Polymer.CaseMap.camelToDashCase(name));
this._serializing = false;
},
serializeValueToAttribute: function(value, attribute, node) {
var str = this.serialize(value);
(node || this)[str === undefined ? "removeAttribute" : "setAttribute"](attribute, str);
},
deserialize: function(value, type) {
switch (type) {
case Number:
value = Number(value);
break;

case Boolean:
value = value !== null;
break;

case Object:
try {
value = JSON.parse(value);
} catch (x) {}
break;

case Array:
try {
value = JSON.parse(value);
} catch (x) {
value = null;
console.warn("Polymer::Attributes: couldn`t decode Array as JSON");
}
break;

case Date:
value = new Date(value);
break;

case String:
default:
break;
}
return value;
},
serialize: function(value) {
switch (typeof value) {
case "boolean":
return value ? "" : undefined;

case "object":
if (value instanceof Date) {
return value;
} else if (value) {
try {
return JSON.stringify(value);
} catch (x) {
return "";
}
}

default:
return value != null ? value : undefined;
}
}
});

Polymer.Base._addFeature({
_setupDebouncers: function() {
this._debouncers = {};
},
debounce: function(jobName, callback, wait) {
this._debouncers[jobName] = Polymer.Debounce.call(this, this._debouncers[jobName], callback, wait);
},
isDebouncerActive: function(jobName) {
var debouncer = this._debouncers[jobName];
return debouncer && debouncer.finish;
},
flushDebouncer: function(jobName) {
var debouncer = this._debouncers[jobName];
if (debouncer) {
debouncer.complete();
}
},
cancelDebouncer: function(jobName) {
var debouncer = this._debouncers[jobName];
if (debouncer) {
debouncer.stop();
}
}
});

Polymer.version = "1.0.0";

Polymer.Base._addFeature({
_registerFeatures: function() {
this._prepIs();
this._prepAttributes();
this._prepBehaviors();
this._prepExtends();
this._prepConstructor();
},
_prepBehavior: function(b) {
this._addHostAttributes(b.hostAttributes);
},
_marshalBehavior: function(b) {},
_initFeatures: function() {
this._marshalHostAttributes();
this._setupDebouncers();
this._marshalBehaviors();
}
});</script>