animejs 4.4.0 → 4.5.0

package/dist/modules/adapters/index.cjs

@@ -0,0 +1,14 @@
+/**
+ * Anime.js - adapters - CJS
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+'use strict';
+
+var registry = require('./registry.cjs');
+
+
+
+exports.registerAdapter = registry.registerAdapter;

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

@@ -0,0 +1 @@
+export { registerAdapter } from "./registry.js";

package/dist/modules/adapters/index.js

@@ -0,0 +1,8 @@
+/**
+ * Anime.js - adapters - ESM
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+export { registerAdapter } from './registry.js';

package/dist/modules/adapters/registry.cjs

@@ -0,0 +1,149 @@
+/**
+ * Anime.js - adapters - CJS
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+'use strict';
+
+/**
+ * Anime.js adapter API. Each library or class group that wants to extend `animate()` and `utils.set()` calls `registerAdapter()` to create its own `Adapter`. The returned `Adapter` exposes `registerTargetAdapter(detect)` for per-class detection and `registerPropertyResolver(fn)` for global Color / Vector / pattern-based fallbacks.
+ *
+ *   import { registerAdapter } from 'animejs/adapters';
+ *
+ *   const myAdapter = registerAdapter();
+ *   const widget = myAdapter.registerTargetAdapter((t) => t instanceof MyWidget);
+ *   widget.registerProperty('value',
+ *     (t) => t.getValue(),
+ *     (target, value) => target.setValue(value),
+ *   );
+ *
+ * For scalar tweens, `value` is the interpolated number. For color and complex tweens it is `undefined`; read `tween._numbers` instead. `gate(target)` scopes the prop to a subset of matching targets.
+ *
+ * Resolution order: every Adapter's target adapters in registration order (first match wins) then every Adapter's property resolvers (first non-null wins) then engine direct property path.
+ */
+
+/**
+ * @typedef TargetAdapterEntry
+ * @property {(t: any) => any} get
+ * @property {(target: any, value: number, tween: any) => void} set
+ * @property {(t: any) => boolean} [gate]
+ */
+
+const alwaysTrue = () => true;
+
+class TargetAdapter {
+  /**
+   * @param {(t: any) => boolean} detect
+   */
+  constructor(detect) {
+    this.detect = detect;
+    /** @type {Record<string, TargetAdapterEntry>} */
+    this.props = {};
+  }
+
+  /**
+   * Registers a property the adapter handles. `setter` receives `(target, value, tween)`. For color and complex tweens `value` is `undefined`, read `tween._numbers` instead. `gate(target)` scopes the prop to a subset of matching targets.
+   *
+   * @param {string} name
+   * @param {(t: any) => any} getter
+   * @param {(target: any, value: number, tween: any) => void} setter
+   * @param {(t: any) => boolean} [gate]
+   */
+  registerProperty(name, getter, setter, gate) {
+    this.props[name] = {
+      get: getter,
+      set: setter,
+      gate: gate || alwaysTrue,
+    };
+  }
+}
+
+class Adapter {
+  /**
+   * @param {((t: any) => boolean) | null} [detect]
+   *   Optional gate. When provided, every lookup against this Adapter's target adapters and resolvers is skipped if `detect(target)` returns falsy. Lets the Adapter as a whole short-circuit on unrelated targets.
+   */
+  constructor(detect) {
+    /** @type {((t: any) => boolean) | null} */
+    this.detect = detect || null;
+    /** @type {TargetAdapter[]} */
+    this.targetAdapters = [];
+    /** @type {((target: any, name: string) => TargetAdapterEntry | null)[]} */
+    this.propertyResolvers = [];
+  }
+
+  /**
+   * Creates and registers a `TargetAdapter` scoped to this Adapter.
+   *
+   * @param {(t: any) => boolean} detect
+   * @return {TargetAdapter}
+   */
+  registerTargetAdapter(detect) {
+    const ta = new TargetAdapter(detect);
+    this.targetAdapters.push(ta);
+    return ta;
+  }
+
+  /**
+   * Registers a property resolver scoped to this Adapter. Resolvers are functions invoked at tween creation when no target adapter has claimed the name; the function returns an entry for names it handles or `null` to defer. Use for runtime-matched patterns (Color / Vector axis detection, name-prefix conventions, etc.).
+   *
+   * @param {(target: any, name: string) => TargetAdapterEntry | null} resolver
+   */
+  registerPropertyResolver(resolver) {
+    if (this.propertyResolvers.indexOf(resolver) === -1) this.propertyResolvers.push(resolver);
+  }
+}
+
+const adapters = /** @type {Adapter[]} */([]);
+
+/**
+ * Creates and registers an Adapter. Each library extending `animate()` calls this once and uses the returned Adapter to wire up its target adapters and property resolvers. The optional `detect` short-circuits all lookups against the Adapter when the target is unrelated.
+ *
+ * @param {(t: any) => boolean} [detect]
+ * @return {Adapter}
+ */
+function registerAdapter(detect) {
+  const a = new Adapter(detect);
+  adapters.push(a);
+  return a;
+}
+
+/**
+ * Internal resolution. Tries every Adapter's target adapters first (in registration order, first match wins), then every Adapter's property resolvers.
+ *
+ * @param {any} target
+ * @param {string} name
+ * @return {TargetAdapterEntry | null}
+ */
+function resolveAdapterEntry(target, name) {
+  if (!target) return null;
+  const al = adapters.length;
+  outer: for (let i = 0; i < al; i++) {
+    const a = adapters[i];
+    if (a.detect && !a.detect(target)) continue;
+    const tas = a.targetAdapters;
+    for (let j = 0, m = tas.length; j < m; j++) {
+      const ta = tas[j];
+      if (ta.detect(target)) {
+        const entry = ta.props[name];
+        if (entry && (!entry.gate || entry.gate(target))) return entry;
+        break outer;
+      }
+    }
+  }
+  for (let i = 0; i < al; i++) {
+    const a = adapters[i];
+    if (a.detect && !a.detect(target)) continue;
+    const rs = a.propertyResolvers;
+    for (let j = 0, m = rs.length; j < m; j++) {
+      const entry = rs[j](target, name);
+      if (entry) return entry;
+    }
+  }
+  return null;
+}
+
+exports.registerAdapter = registerAdapter;
+exports.resolveAdapterEntry = resolveAdapterEntry;

