polymer-paper-rails 0.2.0 → 0.2.5

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

@@ -0,0 +1,193 @@
+// 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 sequenceNumber = 0;
+
+  var AnimationPlayerEvent = function(target, currentTime, timelineTime) {
+    this.target = target;
+    this.currentTime = currentTime;
+    this.timelineTime = timelineTime;
+
+    this.type = 'finish';
+    this.bubbles = false;
+    this.cancelable = false;
+    this.currentTarget = target;
+    this.defaultPrevented = false;
+    this.eventPhase = Event.AT_TARGET;
+    this.timeStamp = Date.now();
+  };
+
+  scope.Player = function(source) {
+    this._sequenceNumber = sequenceNumber++;
+    this._currentTime = 0;
+    this._startTime = null;
+    this.paused = false;
+    this._playbackRate = 1;
+    this._inTimeline = true;
+    this._finishedFlag = false;
+    this.onfinish = null;
+    this._finishHandlers = [];
+    this._source = source;
+    this._inEffect = this._source._update(0);
+    this._idle = true;
+    this._currentTimePending = false;
+  };
+
+  scope.Player.prototype = {
+    _ensureAlive: function() {
+      this._inEffect = this._source._update(this.currentTime);
+      if (!this._inTimeline && (this._inEffect || !this._finishedFlag)) {
+        this._inTimeline = true;
+        scope.timeline._players.push(this);
+      }
+    },
+    _tickCurrentTime: function(newTime, ignoreLimit) {
+      if (newTime != this._currentTime) {
+        this._currentTime = newTime;
+        if (this.finished && !ignoreLimit)
+          this._currentTime = this._playbackRate > 0 ? this._totalDuration : 0;
+        this._ensureAlive();
+      }
+    },
+    get currentTime() {
+      if (this._idle || this._currentTimePending)
+        return null;
+      return this._currentTime;
+    },
+    set currentTime(newTime) {
+      newTime = +newTime;
+      if (isNaN(newTime))
+        return;
+      scope.restart();
+      if (!this.paused && this._startTime != null) {
+        this._startTime = this._timeline.currentTime - newTime / this._playbackRate;
+      }
+      this._currentTimePending = false;
+      if (this._currentTime == newTime)
+        return;
+      this._tickCurrentTime(newTime, true);
+      scope.invalidateEffects();
+    },
+    get startTime() {
+      return this._startTime;
+    },
+    set startTime(newTime) {
+      newTime = +newTime;
+      if (isNaN(newTime))
+        return;
+      if (this.paused || this._idle)
+        return;
+      this._startTime = newTime;
+      this._tickCurrentTime((this._timeline.currentTime - this._startTime) * this.playbackRate);
+      scope.invalidateEffects();
+    },
+    get playbackRate() { return this._playbackRate; },
+    get finished() {
+      return !this._idle && (this._playbackRate > 0 && this._currentTime >= this._totalDuration ||
+          this._playbackRate < 0 && this._currentTime <= 0);
+    },
+    get _totalDuration() { return this._source._totalDuration; },
+    get playState() {
+      if (this._idle)
+        return 'idle';
+      if ((this._startTime == null && !this.paused && this.playbackRate != 0) || this._currentTimePending)
+        return 'pending';
+      if (this.paused)
+        return 'paused';
+      if (this.finished)
+        return 'finished';
+      return 'running';
+    },
+    play: function() {
+      this.paused = false;
+      if (this.finished || this._idle) {
+        this._currentTime = this._playbackRate > 0 ? 0 : this._totalDuration;
+        this._startTime = null;
+        scope.invalidateEffects();
+      }
+      this._finishedFlag = false;
+      scope.restart();
+      this._idle = false;
+      this._ensureAlive();
+    },
+    pause: function() {
+      if (!this.finished && !this.paused && !this._idle) {
+        this._currentTimePending = true;
+      }
+      this._startTime = null;
+      this.paused = true;
+    },
+    finish: function() {
+      if (this._idle)
+        return;
+      this.currentTime = this._playbackRate > 0 ? this._totalDuration : 0;
+      this._startTime = this._totalDuration - this.currentTime;
+      this._currentTimePending = false;
+    },
+    cancel: function() {
+      this._inEffect = false;
+      this._idle = true;
+      this.currentTime = 0;
+      this._startTime = null;
+    },
+    reverse: function() {
+      this._playbackRate *= -1;
+      this._startTime = null;
+      this.play();
+    },
+    addEventListener: function(type, handler) {
+      if (typeof handler == 'function' && type == 'finish')
+        this._finishHandlers.push(handler);
+    },
+    removeEventListener: function(type, handler) {
+      if (type != 'finish')
+        return;
+      var index = this._finishHandlers.indexOf(handler);
+      if (index >= 0)
+        this._finishHandlers.splice(index, 1);
+    },
+    _fireEvents: function(baseTime) {
+      var finished = this.finished;
+      if ((finished || this._idle) && !this._finishedFlag) {
+        var event = new AnimationPlayerEvent(this, this._currentTime, baseTime);
+        var handlers = this._finishHandlers.concat(this.onfinish ? [this.onfinish] : []);
+        setTimeout(function() {
+          handlers.forEach(function(handler) {
+            handler.call(event.target, event);
+          });
+        }, 0);
+      }
+      this._finishedFlag = finished;
+    },
+    _tick: function(timelineTime) {
+      if (!this._idle && !this.paused) {
+        if (this._startTime == null)
+          this.startTime = timelineTime - this._currentTime / this.playbackRate;
+        else if (!this.finished)
+          this._tickCurrentTime((timelineTime - this._startTime) * this.playbackRate);
+      }
+
+      this._currentTimePending = false;
+      this._fireEvents(timelineTime);
+      return !this._idle && (this._inEffect || !this._finishedFlag);
+    },
+  };
+
+  if (WEB_ANIMATIONS_TESTING) {
+    testing.Player = scope.Player;
+  }
+
+})(webAnimationsMinifill, webAnimationsTesting);

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

