animejs 4.1.2 → 4.2.0-beta.0

package/dist/modules/utils/target.js

@@ -0,0 +1,125 @@
+/**
+ * Anime.js - utils - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+import { globals } from '../core/globals.js';
+import { valueTypes, minValue, compositionTypes } from '../core/consts.js';
+import { isUnd, round } from '../core/helpers.js';
+import { registerTargets, parseTargets } from '../core/targets.js';
+import { sanitizePropertyName } from '../core/styles.js';
+export { cleanInlineStyles } from '../core/styles.js';
+import { getTweenType, getOriginalAnimatableValue, decomposeRawValue, decomposedOriginalValue, setValue } from '../core/values.js';
+import { convertValueUnit } from '../core/units.js';
+import { removeWAAPIAnimation } from '../waapi/composition.js';
+import { removeTargetsFromRenderable } from '../animation/composition.js';
+import { JSAnimation } from '../animation/animation.js';
+
+/**
+ * @import {
+ *   Renderable,
+ *   DOMTargetSelector,
+ *   JSTargetsParam,
+ *   DOMTargetsParam,
+ *   TargetsParam,
+ *   DOMTarget,
+ *   AnimationParams,
+ *   TargetsArray,
+ * } from '../types/index.js'
+*/
+
+/**
+ * @import {
+ *   WAAPIAnimation
+ * } from '../waapi/waapi.js'
+*/
+
+/**
+ * @overload
+ * @param  {DOMTargetSelector} targetSelector
+ * @param  {String} propName
+ * @return {String}
+ *
+ * @overload
+ * @param  {JSTargetsParam} targetSelector
+ * @param  {String} propName
+ * @return {Number|String}
+ *
+ * @overload
+ * @param  {DOMTargetsParam} targetSelector
+ * @param  {String} propName
+ * @param  {String} unit
+ * @return {String}
+ *
+ * @overload
+ * @param  {TargetsParam} targetSelector
+ * @param  {String} propName
+ * @param  {Boolean} unit
+ * @return {Number}
+ *
+ * @param  {TargetsParam} targetSelector
+ * @param  {String} propName
+ * @param  {String|Boolean} [unit]
+ */
+function get(targetSelector, propName, unit) {
+  const targets = registerTargets(targetSelector);
+  if (!targets.length) return;
+  const [ target ] = targets;
+  const tweenType = getTweenType(target, propName);
+  const normalizePropName = sanitizePropertyName(propName, target, tweenType);
+  let originalValue = getOriginalAnimatableValue(target, normalizePropName);
+  if (isUnd(unit)) {
+    return originalValue;
+  } else {
+    decomposeRawValue(originalValue, decomposedOriginalValue);
+    if (decomposedOriginalValue.t === valueTypes.NUMBER || decomposedOriginalValue.t === valueTypes.UNIT) {
+      if (unit === false) {
+        return decomposedOriginalValue.n;
+      } else {
+        const convertedValue = convertValueUnit(/** @type {DOMTarget} */(target), decomposedOriginalValue, /** @type {String} */(unit), false);
+        return `${round(convertedValue.n, globals.precision)}${convertedValue.u}`;
+      }
+    }
+  }
+}
+
+/**
+ * @param  {TargetsParam} targets
+ * @param  {AnimationParams} parameters
+ * @return {JSAnimation}
+ */
+const set = (targets, parameters) => {
+  if (isUnd(parameters)) return;
+  parameters.duration = minValue;
+  // Do not overrides currently active tweens by default
+  parameters.composition = setValue(parameters.composition, compositionTypes.none);
+  // Skip init() and force rendering by playing the animation
+  return new JSAnimation(targets, parameters, null, 0, true).resume();
+};
+
+/**
+ * @param  {TargetsParam} targets
+ * @param  {Renderable|WAAPIAnimation} [renderable]
+ * @param  {String} [propertyName]
+ * @return {TargetsArray}
+ */
+const remove = (targets, renderable, propertyName) => {
+  const targetsArray = parseTargets(targets);
+  for (let i = 0, l = targetsArray.length; i < l; i++) {
+    removeWAAPIAnimation(
+      /** @type {DOMTarget}  */(targetsArray[i]),
+      propertyName,
+      renderable && /** @type {WAAPIAnimation} */(renderable).controlAnimation && /** @type {WAAPIAnimation} */(renderable),
+    );
+  }
+  removeTargetsFromRenderable(
+    targetsArray,
+    /** @type {Renderable} */(renderable),
+    propertyName
+  );
+  return targetsArray;
+};
+
+export { registerTargets as $, get, remove, set };