package/dist/modules/adapters/registry.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Creates and registers an Adapter. Each library extending `animate()` calls this once and uses the returned Adapter to wire up its target adapters and property resolvers. The optional `detect` short-circuits all lookups against the Adapter when the target is unrelated.
+ *
+ * @param {(t: any) => boolean} [detect]
+ * @return {Adapter}
+ */
+export function registerAdapter(detect?: (t: any) => boolean): Adapter;
+/**
+ * Internal resolution. Tries every Adapter's target adapters first (in registration order, first match wins), then every Adapter's property resolvers.
+ *
+ * @param {any} target
+ * @param {string} name
+ * @return {TargetAdapterEntry | null}
+ */
+export function resolveAdapterEntry(target: any, name: string): TargetAdapterEntry | null;
+export type TargetAdapterEntry = {
+    get: (t: any) => any;
+    set: (target: any, value: number, tween: any) => void;
+    gate?: (t: any) => boolean;
+};
+declare class Adapter {
+    /**
+     * @param {((t: any) => boolean) | null} [detect]
+     *   Optional gate. When provided, every lookup against this Adapter's target adapters and resolvers is skipped if `detect(target)` returns falsy. Lets the Adapter as a whole short-circuit on unrelated targets.
+     */
+    constructor(detect?: ((t: any) => boolean) | null);
+    /** @type {((t: any) => boolean) | null} */
+    detect: ((t: any) => boolean) | null;
+    /** @type {TargetAdapter[]} */
+    targetAdapters: TargetAdapter[];
+    /** @type {((target: any, name: string) => TargetAdapterEntry | null)[]} */
+    propertyResolvers: ((target: any, name: string) => TargetAdapterEntry | null)[];
+    /**
+     * Creates and registers a `TargetAdapter` scoped to this Adapter.
+     *
+     * @param {(t: any) => boolean} detect
+     * @return {TargetAdapter}
+     */
+    registerTargetAdapter(detect: (t: any) => boolean): TargetAdapter;
+    /**
+     * Registers a property resolver scoped to this Adapter. Resolvers are functions invoked at tween creation when no target adapter has claimed the name; the function returns an entry for names it handles or `null` to defer. Use for runtime-matched patterns (Color / Vector axis detection, name-prefix conventions, etc.).
+     *
+     * @param {(target: any, name: string) => TargetAdapterEntry | null} resolver
+     */
+    registerPropertyResolver(resolver: (target: any, name: string) => TargetAdapterEntry | null): void;
+}
+declare class TargetAdapter {
+    /**
+     * @param {(t: any) => boolean} detect
+     */
+    constructor(detect: (t: any) => boolean);
+    detect: (t: any) => boolean;
+    /** @type {Record<string, TargetAdapterEntry>} */
+    props: Record<string, TargetAdapterEntry>;
+    /**
+     * Registers a property the adapter handles. `setter` receives `(target, value, tween)`. For color and complex tweens `value` is `undefined`, read `tween._numbers` instead. `gate(target)` scopes the prop to a subset of matching targets.
+     *
+     * @param {string} name
+     * @param {(t: any) => any} getter
+     * @param {(target: any, value: number, tween: any) => void} setter
+     * @param {(t: any) => boolean} [gate]
+     */
+    registerProperty(name: string, getter: (t: any) => any, setter: (target: any, value: number, tween: any) => void, gate?: (t: any) => boolean): void;
+}
+export {};