@@ -0,0 +1,117 @@
+// 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) {
+
+  function negateDimension(dimension) {
+    var result = {};
+    for (var k in dimension) {
+      result[k] = -dimension[k];
+    }
+    return result;
+  }
+
+  function consumeOffset(string) {
+    return scope.consumeToken(/^(left|center|right|top|bottom)\b/i, string) || scope.consumeLengthOrPercent(string);
+  }
+
+  var offsetMap = {
+    left: {'%': 0},
+    center: {'%': 50},
+    right: {'%': 100},
+    top: {'%': 0},
+    bottom: {'%': 100},
+  };
+
+  function parseOrigin(slots, string) {
+    var result = scope.consumeRepeated(consumeOffset, /^/, string);
+    if (!result || result[1] != '') return;
+    var tokens = result[0];
+    tokens[0] = tokens[0] || 'center';
+    tokens[1] = tokens[1] || 'center';
+    if (slots == 3) {
+      tokens[2] = tokens[2] || {px: 0};
+    }
+    if (tokens.length != slots) {
+      return;
+    }
+    // Reorder so that the horizontal axis comes first.
+    if (/top|bottom/.test(tokens[0]) || /left|right/.test(tokens[1])) {
+      var tmp = tokens[0];
+      tokens[0] = tokens[1];
+      tokens[1] = tmp;
+    }
+    // Invalid if not horizontal then vertical.
+    if (!/left|right|center|Object/.test(tokens[0]))
+      return;
+    if (!/top|bottom|center|Object/.test(tokens[1]))
+      return;
+    return tokens.map(function(position) {
+      return typeof position == 'object' ? position : offsetMap[position];
+    });
+  }
+
+  var mergeOffsetList = scope.mergeNestedRepeated.bind(null, scope.mergeDimensions, ' ');
+  scope.addPropertiesHandler(parseOrigin.bind(null, 3), mergeOffsetList, ['transform-origin']);
+  scope.addPropertiesHandler(parseOrigin.bind(null, 2), mergeOffsetList, ['perspective-origin']);
+
+  function consumePosition(string) {
+    var result = scope.consumeRepeated(consumeOffset, /^/, string);
+    if (!result) {
+      return;
+    }
+
+    var tokens = result[0];
+    var out = [{'%': 50}, {'%': 50}];
+    var pos = 0;
+    var bottomOrRight = false;
+
+    for (var i = 0; i < tokens.length; i++) {
+      var token = tokens[i];
+      if (typeof token == 'string') {
+        bottomOrRight = /bottom|right/.test(token);
+        pos = {left: 0, right: 0, center: pos, top: 1, bottom: 1}[token];
+        out[pos] = offsetMap[token];
+        if (token == 'center') {
+          // Center doesn't accept a length offset.
+          pos++;
+        }
+      } else {
+        if (bottomOrRight) {
+          // If bottom or right we need to subtract the length from 100%
+          token = negateDimension(token);
+          token['%'] = (token['%'] || 0) + 100;
+        }
+        out[pos] = token;
+        pos++;
+        bottomOrRight = false;
+      }
+    }
+    return [out, result[1]];
+  }
+
+  function parsePositionList(string) {
+    var result = scope.consumeRepeated(consumePosition, /^,/, string);
+    if (result && result[1] == '') {
+      return result[0];
+    }
+  }
+
+  scope.consumePosition = consumePosition;
+  scope.mergeOffsetList = mergeOffsetList;
+
+  var mergePositionList = scope.mergeNestedRepeated.bind(null, mergeOffsetList, ', ');
+  scope.addPropertiesHandler(parsePositionList, mergePositionList, ['background-position', 'object-position']);
+
+})(webAnimationsMinifill);

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

