polymer-paper-rails 0.2.0 → 0.2.5

data/app/assets/components/web-animations-next/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "web-animations-js",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/web-animations/web-animations-js.git"
+  },
+  "devDependencies": {
+    "mocha": "1.21.4",
+    "chai": "^1.9.1",
+    "grunt": "~0.4.5",
+    "grunt-contrib-uglify": "^0.4.0",
+    "grunt-gjslint": "^0.1.4",
+    "grunt-karma": "^0.8.2",
+    "karma": "^0.12.14",
+    "karma-mocha": "^0.1.3",
+    "karma-chai": "^0.1.0",
+    "karma-chrome-launcher": "~0.1.4",
+    "karma-firefox-launcher": "~0.1.3",
+    "karma-ie-launcher": "~0.1.5",
+    "karma-safari-launcher": "~0.1.1",
+    "karma-sauce-launcher": "~0.2.3",
+    "grunt-checkrepo": "~0.1.0",
+    "grunt-saucelabs": "~4.0.2",
+    "grunt-checkrepo": "~0.1.0",
+    "grunt-git-status": "~1.0.0",
+    "grunt-template": "~0.2.3",
+    "source-map": "~0.1.40"
+  },
+  "scripts": {
+    "test": "grunt test gjslint git-status checkrepo"
+  }
+}

data/app/assets/components/web-animations-next/src/animation-constructor.js

@@ -0,0 +1,139 @@
+// Copyright 2014 Google Inc. All rights reserved.
+//
+// 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(shared, scope, testing) {
+
+  function groupChildDuration(node) {
+    return node._timing.delay + node.activeDuration + node._timing.endDelay;
+  };
+
+  function KeyframeEffect(effect) {
+    this._frames = shared.normalizeKeyframes(effect);
+  }
+
+  KeyframeEffect.prototype = {
+    getFrames: function() { return this._frames; }
+  };
+
+  scope.Animation = function(target, effect, timingInput) {
+    this.target = target;
+
+    // TODO: Store a clone, not the same instance.
+    this._timingInput = timingInput;
+    this._timing = shared.normalizeTimingInput(timingInput);
+
+    // TODO: Make modifications to timing update the underlying player
+    this.timing = shared.makeTiming(timingInput);
+    // TODO: Make this a live object - will need to separate normalization of
+    // keyframes into a shared module.
+    if (typeof effect == 'function')
+      this.effect = effect;
+    else
+      this.effect = new KeyframeEffect(effect);
+    this._effect = effect;
+    this.activeDuration = shared.calculateActiveDuration(this._timing);
+    return this;
+  };
+
+  var originalElementAnimate = Element.prototype.animate;
+  Element.prototype.animate = function(effect, timing) {
+    return scope.timeline.play(new scope.Animation(this, effect, timing));
+  };
+
+  var nullTarget = document.createElement('div');
+  scope.newUnderlyingPlayerForAnimation = function(animation) {
+    var target = animation.target || nullTarget;
+    var effect = animation._effect;
+    if (typeof effect == 'function') {
+      effect = [];
+    }
+    return originalElementAnimate.apply(target, [effect, animation._timingInput]);
+  };
+
+  scope.bindPlayerForAnimation = function(player) {
+    if (player.source && typeof player.source.effect == 'function') {
+      scope.bindPlayerForCustomEffect(player);
+    }
+  };
+
+  var pendingGroups = [];
+  scope.awaitStartTime = function(groupPlayer) {
+    if (groupPlayer.startTime !== null || !groupPlayer._isGroup)
+      return;
+    if (pendingGroups.length == 0) {
+      requestAnimationFrame(updatePendingGroups);
+    }
+    pendingGroups.push(groupPlayer);
+  };
+  function updatePendingGroups() {
+    var updated = false;
+    while (pendingGroups.length) {
+      pendingGroups.shift()._updateChildren();
+      updated = true;
+    }
+    return updated;
+  }
+  var originalGetComputedStyle = window.getComputedStyle;
+  Object.defineProperty(window, 'getComputedStyle', {
+    configurable: true,
+    enumerable: true,
+    value: function() {
+      var result = originalGetComputedStyle.apply(this, arguments);
+      if (updatePendingGroups())
+        result = originalGetComputedStyle.apply(this, arguments);
+      return result;
+    },
+  });
+
+  // TODO: Call into this less frequently.
+  scope.Player.prototype._updateChildren = function() {
+    if (this.startTime === null || !this.source || !this._isGroup)
+      return;
+    var offset = this.source._timing.delay;
+    for (var i = 0; i < this.source.children.length; i++) {
+      var child = this.source.children[i];
+      var childPlayer;
+
+      if (i >= this._childPlayers.length) {
+        childPlayer = window.document.timeline.play(child);
+        child.player = this.source.player;
+        this._childPlayers.push(childPlayer);
+      } else {
+        childPlayer = this._childPlayers[i];
+      }
+
+      if (childPlayer.startTime != this.startTime + offset) {
+        childPlayer.startTime = this.startTime + offset;
+        childPlayer._updateChildren();
+      }
+
+      if (this.playbackRate == -1 && this.currentTime < offset && childPlayer.currentTime !== -1) {
+        childPlayer.currentTime = -1;
+      }
+
+      if (this.source instanceof window.AnimationSequence)
+        offset += groupChildDuration(child);
+    }
+  };
+
+  window.Animation = scope.Animation;
+  window.Element.prototype.getAnimationPlayers = function() {
+    return document.timeline.getAnimationPlayers().filter(function(player) {
+      return player.source !== null && player.source.target == this;
+    }.bind(this));
+  };
+
+  scope.groupChildDuration = groupChildDuration;
+
+}(webAnimationsShared, webAnimationsMaxifill, webAnimationsTesting));