package/dist/modules/utils/time.cjs

@@ -0,0 +1,57 @@
+/**
+ * Anime.js - utils - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var consts = require('../core/consts.cjs');
+var globals = require('../core/globals.cjs');
+var helpers = require('../core/helpers.cjs');
+var timer = require('../timer/timer.cjs');
+
+/**
+ * @import {
+ *   Callback,
+ *   Tickable,
+ * } from '../types/index.js'
+*/
+
+/**
+ * @param  {Callback<Timer>} [callback]
+ * @return {Timer}
+ */
+const sync = (callback = consts.noop) => {
+  return new timer.Timer({ duration: 1 * globals.globals.timeScale, onComplete: callback }, null, 0).resume();
+};
+
+/**
+ * @param  {(...args: any[]) => Tickable | ((...args: any[]) => void)} constructor
+ * @return {(...args: any[]) => Tickable | ((...args: any[]) => void)}
+ */
+const keepTime = constructor => {
+  /** @type {Tickable} */
+  let tracked;
+  return (...args) => {
+    let currentIteration, currentIterationProgress, reversed, alternate;
+    if (tracked) {
+      currentIteration = tracked.currentIteration;
+      currentIterationProgress = tracked.iterationProgress;
+      reversed = tracked.reversed;
+      alternate = tracked._alternate;
+      tracked.revert();
+    }
+    const cleanup = constructor(...args);
+    if (cleanup && !helpers.isFnc(cleanup) && cleanup.revert) tracked = cleanup;
+    if (!helpers.isUnd(currentIterationProgress)) {
+      /** @type {Tickable} */(tracked).currentIteration = currentIteration;
+      /** @type {Tickable} */(tracked).iterationProgress = (alternate ? !(currentIteration % 2) ? reversed : !reversed : reversed) ? 1 - currentIterationProgress : currentIterationProgress;
+    }
+    return cleanup || consts.noop;
+  }
+};
+
+exports.keepTime = keepTime;
+exports.sync = sync;

package/dist/modules/utils/time.d.ts

@@ -0,0 +1,5 @@
+export function sync(callback?: Callback<Timer>): Timer;
+export function keepTime(constructor: (...args: any[]) => Tickable | ((...args: any[]) => void)): (...args: any[]) => Tickable | ((...args: any[]) => void);
+import { Timer } from '../timer/timer.js';
+import type { Callback } from '../types/index.js';
+import type { Tickable } from '../types/index.js';

package/dist/modules/utils/time.js

@@ -0,0 +1,54 @@
+/**
+ * Anime.js - utils - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+import { noop } from '../core/consts.js';
+import { globals } from '../core/globals.js';
+import { isFnc, isUnd } from '../core/helpers.js';
+import { Timer } from '../timer/timer.js';
+
+/**
+ * @import {
+ *   Callback,
+ *   Tickable,
+ * } from '../types/index.js'
+*/
+
+/**
+ * @param  {Callback<Timer>} [callback]
+ * @return {Timer}
+ */
+const sync = (callback = noop) => {
+  return new Timer({ duration: 1 * globals.timeScale, onComplete: callback }, null, 0).resume();
+};
+
+/**
+ * @param  {(...args: any[]) => Tickable | ((...args: any[]) => void)} constructor
+ * @return {(...args: any[]) => Tickable | ((...args: any[]) => void)}
+ */
+const keepTime = constructor => {
+  /** @type {Tickable} */
+  let tracked;
+  return (...args) => {
+    let currentIteration, currentIterationProgress, reversed, alternate;
+    if (tracked) {
+      currentIteration = tracked.currentIteration;
+      currentIterationProgress = tracked.iterationProgress;
+      reversed = tracked.reversed;
+      alternate = tracked._alternate;
+      tracked.revert();
+    }
+    const cleanup = constructor(...args);
+    if (cleanup && !isFnc(cleanup) && cleanup.revert) tracked = cleanup;
+    if (!isUnd(currentIterationProgress)) {
+      /** @type {Tickable} */(tracked).currentIteration = currentIteration;
+      /** @type {Tickable} */(tracked).iterationProgress = (alternate ? !(currentIteration % 2) ? reversed : !reversed : reversed) ? 1 - currentIterationProgress : currentIterationProgress;
+    }
+    return cleanup || noop;
+  }
+};
+
+export { keepTime, sync };