@@ -0,0 +1,62 @@
+// 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 propertyHandlers = {};
+
+  function addPropertyHandler(parser, merger, property) {
+    propertyHandlers[property] = propertyHandlers[property] || [];
+    propertyHandlers[property].push([parser, merger]);
+  }
+  function addPropertiesHandler(parser, merger, properties) {
+    for (var i = 0; i < properties.length; i++) {
+      var property = properties[i];
+      WEB_ANIMATIONS_TESTING && console.assert(property.toLowerCase() === property);
+      addPropertyHandler(parser, merger, property);
+      if (/-/.test(property)) {
+        // Add camel cased variant.
+        addPropertyHandler(parser, merger, property.replace(/-(.)/g, function(_, c) {
+          return c.toUpperCase();
+        }));
+      }
+    }
+  }
+  scope.addPropertiesHandler = addPropertiesHandler;
+
+  function propertyInterpolation(property, left, right) {
+    var handlers = left == right ? [] : propertyHandlers[property];
+    for (var i = 0; handlers && i < handlers.length; i++) {
+      var parsedLeft = handlers[i][0](left);
+      var parsedRight = handlers[i][0](right);
+      if (parsedLeft !== undefined && parsedRight !== undefined) {
+        var interpolationArgs = handlers[i][1](parsedLeft, parsedRight);
+        if (interpolationArgs) {
+          var interp = scope.Interpolation.apply(null, interpolationArgs);
+          return function(t) {
+            if (t == 0) return left;
+            if (t == 1) return right;
+            return interp(t);
+          };
+        }
+      }
+    }
+    return scope.Interpolation(false, true, function(bool) {
+      return bool ? right : left;
+    });
+  }
+  scope.propertyInterpolation = propertyInterpolation;
+
+})(webAnimationsMinifill, webAnimationsTesting);
+

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

@@ -0,0 +1,35 @@
+// 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 aliased = {};
+
+  function alias(name, aliases) {
+    aliases.concat([name]).forEach(function(candidate) {
+      if (candidate in document.documentElement.style) {
+        aliased[name] = candidate;
+      }
+    });
+  }
+  alias('transform', ['webkitTransform', 'msTransform']);
+  alias('transformOrigin', ['webkitTransformOrigin']);
+  alias('perspective', ['webkitPerspective']);
+  alias('perspectiveOrigin', ['webkitPerspectiveOrigin']);
+
+  scope.propertyName = function(property) {
+    return aliased[property] || property;
+  };
+
+})(webAnimationsMinifill, webAnimationsTesting);

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

