Skip to content

armgit / anime

Public Imported from GitHub
0

JavaScript animation engine

Timeline research

Julian Garniere2178c39deb4
diff --git a/anime-timeline.js b/anime-timeline.js
new file mode 100644
index 00000000..2b3dd4b0
--- /dev/null
+++ b/anime-timeline.js
@@ -0,0 +1,825 @@
+/**
+ * http://anime-js.com
+ * JavaScript animation engine
+ * @version v2.0.0
+ * @author Julian Garnier
+ * @copyright © 2017 Julian Garnier
+ * Released under the MIT license
+**/
+
+(function(root, factory) {
+ if (typeof define === 'function' && define.amd) {
+ // AMD. Register as an anonymous module.
+ define([], factory);
+ } else if (typeof module === 'object' && module.exports) {
+ // Node. Does not work with strict CommonJS, but
+ // only CommonJS-like environments that support module.exports,
+ // like Node.
+ module.exports = factory();
+ } else {
+ // Browser globals (root is window)
+ root.anime = factory();
+ }
+}(this, () => {
+
+ // Defaults
+
+ const defaultInstanceSettings = {
+ begin: undefined,
+ update: undefined,
+ complete: undefined,
+ loop: 0,
+ direction: 'normal',
+ autoplay: true,
+ offset: 0
+ }
+
+ const defaultTweenSettings = {
+ duration: 1000,
+ delay: 0,
+ easing: 'easeOutElastic',
+ elasticity: 500,
+ round: 0
+ }
+
+ const validTransforms = ['translateX', 'translateY', 'translateZ', 'rotate', 'rotateX', 'rotateY', 'rotateZ', 'scale', 'scaleX', 'scaleY', 'scaleZ', 'skewX', 'skewY'];
+ let transformString;
+
+ // Utils
+
+ function stringContains(str, text) {
+ return str.indexOf(text) > -1;
+ }
+
+ const is = {
+ arr: a => Array.isArray(a),
+ obj: a => stringContains(Object.prototype.toString.call(a), 'Object'),
+ svg: a => a instanceof SVGElement,
+ dom: a => a.nodeType || is.svg(a),
+ str: a => typeof a === 'string',
+ fnc: a => typeof a === 'function',
+ und: a => typeof a === 'undefined',
+ hex: a => /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(a),
+ rgb: a => /^rgb/.test(a),
+ hsl: a => /^hsl/.test(a),
+ col: a => (is.hex(a) || is.rgb(a) || is.hsl(a))
+ }
+
+ // BezierEasing https://github.com/gre/bezier-easing
+
+ const bezier = (() => {
+
+ const kSplineTableSize = 11;
+ const kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
+
+ function A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1 };
+ function B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1 };
+ function C (aA1) { return 3.0 * aA1 };
+
+ function calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT };
+ function getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1) };
+
+ function binarySubdivide (aX, aA, aB, mX1, mX2) {
+ let currentX, currentT, i = 0;
+ do {
+ currentT = aA + (aB - aA) / 2.0;
+ currentX = calcBezier(currentT, mX1, mX2) - aX;
+ if (currentX > 0.0) { aB = currentT } else { aA = currentT };
+ } while (Math.abs(currentX) > 0.0000001 && ++i < 10);
+ return currentT;
+ }
+
+ function newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {
+ for (let i = 0; i < 4; ++i) {
+ const currentSlope = getSlope(aGuessT, mX1, mX2);
+ if (currentSlope === 0.0) return aGuessT;
+ const currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+ aGuessT -= currentX / currentSlope;
+ }
+ return aGuessT;
+ }
+
+ function bezier(mX1, mY1, mX2, mY2) {
+
+ if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) return;
+ let sampleValues = new Float32Array(kSplineTableSize);
+
+ if (mX1 !== mY1 || mX2 !== mY2) {
+ for (let i = 0; i < kSplineTableSize; ++i) {
+ sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+ }
+ }
+
+ function getTForX(aX) {
+
+ let intervalStart = 0.0;
+ let currentSample = 1;
+ const lastSample = kSplineTableSize - 1;
+
+ for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
+ intervalStart += kSampleStepSize;
+ }
+
+ --currentSample;
+
+ const dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+ const guessForT = intervalStart + dist * kSampleStepSize;
+ const initialSlope = getSlope(guessForT, mX1, mX2);
+
+ if (initialSlope >= 0.001) {
+ return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+ } else if (initialSlope === 0.0) {
+ return guessForT;
+ } else {
+ return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+ }
+
+ }
+
+ return (x) => {
+ if (mX1 === mY1 && mX2 === mY2) return x;
+ if (x === 0) return 0;
+ if (x === 1) return 1;
+ return calcBezier(getTForX(x), mY1, mY2);
+ }
+
+ }
+
+ return bezier;
+
+ })();
+
+ const easings = (() => {
+
+ const names = ['Quad', 'Cubic', 'Quart', 'Quint', 'Sine', 'Expo', 'Circ', 'Back', 'Elastic'];
+
+ // Elastic easing adapted from jQueryUI http://api.jqueryui.com/easings/
+
+ function elastic(t, p) {
+ return t === 0 || t === 1 ? t :
+ -Math.pow(2, 10 * (t - 1)) * Math.sin((((t - 1) - (p / (Math.PI * 2.0) * Math.asin(1))) * (Math.PI * 2)) / p );
+ }
+
+ // Approximated Penner equations http://matthewlein.com/ceaser/
+
+ const equations = {
+ In: [
+ [0.550, 0.085, 0.680, 0.530], /* InQuad */
+ [0.550, 0.055, 0.675, 0.190], /* InCubic */
+ [0.895, 0.030, 0.685, 0.220], /* InQuart */
+ [0.755, 0.050, 0.855, 0.060], /* InQuint */
+ [0.470, 0.000, 0.745, 0.715], /* InSine */
+ [0.950, 0.050, 0.795, 0.035], /* InExpo */
+ [0.600, 0.040, 0.980, 0.335], /* InCirc */
+ [0.600, -0.280, 0.735, 0.045], /* InBack */
+ elastic /* InElastic */
+ ], Out: [
+ [0.250, 0.460, 0.450, 0.940], /* OutQuad */
+ [0.215, 0.610, 0.355, 1.000], /* OutCubic */
+ [0.165, 0.840, 0.440, 1.000], /* OutQuart */
+ [0.230, 1.000, 0.320, 1.000], /* OutQuint */
+ [0.390, 0.575, 0.565, 1.000], /* OutSine */
+ [0.190, 1.000, 0.220, 1.000], /* OutExpo */
+ [0.075, 0.820, 0.165, 1.000], /* OutCirc */
+ [0.175, 0.885, 0.320, 1.275], /* OutBack */
+ (t, f) => 1 - elastic(1 - t, f) /* OutElastic */
+ ], InOut: [
+ [0.455, 0.030, 0.515, 0.955], /* InOutQuad */
+ [0.645, 0.045, 0.355, 1.000], /* InOutCubic */
+ [0.770, 0.000, 0.175, 1.000], /* InOutQuart */
+ [0.860, 0.000, 0.070, 1.000], /* InOutQuint */
+ [0.445, 0.050, 0.550, 0.950], /* InOutSine */
+ [1.000, 0.000, 0.000, 1.000], /* InOutExpo */
+ [0.785, 0.135, 0.150, 0.860], /* InOutCirc */
+ [0.680, -0.550, 0.265, 1.550], /* InOutBack */
+ (t, f) => t < .5 ? elastic(t * 2, f) / 2 : 1 - elastic(t * -2 + 2, f) / 2 /* InOutElastic */
+ ]
+ }
+
+ let functions = {
+ linear: bezier(0.250, 0.250, 0.750, 0.750)
+ }
+
+ for (let type in equations) {
+ equations[type].forEach((f, i) => {
+ functions['ease'+type+names[i]] = is.fnc(f) ? f : bezier.apply(this, f);
+ });
+ }
+
+ return functions;
+
+ })();
+
+ // Strings
+
+ function stringToHyphens(str) {
+ return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+ }
+
+ function selectString(str) {
+ if (is.col(str)) return;
+ try {
+ let nodes = document.querySelectorAll(str);
+ return nodes;
+ } catch(e) {
+ return;
+ }
+ }
+
+ // Arrays
+
+ function arrayLength(arr) {
+ return arr.length;
+ }
+
+ function flattenArray(arr) {
+ return arr.reduce((a, b) => a.concat(is.arr(b) ? flattenArray(b) : b), []);
+ }
+
+ function toArray(o) {
+ if (is.arr(o)) return o;
+ if (is.str(o)) o = selectString(o) || o;
+ if (o instanceof NodeList || o instanceof HTMLCollection) return [].slice.call(o);
+ return [o];
+ }
+
+ function arrayContains(arr, val) {
+ return arr.some((a) => a === val);
+ }
+
+ // Objects
+
+ function objectHas(obj, prop) {
+ return obj.hasOwnProperty(prop);
+ }
+
+ function cloneObject(o) {
+ let clone = {};
+ for (let p in o) clone[p] = o[p];
+ return clone;
+ }
+
+ function replaceObjectProps(o1, o2) {
+ let o = cloneObject(o1);
+ for (let p in o1) o[p] = objectHas(o2, p) ? o2[p] : o1[p];
+ return o;
+ }
+
+ function mergeObjects(o1, o2) {
+ let o = cloneObject(o1);
+ for (let p in o2) o[p] = is.und(o1[p]) ? o2[p] : o1[p];
+ return o;
+ }
+
+ // Colors
+
+ function hexToRgb(hexValue) {
+ const rgx = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+ const hex = hexValue.replace(rgx, (m, r, g, b) => r + r + g + g + b + b );
+ const rgb = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+ const r = parseInt(rgb[1], 16);
+ const g = parseInt(rgb[2], 16);
+ const b = parseInt(rgb[3], 16);
+ return `rgb(${r},${g},${b})`;
+ }
+
+ function hslToRgb(hslValue) {
+ const hsl = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.exec(hslValue);
+ const h = parseInt(hsl[1]) / 360;
+ const s = parseInt(hsl[2]) / 100;
+ const l = parseInt(hsl[3]) / 100;
+ function hue2rgb(p, q, t) {
+ if (t < 0) t += 1;
+ if (t > 1) t -= 1;
+ if (t < 1/6) return p + (q - p) * 6 * t;
+ if (t < 1/2) return q;
+ if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
+ return p;
+ }
+ let r, g, b;
+ if (s == 0) {
+ r = g = b = l;
+ } else {
+ const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+ const p = 2 * l - q;
+ r = hue2rgb(p, q, h + 1/3);
+ g = hue2rgb(p, q, h);
+ b = hue2rgb(p, q, h - 1/3);
+ }
+ return `rgb(${r * 255},${g * 255},${b * 255})`;
+ }
+
+ function colorToRgb(val) {
+ if (is.rgb(val)) return val;
+ if (is.hex(val)) return hexToRgb(val);
+ if (is.hsl(val)) return hslToRgb(val);
+ }
+
+ // Units
+
+ function getUnit(val) {
+ const split = /([\+\-]?[0-9#\.]+)(%|px|pt|em|rem|in|cm|mm|ex|pc|vw|vh|deg|rad|turn)?/.exec(val);
+ if (split) return split[2];
+ }
+
+ function getTransformUnit(propName) {
+ if (stringContains(propName, 'translate')) return 'px';
+ if (stringContains(propName, 'rotate') || stringContains(propName, 'skew')) return 'deg';
+ }
+
+ // Values
+
+ function parseFloatValue(val) {
+ return parseFloat(val);
+ }
+
+ function getCSSValue(el, prop) {
+ if (prop in el.style) {
+ return getComputedStyle(el).getPropertyValue(stringToHyphens(prop)) || '0';
+ }
+ }
+
+ function getAnimationType(el, prop) {
+ if (is.dom(el) && arrayContains(validTransforms, prop)) return 'transform';
+ if (is.dom(el) && (el.getAttribute(prop) || (is.svg(el) && el[prop]))) return 'attribute';
+ if (is.dom(el) && (prop !== 'transform' && getCSSValue(el, prop))) return 'css';
+ if (el[prop] != null) return 'object';
+ }
+
+ function getTransformValue(el, propName) {
+ const defaultUnit = getTransformUnit(propName);
+ const defaultVal = stringContains(propName, 'scale') ? 1 : 0 + defaultUnit;
+ const str = el.style.transform;
+ if (!str) return defaultVal;
+ let match = [];
+ let props = [];
+ let values = [];
+ const rgx = /(\w+)\((.+?)\)/g;
+ while (match = rgx.exec(str)) {
+ props.push(match[1]);
+ values.push(match[2]);
+ }
+ const value = values.filter((val, i) => props[i] === propName );
+ return arrayLength(value) ? value[0] : defaultVal;
+ }
+
+ function getOriginalTargetValue(target, propName) {
+ switch (getAnimationType(target, propName)) {
+ case 'transform': return getTransformValue(target, propName);
+ case 'css': return getCSSValue(target, propName);
+ case 'attribute': return target.getAttribute(propName);
+ }
+ return target[propName] || 0;
+ }
+
+ function checkValueOperator(value) {
+ const matches = /^(\*=|\+=|-=)/.exec(value);
+ if (matches) return matches[0];
+ }
+
+ function getRelativeValue(to, from) {
+ const operator = checkValueOperator(to);
+ if (!operator) return to;
+ const x = parseFloatValue(from);
+ const y = parseFloatValue(to.replace(operator, ''));
+ switch (operator[0]) {
+ case '+': return x + y;
+ case '-': return x - y;
+ case '*': return x * y;
+ }
+ }
+
+ function validateValue(val, unit) {
+ if (is.col(val)) return colorToRgb(val);
+ const originalUnit = getUnit(val);
+ const unitLess = originalUnit ? val.substr(0, arrayLength(val) - arrayLength(originalUnit)) : val;
+ return unit ? unitLess + unit : unitLess;
+ }
+
+ // Motion path
+
+ function isPath(val) {
+ return is.obj(val) && objectHas(val, 'totalLength');
+ }
+
+ function setDashoffset(el) {
+ const pathLength = el.getTotalLength();
+ el.setAttribute('stroke-dasharray', pathLength);
+ return pathLength;
+ }
+
+ function getPath(path, percent) {
+ const el = is.str(path) ? selectString(path)[0] : path;
+ const p = percent || 100;
+ return function(prop) {
+ return {
+ el: el,
+ property: prop,
+ totalLength: el.getTotalLength() * (p / 100)
+ }
+ }
+ }
+
+ function getPathProgress(path, progress) {
+ function point(offset = 0) {
+ const l = progress + offset >= 1 ? progress + offset : 0;
+ return path.el.getPointAtLength(l);
+ }
+ const p = point();
+ const p0 = point(-1);
+ const p1 = point(+1);
+ switch (path.property) {
+ case 'x': return p.x;
+ case 'y': return p.y;
+ case 'angle': return Math.atan2(p1.y - p0.y, p1.x - p0.x) * 180 / Math.PI;
+ }
+ }
+
+ // Decompose / recompose functions adapted from Animate Plus https://github.com/bendc/animateplus
+
+ function decomposeValue(val, unit) {
+ const rgx = /-?\d*\.?\d+/g;
+ const value = validateValue((isPath(val) ? val.totalLength : val), unit) + '';
+ return {
+ original: value,
+ numbers: value.match(rgx) ? value.match(rgx).map(Number) : [0],
+ strings: value.split(rgx)
+ }
+ }
+
+ function recomposeValue(numbers, strings) {
+ return strings.reduce((a, b, i) => a + numbers[i - 1] + b);
+ }
+
+ // Animatables
+
+ function parseTargets(targets) {
+ const targetsArray = targets ? (flattenArray(is.arr(targets) ? targets.map(toArray) : toArray(targets))) : [];
+ return targetsArray.filter((item, pos, self) => self.indexOf(item) === pos);
+ }
+
+ function getAnimatables(targets) {
+ const parsed = parseTargets(targets);
+ return parsed.map((t, i) => {
+ return {target: t, id: i, total: arrayLength(parsed)};
+ });
+ }
+
+ // Properties
+
+ function normalizePropertyTweens(prop, tweenSettings) {
+ let settings = cloneObject(tweenSettings);
+ if (is.arr(prop)) {
+ const l = arrayLength(prop);
+ const isFromTo = (l === 2 && !is.obj(prop[0]));
+ if (!isFromTo) {
+ // Duration divided by the number of tweens
+ if (!is.fnc(tweenSettings.duration)) settings.duration = tweenSettings.duration / l;
+ } else {
+ // Transform [from, to] values shorthand to a valid tween value
+ prop = {value: prop};
+ }
+ }
+ return toArray(prop).map((v, i) => {
+ // Default delay value should be applied only on the first tween
+ const delay = !i ? tweenSettings.delay : 0;
+ // Use path object as a tween value
+ let obj = is.obj(v) && !isPath(v) ? v : {value: v};
+ // Set default delay value
+ if (is.und(obj.delay)) obj.delay = delay;
+ return obj;
+ }).map(k => mergeObjects(k, settings));
+ }
+
+ function getProperties(instanceSettings, tweenSettings, params) {
+ let properties = [];
+ const settings = mergeObjects(instanceSettings, tweenSettings);
+ for (let p in params) {
+ if (!objectHas(settings, p) && p !== 'targets') {
+ properties.push({
+ name: p,
+ offset: settings.offset,
+ tweens: normalizePropertyTweens(params[p], tweenSettings)
+ });
+ }
+ }
+ return properties;
+ }
+
+ // Tweens
+
+ function getFunctionValue(val, animatable) {
+ if (!is.fnc(val)) return val;
+ return val(animatable.target, animatable.id, animatable.total);
+ }
+
+ function normalizeTweenValues(tween, animatable) {
+ let t = {};
+ for (let p in tween) {
+ let value = getFunctionValue(tween[p], animatable);
+ if (is.arr(value)) {
+ value = value.map(v => getFunctionValue(v, animatable));
+ if (arrayLength(value) === 1) value = value[0];
+ }
+ t[p] = value;
+ }
+ t.duration = parseFloatValue(t.duration);
+ t.delay = parseFloatValue(t.delay);
+ return t;
+ }
+
+ function normalizeEasing(val) {
+ return is.arr(val) ? bezier.apply(this, val) : easings[val];
+ }
+
+ function normalizeTweens(prop, animatable) {
+ let previousTween;
+ return prop.tweens.map(function(t, i) {
+ let tween = normalizeTweenValues(t, animatable);
+ const tweenValue = tween.value;
+ const originalValue = getOriginalTargetValue(animatable.target, prop.name);
+ const previousValue = previousTween ? previousTween.to.original : originalValue;
+ const from = is.arr(tweenValue) ? tweenValue[0] : previousValue;
+ const to = getRelativeValue(is.arr(tweenValue) ? tweenValue[1] : tweenValue, from);
+ const unit = getUnit(to) || getUnit(from) || getUnit(originalValue);
+ if (!i) tween.delay += prop.offset;
+ tween.from = decomposeValue(from, unit);
+ tween.to = decomposeValue(to, unit);
+ tween.start = previousTween ? previousTween.end + tween.delay : tween.delay;
+ tween.end = tween.start + tween.duration;
+ tween.easing = normalizeEasing(tween.easing);
+ tween.elasticity = (1000 - Math.min(Math.max(tween.elasticity, 1), 999)) / 1000;
+ if (is.col(tween.from.original)) tween.round = 1;
+ previousTween = tween;
+ return tween;
+ });
+ }
+
+ // Tween progress
+
+ function getTweenProgress(tween, time) {
+ const elapsed = Math.min(Math.max(time - tween.start, 0), tween.duration);
+ const path = isPath(tween.value);
+ let progress = (elapsed / tween.duration);
+ const round = tween.round;
+ return recomposeValue(tween.to.numbers.map((number, p) => {
+ const eased = tween.easing(progress, tween.elasticity);
+ const start = path ? 0 : tween.from.numbers[p];
+ let value = start + eased * (number - start);
+ if (path) value = getPathProgress(tween.value, value);
+ if (round) value = Math.round(value * round) / round;
+ return value;
+ }), tween.to.strings);
+ }
+
+ // Animations
+
+ function createAnimation(animatable, prop) {
+ const animType = getAnimationType(animatable.target, prop.name);
+ if (animType) {
+ const tweens = normalizeTweens(prop, animatable);
+ return {
+ type: animType,
+ property: prop.name,
+ animatable: animatable,
+ tweens: tweens,
+ duration: tweens.reduce((a, b) => a + b.delay + b.duration, 0),
+ delay: tweens[0].delay
+ }
+ }
+ }
+
+ function getAnimations(animatables, properties) {
+ return flattenArray(animatables.map(animatable => {
+ return properties.map(prop => {
+ return createAnimation(animatable, prop);
+ });
+ })).filter(a => !is.und(a));
+ }
+
+ const setAnimationProgress = {
+ css: (t, p, v) => t.style[p] = v,
+ attribute: (t, p, v) => t.setAttribute(p, v),
+ object: (t, p, v) => t[p] = v,
+ transform: (t, p, v, transforms, id) => {
+ if (!transforms[id]) transforms[id] = [];
+ transforms[id].push(`${p}(${v})`);
+ }
+ }
+
+ // Instance
+
+ function toggleInstanceDirection(instance) {
+ instance.reversed = !instance.reversed;
+ }
+
+ function adjustInstanceTime(instance, time) {
+ return instance.reversed ? instance.duration - time : time;
+ }
+
+ function syncInstanceChildren(instance, instanceTime) {
+ const children = instance.children;
+ for (let i = 0; i < arrayLength(children); i++) children[i].seek(instanceTime);
+ }
+
+ function setInstanceProgress(instance, time) {
+ let transforms = {};
+ const animations = instance.animations;
+ const currentTime = adjustInstanceTime(instance, time);
+ if (currentTime >= instance.delay) {
+ instance.currentTime = currentTime;
+ instance.progress = (currentTime / instance.duration) * 100;
+ for (let i = 0; i < arrayLength(animations); i++) {
+ const anim = animations[i];
+ const tweens = anim.tweens;
+ const tween = tweens.filter(tween => (tween.start - tween.delay <= currentTime && tween.end >= currentTime))[0];
+ const activeTween = tween || tweens[arrayLength(tweens) - 1];
+ const progress = getTweenProgress(activeTween, currentTime);
+ const animatable = anim.animatable;
+ const setProgress = setAnimationProgress[anim.type];
+ setProgress(animatable.target, anim.property, progress, transforms, animatable.id);
+ anim.currentValue = progress;
+ }
+ if (transforms) {
+ let id; for (id in transforms) {
+ if (!transformString) {
+ const t = 'transform';
+ transformString = (getCSSValue(document.body, t) ? t : `-webkit-${t}`);
+ }
+ instance.animatables[id].target.style[transformString] = transforms[id].join(' ');
+ }
+ }
+ if (instance.update) instance.update(instance);
+ if (instance.children) syncInstanceChildren(instance, currentTime);
+ }
+ }
+
+ function getInstanceTimings(type, animations, tweenSettings) {
+ const math = (type === 'delay') ? Math.min : Math.max;
+ return arrayLength(animations) ? math.apply(Math, animations.map((anim) => anim[type])) : tweenSettings[type];
+ }
+
+ function createNewInstance(params = {}) {
+ const instanceSettings = replaceObjectProps(defaultInstanceSettings, params);
+ const tweenSettings = replaceObjectProps(defaultTweenSettings, params);
+ const animatables = getAnimatables(params.targets);
+ const properties = getProperties(instanceSettings, tweenSettings, params);
+ const animations = getAnimations(animatables, properties);
+ return mergeObjects(instanceSettings, {
+ animatables: animatables,
+ animations: animations,
+ duration: getInstanceTimings('duration', animations, tweenSettings),
+ delay: getInstanceTimings('delay', animations, tweenSettings),
+ currentTime: 0,
+ progress: 0,
+ paused: true,
+ began: false,
+ completed: false,
+ remaining: instanceSettings.loop
+ });
+ }
+
+ // Core
+
+ let activeInstances = [];
+ let raf = 0;
+
+ const engine = (() => {
+ function play() { raf = requestAnimationFrame(step); };
+ function step(t) {
+ if (arrayLength(activeInstances)) {
+ for (let i = 0; i < arrayLength(activeInstances); i++) activeInstances[i].tick(t);
+ play();
+ } else {
+ cancelAnimationFrame(raf);
+ raf = 0;
+ }
+ }
+ return play;
+ })();
+
+ // Public
+
+ function anime(params) {
+
+ let startTime, lastTime = 0;
+ let instance = createNewInstance(params);
+
+ instance.tick = function(now) {
+ if (!startTime) startTime = now;
+ const instanceTime = (lastTime + now - startTime) * anime.speed;
+ // const instanceTime = Math.min(Math.max(currentTime, 0), instance.duration);
+ // console.log(Math.max(currentTime, 0), instanceTime, instance.duration);
+ setInstanceProgress(instance, instanceTime);
+ if (!instance.began && instanceTime >= instance.delay) {
+ instance.began = true;
+ if (instance.begin) instance.begin(instance);
+ }
+ if (instanceTime >= instance.duration) {
+ if (instance.remaining && !isNaN(parseFloat(instance.remaining))) instance.remaining--;
+ if (instance.remaining) {
+ startTime = now;
+ if (instance.direction === 'alternate') toggleInstanceDirection(instance);
+ } else {
+ // setInstanceProgress(instance, instance.duration);
+ instance.completed = true;
+ instance.began = false;
+ instance.pause();
+ if (instance.complete) instance.complete(instance);
+ }
+ lastTime = 0;
+ }
+ }
+
+ instance.seek = function(time) {
+ const now = adjustInstanceTime(instance, time);
+ setInstanceProgress(instance, now);
+ }
+
+ instance.pause = function() {
+ const i = activeInstances.indexOf(instance);
+ if (i > -1) activeInstances.splice(i, 1);
+ instance.paused = true;
+ }
+
+ instance.play = function() {
+ if (!instance.paused) return;
+ instance.paused = false;
+ startTime = 0;
+ lastTime = instance.completed ? 0 : adjustInstanceTime(instance, instance.currentTime);
+ if (instance.direction === 'reverse' && !instance.reversed) toggleInstanceDirection(instance);
+ if (instance.direction === 'alternate') {
+ if (instance.reversed && !instance.remaining % 2) toggleInstanceDirection(instance);
+ if (!instance.remaining) instance.remaining = 2;
+ }
+ activeInstances.push(instance);
+ if (!raf) engine();
+ }
+
+ instance.restart = function() {
+ instance.pause();
+ if (instance.reversed) toggleInstanceDirection(instance);
+ instance.completed = false;
+ instance.began = false;
+ instance.remaining = instance.loop;
+ instance.seek(0);
+ instance.play();
+ }
+
+ if (instance.autoplay) instance.restart();
+
+ return instance;
+
+ }
+
+ // Remove targets from animation
+
+ function removeTargets(targets) {
+ const targetsArray = parseTargets(targets);
+ for (let i = arrayLength(activeInstances)-1; i >= 0; i--) {
+ const instance = activeInstances[i];
+ const animations = instance.animations;
+ for (let a = arrayLength(animations)-1; a >= 0; a--) {
+ if (arrayContains(targetsArray, animations[a].animatable.target)) {
+ animations.splice(a, 1);
+ if (!arrayLength(animations)) instance.pause();
+ }
+ }
+ }
+ }
+
+ // Timeline
+
+ function timeline(params = {}) {
+ let group = anime(params);
+ group.duration = 0;
+ group.children = [];
+ group.add = (instancesParam) => {
+ toArray(instancesParam).forEach(insParam => {
+ const offset = insParam.offset;
+ const groupDuration = group.duration;
+ insParam.offset = is.und(offset) ? groupDuration : getRelativeValue(offset, groupDuration);
+ const ins = anime(insParam);
+ if (ins.duration > groupDuration) group.duration = ins.duration;
+ ins.pause();
+ group.children.push(ins);
+ });
+ }
+ return group;
+ }
+
+ anime.version = '2.0.0';
+ anime.speed = 1;
+ anime.running = activeInstances;
+ anime.remove = removeTargets;
+ anime.getValue = getOriginalTargetValue;
+ anime.path = getPath;
+ anime.setDashoffset = setDashoffset;
+ anime.bezier = bezier;
+ anime.easings = easings;
+ anime.timeline = timeline;
+ anime.random = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
+
+ return anime;
+
+}));