animejs 4.1.3 → 4.2.0-beta.0

package/dist/modules/index.cjs

@@ -0,0 +1,103 @@
+/**
+ * Anime.js - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var timer = require('./timer/timer.cjs');
+var animation = require('./animation/animation.cjs');
+var timeline = require('./timeline/timeline.cjs');
+var animatable = require('./animatable/animatable.cjs');
+var draggable = require('./draggable/draggable.cjs');
+var scope = require('./scope/scope.cjs');
+var scroll = require('./events/scroll.cjs');
+var spring = require('./spring/spring.cjs');
+var engine = require('./engine/engine.cjs');
+var index = require('./easings/index.cjs');
+var index$1 = require('./utils/index.cjs');
+var index$2 = require('./svg/index.cjs');
+var index$3 = require('./text/index.cjs');
+var waapi = require('./waapi/waapi.cjs');
+var none = require('./easings/none.cjs');
+var cubicBezier = require('./easings/cubic-bezier.cjs');
+var steps = require('./easings/steps.cjs');
+var linear = require('./easings/linear.cjs');
+var irregular = require('./easings/irregular.cjs');
+var eases = require('./easings/eases.cjs');
+var chainable = require('./utils/chainable.cjs');
+var random = require('./utils/random.cjs');
+var time = require('./utils/time.cjs');
+var styles = require('./core/styles.cjs');
+var targets = require('./core/targets.cjs');
+var target = require('./utils/target.cjs');
+var stagger = require('./utils/stagger.cjs');
+var motionpath = require('./svg/motionpath.cjs');
+var drawable = require('./svg/drawable.cjs');
+var morphto = require('./svg/morphto.cjs');
+var split = require('./text/split.cjs');
+
+
+
+exports.Timer = timer.Timer;
+exports.createTimer = timer.createTimer;
+exports.JSAnimation = animation.JSAnimation;
+exports.animate = animation.animate;
+exports.Timeline = timeline.Timeline;
+exports.createTimeline = timeline.createTimeline;
+exports.Animatable = animatable.Animatable;
+exports.createAnimatable = animatable.createAnimatable;
+exports.Draggable = draggable.Draggable;
+exports.createDraggable = draggable.createDraggable;
+exports.Scope = scope.Scope;
+exports.createScope = scope.createScope;
+exports.ScrollObserver = scroll.ScrollObserver;
+exports.onScroll = scroll.onScroll;
+exports.scrollContainers = scroll.scrollContainers;
+exports.Spring = spring.Spring;
+exports.createSpring = spring.createSpring;
+exports.engine = engine.engine;
+exports.easings = index;
+exports.utils = index$1;
+exports.svg = index$2;
+exports.text = index$3;
+exports.WAAPIAnimation = waapi.WAAPIAnimation;
+exports.waapi = waapi.waapi;
+exports.none = none.none;
+exports.cubicBezier = cubicBezier.cubicBezier;
+exports.steps = steps.steps;
+exports.linear = linear.linear;
+exports.irregular = irregular.irregular;
+exports.eases = eases.eases;
+exports.clamp = chainable.clamp;
+exports.damp = chainable.damp;
+exports.degToRad = chainable.degToRad;
+exports.lerp = chainable.lerp;
+exports.mapRange = chainable.mapRange;
+exports.padEnd = chainable.padEnd;
+exports.padStart = chainable.padStart;
+exports.radToDeg = chainable.radToDeg;
+exports.round = chainable.round;
+exports.roundPad = chainable.roundPad;
+exports.snap = chainable.snap;
+exports.wrap = chainable.wrap;
+exports.createSeededRandom = random.createSeededRandom;
+exports.random = random.random;
+exports.randomPick = random.randomPick;
+exports.shuffle = random.shuffle;
+exports.keepTime = time.keepTime;
+exports.sync = time.sync;
+exports.cleanInlineStyles = styles.cleanInlineStyles;
+exports.$ = targets.registerTargets;
+exports.get = target.get;
+exports.remove = target.remove;
+exports.set = target.set;
+exports.stagger = stagger.stagger;
+exports.createMotionPath = motionpath.createMotionPath;
+exports.createDrawable = drawable.createDrawable;
+exports.morphTo = morphto.morphTo;
+exports.TextSplitter = split.TextSplitter;
+exports.split = split.split;
+exports.splitText = split.splitText;

package/dist/modules/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./timer/index.js";
+export * from "./animation/index.js";
+export * from "./timeline/index.js";
+export * from "./animatable/index.js";
+export * from "./draggable/index.js";
+export * from "./scope/index.js";
+export * from "./events/index.js";
+export * from "./spring/index.js";
+export * from "./engine/index.js";
+export * from "./easings/index.js";
+export * from "./utils/index.js";
+export * from "./svg/index.js";
+export * from "./text/index.js";
+export * from "./waapi/index.js";
+export * from "./types/index.js";
+export * as easings from "./easings/index.js";
+export * as utils from "./utils/index.js";
+export * as svg from "./svg/index.js";
+export * as text from "./text/index.js";

package/dist/modules/index.js

@@ -0,0 +1,42 @@
+/**
+ * Anime.js - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+export { Timer, createTimer } from './timer/timer.js';
+export { JSAnimation, animate } from './animation/animation.js';
+export { Timeline, createTimeline } from './timeline/timeline.js';
+export { Animatable, createAnimatable } from './animatable/animatable.js';
+export { Draggable, createDraggable } from './draggable/draggable.js';
+export { Scope, createScope } from './scope/scope.js';
+export { ScrollObserver, onScroll, scrollContainers } from './events/scroll.js';
+export { Spring, createSpring } from './spring/spring.js';
+export { engine } from './engine/engine.js';
+import * as index from './easings/index.js';
+export { index as easings };
+import * as index$1 from './utils/index.js';
+export { index$1 as utils };
+import * as index$2 from './svg/index.js';
+export { index$2 as svg };
+import * as index$3 from './text/index.js';
+export { index$3 as text };
+export { WAAPIAnimation, waapi } from './waapi/waapi.js';
+export { none } from './easings/none.js';
+export { cubicBezier } from './easings/cubic-bezier.js';
+export { steps } from './easings/steps.js';
+export { linear } from './easings/linear.js';
+export { irregular } from './easings/irregular.js';
+export { eases } from './easings/eases.js';
+export { clamp, damp, degToRad, lerp, mapRange, padEnd, padStart, radToDeg, round, roundPad, snap, wrap } from './utils/chainable.js';
+export { createSeededRandom, random, randomPick, shuffle } from './utils/random.js';
+export { keepTime, sync } from './utils/time.js';
+export { cleanInlineStyles } from './core/styles.js';
+export { registerTargets as $ } from './core/targets.js';
+export { get, remove, set } from './utils/target.js';
+export { stagger } from './utils/stagger.js';
+export { createMotionPath } from './svg/motionpath.js';
+export { createDrawable } from './svg/drawable.js';
+export { morphTo } from './svg/morphto.js';
+export { TextSplitter, split, splitText } from './text/split.js';

package/dist/modules/scope/index.cjs

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

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

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

package/dist/modules/scope/index.js

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

package/dist/modules/scope/scope.cjs

@@ -0,0 +1,254 @@
+/**
+ * Anime.js - scope - 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 targets = require('../core/targets.cjs');
+var time = require('../utils/time.cjs');
+
+/**
+ * @import {
+ *   Tickable,
+ *   ScopeParams,
+ *   DOMTarget,
+ *   ReactRef,
+ *   AngularRef,
+ *   DOMTargetSelector,
+ *   DefaultsParams,
+ *   ScopeConstructorCallback,
+ *   ScopeCleanupCallback,
+ *   Revertible,
+ *   ScopeMethod,
+ *   ScopedCallback,
+ * } from '../types/index.js'
+*/
+
+class Scope {
+  /** @param {ScopeParams} [parameters] */
+  constructor(parameters = {}) {
+    if (globals.scope.current) globals.scope.current.register(this);
+    const rootParam = parameters.root;
+    /** @type {Document|DOMTarget} */
+    let root = consts.doc;
+    if (rootParam) {
+      root = /** @type {ReactRef} */(rootParam).current ||
+             /** @type {AngularRef} */(rootParam).nativeElement ||
+             targets.parseTargets(/** @type {DOMTargetSelector} */(rootParam))[0] ||
+             consts.doc;
+    }
+    const scopeDefaults = parameters.defaults;
+    const globalDefault = globals.globals.defaults;
+    const mediaQueries = parameters.mediaQueries;
+    /** @type {DefaultsParams} */
+    this.defaults = scopeDefaults ? helpers.mergeObjects(scopeDefaults, globalDefault) : globalDefault;
+    /** @type {Document|DOMTarget} */
+    this.root = root;
+    /** @type {Array<ScopeConstructorCallback>} */
+    this.constructors = [];
+    /** @type {Array<ScopeCleanupCallback>} */
+    this.revertConstructors = [];
+    /** @type {Array<Revertible>} */
+    this.revertibles = [];
+    /** @type {Array<ScopeConstructorCallback | ((scope: this) => Tickable)>} */
+    this.constructorsOnce = [];
+    /** @type {Array<ScopeCleanupCallback>} */
+    this.revertConstructorsOnce = [];
+    /** @type {Array<Revertible>} */
+    this.revertiblesOnce = [];
+    /** @type {Boolean} */
+    this.once = false;
+    /** @type {Number} */
+    this.onceIndex = 0;
+    /** @type {Record<String, ScopeMethod>} */
+    this.methods = {};
+    /** @type {Record<String, Boolean>} */
+    this.matches = {};
+    /** @type {Record<String, MediaQueryList>} */
+    this.mediaQueryLists = {};
+    /** @type {Record<String, any>} */
+    this.data = {};
+    if (mediaQueries) {
+      for (let mq in mediaQueries) {
+        const _mq = consts.win.matchMedia(mediaQueries[mq]);
+        this.mediaQueryLists[mq] = _mq;
+        _mq.addEventListener('change', this);
+      }
+    }
+  }
+
+  /**
+   * @param {Revertible} revertible
+   */
+  register(revertible) {
+    const store = this.once ? this.revertiblesOnce : this.revertibles;
+    store.push(revertible);
+  }
+
+  /**
+   * @template T
+   * @param {ScopedCallback<T>} cb
+   * @return {T}
+   */
+  execute(cb) {
+    let activeScope = globals.scope.current;
+    let activeRoot = globals.scope.root;
+    let activeDefaults = globals.globals.defaults;
+    globals.scope.current = this;
+    globals.scope.root = this.root;
+    globals.globals.defaults = this.defaults;
+    const mqs = this.mediaQueryLists;
+    for (let mq in mqs) this.matches[mq] = mqs[mq].matches;
+    const returned = cb(this);
+    globals.scope.current = activeScope;
+    globals.scope.root = activeRoot;
+    globals.globals.defaults = activeDefaults;
+    return returned;
+  }
+
+  /**
+   * @return {this}
+   */
+  refresh() {
+    this.onceIndex = 0;
+    this.execute(() => {
+      let i = this.revertibles.length;
+      let y = this.revertConstructors.length;
+      while (i--) this.revertibles[i].revert();
+      while (y--) this.revertConstructors[y](this);
+      this.revertibles.length = 0;
+      this.revertConstructors.length = 0;
+      this.constructors.forEach((/** @type {ScopeConstructorCallback} */constructor) => {
+        const revertConstructor = constructor(this);
+        if (helpers.isFnc(revertConstructor)) {
+          this.revertConstructors.push(revertConstructor);
+        }
+      });
+    });
+    return this;
+  }
+
+  /**
+   * @overload
+   * @param {String} a1
+   * @param {ScopeMethod} a2
+   * @return {this}
+   *
+   * @overload
+   * @param {ScopeConstructorCallback} a1
+   * @return {this}
+   *
+   * @param {String|ScopeConstructorCallback} a1
+   * @param {ScopeMethod} [a2]
+   */
+  add(a1, a2) {
+    this.once = false;
+    if (helpers.isFnc(a1)) {
+      const constructor = /** @type {ScopeConstructorCallback} */(a1);
+      this.constructors.push(constructor);
+      this.execute(() => {
+        const revertConstructor = constructor(this);
+        if (helpers.isFnc(revertConstructor)) {
+          this.revertConstructors.push(revertConstructor);
+        }
+      });
+    } else {
+      this.methods[/** @type {String} */(a1)] = (/** @type {any} */...args) => this.execute(() => a2(...args));
+    }
+    return this;
+  }
+
+  /**
+   * @param {ScopeConstructorCallback} scopeConstructorCallback
+   * @return {this}
+   */
+  addOnce(scopeConstructorCallback) {
+    this.once = true;
+    if (helpers.isFnc(scopeConstructorCallback)) {
+      const currentIndex = this.onceIndex++;
+      const tracked = this.constructorsOnce[currentIndex];
+      if (tracked) return this;
+      const constructor = /** @type {ScopeConstructorCallback} */(scopeConstructorCallback);
+      this.constructorsOnce[currentIndex] = constructor;
+      this.execute(() => {
+        const revertConstructor = constructor(this);
+        if (helpers.isFnc(revertConstructor)) {
+          this.revertConstructorsOnce.push(revertConstructor);
+        }
+      });
+    }
+    return this;
+  }
+
+  /**
+   * @param  {(scope: this) => Tickable} cb
+   * @return {Tickable}
+   */
+  keepTime(cb) {
+    this.once = true;
+    const currentIndex = this.onceIndex++;
+    const tracked = /** @type {(scope: this) => Tickable} */(this.constructorsOnce[currentIndex]);
+    if (helpers.isFnc(tracked)) return tracked(this);
+    const constructor = /** @type {(scope: this) => Tickable} */(time.keepTime(cb));
+    this.constructorsOnce[currentIndex] = constructor;
+    let trackedTickable;
+    this.execute(() => {
+      trackedTickable = constructor(this);
+    });
+    return trackedTickable;
+  }
+
+  /**
+   * @param {Event} e
+   */
+  handleEvent(e) {
+    switch (e.type) {
+      case 'change':
+        this.refresh();
+        break;
+    }
+  }
+
+  revert() {
+    const revertibles = this.revertibles;
+    const revertConstructors = this.revertConstructors;
+    const revertiblesOnce = this.revertiblesOnce;
+    const revertConstructorsOnce = this.revertConstructorsOnce;
+    const mqs = this.mediaQueryLists;
+    let i = revertibles.length;
+    let j = revertConstructors.length;
+    let k = revertiblesOnce.length;
+    let l = revertConstructorsOnce.length;
+    while (i--) revertibles[i].revert();
+    while (j--) revertConstructors[j](this);
+    while (k--) revertiblesOnce[k].revert();
+    while (l--) revertConstructorsOnce[l](this);
+    for (let mq in mqs) mqs[mq].removeEventListener('change', this);
+    revertibles.length = 0;
+    revertConstructors.length = 0;
+    this.constructors.length = 0;
+    revertiblesOnce.length = 0;
+    revertConstructorsOnce.length = 0;
+    this.constructorsOnce.length = 0;
+    this.onceIndex = 0;
+    this.matches = {};
+    this.methods = {};
+    this.mediaQueryLists = {};
+    this.data = {};
+  }
+}
+
+/**
+ * @param {ScopeParams} [params]
+ * @return {Scope}
+ */
+const createScope = params => new Scope(params);
+
+exports.Scope = Scope;
+exports.createScope = createScope;