package/dist/modules/waapi/composition.cjs

@@ -0,0 +1,89 @@
+/**
+ * Anime.js - waapi - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var helpers = require('../core/helpers.cjs');
+
+/**
+ * @import {
+ *   DOMTarget,
+ * } from '../types/index.js'
+*/
+
+/**
+ * @import {
+ *   WAAPIAnimation,
+ * } from '../waapi/waapi.js'
+*/
+
+const WAAPIAnimationsLookups = {
+  _head: null,
+  _tail: null,
+};
+
+/**
+ * @param {DOMTarget} $el
+ * @param {String} [property]
+ * @param {WAAPIAnimation} [parent]
+ */
+const removeWAAPIAnimation = ($el, property, parent) => {
+  let nextLookup = WAAPIAnimationsLookups._head;
+  while (nextLookup) {
+    const next = nextLookup._next;
+    const matchTarget = nextLookup.$el === $el;
+    const matchProperty = !property || nextLookup.property === property;
+    const matchParent = !parent || nextLookup.parent === parent;
+    if (matchTarget && matchProperty && matchParent) {
+      const anim = nextLookup.animation;
+      try { anim.commitStyles(); } catch {}      anim.cancel();
+      helpers.removeChild(WAAPIAnimationsLookups, nextLookup);
+      const lookupParent = nextLookup.parent;
+      if (lookupParent) {
+        lookupParent._completed++;
+        if (lookupParent.animations.length === lookupParent._completed) {
+          lookupParent.completed = true;
+          if (!lookupParent.muteCallbacks) {
+            lookupParent.paused = true;
+            lookupParent.onComplete(lookupParent);
+            lookupParent._resolve(lookupParent);
+          }
+        }
+      }
+    }
+    nextLookup = next;
+  }
+};
+
+/**
+ * @param {WAAPIAnimation} parent
+ * @param {DOMTarget} $el
+ * @param {String} property
+ * @param {PropertyIndexedKeyframes} keyframes
+ * @param {KeyframeAnimationOptions} params
+ * @retun {Animation}
+ */
+const addWAAPIAnimation = (parent, $el, property, keyframes, params) => {
+  const animation = $el.animate(keyframes, params);
+  const animTotalDuration = params.delay + (+params.duration * params.iterations);
+  animation.playbackRate = parent._speed;
+  if (parent.paused) animation.pause();
+  if (parent.duration < animTotalDuration) {
+    parent.duration = animTotalDuration;
+    parent.controlAnimation = animation;
+  }
+  parent.animations.push(animation);
+  removeWAAPIAnimation($el, property);
+  helpers.addChild(WAAPIAnimationsLookups, { parent, animation, $el, property, _next: null, _prev: null });
+  const handleRemove = () => { removeWAAPIAnimation($el, property, parent); };
+  animation.onremove = handleRemove;
+  animation.onfinish = handleRemove;
+  return animation;
+};
+
+exports.addWAAPIAnimation = addWAAPIAnimation;
+exports.removeWAAPIAnimation = removeWAAPIAnimation;

package/dist/modules/waapi/composition.d.ts

