animejs 4.1.2 → 4.2.0-beta.0

package/dist/modules/core/globals.js

@@ -0,0 +1,72 @@
+/**
+ * Anime.js - core - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+import { isBrowser, win, noop, maxFps, K, compositionTypes, doc } from './consts.js';
+
+/**
+ * @import {
+ *   DefaultsParams,
+ *   DOMTarget,
+ * } from '../types/index.js'
+ *
+ * @import {
+ *   Scope,
+ * } from '../scope/index.js'
+*/
+
+/** @type {DefaultsParams} */
+const defaults = {
+  id: null,
+  keyframes: null,
+  playbackEase: null,
+  playbackRate: 1,
+  frameRate: maxFps,
+  loop: 0,
+  reversed: false,
+  alternate: false,
+  autoplay: true,
+  duration: K,
+  delay: 0,
+  loopDelay: 0,
+  ease: 'out(2)',
+  composition: compositionTypes.replace,
+  modifier: v => v,
+  onBegin: noop,
+  onBeforeUpdate: noop,
+  onUpdate: noop,
+  onLoop: noop,
+  onPause: noop,
+  onComplete: noop,
+  onRender: noop,
+};
+
+const scope = {
+  /** @type {Scope} */
+  current: null,
+  /** @type {Document|DOMTarget} */
+  root: doc,
+};
+
+const globals = {
+  /** @type {DefaultsParams} */
+  defaults,
+  /** @type {Number} */
+  precision: 4,
+  /** @type {Number} equals 1 in ms mode, 0.001 in s mode */
+  timeScale: 1,
+  /** @type {Number} */
+  tickThreshold: 200,
+};
+
+const globalVersions = { version: '4.2.0', engine: null };
+
+if (isBrowser) {
+  if (!win.AnimeJS) win.AnimeJS = [];
+  win.AnimeJS.push(globalVersions);
+}
+
+export { defaults, globalVersions, globals, scope };

package/dist/modules/core/helpers.cjs