package/dist/modules/scope/scope.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @import {
+ *   Tickable,
+ *   ScopeParams,
+ *   DOMTarget,
+ *   ReactRef,
+ *   AngularRef,
+ *   DOMTargetSelector,
+ *   DefaultsParams,
+ *   ScopeConstructorCallback,
+ *   ScopeCleanupCallback,
+ *   Revertible,
+ *   ScopeMethod,
+ *   ScopedCallback,
+ * } from '../types/index.js'
+*/
+export class Scope {
+    /** @param {ScopeParams} [parameters] */
+    constructor(parameters?: ScopeParams);
+    /** @type {DefaultsParams} */
+    defaults: DefaultsParams;
+    /** @type {Document|DOMTarget} */
+    root: Document | DOMTarget;
+    /** @type {Array<ScopeConstructorCallback>} */
+    constructors: Array<ScopeConstructorCallback>;
+    /** @type {Array<ScopeCleanupCallback>} */
+    revertConstructors: Array<ScopeCleanupCallback>;
+    /** @type {Array<Revertible>} */
+    revertibles: Array<Revertible>;
+    /** @type {Array<ScopeConstructorCallback | ((scope: this) => Tickable)>} */
+    constructorsOnce: Array<ScopeConstructorCallback | ((scope: this) => Tickable)>;
+    /** @type {Array<ScopeCleanupCallback>} */
+    revertConstructorsOnce: Array<ScopeCleanupCallback>;
+    /** @type {Array<Revertible>} */
+    revertiblesOnce: Array<Revertible>;
+    /** @type {Boolean} */
+    once: boolean;
+    /** @type {Number} */
+    onceIndex: number;
+    /** @type {Record<String, ScopeMethod>} */
+    methods: Record<string, ScopeMethod>;
+    /** @type {Record<String, Boolean>} */
+    matches: Record<string, boolean>;
+    /** @type {Record<String, MediaQueryList>} */
+    mediaQueryLists: Record<string, MediaQueryList>;
+    /** @type {Record<String, any>} */
+    data: Record<string, any>;
+    /**
+     * @param {Revertible} revertible
+     */
+    register(revertible: Revertible): void;
+    /**
+     * @template T
+     * @param {ScopedCallback<T>} cb
+     * @return {T}
+     */
+    execute<T>(cb: ScopedCallback<T>): T;
+    /**
+     * @return {this}
+     */
+    refresh(): this;
+    /**
+     * @overload
+     * @param {String} a1
+     * @param {ScopeMethod} a2
+     * @return {this}
+     *
+     * @overload
+     * @param {ScopeConstructorCallback} a1
+     * @return {this}
+     *
+     * @param {String|ScopeConstructorCallback} a1
+     * @param {ScopeMethod} [a2]
+     */
+    add(a1: string, a2: ScopeMethod): this;
+    /**
+     * @overload
+     * @param {String} a1
+     * @param {ScopeMethod} a2
+     * @return {this}
+     *
+     * @overload
+     * @param {ScopeConstructorCallback} a1
+     * @return {this}
+     *
+     * @param {String|ScopeConstructorCallback} a1
+     * @param {ScopeMethod} [a2]
+     */
+    add(a1: ScopeConstructorCallback): this;
+    /**
+     * @param {ScopeConstructorCallback} scopeConstructorCallback
+     * @return {this}
+     */
+    addOnce(scopeConstructorCallback: ScopeConstructorCallback): this;
+    /**
+     * @param  {(scope: this) => Tickable} cb
+     * @return {Tickable}
+     */
+    keepTime(cb: (scope: this) => Tickable): Tickable;
+    /**
+     * @param {Event} e
+     */
+    handleEvent(e: Event): void;
+    revert(): void;
+}
+export function createScope(params?: ScopeParams): Scope;
+import type { DefaultsParams } from '../types/index.js';
+import type { DOMTarget } from '../types/index.js';
+import type { ScopeConstructorCallback } from '../types/index.js';
+import type { ScopeCleanupCallback } from '../types/index.js';
+import type { Revertible } from '../types/index.js';
+import type { Tickable } from '../types/index.js';
+import type { ScopeMethod } from '../types/index.js';
+import type { ScopedCallback } from '../types/index.js';
+import type { ScopeParams } from '../types/index.js';