package/dist/modules/adapters/registry.js

@@ -0,0 +1,146 @@
+/**
+ * Anime.js - adapters - ESM
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+/**
+ * Anime.js adapter API. Each library or class group that wants to extend `animate()` and `utils.set()` calls `registerAdapter()` to create its own `Adapter`. The returned `Adapter` exposes `registerTargetAdapter(detect)` for per-class detection and `registerPropertyResolver(fn)` for global Color / Vector / pattern-based fallbacks.
+ *
+ *   import { registerAdapter } from 'animejs/adapters';
+ *
+ *   const myAdapter = registerAdapter();
+ *   const widget = myAdapter.registerTargetAdapter((t) => t instanceof MyWidget);
+ *   widget.registerProperty('value',
+ *     (t) => t.getValue(),
+ *     (target, value) => target.setValue(value),
+ *   );
+ *
+ * For scalar tweens, `value` is the interpolated number. For color and complex tweens it is `undefined`; read `tween._numbers` instead. `gate(target)` scopes the prop to a subset of matching targets.
+ *
+ * Resolution order: every Adapter's target adapters in registration order (first match wins) then every Adapter's property resolvers (first non-null wins) then engine direct property path.
+ */
+
+/**
+ * @typedef TargetAdapterEntry
+ * @property {(t: any) => any} get
+ * @property {(target: any, value: number, tween: any) => void} set
+ * @property {(t: any) => boolean} [gate]
+ */
+
+const alwaysTrue = () => true;
+
+class TargetAdapter {
+  /**
+   * @param {(t: any) => boolean} detect
+   */
+  constructor(detect) {
+    this.detect = detect;
+    /** @type {Record<string, TargetAdapterEntry>} */
+    this.props = {};
+  }
+
+  /**
+   * Registers a property the adapter handles. `setter` receives `(target, value, tween)`. For color and complex tweens `value` is `undefined`, read `tween._numbers` instead. `gate(target)` scopes the prop to a subset of matching targets.
+   *
+   * @param {string} name
+   * @param {(t: any) => any} getter
+   * @param {(target: any, value: number, tween: any) => void} setter
+   * @param {(t: any) => boolean} [gate]
+   */
+  registerProperty(name, getter, setter, gate) {
+    this.props[name] = {
+      get: getter,
+      set: setter,
+      gate: gate || alwaysTrue,
+    };
+  }
+}
+
+class Adapter {
+  /**
+   * @param {((t: any) => boolean) | null} [detect]
+   *   Optional gate. When provided, every lookup against this Adapter's target adapters and resolvers is skipped if `detect(target)` returns falsy. Lets the Adapter as a whole short-circuit on unrelated targets.
+   */
+  constructor(detect) {
+    /** @type {((t: any) => boolean) | null} */
+    this.detect = detect || null;
+    /** @type {TargetAdapter[]} */
+    this.targetAdapters = [];
+    /** @type {((target: any, name: string) => TargetAdapterEntry | null)[]} */
+    this.propertyResolvers = [];
+  }
+
+  /**
+   * Creates and registers a `TargetAdapter` scoped to this Adapter.
+   *
+   * @param {(t: any) => boolean} detect
+   * @return {TargetAdapter}
+   */
+  registerTargetAdapter(detect) {
+    const ta = new TargetAdapter(detect);
+    this.targetAdapters.push(ta);
+    return ta;
+  }
+
+  /**
+   * Registers a property resolver scoped to this Adapter. Resolvers are functions invoked at tween creation when no target adapter has claimed the name; the function returns an entry for names it handles or `null` to defer. Use for runtime-matched patterns (Color / Vector axis detection, name-prefix conventions, etc.).
+   *
+   * @param {(target: any, name: string) => TargetAdapterEntry | null} resolver
+   */
+  registerPropertyResolver(resolver) {
+    if (this.propertyResolvers.indexOf(resolver) === -1) this.propertyResolvers.push(resolver);
+  }
+}
+
+const adapters = /** @type {Adapter[]} */([]);
+
+/**
+ * Creates and registers an Adapter. Each library extending `animate()` calls this once and uses the returned Adapter to wire up its target adapters and property resolvers. The optional `detect` short-circuits all lookups against the Adapter when the target is unrelated.
+ *
+ * @param {(t: any) => boolean} [detect]
+ * @return {Adapter}
+ */
+function registerAdapter(detect) {
+  const a = new Adapter(detect);
+  adapters.push(a);
+  return a;
+}
+
+/**
+ * Internal resolution. Tries every Adapter's target adapters first (in registration order, first match wins), then every Adapter's property resolvers.
+ *
+ * @param {any} target
+ * @param {string} name
+ * @return {TargetAdapterEntry | null}
+ */
+function resolveAdapterEntry(target, name) {
+  if (!target) return null;
+  const al = adapters.length;
+  outer: for (let i = 0; i < al; i++) {
+    const a = adapters[i];
+    if (a.detect && !a.detect(target)) continue;
+    const tas = a.targetAdapters;
+    for (let j = 0, m = tas.length; j < m; j++) {
+      const ta = tas[j];
+      if (ta.detect(target)) {
+        const entry = ta.props[name];
+        if (entry && (!entry.gate || entry.gate(target))) return entry;
+        break outer;
+      }
+    }
+  }
+  for (let i = 0; i < al; i++) {
+    const a = adapters[i];
+    if (a.detect && !a.detect(target)) continue;
+    const rs = a.propertyResolvers;
+    for (let j = 0, m = rs.length; j < m; j++) {
+      const entry = rs[j](target, name);
+      if (entry) return entry;
+    }
+  }
+  return null;
+}
+
+export { registerAdapter, resolveAdapterEntry };