data/app/assets/components/web-animations-next/src/animation-node.js

@@ -0,0 +1,31 @@
+// Copyright 2014 Google Inc. All rights reserved.
+//
+// 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(shared, scope) {
+
+  scope.AnimationNode = function(timing) {
+    var timeFraction = 0;
+    var activeDuration = shared.calculateActiveDuration(timing);
+    var animationNode = function(localTime) {
+      return shared.calculateTimeFraction(activeDuration, localTime, timing);
+    };
+    animationNode._totalDuration = timing.delay + activeDuration + timing.endDelay;
+    animationNode._isCurrent = function(localTime) {
+      var phase = shared.calculatePhase(activeDuration, localTime, timing);
+      return phase === PhaseActive || phase === PhaseBefore;
+    };
+    return animationNode;
+  };
+
+})(webAnimationsShared, webAnimationsMinifill);

data/app/assets/components/web-animations-next/src/animation.js

@@ -0,0 +1,65 @@
+// Copyright 2014 Google Inc. All rights reserved.
+//
+// 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(shared, scope, testing) {
+
+  scope.Animation = function(target, effectInput, timingInput) {
+    var animationNode = scope.AnimationNode(shared.normalizeTimingInput(timingInput));
+    var effect = scope.convertEffectInput(effectInput);
+    var timeFraction;
+    var animation = function() {
+      WEB_ANIMATIONS_TESTING && console.assert(typeof timeFraction !== 'undefined');
+      effect(target, timeFraction);
+    };
+    // Returns whether the animation is in effect or not after the timing update.
+    animation._update = function(localTime) {
+      timeFraction = animationNode(localTime);
+      return timeFraction !== null;
+    };
+    animation._clear = function() {
+      effect(target, null);
+    };
+    animation._hasSameTarget = function(otherTarget) {
+      return target === otherTarget;
+    };
+    animation._isCurrent = animationNode._isCurrent;
+    animation._totalDuration = animationNode._totalDuration;
+    return animation;
+  };
+
+  scope.NullAnimation = function(clear) {
+    var nullAnimation = function() {
+      if (clear) {
+        clear();
+        clear = null;
+      }
+    };
+    nullAnimation._update = function() {
+      return null;
+    };
+    nullAnimation._totalDuration = 0;
+    nullAnimation._isCurrent = function() {
+      return false;
+    };
+    nullAnimation._hasSameTarget = function() {
+      return false;
+    };
+    return nullAnimation;
+  };
+
+  if (WEB_ANIMATIONS_TESTING) {
+    testing.minifillAnimation = scope.Animation;
+  }
+
+})(webAnimationsShared, webAnimationsMinifill, webAnimationsTesting);

data/app/assets/components/web-animations-next/src/apply-preserving-inline-style.js

