polymer-paper-rails 0.2.0 → 0.2.5

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

@@ -0,0 +1,85 @@
+// 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) {
+
+  var consumeLengthOrPercent = scope.consumeParenthesised.bind(null, scope.parseLengthOrPercent);
+  var consumeLengthOrPercentPair = scope.consumeRepeated.bind(undefined, consumeLengthOrPercent, /^/);
+
+  var mergeSizePair = scope.mergeNestedRepeated.bind(undefined, scope.mergeDimensions, ' ');
+  var mergeSizePairList = scope.mergeNestedRepeated.bind(undefined, mergeSizePair, ',');
+
+  function parseShape(input) {
+    var circle = scope.consumeToken(/^circle/, input);
+    if (circle && circle[0]) {
+      return ['circle'].concat(scope.consumeList([
+        scope.ignore(scope.consumeToken.bind(undefined, /^\(/)),
+        consumeLengthOrPercent,
+        scope.ignore(scope.consumeToken.bind(undefined, /^at/)),
+        scope.consumePosition,
+        scope.ignore(scope.consumeToken.bind(undefined, /^\)/))
+      ], circle[1]));
+    }
+    var ellipse = scope.consumeToken(/^ellipse/, input);
+    if (ellipse && ellipse[0]) {
+      return ['ellipse'].concat(scope.consumeList([
+        scope.ignore(scope.consumeToken.bind(undefined, /^\(/)),
+        consumeLengthOrPercentPair,
+        scope.ignore(scope.consumeToken.bind(undefined, /^at/)),
+        scope.consumePosition,
+        scope.ignore(scope.consumeToken.bind(undefined, /^\)/))
+      ], ellipse[1]));
+    }
+    var polygon = scope.consumeToken(/^polygon/, input);
+    if (polygon && polygon[0]) {
+      return ['polygon'].concat(scope.consumeList([
+        scope.ignore(scope.consumeToken.bind(undefined, /^\(/)),
+        scope.optional(scope.consumeToken.bind(undefined, /^nonzero\s*,|^evenodd\s*,/), 'nonzero,'),
+        scope.consumeSizePairList,
+        scope.ignore(scope.consumeToken.bind(undefined, /^\)/))
+      ], polygon[1]));
+    }
+  }
+
+  function mergeShapes(left, right) {
+    if (left[0] !== right[0])
+      return;
+    if (left[0] == 'circle') {
+      return scope.mergeList(left.slice(1), right.slice(1), [
+        'circle(',
+        scope.mergeDimensions,
+        ' at ',
+        scope.mergeOffsetList,
+        ')']);
+    }
+    if (left[0] == 'ellipse') {
+      return scope.mergeList(left.slice(1), right.slice(1), [
+        'ellipse(',
+        scope.mergeNonNegativeSizePair,
+        ' at ',
+        scope.mergeOffsetList,
+        ')']);
+    }
+    if (left[0] == 'polygon' && left[1] == right[1]) {
+      return scope.mergeList(left.slice(2), right.slice(2), [
+        'polygon(',
+        left[1],
+        mergeSizePairList,
+        ')']);
+    }
+  }
+
+  scope.addPropertiesHandler(parseShape, mergeShapes, ['shape-outside']);
+
+})(webAnimationsMinifill);

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