package/dist/modules/adapters/three/adapter.cjs

@@ -0,0 +1,26 @@
+/**
+ * Anime.js - adapters - CJS
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+'use strict';
+
+var registry = require('../registry.cjs');
+
+// Duck-typed gate for three.js targets, used as threeAdapter's Adapter-level detect.
+// Early-rejects DOM nodes via nodeType so the OR chain only runs on non-DOM objects.
+// Includes the isAnimejsInstanceProxy marker set in instance.js for per-instance wrappers.
+const isThreeTarget = (t) => !!(
+  t && !t.nodeType && (
+    t.isObject3D || t.isMaterial || t.isTexture ||
+    t.isFog || t.isFogExp2 || t.isUniformNode ||
+    t.isColor || t.isVector2 || t.isVector3 || t.isVector4 ||
+    t.isAnimejsInstanceProxy
+  )
+);
+
+const threeAdapter = registry.registerAdapter(isThreeTarget);
+
+exports.threeAdapter = threeAdapter;

package/dist/modules/adapters/three/adapter.d.ts

@@ -0,0 +1,15 @@
+export const threeAdapter: {
+    detect: (t: any) => boolean;
+    targetAdapters: {
+        detect: (t: any) => boolean;
+        props: Record<string, import("../registry.js").TargetAdapterEntry>;
+        registerProperty(name: string, getter: (t: any) => any, setter: (target: any, value: number, tween: any) => void, gate?: (t: any) => boolean): void;
+    }[];
+    propertyResolvers: ((target: any, name: string) => import("../registry.js").TargetAdapterEntry | null)[];
+    registerTargetAdapter(detect: (t: any) => boolean): {
+        detect: (t: any) => boolean;
+        props: Record<string, import("../registry.js").TargetAdapterEntry>;
+        registerProperty(name: string, getter: (t: any) => any, setter: (target: any, value: number, tween: any) => void, gate?: (t: any) => boolean): void;
+    };
+    registerPropertyResolver(resolver: (target: any, name: string) => TargetAdapterEntry | null): void;
+};

package/dist/modules/adapters/three/adapter.js

@@ -0,0 +1,24 @@
+/**
+ * Anime.js - adapters - ESM
+ * @version v4.5.0
+ * @license MIT
+ * @copyright 2026 - Julian Garnier
+ */
+
+import { registerAdapter } from '../registry.js';
+
+// Duck-typed gate for three.js targets, used as threeAdapter's Adapter-level detect.
+// Early-rejects DOM nodes via nodeType so the OR chain only runs on non-DOM objects.
+// Includes the isAnimejsInstanceProxy marker set in instance.js for per-instance wrappers.
+const isThreeTarget = (t) => !!(
+  t && !t.nodeType && (
+    t.isObject3D || t.isMaterial || t.isTexture ||
+    t.isFog || t.isFogExp2 || t.isUniformNode ||
+    t.isColor || t.isVector2 || t.isVector3 || t.isVector4 ||
+    t.isAnimejsInstanceProxy
+  )
+);
+
+const threeAdapter = registerAdapter(isThreeTarget);
+
+export { threeAdapter };