@@ -0,0 +1,304 @@
+/**
+ * Anime.js - core - CJS
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+'use strict';
+
+var consts = require('./consts.cjs');
+var globals = require('./globals.cjs');
+
+/**
+ * @import {
+ *   Target,
+ *   DOMTarget,
+ * } from '../types/index.js'
+*/
+
+// Strings
+
+/**
+ * @param  {String} str
+ * @return {String}
+ */
+const toLowerCase = str => str.replace(consts.lowerCaseRgx, '$1-$2').toLowerCase();
+
+/**
+ * Prioritize this method instead of regex when possible
+ * @param  {String} str
+ * @param  {String} sub
+ * @return {Boolean}
+ */
+const stringStartsWith = (str, sub) => str.indexOf(sub) === 0;
+
+// Note: Date.now is used instead of performance.now since it is precise enough for timings calculations, performs slightly faster and works in Node.js environement.
+const now = Date.now;
+
+// Types checkers
+
+const isArr = Array.isArray;
+/**@param {any} a @return {a is Record<String, any>} */
+const isObj = a => a && a.constructor === Object;
+/**@param {any} a @return {a is Number} */
+const isNum = a => typeof a === 'number' && !isNaN(a);
+/**@param {any} a @return {a is String} */
+const isStr = a => typeof a === 'string';
+/**@param {any} a @return {a is Function} */
+const isFnc = a => typeof a === 'function';
+/**@param {any} a @return {a is undefined} */
+const isUnd = a => typeof a === 'undefined';
+/**@param {any} a @return {a is null | undefined} */
+const isNil = a => isUnd(a) || a === null;
+/**@param {any} a @return {a is SVGElement} */
+const isSvg = a => consts.isBrowser && a instanceof SVGElement;
+/**@param {any} a @return {Boolean} */
+const isHex = a => consts.hexTestRgx.test(a);
+/**@param {any} a @return {Boolean} */
+const isRgb = a => stringStartsWith(a, 'rgb');
+/**@param {any} a @return {Boolean} */
+const isHsl = a => stringStartsWith(a, 'hsl');
+/**@param {any} a @return {Boolean} */
+const isCol = a => isHex(a) || isRgb(a) || isHsl(a);
+/**@param {any} a @return {Boolean} */
+const isKey = a => !globals.globals.defaults.hasOwnProperty(a);
+
+// SVG
+
+// Consider the following as CSS animation
+// CSS opacity animation has better default values (opacity: 1 instead of 0))
+// rotate is more commonly intended to be used as a transform
+const svgCssReservedProperties = ['opacity', 'rotate', 'overflow', 'color'];
+
+/**
+ * @param  {Target} el
+ * @param  {String} propertyName
+ * @return {Boolean}
+ */
+const isValidSVGAttribute = (el, propertyName) => {
+  if (svgCssReservedProperties.includes(propertyName)) return false;
+  if (el.getAttribute(propertyName) || propertyName in el) {
+    if (propertyName === 'scale') { // Scale
+      const elParentNode = /** @type {SVGGeometryElement} */(/** @type {DOMTarget} */(el).parentNode);
+      // Only consider scale as a valid SVG attribute on filter element
+      return elParentNode && elParentNode.tagName === 'filter';
+    }
+    return true;
+  }
+};
+
+// Number
+
+/**
+ * @param  {Number|String} str
+ * @return {Number}
+ */
+const parseNumber = str => isStr(str) ?
+  parseFloat(/** @type {String} */(str)) :
+  /** @type {Number} */(str);
+
+// Math
+
+const pow = Math.pow;
+const sqrt = Math.sqrt;
+const sin = Math.sin;
+const cos = Math.cos;
+const abs = Math.abs;
+const exp = Math.exp;
+const ceil = Math.ceil;
+const floor = Math.floor;
+const asin = Math.asin;
+const max = Math.max;
+const atan2 = Math.atan2;
+const PI = Math.PI;
+const _round = Math.round;
+
+/**
+ * Clamps a value between min and max bounds
+ *
+ * @param  {Number} v - Value to clamp
+ * @param  {Number} min - Minimum boundary
+ * @param  {Number} max - Maximum boundary
+ * @return {Number}
+ */
+const clamp = (v, min, max) => v < min ? min : v > max ? max : v;
+
+const powCache = {};
+
+/**
+ * Rounds a number to specified decimal places
+ *
+ * @param  {Number} v - Value to round
+ * @param  {Number} decimalLength - Number of decimal places
+ * @return {Number}
+ */
+const round = (v, decimalLength) => {
+  if (decimalLength < 0) return v;
+  if (!decimalLength) return _round(v);
+  let p = powCache[decimalLength];
+  if (!p) p = powCache[decimalLength] = 10 ** decimalLength;
+  return _round(v * p) / p;
+};
+
+/**
+ * Snaps a value to nearest increment or array value
+ *
+ * @param  {Number} v - Value to snap
+ * @param  {Number|Array<Number>} increment - Step size or array of snap points
+ * @return {Number}
+ */
+const snap = (v, increment) => isArr(increment) ? increment.reduce((closest, cv) => (abs(cv - v) < abs(closest - v) ? cv : closest)) : increment ? _round(v / increment) * increment : v;
+
+/**
+ * Linear interpolation between two values
+ *
+ * @param  {Number} start - Starting value
+ * @param  {Number} end - Ending value
+ * @param  {Number} factor - Interpolation factor in the range [0, 1]
+ * @return {Number} The interpolated value
+ */
+const lerp = (start, end, factor) => start + (end - start) * factor;
+
+/**
+ * Replaces infinity with maximum safe value
+ *
+ * @param  {Number} v - Value to check
+ * @return {Number}
+ */
+const clampInfinity = v => v === Infinity ? consts.maxValue : v === -Infinity ? -consts.maxValue : v;
+
+/**
+ * Normalizes time value with minimum threshold
+ *
+ * @param  {Number} v - Time value to normalize
+ * @return {Number}
+ */
+const normalizeTime = v => v <= consts.minValue ? consts.minValue : clampInfinity(round(v, 11));
+
+// Arrays
+
+/**
+ * @template T
+ * @param    {T[]} a
+ * @return   {T[]}
+ */
+const cloneArray = a => isArr(a) ? [ ...a ] : a;
+
+// Objects
+
+/**
+ * @template T
+ * @template U
+ * @param    {T} o1
+ * @param    {U} o2
+ * @return   {T & U}
+ */
+const mergeObjects = (o1, o2) => {
+  const merged = /** @type {T & U} */({ ...o1 });
+  for (let p in o2) {
+    const o1p = /** @type {T & U} */(o1)[p];
+    merged[p] = isUnd(o1p) ? /** @type {T & U} */(o2)[p] : o1p;
+  }  return merged;
+};
+
+// Linked lists
+
+/**
+ * @param  {Object} parent
+ * @param  {Function} callback
+ * @param  {Boolean} [reverse]
+ * @param  {String} [prevProp]
+ * @param  {String} [nextProp]
+ * @return {void}
+ */
+const forEachChildren = (parent, callback, reverse, prevProp = '_prev', nextProp = '_next') => {
+  let next = parent._head;
+  let adjustedNextProp = nextProp;
+  if (reverse) {
+    next = parent._tail;
+    adjustedNextProp = prevProp;
+  }
+  while (next) {
+    const currentNext = next[adjustedNextProp];
+    callback(next);
+    next = currentNext;
+  }
+};
+
+/**
+ * @param  {Object} parent
+ * @param  {Object} child
+ * @param  {String} [prevProp]
+ * @param  {String} [nextProp]
+ * @return {void}
+ */
+const removeChild = (parent, child, prevProp = '_prev', nextProp = '_next') => {
+  const prev = child[prevProp];
+  const next = child[nextProp];
+  prev ? prev[nextProp] = next : parent._head = next;
+  next ? next[prevProp] = prev : parent._tail = prev;
+  child[prevProp] = null;
+  child[nextProp] = null;
+};
+
+/**
+ * @param  {Object} parent
+ * @param  {Object} child
+ * @param  {Function} [sortMethod]
+ * @param  {String} prevProp
+ * @param  {String} nextProp
+ * @return {void}
+ */
+const addChild = (parent, child, sortMethod, prevProp = '_prev', nextProp = '_next') => {
+  let prev = parent._tail;
+  while (prev && sortMethod && sortMethod(prev, child)) prev = prev[prevProp];
+  const next = prev ? prev[nextProp] : parent._head;
+  prev ? prev[nextProp] = child : parent._head = child;
+  next ? next[prevProp] = child : parent._tail = child;
+  child[prevProp] = prev;
+  child[nextProp] = next;
+};
+
+exports.PI = PI;
+exports._round = _round;
+exports.abs = abs;
+exports.addChild = addChild;
+exports.asin = asin;
+exports.atan2 = atan2;
+exports.ceil = ceil;
+exports.clamp = clamp;
+exports.clampInfinity = clampInfinity;
+exports.cloneArray = cloneArray;
+exports.cos = cos;
+exports.exp = exp;
+exports.floor = floor;
+exports.forEachChildren = forEachChildren;
+exports.isArr = isArr;
+exports.isCol = isCol;
+exports.isFnc = isFnc;
+exports.isHex = isHex;
+exports.isHsl = isHsl;
+exports.isKey = isKey;
+exports.isNil = isNil;
+exports.isNum = isNum;
+exports.isObj = isObj;
+exports.isRgb = isRgb;
+exports.isStr = isStr;
+exports.isSvg = isSvg;
+exports.isUnd = isUnd;
+exports.isValidSVGAttribute = isValidSVGAttribute;
+exports.lerp = lerp;
+exports.max = max;
+exports.mergeObjects = mergeObjects;
+exports.normalizeTime = normalizeTime;
+exports.now = now;
+exports.parseNumber = parseNumber;
+exports.pow = pow;
+exports.removeChild = removeChild;
+exports.round = round;
+exports.sin = sin;
+exports.snap = snap;
+exports.sqrt = sqrt;
+exports.stringStartsWith = stringStartsWith;
+exports.toLowerCase = toLowerCase;