@@ -0,0 +1,192 @@
+// Copyright 2014 Google Inc. All rights reserved.
+//
+// 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(scope, testing) {
+
+  var styleAttributes = {
+    cssText: 1,
+    length: 1,
+    parentRule: 1,
+  };
+
+  var styleMethods = {
+    getPropertyCSSValue: 1,
+    getPropertyPriority: 1,
+    getPropertyValue: 1,
+    item: 1,
+    removeProperty: 1,
+    setProperty: 1,
+  };
+
+  var styleMutatingMethods = {
+    removeProperty: 1,
+    setProperty: 1,
+  };
+
+  function configureProperty(object, property, descriptor) {
+    descriptor.enumerable = true;
+    descriptor.configurable = true;
+    Object.defineProperty(object, property, descriptor);
+  }
+
+  function AnimatedCSSStyleDeclaration(element) {
+    WEB_ANIMATIONS_TESTING && console.assert(!(element.style instanceof AnimatedCSSStyleDeclaration),
+        'Element must not already have an animated style attached.');
+
+    // Stores the inline style of the element on its behalf while the
+    // polyfill uses the element's inline style to simulate web animations.
+    // This is needed to fake regular inline style CSSOM access on the element.
+    this._surrogateElement = document.createElement('div');
+    this._surrogateStyle = this._surrogateElement.style;
+    this._style = element.style;
+    this._length = 0;
+    this._isAnimatedProperty = {};
+
+    // Copy the inline style contents over to the surrogate.
+    for (var i = 0; i < this._style.length; i++) {
+      var property = this._style[i];
+      this._surrogateStyle[property] = this._style[property];
+    }
+    this._updateIndices();
+  }
+
+  AnimatedCSSStyleDeclaration.prototype = {
+    get cssText() {
+      return this._surrogateStyle.cssText;
+    },
+    set cssText(text) {
+      var isAffectedProperty = {};
+      for (var i = 0; i < this._surrogateStyle.length; i++) {
+        isAffectedProperty[this._surrogateStyle[i]] = true;
+      }
+      this._surrogateStyle.cssText = text;
+      this._updateIndices();
+      for (var i = 0; i < this._surrogateStyle.length; i++) {
+        isAffectedProperty[this._surrogateStyle[i]] = true;
+      }
+      for (var property in isAffectedProperty) {
+        if (!this._isAnimatedProperty[property]) {
+          this._style.setProperty(property, this._surrogateStyle.getPropertyValue(property));
+        }
+      }
+    },
+    get length() {
+      return this._surrogateStyle.length;
+    },
+    get parentRule() {
+      return this._style.parentRule;
+    },
+    // Mirror the indexed getters and setters of the surrogate style.
+    _updateIndices: function() {
+      while (this._length < this._surrogateStyle.length) {
+        Object.defineProperty(this, this._length, {
+          configurable: true,
+          enumerable: false,
+          get: (function(index) {
+            return function() { return this._surrogateStyle[index]; };
+          })(this._length)
+        });
+        this._length++;
+      }
+      while (this._length > this._surrogateStyle.length) {
+        this._length--;
+        Object.defineProperty(this, this._length, {
+          configurable: true,
+          enumerable: false,
+          value: undefined
+        });
+      }
+    },
+    _set: function(property, value) {
+      this._style[property] = value;
+      this._isAnimatedProperty[property] = true;
+    },
+    _clear: function(property) {
+      this._style[property] = this._surrogateStyle[property];
+      delete this._isAnimatedProperty[property];
+    },
+  };
+
+  // Wrap the style methods.
+  for (var method in styleMethods) {
+    AnimatedCSSStyleDeclaration.prototype[method] = (function(method, modifiesStyle) {
+      return function() {
+        var result = this._surrogateStyle[method].apply(this._surrogateStyle, arguments);
+        if (modifiesStyle) {
+          if (!this._isAnimatedProperty[arguments[0]])
+            this._style[method].apply(this._style, arguments);
+          this._updateIndices();
+        }
+        return result;
+      }
+    })(method, method in styleMutatingMethods);
+  }
+
+  // Wrap the style.cssProperty getters and setters.
+  for (var property in document.documentElement.style) {
+    if (property in styleAttributes || property in styleMethods) {
+      continue;
+    }
+    (function(property) {
+      configureProperty(AnimatedCSSStyleDeclaration.prototype, property, {
+        get: function() {
+          return this._surrogateStyle[property];
+        },
+        set: function(value) {
+          this._surrogateStyle[property] = value;
+          this._updateIndices();
+          if (!this._isAnimatedProperty[property])
+            this._style[property] = value;
+        }
+      });
+    })(property);
+  }
+
+  function ensureStyleIsPatched(element) {
+    if (element._webAnimationsPatchedStyle)
+      return;
+
+    var animatedStyle = new AnimatedCSSStyleDeclaration(element);
+    try {
+      configureProperty(element, 'style', { get: function() { return animatedStyle; } });
+    } catch (_) {
+      // iOS and older versions of Safari (pre v7) do not support overriding an element's
+      // style object. Animations will clobber any inline styles as a result.
+      element.style._set = function(property, value) {
+        element.style[property] = value;
+      };
+      element.style._clear = function(property) {
+        element.style[property] = '';
+      };
+    }
+
+    // We must keep a handle on the patched style to prevent it from getting GC'd.
+    element._webAnimationsPatchedStyle = element.style;
+  }
+
+  scope.apply = function(element, property, value) {
+    ensureStyleIsPatched(element);
+    element.style._set(scope.propertyName(property), value);
+  };
+
+  scope.clear = function(element, property) {
+    if (element._webAnimationsPatchedStyle) {
+      element.style._clear(scope.propertyName(property));
+    }
+  };
+
+  if (WEB_ANIMATIONS_TESTING)
+    testing.ensureStyleIsPatched = ensureStyleIsPatched;
+
+})(webAnimationsMinifill, webAnimationsTesting);