@@ -0,0 +1,148 @@
+// 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) {
+  var originalRequestAnimationFrame = window.requestAnimationFrame;
+  var rafCallbacks = [];
+  var rafId = 0;
+  window.requestAnimationFrame = function(f) {
+    var id = rafId++;
+    if (rafCallbacks.length == 0 && !WEB_ANIMATIONS_TESTING) {
+      originalRequestAnimationFrame(processRafCallbacks);
+    }
+    rafCallbacks.push([id, f]);
+    return id;
+  };
+
+  window.cancelAnimationFrame = function(id) {
+    rafCallbacks.forEach(function(entry) {
+      if (entry[0] == id) {
+        entry[1] = function() {};
+      }
+    });
+  };
+
+  function processRafCallbacks(t) {
+    var processing = rafCallbacks;
+    rafCallbacks = [];
+    tick(t);
+    processing.forEach(function(entry) { entry[1](t); });
+    if (needsRetick)
+      tick(t);
+    applyPendingEffects();
+  }
+
+  function comparePlayers(leftPlayer, rightPlayer) {
+    return leftPlayer._sequenceNumber - rightPlayer._sequenceNumber;
+  }
+
+  function InternalTimeline() {
+    this._players = [];
+    // Android 4.3 browser has window.performance, but not window.performance.now
+    this.currentTime = window.performance && performance.now ? performance.now() : 0;
+  };
+
+  InternalTimeline.prototype = {
+    _play: function(source) {
+      source._timing = shared.normalizeTimingInput(source.timing);
+      var player = new scope.Player(source);
+      player._idle = false;
+      player._timeline = this;
+      this._players.push(player);
+      scope.restart();
+      scope.invalidateEffects();
+      return player;
+    }
+  };
+
+  var ticking = false;
+  var hasRestartedThisFrame = false;
+
+  scope.restart = function() {
+    if (!ticking) {
+      ticking = true;
+      requestAnimationFrame(function() {});
+      hasRestartedThisFrame = true;
+    }
+    return hasRestartedThisFrame;
+  };
+
+  var needsRetick = false;
+  scope.invalidateEffects = function() {
+    needsRetick = true;
+  };
+
+  var pendingEffects = [];
+  function applyPendingEffects() {
+    pendingEffects.forEach(function(f) { f(); });
+  }
+
+  var originalGetComputedStyle = window.getComputedStyle;
+  Object.defineProperty(window, 'getComputedStyle', {
+    configurable: true,
+    enumerable: true,
+    value: function() {
+      if (needsRetick) tick(timeline.currentTime);
+      applyPendingEffects();
+      return originalGetComputedStyle.apply(this, arguments);
+    },
+  });
+
+  function tick(t) {
+    hasRestartedThisFrame = false;
+    var timeline = scope.timeline;
+    timeline.currentTime = t;
+    timeline._players.sort(comparePlayers);
+    ticking = false;
+    var updatingPlayers = timeline._players;
+    timeline._players = [];
+
+    var newPendingClears = [];
+    var newPendingEffects = [];
+    updatingPlayers = updatingPlayers.filter(function(player) {
+      player._inTimeline = player._tick(t);
+
+      if (!player._inEffect)
+        newPendingClears.push(player._source);
+      else
+        newPendingEffects.push(player._source);
+
+      if (!player.finished && !player.paused && !player._idle)
+        ticking = true;
+
+      return player._inTimeline;
+    });
+
+    pendingEffects.length = 0;
+    pendingEffects.push.apply(pendingEffects, newPendingClears);
+    pendingEffects.push.apply(pendingEffects, newPendingEffects);
+
+    timeline._players.push.apply(timeline._players, updatingPlayers);
+    needsRetick = false;
+
+    if (ticking)
+      requestAnimationFrame(function() {});
+  };
+
+  if (WEB_ANIMATIONS_TESTING) {
+    testing.tick = processRafCallbacks;
+    testing.isTicking = function() { return ticking; };
+    testing.setTicking = function(newVal) { ticking = newVal; };
+  }
+
+  var timeline = new InternalTimeline();
+  scope.timeline = timeline;
+
+})(webAnimationsShared, webAnimationsMinifill, webAnimationsTesting);

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

@@ -0,0 +1,77 @@
+// 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.AnimationTimeline = function() {
+    this._players = [];
+    this.currentTime = undefined;
+  };
+
+  scope.AnimationTimeline.prototype = {
+    // FIXME: This needs to return the wrapped players in maxifill
+    // TODO: Does this need to be sorted?
+    // TODO: Do we need to consider needsRetick?
+    getAnimationPlayers: function() {
+      this._discardPlayers();
+      return this._players.slice();
+    },
+    _discardPlayers: function() {
+      this._players = this._players.filter(function(player) {
+        return player.playState != 'finished' && player.playState != 'idle';
+      });
+    },
+    play: function(source) {
+      var player = new scope.Player(source);
+      this._players.push(player);
+      scope.restartMaxifillTick();
+      player.play();
+      return player;
+    },
+  };
+
+  var ticking = false;
+
+  scope.restartMaxifillTick = function() {
+    if (!ticking) {
+      ticking = true;
+      requestAnimationFrame(maxifillTick);
+    }
+  };
+
+  function maxifillTick(t) {
+    var timeline = window.document.timeline;
+    timeline.currentTime = t;
+    timeline._discardPlayers();
+    if (timeline._players.length == 0)
+      ticking = false;
+    else
+      requestAnimationFrame(maxifillTick);
+  }
+
+  var timeline = new scope.AnimationTimeline();
+  scope.timeline = timeline;
+
+  try {
+    Object.defineProperty(window.document, 'timeline', {
+      configurable: true,
+      get: function() { return timeline; }
+    });
+  } catch (e) { }
+  try {
+    window.document.timeline = timeline;
+  } catch (e) { }
+
+})(webAnimationsShared, webAnimationsMaxifill, webAnimationsTesting);

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