package/dist/modules/core/helpers.d.ts

@@ -0,0 +1,43 @@
+export function toLowerCase(str: string): string;
+export function stringStartsWith(str: string, sub: string): boolean;
+export const now: () => number;
+export const isArr: (arg: any) => arg is any[];
+export function isObj(a: any): a is Record<string, any>;
+export function isNum(a: any): a is number;
+export function isStr(a: any): a is string;
+export function isFnc(a: any): a is Function;
+export function isUnd(a: any): a is undefined;
+export function isNil(a: any): a is null | undefined;
+export function isSvg(a: any): a is SVGElement;
+export function isHex(a: any): boolean;
+export function isRgb(a: any): boolean;
+export function isHsl(a: any): boolean;
+export function isCol(a: any): boolean;
+export function isKey(a: any): boolean;
+export function isValidSVGAttribute(el: Target, propertyName: string): boolean;
+export function parseNumber(str: number | string): number;
+export const pow: (x: number, y: number) => number;
+export const sqrt: (x: number) => number;
+export const sin: (x: number) => number;
+export const cos: (x: number) => number;
+export const abs: (x: number) => number;
+export const exp: (x: number) => number;
+export const ceil: (x: number) => number;
+export const floor: (x: number) => number;
+export const asin: (x: number) => number;
+export const max: (...values: number[]) => number;
+export const atan2: (y: number, x: number) => number;
+export const PI: number;
+export const _round: (x: number) => number;
+export function clamp(v: number, min: number, max: number): number;
+export function round(v: number, decimalLength: number): number;
+export function snap(v: number, increment: number | Array<number>): number;
+export function lerp(start: number, end: number, factor: number): number;
+export function clampInfinity(v: number): number;
+export function normalizeTime(v: number): number;
+export function cloneArray<T>(a: T[]): T[];
+export function mergeObjects<T, U>(o1: T, o2: U): T & U;
+export function forEachChildren(parent: any, callback: Function, reverse?: boolean, prevProp?: string, nextProp?: string): void;
+export function removeChild(parent: any, child: any, prevProp?: string, nextProp?: string): void;
+export function addChild(parent: any, child: any, sortMethod?: Function, prevProp?: string, nextProp?: string): void;
+import type { Target } from '../types/index.js';