@@ -0,0 +1,4 @@
+export function removeWAAPIAnimation($el: DOMTarget, property?: string, parent?: WAAPIAnimation): void;
+export function addWAAPIAnimation(parent: WAAPIAnimation, $el: DOMTarget, property: string, keyframes: PropertyIndexedKeyframes, params: KeyframeAnimationOptions): Animation;
+import type { DOMTarget } from '../types/index.js';
+import type { WAAPIAnimation } from '../waapi/waapi.js';

package/dist/modules/waapi/composition.js

@@ -0,0 +1,86 @@
+/**
+ * Anime.js - waapi - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+import { removeChild, addChild } from '../core/helpers.js';
+
+/**
+ * @import {
+ *   DOMTarget,
+ * } from '../types/index.js'
+*/
+
+/**
+ * @import {
+ *   WAAPIAnimation,
+ * } from '../waapi/waapi.js'
+*/
+
+const WAAPIAnimationsLookups = {
+  _head: null,
+  _tail: null,
+};
+
+/**
+ * @param {DOMTarget} $el
+ * @param {String} [property]
+ * @param {WAAPIAnimation} [parent]
+ */
+const removeWAAPIAnimation = ($el, property, parent) => {
+  let nextLookup = WAAPIAnimationsLookups._head;
+  while (nextLookup) {
+    const next = nextLookup._next;
+    const matchTarget = nextLookup.$el === $el;
+    const matchProperty = !property || nextLookup.property === property;
+    const matchParent = !parent || nextLookup.parent === parent;
+    if (matchTarget && matchProperty && matchParent) {
+      const anim = nextLookup.animation;
+      try { anim.commitStyles(); } catch {}      anim.cancel();
+      removeChild(WAAPIAnimationsLookups, nextLookup);
+      const lookupParent = nextLookup.parent;
+      if (lookupParent) {
+        lookupParent._completed++;
+        if (lookupParent.animations.length === lookupParent._completed) {
+          lookupParent.completed = true;
+          if (!lookupParent.muteCallbacks) {
+            lookupParent.paused = true;
+            lookupParent.onComplete(lookupParent);
+            lookupParent._resolve(lookupParent);
+          }
+        }
+      }
+    }
+    nextLookup = next;
+  }
+};
+
+/**
+ * @param {WAAPIAnimation} parent
+ * @param {DOMTarget} $el
+ * @param {String} property
+ * @param {PropertyIndexedKeyframes} keyframes
+ * @param {KeyframeAnimationOptions} params
+ * @retun {Animation}
+ */
+const addWAAPIAnimation = (parent, $el, property, keyframes, params) => {
+  const animation = $el.animate(keyframes, params);
+  const animTotalDuration = params.delay + (+params.duration * params.iterations);
+  animation.playbackRate = parent._speed;
+  if (parent.paused) animation.pause();
+  if (parent.duration < animTotalDuration) {
+    parent.duration = animTotalDuration;
+    parent.controlAnimation = animation;
+  }
+  parent.animations.push(animation);
+  removeWAAPIAnimation($el, property);
+  addChild(WAAPIAnimationsLookups, { parent, animation, $el, property, _next: null, _prev: null });
+  const handleRemove = () => { removeWAAPIAnimation($el, property, parent); };
+  animation.onremove = handleRemove;
+  animation.onfinish = handleRemove;
+  return animation;
+};
+
+export { addWAAPIAnimation, removeWAAPIAnimation };

package/dist/modules/waapi/index.cjs

@@ -0,0 +1,15 @@
+/**
+ * Anime.js - waapi - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var waapi = require('./waapi.cjs');
+
+
+
+exports.WAAPIAnimation = waapi.WAAPIAnimation;
+exports.waapi = waapi.waapi;

package/dist/modules/waapi/index.d.ts

@@ -0,0 +1 @@
+export * from "./waapi.js";

package/dist/modules/waapi/index.js

@@ -0,0 +1,8 @@
+/**
+ * Anime.js - waapi - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+export { WAAPIAnimation, waapi } from './waapi.js';