@@ -0,0 +1,242 @@
+// 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, testing) {
+
+  var fills = 'backwards|forwards|both'.split('|');
+  var directions = 'reverse|alternate|alternate-reverse'.split('|');
+
+  function makeTiming(timingInput, forGroup) {
+    var timing = {
+      delay: 0,
+      endDelay: 0,
+      fill: forGroup ? 'both' : 'none',
+      iterationStart: 0,
+      iterations: 1,
+      duration: forGroup ? 'auto' : 0,
+      playbackRate: 1,
+      direction: 'normal',
+      easing: 'linear',
+    };
+    if (typeof timingInput == 'number' && !isNaN(timingInput)) {
+      timing.duration = timingInput;
+    } else if (timingInput !== undefined) {
+      Object.getOwnPropertyNames(timingInput).forEach(function(property) {
+        if (timingInput[property] != 'auto') {
+          if (typeof timing[property] == 'number' || property == 'duration') {
+            if (typeof timingInput[property] != 'number' || isNaN(timingInput[property])) {
+              return;
+            }
+          }
+          if ((property == 'fill') && (fills.indexOf(timingInput[property]) == -1)) {
+            return;
+          }
+          if ((property == 'direction') && (directions.indexOf(timingInput[property]) == -1)) {
+            return;
+          }
+          if (property == 'playbackRate' && shared.isDeprecated('AnimationTiming.playbackRate', '2014-11-28', 'Use AnimationPlayer.playbackRate instead.')) {
+            return;
+          }
+          timing[property] = timingInput[property];
+        }
+      });
+    }
+    return timing;
+  }
+
+  function normalizeTimingInput(timingInput, forGroup) {
+    var timing = makeTiming(timingInput, forGroup);
+    timing.easing = toTimingFunction(timing.easing);
+    return timing;
+  }
+
+  function cubic(a, b, c, d) {
+    if (a < 0 || a > 1 || c < 0 || c > 1) {
+      return linear;
+    }
+    return function(x) {
+      var start = 0, end = 1;
+      while (1) {
+        var mid = (start + end) / 2;
+        function f(a, b, m) { return 3 * a * (1 - m) * (1 - m) * m + 3 * b * (1 - m) * m * m + m * m * m};
+        var xEst = f(a, c, mid);
+        if (Math.abs(x - xEst) < 0.001) {
+          return f(b, d, mid);
+        }
+        if (xEst < x) {
+          start = mid;
+        } else {
+          end = mid;
+        }
+      }
+    }
+  }
+
+  var Start = 1;
+  var Middle = 0.5;
+  var End = 0;
+
+  function step(count, pos) {
+    return function(x) {
+      if (x >= 1) {
+        return 1;
+      }
+      var stepSize = 1 / count;
+      x += pos * stepSize;
+      return x - x % stepSize;
+    }
+  }
+
+  var presets = {
+    'ease': cubic(0.25, 0.1, 0.25, 1),
+    'ease-in': cubic(0.42, 0, 1, 1),
+    'ease-out': cubic(0, 0, 0.58, 1),
+    'ease-in-out': cubic(0.42, 0, 0.58, 1),
+    'step-start': step(1, Start),
+    'step-middle': step(1, Middle),
+    'step-end': step(1, End)
+  };
+
+  var numberString = '\\s*(-?\\d+\\.?\\d*|-?\\.\\d+)\\s*';
+  var cubicBezierRe = new RegExp('cubic-bezier\\(' + numberString + ',' + numberString + ',' + numberString + ',' + numberString + '\\)');
+  var stepRe = /steps\(\s*(\d+)\s*,\s*(start|middle|end)\s*\)/;
+  var linear = function(x) { return x; };
+
+  function toTimingFunction(easing) {
+    var cubicData = cubicBezierRe.exec(easing);
+    if (cubicData) {
+      return cubic.apply(this, cubicData.slice(1).map(Number));
+    }
+    var stepData = stepRe.exec(easing);
+    if (stepData) {
+      return step(Number(stepData[1]), {'start': Start, 'middle': Middle, 'end': End}[stepData[2]]);
+    }
+    var preset = presets[easing];
+    if (preset) {
+      return preset;
+    }
+    return linear;
+  };
+
+  function calculateActiveDuration(timing) {
+    return Math.abs(repeatedDuration(timing) / timing.playbackRate);
+  }
+
+  function repeatedDuration(timing) {
+    return timing.duration * timing.iterations;
+  }
+
+  var PhaseNone = 0;
+  var PhaseBefore = 1;
+  var PhaseAfter = 2;
+  var PhaseActive = 3;
+
+  function calculatePhase(activeDuration, localTime, timing) {
+    if (localTime == null) {
+      return PhaseNone;
+    }
+    if (localTime < timing.delay) {
+      return PhaseBefore;
+    }
+    if (localTime >= timing.delay + activeDuration) {
+      return PhaseAfter;
+    }
+    return PhaseActive;
+  }
+
+  function calculateActiveTime(activeDuration, fillMode, localTime, phase, delay) {
+    switch (phase) {
+      case PhaseBefore:
+        if (fillMode == 'backwards' || fillMode == 'both')
+          return 0;
+        return null;
+      case PhaseActive:
+        return localTime - delay;
+      case PhaseAfter:
+        if (fillMode == 'forwards' || fillMode == 'both')
+          return activeDuration;
+        return null;
+      case PhaseNone:
+        return null;
+    }
+  }
+
+  function calculateScaledActiveTime(activeDuration, activeTime, startOffset, timing) {
+    return (timing.playbackRate < 0 ? activeTime - activeDuration : activeTime) * timing.playbackRate + startOffset;
+  }
+
+  function calculateIterationTime(iterationDuration, repeatedDuration, scaledActiveTime, startOffset, timing) {
+    if (scaledActiveTime === Infinity || scaledActiveTime === -Infinity || (scaledActiveTime - startOffset == repeatedDuration && timing.iterations && ((timing.iterations + timing.iterationStart) % 1 == 0))) {
+      return iterationDuration;
+    }
+
+    return scaledActiveTime % iterationDuration;
+  }
+
+  function calculateCurrentIteration(iterationDuration, iterationTime, scaledActiveTime, timing) {
+    if (scaledActiveTime === 0) {
+      return 0;
+    }
+    if (iterationTime == iterationDuration) {
+      return timing.iterationStart + timing.iterations - 1;
+    }
+    return Math.floor(scaledActiveTime / iterationDuration);
+  }
+
+  function calculateTransformedTime(currentIteration, iterationDuration, iterationTime, timing) {
+    var currentIterationIsOdd = currentIteration % 2 >= 1;
+    var currentDirectionIsForwards = timing.direction == 'normal' || timing.direction == (currentIterationIsOdd ? 'alternate-reverse' : 'alternate');
+    var directedTime = currentDirectionIsForwards ? iterationTime : iterationDuration - iterationTime;
+    var timeFraction = directedTime / iterationDuration;
+    return iterationDuration * timing.easing(timeFraction);
+  }
+
+  function calculateTimeFraction(activeDuration, localTime, timing) {
+    var phase = calculatePhase(activeDuration, localTime, timing);
+    var activeTime = calculateActiveTime(activeDuration, timing.fill, localTime, phase, timing.delay);
+    if (activeTime === null)
+      return null;
+    if (activeDuration === 0)
+      return phase === PhaseBefore ? 0 : 1;
+    var startOffset = timing.iterationStart * timing.duration;
+    var scaledActiveTime = calculateScaledActiveTime(activeDuration, activeTime, startOffset, timing);
+    var iterationTime = calculateIterationTime(timing.duration, repeatedDuration(timing), scaledActiveTime, startOffset, timing);
+    var currentIteration = calculateCurrentIteration(timing.duration, iterationTime, scaledActiveTime, timing);
+    return calculateTransformedTime(currentIteration, timing.duration, iterationTime, timing) / timing.duration;
+  }
+
+  shared.makeTiming = makeTiming;
+  shared.normalizeTimingInput = normalizeTimingInput;
+  shared.calculateActiveDuration = calculateActiveDuration;
+  shared.calculateTimeFraction = calculateTimeFraction;
+  shared.calculatePhase = calculatePhase;
+  shared.toTimingFunction = toTimingFunction;
+
+  if (WEB_ANIMATIONS_TESTING) {
+    testing.normalizeTimingInput = normalizeTimingInput;
+    testing.toTimingFunction = toTimingFunction;
+    testing.calculateActiveDuration = calculateActiveDuration;
+    testing.calculatePhase = calculatePhase;
+    testing.PhaseNone = PhaseNone;
+    testing.PhaseBefore = PhaseBefore;
+    testing.PhaseActive = PhaseActive;
+    testing.PhaseAfter = PhaseAfter;
+    testing.calculateActiveTime = calculateActiveTime;
+    testing.calculateScaledActiveTime = calculateScaledActiveTime;
+    testing.calculateIterationTime = calculateIterationTime;
+    testing.calculateCurrentIteration = calculateCurrentIteration;
+    testing.calculateTransformedTime = calculateTransformedTime;
+  }
+
+})(webAnimationsShared, webAnimationsTesting);