@@ -0,0 +1,20 @@
+// 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.
+
+var webAnimationsShared = {};
+var webAnimationsMinifill = {};
+var webAnimationsMaxifill = {};
+
+if (!WEB_ANIMATIONS_TESTING)
+  var webAnimationsTesting = null;

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

@@ -0,0 +1,108 @@
+// 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) {
+
+  function consumeShadow(string) {
+    var shadow = {
+      inset: false,
+      lengths: [],
+      color: null,
+    };
+    function consumePart(string) {
+      var result = scope.consumeToken(/^inset/i, string);
+      if (result) {
+        shadow.inset = true;
+        return result;
+      }
+      var result = scope.consumeLengthOrPercent(string);
+      if (result) {
+        shadow.lengths.push(result[0]);
+        return result;
+      }
+      var result = scope.consumeColor(string);
+      if (result) {
+        shadow.color = result[0];
+        return result;
+      }
+    }
+    var result = scope.consumeRepeated(consumePart, /^/, string);
+    if (result && result[0].length) {
+      return [shadow, result[1]];
+    }
+  }
+
+  function parseShadowList(string) {
+    var result = scope.consumeRepeated(consumeShadow, /^,/, string);
+    if (result && result[1] == '') {
+      return result[0];
+    }
+  }
+
+  function mergeShadow(left, right) {
+    while (left.lengths.length < Math.max(left.lengths.length, right.lengths.length))
+      left.lengths.push({px: 0});
+    while (right.lengths.length < Math.max(left.lengths.length, right.lengths.length))
+      right.lengths.push({px: 0});
+
+    if (left.inset != right.inset || !!left.color != !!right.color) {
+      return;
+    }
+    var lengthReconstitution = [];
+    var colorReconstitution;
+    var matchingLeft = [[], 0];
+    var matchingRight = [[], 0];
+    for (var i = 0; i < left.lengths.length; i++) {
+      var mergedDimensions = scope.mergeDimensions(left.lengths[i], right.lengths[i], i == 2);
+      matchingLeft[0].push(mergedDimensions[0]);
+      matchingRight[0].push(mergedDimensions[1]);
+      lengthReconstitution.push(mergedDimensions[2]);
+    }
+    if (left.color && right.color) {
+      var mergedColor = scope.mergeColors(left.color, right.color);
+      matchingLeft[1] = mergedColor[0];
+      matchingRight[1] = mergedColor[1];
+      colorReconstitution = mergedColor[2];
+    }
+    return [matchingLeft, matchingRight, function(value) {
+      var result = left.inset ? 'inset ' : ' ';
+      for (var i = 0; i < lengthReconstitution.length; i++) {
+        result += lengthReconstitution[i](value[0][i]) + ' ';
+      }
+      if (colorReconstitution) {
+        result += colorReconstitution(value[1]);
+      }
+      return result;
+    }];
+  }
+
+  function mergeNestedRepeatedShadow(nestedMerge, separator, left, right) {
+    var leftCopy = [];
+    var rightCopy = [];
+    function defaultShadow(inset) {
+      return {inset: inset, color: [0, 0, 0, 0], lengths: [{px: 0}, {px: 0}, {px: 0}, {px: 0}]};
+    }
+    for (var i = 0; i < left.length || i < right.length; i++) {
+      var l = left[i] || defaultShadow(right[i].inset);
+      var r = right[i] || defaultShadow(left[i].inset);
+      leftCopy.push(l);
+      rightCopy.push(r);
+    }
+    return scope.mergeNestedRepeated(nestedMerge, separator, leftCopy, rightCopy);
+  }
+
+  var mergeShadowList = mergeNestedRepeatedShadow.bind(null, mergeShadow, ', ');
+  scope.addPropertiesHandler(parseShadowList, mergeShadowList, ['box-shadow', 'text-shadow']);
+
+})(webAnimationsMinifill);