package/dist/modules/core/helpers.js

@@ -0,0 +1,261 @@
+/**
+ * Anime.js - core - ESM
+ * @version v4.2.0
+ * @license MIT
+ * @copyright 2025 - Julian Garnier
+ */
+
+import { isBrowser, maxValue, minValue, hexTestRgx, lowerCaseRgx } from './consts.js';
+import { globals } from './globals.js';
+
+/**
+ * @import {
+ *   Target,
+ *   DOMTarget,
+ * } from '../types/index.js'
+*/
+
+// Strings
+
+/**
+ * @param  {String} str
+ * @return {String}
+ */
+const toLowerCase = str => str.replace(lowerCaseRgx, '$1-$2').toLowerCase();
+
+/**
+ * Prioritize this method instead of regex when possible
+ * @param  {String} str
+ * @param  {String} sub
+ * @return {Boolean}
+ */
+const stringStartsWith = (str, sub) => str.indexOf(sub) === 0;
+
+// Note: Date.now is used instead of performance.now since it is precise enough for timings calculations, performs slightly faster and works in Node.js environement.
+const now = Date.now;
+
+// Types checkers
+
+const isArr = Array.isArray;
+/**@param {any} a @return {a is Record<String, any>} */
+const isObj = a => a && a.constructor === Object;
+/**@param {any} a @return {a is Number} */
+const isNum = a => typeof a === 'number' && !isNaN(a);
+/**@param {any} a @return {a is String} */
+const isStr = a => typeof a === 'string';
+/**@param {any} a @return {a is Function} */
+const isFnc = a => typeof a === 'function';
+/**@param {any} a @return {a is undefined} */
+const isUnd = a => typeof a === 'undefined';
+/**@param {any} a @return {a is null | undefined} */
+const isNil = a => isUnd(a) || a === null;
+/**@param {any} a @return {a is SVGElement} */
+const isSvg = a => isBrowser && a instanceof SVGElement;
+/**@param {any} a @return {Boolean} */
+const isHex = a => hexTestRgx.test(a);
+/**@param {any} a @return {Boolean} */
+const isRgb = a => stringStartsWith(a, 'rgb');
+/**@param {any} a @return {Boolean} */
+const isHsl = a => stringStartsWith(a, 'hsl');
+/**@param {any} a @return {Boolean} */
+const isCol = a => isHex(a) || isRgb(a) || isHsl(a);
+/**@param {any} a @return {Boolean} */
+const isKey = a => !globals.defaults.hasOwnProperty(a);
+
+// SVG
+
+// Consider the following as CSS animation
+// CSS opacity animation has better default values (opacity: 1 instead of 0))
+// rotate is more commonly intended to be used as a transform
+const svgCssReservedProperties = ['opacity', 'rotate', 'overflow', 'color'];
+
+/**
+ * @param  {Target} el
+ * @param  {String} propertyName
+ * @return {Boolean}
+ */
+const isValidSVGAttribute = (el, propertyName) => {
+  if (svgCssReservedProperties.includes(propertyName)) return false;
+  if (el.getAttribute(propertyName) || propertyName in el) {
+    if (propertyName === 'scale') { // Scale
+      const elParentNode = /** @type {SVGGeometryElement} */(/** @type {DOMTarget} */(el).parentNode);
+      // Only consider scale as a valid SVG attribute on filter element
+      return elParentNode && elParentNode.tagName === 'filter';
+    }
+    return true;
+  }
+};
+
+// Number
+
+/**
+ * @param  {Number|String} str
+ * @return {Number}
+ */
+const parseNumber = str => isStr(str) ?
+  parseFloat(/** @type {String} */(str)) :
+  /** @type {Number} */(str);
+
+// Math
+
+const pow = Math.pow;
+const sqrt = Math.sqrt;
+const sin = Math.sin;
+const cos = Math.cos;
+const abs = Math.abs;
+const exp = Math.exp;
+const ceil = Math.ceil;
+const floor = Math.floor;
+const asin = Math.asin;
+const max = Math.max;
+const atan2 = Math.atan2;
+const PI = Math.PI;
+const _round = Math.round;
+
+/**
+ * Clamps a value between min and max bounds
+ *
+ * @param  {Number} v - Value to clamp
+ * @param  {Number} min - Minimum boundary
+ * @param  {Number} max - Maximum boundary
+ * @return {Number}
+ */
+const clamp = (v, min, max) => v < min ? min : v > max ? max : v;
+
+const powCache = {};
+
+/**
+ * Rounds a number to specified decimal places
+ *
+ * @param  {Number} v - Value to round
+ * @param  {Number} decimalLength - Number of decimal places
+ * @return {Number}
+ */
+const round = (v, decimalLength) => {
+  if (decimalLength < 0) return v;
+  if (!decimalLength) return _round(v);
+  let p = powCache[decimalLength];
+  if (!p) p = powCache[decimalLength] = 10 ** decimalLength;
+  return _round(v * p) / p;
+};
+
+/**
+ * Snaps a value to nearest increment or array value
+ *
+ * @param  {Number} v - Value to snap
+ * @param  {Number|Array<Number>} increment - Step size or array of snap points
+ * @return {Number}
+ */
+const snap = (v, increment) => isArr(increment) ? increment.reduce((closest, cv) => (abs(cv - v) < abs(closest - v) ? cv : closest)) : increment ? _round(v / increment) * increment : v;
+
+/**
+ * Linear interpolation between two values
+ *
+ * @param  {Number} start - Starting value
+ * @param  {Number} end - Ending value
+ * @param  {Number} factor - Interpolation factor in the range [0, 1]
+ * @return {Number} The interpolated value
+ */
+const lerp = (start, end, factor) => start + (end - start) * factor;
+
+/**
+ * Replaces infinity with maximum safe value
+ *
+ * @param  {Number} v - Value to check
+ * @return {Number}
+ */
+const clampInfinity = v => v === Infinity ? maxValue : v === -Infinity ? -maxValue : v;
+
+/**
+ * Normalizes time value with minimum threshold
+ *
+ * @param  {Number} v - Time value to normalize
+ * @return {Number}
+ */
+const normalizeTime = v => v <= minValue ? minValue : clampInfinity(round(v, 11));
+
+// Arrays
+
+/**
+ * @template T
+ * @param    {T[]} a
+ * @return   {T[]}
+ */
+const cloneArray = a => isArr(a) ? [ ...a ] : a;
+
+// Objects
+
+/**
+ * @template T
+ * @template U
+ * @param    {T} o1
+ * @param    {U} o2
+ * @return   {T & U}
+ */
+const mergeObjects = (o1, o2) => {
+  const merged = /** @type {T & U} */({ ...o1 });
+  for (let p in o2) {
+    const o1p = /** @type {T & U} */(o1)[p];
+    merged[p] = isUnd(o1p) ? /** @type {T & U} */(o2)[p] : o1p;
+  }  return merged;
+};
+
+// Linked lists
+
+/**
+ * @param  {Object} parent
+ * @param  {Function} callback
+ * @param  {Boolean} [reverse]
+ * @param  {String} [prevProp]
+ * @param  {String} [nextProp]
+ * @return {void}
+ */
+const forEachChildren = (parent, callback, reverse, prevProp = '_prev', nextProp = '_next') => {
+  let next = parent._head;
+  let adjustedNextProp = nextProp;
+  if (reverse) {
+    next = parent._tail;
+    adjustedNextProp = prevProp;
+  }
+  while (next) {
+    const currentNext = next[adjustedNextProp];
+    callback(next);
+    next = currentNext;
+  }
+};
+
+/**
+ * @param  {Object} parent
+ * @param  {Object} child
+ * @param  {String} [prevProp]
+ * @param  {String} [nextProp]
+ * @return {void}
+ */
+const removeChild = (parent, child, prevProp = '_prev', nextProp = '_next') => {
+  const prev = child[prevProp];
+  const next = child[nextProp];
+  prev ? prev[nextProp] = next : parent._head = next;
+  next ? next[prevProp] = prev : parent._tail = prev;
+  child[prevProp] = null;
+  child[nextProp] = null;
+};
+
+/**
+ * @param  {Object} parent
+ * @param  {Object} child
+ * @param  {Function} [sortMethod]
+ * @param  {String} prevProp
+ * @param  {String} nextProp
+ * @return {void}
+ */
+const addChild = (parent, child, sortMethod, prevProp = '_prev', nextProp = '_next') => {
+  let prev = parent._tail;
+  while (prev && sortMethod && sortMethod(prev, child)) prev = prev[prevProp];
+  const next = prev ? prev[nextProp] : parent._head;
+  prev ? prev[nextProp] = child : parent._head = child;
+  next ? next[prevProp] = child : parent._tail = child;
+  child[prevProp] = prev;
+  child[nextProp] = next;
+};
+
+export { PI, _round, abs, addChild, asin, atan2, ceil, clamp, clampInfinity, cloneArray, cos, exp, floor, forEachChildren, isArr, isCol, isFnc, isHex, isHsl, isKey, isNil, isNum, isObj, isRgb, isStr, isSvg, isUnd, isValidSVGAttribute, lerp, max, mergeObjects, normalizeTime, now, parseNumber, pow, removeChild, round, sin, snap, sqrt, stringStartsWith, toLowerCase };