Initial commit xmarticaims
This commit is contained in:
+193
@@ -0,0 +1,193 @@
|
||||
/**
|
||||
* Anime.js - utils - CJS
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
var consts = require('../core/consts.cjs');
|
||||
var number = require('./number.cjs');
|
||||
|
||||
// Chain-able utilities
|
||||
|
||||
const numberUtils = number; // Needed to keep the import when bundling
|
||||
|
||||
const chainables = {};
|
||||
|
||||
/**
|
||||
* @callback UtilityFunction
|
||||
* @param {...*} args
|
||||
* @return {Number|String}
|
||||
*
|
||||
* @param {UtilityFunction} fn
|
||||
* @param {Number} [last=0]
|
||||
* @return {function(...(Number|String)): function(Number|String): (Number|String)}
|
||||
*/
|
||||
const curry = (fn, last = 0) => (...args) => last ? v => fn(...args, v) : v => fn(v, ...args);
|
||||
|
||||
/**
|
||||
* @param {Function} fn
|
||||
* @return {function(...(Number|String))}
|
||||
*/
|
||||
const chain = fn => {
|
||||
return (...args) => {
|
||||
const result = fn(...args);
|
||||
return new Proxy(consts.noop, {
|
||||
apply: (_, __, [v]) => result(v),
|
||||
get: (_, prop) => {
|
||||
if (!chainables[prop]) return undefined;
|
||||
return chain(/**@param {...Number|String} nextArgs */(...nextArgs) => {
|
||||
const nextResult = chainables[prop](...nextArgs);
|
||||
return (/**@type {Number|String} */v) => nextResult(result(v));
|
||||
})
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {UtilityFunction} fn
|
||||
* @param {String} name
|
||||
* @param {Number} [right]
|
||||
* @return {function(...(Number|String)): UtilityFunction}
|
||||
*/
|
||||
const makeChainable = (name, fn, right = 0) => {
|
||||
const chained = (...args) => (args.length < fn.length ? chain(curry(fn, right)) : fn)(...args);
|
||||
if (!chainables[name]) chainables[name] = chained;
|
||||
return chained;
|
||||
};
|
||||
|
||||
/**
|
||||
* @typedef {Object} ChainablesMap
|
||||
* @property {ChainedClamp} clamp
|
||||
* @property {ChainedRound} round
|
||||
* @property {ChainedSnap} snap
|
||||
* @property {ChainedWrap} wrap
|
||||
* @property {ChainedLerp} lerp
|
||||
* @property {ChainedDamp} damp
|
||||
* @property {ChainedMapRange} mapRange
|
||||
* @property {ChainedRoundPad} roundPad
|
||||
* @property {ChainedPadStart} padStart
|
||||
* @property {ChainedPadEnd} padEnd
|
||||
* @property {ChainedDegToRad} degToRad
|
||||
* @property {ChainedRadToDeg} radToDeg
|
||||
*/
|
||||
|
||||
/**
|
||||
* @callback ChainedUtilsResult
|
||||
* @param {Number} value - The value to process through the chained operations
|
||||
* @return {Number} The processed result
|
||||
*/
|
||||
|
||||
/**
|
||||
* @typedef {ChainablesMap & ChainedUtilsResult} ChainableUtil
|
||||
*/
|
||||
|
||||
// Chainable
|
||||
|
||||
/**
|
||||
* @callback ChainedRoundPad
|
||||
* @param {Number} decimalLength - Number of decimal places
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const roundPad = /** @type {typeof numberUtils.roundPad & ChainedRoundPad} */(makeChainable('roundPad', numberUtils.roundPad));
|
||||
|
||||
/**
|
||||
* @callback ChainedPadStart
|
||||
* @param {Number} totalLength - Target length
|
||||
* @param {String} padString - String to pad with
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const padStart = /** @type {typeof numberUtils.padStart & ChainedPadStart} */(makeChainable('padStart', numberUtils.padStart));
|
||||
|
||||
/**
|
||||
* @callback ChainedPadEnd
|
||||
* @param {Number} totalLength - Target length
|
||||
* @param {String} padString - String to pad with
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const padEnd = /** @type {typeof numberUtils.padEnd & ChainedPadEnd} */(makeChainable('padEnd', numberUtils.padEnd));
|
||||
|
||||
/**
|
||||
* @callback ChainedWrap
|
||||
* @param {Number} min - Minimum boundary
|
||||
* @param {Number} max - Maximum boundary
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const wrap = /** @type {typeof numberUtils.wrap & ChainedWrap} */(makeChainable('wrap', numberUtils.wrap));
|
||||
|
||||
/**
|
||||
* @callback ChainedMapRange
|
||||
* @param {Number} inLow - Input range minimum
|
||||
* @param {Number} inHigh - Input range maximum
|
||||
* @param {Number} outLow - Output range minimum
|
||||
* @param {Number} outHigh - Output range maximum
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const mapRange = /** @type {typeof numberUtils.mapRange & ChainedMapRange} */(makeChainable('mapRange', numberUtils.mapRange));
|
||||
|
||||
/**
|
||||
* @callback ChainedDegToRad
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const degToRad = /** @type {typeof numberUtils.degToRad & ChainedDegToRad} */(makeChainable('degToRad', numberUtils.degToRad));
|
||||
|
||||
/**
|
||||
* @callback ChainedRadToDeg
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const radToDeg = /** @type {typeof numberUtils.radToDeg & ChainedRadToDeg} */(makeChainable('radToDeg', numberUtils.radToDeg));
|
||||
|
||||
/**
|
||||
* @callback ChainedSnap
|
||||
* @param {Number|Array<Number>} increment - Step size or array of snap points
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const snap = /** @type {typeof numberUtils.snap & ChainedSnap} */(makeChainable('snap', numberUtils.snap));
|
||||
|
||||
/**
|
||||
* @callback ChainedClamp
|
||||
* @param {Number} min - Minimum boundary
|
||||
* @param {Number} max - Maximum boundary
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const clamp = /** @type {typeof numberUtils.clamp & ChainedClamp} */(makeChainable('clamp', numberUtils.clamp));
|
||||
|
||||
/**
|
||||
* @callback ChainedRound
|
||||
* @param {Number} decimalLength - Number of decimal places
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const round = /** @type {typeof numberUtils.round & ChainedRound} */(makeChainable('round', numberUtils.round));
|
||||
|
||||
/**
|
||||
* @callback ChainedLerp
|
||||
* @param {Number} start - Starting value
|
||||
* @param {Number} end - Ending value
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const lerp = /** @type {typeof numberUtils.lerp & ChainedLerp} */(makeChainable('lerp', numberUtils.lerp, 1));
|
||||
|
||||
/**
|
||||
* @callback ChainedDamp
|
||||
* @param {Number} start - Starting value
|
||||
* @param {Number} end - Target value
|
||||
* @param {Number} deltaTime - Delta time in ms
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const damp = /** @type {typeof numberUtils.damp & ChainedDamp} */(makeChainable('damp', numberUtils.damp, 1));
|
||||
|
||||
exports.clamp = clamp;
|
||||
exports.damp = damp;
|
||||
exports.degToRad = degToRad;
|
||||
exports.lerp = lerp;
|
||||
exports.mapRange = mapRange;
|
||||
exports.padEnd = padEnd;
|
||||
exports.padStart = padStart;
|
||||
exports.radToDeg = radToDeg;
|
||||
exports.round = round;
|
||||
exports.roundPad = roundPad;
|
||||
exports.snap = snap;
|
||||
exports.wrap = wrap;
|
||||
+135
@@ -0,0 +1,135 @@
|
||||
/**
|
||||
* @typedef {Object} ChainablesMap
|
||||
* @property {ChainedClamp} clamp
|
||||
* @property {ChainedRound} round
|
||||
* @property {ChainedSnap} snap
|
||||
* @property {ChainedWrap} wrap
|
||||
* @property {ChainedLerp} lerp
|
||||
* @property {ChainedDamp} damp
|
||||
* @property {ChainedMapRange} mapRange
|
||||
* @property {ChainedRoundPad} roundPad
|
||||
* @property {ChainedPadStart} padStart
|
||||
* @property {ChainedPadEnd} padEnd
|
||||
* @property {ChainedDegToRad} degToRad
|
||||
* @property {ChainedRadToDeg} radToDeg
|
||||
*/
|
||||
/**
|
||||
* @callback ChainedUtilsResult
|
||||
* @param {Number} value - The value to process through the chained operations
|
||||
* @return {Number} The processed result
|
||||
*/
|
||||
/**
|
||||
* @typedef {ChainablesMap & ChainedUtilsResult} ChainableUtil
|
||||
*/
|
||||
/**
|
||||
* @callback ChainedRoundPad
|
||||
* @param {Number} decimalLength - Number of decimal places
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const roundPad: typeof numberUtils.roundPad & ChainedRoundPad;
|
||||
/**
|
||||
* @callback ChainedPadStart
|
||||
* @param {Number} totalLength - Target length
|
||||
* @param {String} padString - String to pad with
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const padStart: typeof numberUtils.padStart & ChainedPadStart;
|
||||
/**
|
||||
* @callback ChainedPadEnd
|
||||
* @param {Number} totalLength - Target length
|
||||
* @param {String} padString - String to pad with
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const padEnd: typeof numberUtils.padEnd & ChainedPadEnd;
|
||||
/**
|
||||
* @callback ChainedWrap
|
||||
* @param {Number} min - Minimum boundary
|
||||
* @param {Number} max - Maximum boundary
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const wrap: typeof numberUtils.wrap & ChainedWrap;
|
||||
/**
|
||||
* @callback ChainedMapRange
|
||||
* @param {Number} inLow - Input range minimum
|
||||
* @param {Number} inHigh - Input range maximum
|
||||
* @param {Number} outLow - Output range minimum
|
||||
* @param {Number} outHigh - Output range maximum
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const mapRange: typeof numberUtils.mapRange & ChainedMapRange;
|
||||
/**
|
||||
* @callback ChainedDegToRad
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const degToRad: typeof numberUtils.degToRad & ChainedDegToRad;
|
||||
/**
|
||||
* @callback ChainedRadToDeg
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const radToDeg: typeof numberUtils.radToDeg & ChainedRadToDeg;
|
||||
/**
|
||||
* @callback ChainedSnap
|
||||
* @param {Number|Array<Number>} increment - Step size or array of snap points
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const snap: typeof numberUtils.snap & ChainedSnap;
|
||||
/**
|
||||
* @callback ChainedClamp
|
||||
* @param {Number} min - Minimum boundary
|
||||
* @param {Number} max - Maximum boundary
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const clamp: typeof numberUtils.clamp & ChainedClamp;
|
||||
/**
|
||||
* @callback ChainedRound
|
||||
* @param {Number} decimalLength - Number of decimal places
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const round: typeof numberUtils.round & ChainedRound;
|
||||
/**
|
||||
* @callback ChainedLerp
|
||||
* @param {Number} start - Starting value
|
||||
* @param {Number} end - Ending value
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const lerp: typeof numberUtils.lerp & ChainedLerp;
|
||||
/**
|
||||
* @callback ChainedDamp
|
||||
* @param {Number} start - Starting value
|
||||
* @param {Number} end - Target value
|
||||
* @param {Number} deltaTime - Delta time in ms
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
export const damp: typeof numberUtils.damp & ChainedDamp;
|
||||
export type UtilityFunction = (...args: any[]) => number | string;
|
||||
export type ChainablesMap = {
|
||||
clamp: ChainedClamp;
|
||||
round: ChainedRound;
|
||||
snap: ChainedSnap;
|
||||
wrap: ChainedWrap;
|
||||
lerp: ChainedLerp;
|
||||
damp: ChainedDamp;
|
||||
mapRange: ChainedMapRange;
|
||||
roundPad: ChainedRoundPad;
|
||||
padStart: ChainedPadStart;
|
||||
padEnd: ChainedPadEnd;
|
||||
degToRad: ChainedDegToRad;
|
||||
radToDeg: ChainedRadToDeg;
|
||||
};
|
||||
export type ChainedUtilsResult = (value: number) => number;
|
||||
export type ChainableUtil = ChainablesMap & ChainedUtilsResult;
|
||||
export type ChainedRoundPad = (decimalLength: number) => ChainableUtil;
|
||||
export type ChainedPadStart = (totalLength: number, padString: string) => ChainableUtil;
|
||||
export type ChainedPadEnd = (totalLength: number, padString: string) => ChainableUtil;
|
||||
export type ChainedWrap = (min: number, max: number) => ChainableUtil;
|
||||
export type ChainedMapRange = (inLow: number, inHigh: number, outLow: number, outHigh: number) => ChainableUtil;
|
||||
export type ChainedDegToRad = () => ChainableUtil;
|
||||
export type ChainedRadToDeg = () => ChainableUtil;
|
||||
export type ChainedSnap = (increment: number | Array<number>) => ChainableUtil;
|
||||
export type ChainedClamp = (min: number, max: number) => ChainableUtil;
|
||||
export type ChainedRound = (decimalLength: number) => ChainableUtil;
|
||||
export type ChainedLerp = (start: number, end: number) => ChainableUtil;
|
||||
export type ChainedDamp = (start: number, end: number, deltaTime: number) => ChainableUtil;
|
||||
declare const numberUtils: typeof numberImports;
|
||||
import * as numberImports from './number.js';
|
||||
export {};
|
||||
@@ -0,0 +1,180 @@
|
||||
/**
|
||||
* Anime.js - utils - ESM
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
import { noop } from '../core/consts.js';
|
||||
import * as number from './number.js';
|
||||
|
||||
// Chain-able utilities
|
||||
|
||||
const numberUtils = number; // Needed to keep the import when bundling
|
||||
|
||||
const chainables = {};
|
||||
|
||||
/**
|
||||
* @callback UtilityFunction
|
||||
* @param {...*} args
|
||||
* @return {Number|String}
|
||||
*
|
||||
* @param {UtilityFunction} fn
|
||||
* @param {Number} [last=0]
|
||||
* @return {function(...(Number|String)): function(Number|String): (Number|String)}
|
||||
*/
|
||||
const curry = (fn, last = 0) => (...args) => last ? v => fn(...args, v) : v => fn(v, ...args);
|
||||
|
||||
/**
|
||||
* @param {Function} fn
|
||||
* @return {function(...(Number|String))}
|
||||
*/
|
||||
const chain = fn => {
|
||||
return (...args) => {
|
||||
const result = fn(...args);
|
||||
return new Proxy(noop, {
|
||||
apply: (_, __, [v]) => result(v),
|
||||
get: (_, prop) => {
|
||||
if (!chainables[prop]) return undefined;
|
||||
return chain(/**@param {...Number|String} nextArgs */(...nextArgs) => {
|
||||
const nextResult = chainables[prop](...nextArgs);
|
||||
return (/**@type {Number|String} */v) => nextResult(result(v));
|
||||
})
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {UtilityFunction} fn
|
||||
* @param {String} name
|
||||
* @param {Number} [right]
|
||||
* @return {function(...(Number|String)): UtilityFunction}
|
||||
*/
|
||||
const makeChainable = (name, fn, right = 0) => {
|
||||
const chained = (...args) => (args.length < fn.length ? chain(curry(fn, right)) : fn)(...args);
|
||||
if (!chainables[name]) chainables[name] = chained;
|
||||
return chained;
|
||||
};
|
||||
|
||||
/**
|
||||
* @typedef {Object} ChainablesMap
|
||||
* @property {ChainedClamp} clamp
|
||||
* @property {ChainedRound} round
|
||||
* @property {ChainedSnap} snap
|
||||
* @property {ChainedWrap} wrap
|
||||
* @property {ChainedLerp} lerp
|
||||
* @property {ChainedDamp} damp
|
||||
* @property {ChainedMapRange} mapRange
|
||||
* @property {ChainedRoundPad} roundPad
|
||||
* @property {ChainedPadStart} padStart
|
||||
* @property {ChainedPadEnd} padEnd
|
||||
* @property {ChainedDegToRad} degToRad
|
||||
* @property {ChainedRadToDeg} radToDeg
|
||||
*/
|
||||
|
||||
/**
|
||||
* @callback ChainedUtilsResult
|
||||
* @param {Number} value - The value to process through the chained operations
|
||||
* @return {Number} The processed result
|
||||
*/
|
||||
|
||||
/**
|
||||
* @typedef {ChainablesMap & ChainedUtilsResult} ChainableUtil
|
||||
*/
|
||||
|
||||
// Chainable
|
||||
|
||||
/**
|
||||
* @callback ChainedRoundPad
|
||||
* @param {Number} decimalLength - Number of decimal places
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const roundPad = /** @type {typeof numberUtils.roundPad & ChainedRoundPad} */(makeChainable('roundPad', numberUtils.roundPad));
|
||||
|
||||
/**
|
||||
* @callback ChainedPadStart
|
||||
* @param {Number} totalLength - Target length
|
||||
* @param {String} padString - String to pad with
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const padStart = /** @type {typeof numberUtils.padStart & ChainedPadStart} */(makeChainable('padStart', numberUtils.padStart));
|
||||
|
||||
/**
|
||||
* @callback ChainedPadEnd
|
||||
* @param {Number} totalLength - Target length
|
||||
* @param {String} padString - String to pad with
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const padEnd = /** @type {typeof numberUtils.padEnd & ChainedPadEnd} */(makeChainable('padEnd', numberUtils.padEnd));
|
||||
|
||||
/**
|
||||
* @callback ChainedWrap
|
||||
* @param {Number} min - Minimum boundary
|
||||
* @param {Number} max - Maximum boundary
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const wrap = /** @type {typeof numberUtils.wrap & ChainedWrap} */(makeChainable('wrap', numberUtils.wrap));
|
||||
|
||||
/**
|
||||
* @callback ChainedMapRange
|
||||
* @param {Number} inLow - Input range minimum
|
||||
* @param {Number} inHigh - Input range maximum
|
||||
* @param {Number} outLow - Output range minimum
|
||||
* @param {Number} outHigh - Output range maximum
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const mapRange = /** @type {typeof numberUtils.mapRange & ChainedMapRange} */(makeChainable('mapRange', numberUtils.mapRange));
|
||||
|
||||
/**
|
||||
* @callback ChainedDegToRad
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const degToRad = /** @type {typeof numberUtils.degToRad & ChainedDegToRad} */(makeChainable('degToRad', numberUtils.degToRad));
|
||||
|
||||
/**
|
||||
* @callback ChainedRadToDeg
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const radToDeg = /** @type {typeof numberUtils.radToDeg & ChainedRadToDeg} */(makeChainable('radToDeg', numberUtils.radToDeg));
|
||||
|
||||
/**
|
||||
* @callback ChainedSnap
|
||||
* @param {Number|Array<Number>} increment - Step size or array of snap points
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const snap = /** @type {typeof numberUtils.snap & ChainedSnap} */(makeChainable('snap', numberUtils.snap));
|
||||
|
||||
/**
|
||||
* @callback ChainedClamp
|
||||
* @param {Number} min - Minimum boundary
|
||||
* @param {Number} max - Maximum boundary
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const clamp = /** @type {typeof numberUtils.clamp & ChainedClamp} */(makeChainable('clamp', numberUtils.clamp));
|
||||
|
||||
/**
|
||||
* @callback ChainedRound
|
||||
* @param {Number} decimalLength - Number of decimal places
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const round = /** @type {typeof numberUtils.round & ChainedRound} */(makeChainable('round', numberUtils.round));
|
||||
|
||||
/**
|
||||
* @callback ChainedLerp
|
||||
* @param {Number} start - Starting value
|
||||
* @param {Number} end - Ending value
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const lerp = /** @type {typeof numberUtils.lerp & ChainedLerp} */(makeChainable('lerp', numberUtils.lerp, 1));
|
||||
|
||||
/**
|
||||
* @callback ChainedDamp
|
||||
* @param {Number} start - Starting value
|
||||
* @param {Number} end - Target value
|
||||
* @param {Number} deltaTime - Delta time in ms
|
||||
* @return {ChainableUtil}
|
||||
*/
|
||||
const damp = /** @type {typeof numberUtils.damp & ChainedDamp} */(makeChainable('damp', numberUtils.damp, 1));
|
||||
|
||||
export { clamp, damp, degToRad, lerp, mapRange, padEnd, padStart, radToDeg, round, roundPad, snap, wrap };
|
||||
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* Anime.js - utils - CJS
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
var chainable = require('./chainable.cjs');
|
||||
var random = require('./random.cjs');
|
||||
var time = require('./time.cjs');
|
||||
var target = require('./target.cjs');
|
||||
var stagger = require('./stagger.cjs');
|
||||
var helpers = require('../core/helpers.cjs');
|
||||
var styles = require('../core/styles.cjs');
|
||||
var targets = require('../core/targets.cjs');
|
||||
|
||||
|
||||
|
||||
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.get = target.get;
|
||||
exports.remove = target.remove;
|
||||
exports.set = target.set;
|
||||
exports.stagger = stagger.stagger;
|
||||
exports.addChild = helpers.addChild;
|
||||
exports.forEachChildren = helpers.forEachChildren;
|
||||
exports.removeChild = helpers.removeChild;
|
||||
exports.cleanInlineStyles = styles.cleanInlineStyles;
|
||||
exports.$ = targets.registerTargets;
|
||||
@@ -0,0 +1,6 @@
|
||||
export * from "./chainable.js";
|
||||
export * from "./random.js";
|
||||
export * from "./time.js";
|
||||
export * from "./target.js";
|
||||
export * from "./stagger.js";
|
||||
export { forEachChildren, addChild, removeChild } from "../core/helpers.js";
|
||||
@@ -0,0 +1,15 @@
|
||||
/**
|
||||
* Anime.js - utils - ESM
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
export { clamp, damp, degToRad, lerp, mapRange, padEnd, padStart, radToDeg, round, roundPad, snap, wrap } from './chainable.js';
|
||||
export { createSeededRandom, random, randomPick, shuffle } from './random.js';
|
||||
export { keepTime, sync } from './time.js';
|
||||
export { get, remove, set } from './target.js';
|
||||
export { stagger } from './stagger.js';
|
||||
export { addChild, forEachChildren, removeChild } from '../core/helpers.js';
|
||||
export { cleanInlineStyles } from '../core/styles.js';
|
||||
export { registerTargets as $ } from '../core/targets.js';
|
||||
@@ -0,0 +1,97 @@
|
||||
/**
|
||||
* Anime.js - utils - CJS
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
var helpers = require('../core/helpers.cjs');
|
||||
|
||||
/**
|
||||
* Rounds a number to fixed decimal places
|
||||
* @param {Number|String} v - Value to round
|
||||
* @param {Number} decimalLength - Number of decimal places
|
||||
* @return {String}
|
||||
*/
|
||||
const roundPad = (v, decimalLength) => (+v).toFixed(decimalLength);
|
||||
|
||||
/**
|
||||
* Pads the start of a value with a string
|
||||
* @param {Number} v - Value to pad
|
||||
* @param {Number} totalLength - Target length
|
||||
* @param {String} padString - String to pad with
|
||||
* @return {String}
|
||||
*/
|
||||
const padStart = (v, totalLength, padString) => `${v}`.padStart(totalLength, padString);
|
||||
|
||||
/**
|
||||
* Pads the end of a value with a string
|
||||
* @param {Number} v - Value to pad
|
||||
* @param {Number} totalLength - Target length
|
||||
* @param {String} padString - String to pad with
|
||||
* @return {String}
|
||||
*/
|
||||
const padEnd = (v, totalLength, padString) => `${v}`.padEnd(totalLength, padString);
|
||||
|
||||
/**
|
||||
* Wraps a value within a range
|
||||
* @param {Number} v - Value to wrap
|
||||
* @param {Number} min - Minimum boundary
|
||||
* @param {Number} max - Maximum boundary
|
||||
* @return {Number}
|
||||
*/
|
||||
const wrap = (v, min, max) => (((v - min) % (max - min) + (max - min)) % (max - min)) + min;
|
||||
|
||||
/**
|
||||
* Maps a value from one range to another
|
||||
* @param {Number} value - Input value
|
||||
* @param {Number} inLow - Input range minimum
|
||||
* @param {Number} inHigh - Input range maximum
|
||||
* @param {Number} outLow - Output range minimum
|
||||
* @param {Number} outHigh - Output range maximum
|
||||
* @return {Number}
|
||||
*/
|
||||
const mapRange = (value, inLow, inHigh, outLow, outHigh) => outLow + ((value - inLow) / (inHigh - inLow)) * (outHigh - outLow);
|
||||
|
||||
/**
|
||||
* Converts degrees to radians
|
||||
* @param {Number} degrees - Angle in degrees
|
||||
* @return {Number}
|
||||
*/
|
||||
const degToRad = degrees => degrees * Math.PI / 180;
|
||||
|
||||
/**
|
||||
* Converts radians to degrees
|
||||
* @param {Number} radians - Angle in radians
|
||||
* @return {Number}
|
||||
*/
|
||||
const radToDeg = radians => radians * 180 / Math.PI;
|
||||
|
||||
/**
|
||||
* Frame rate independent damped lerp
|
||||
* Based on: https://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
|
||||
*
|
||||
* @param {Number} start - Starting value
|
||||
* @param {Number} end - Target value
|
||||
* @param {Number} deltaTime - Delta time in ms
|
||||
* @param {Number} factor - Interpolation factor in the range [0, 1]
|
||||
* @return {Number} The interpolated value
|
||||
*/
|
||||
const damp = (start, end, deltaTime, factor) => {
|
||||
return !factor ? start : factor === 1 ? end : helpers.lerp(start, end, 1 - Math.exp(-factor * deltaTime * .1));
|
||||
};
|
||||
|
||||
exports.clamp = helpers.clamp;
|
||||
exports.lerp = helpers.lerp;
|
||||
exports.round = helpers.round;
|
||||
exports.snap = helpers.snap;
|
||||
exports.damp = damp;
|
||||
exports.degToRad = degToRad;
|
||||
exports.mapRange = mapRange;
|
||||
exports.padEnd = padEnd;
|
||||
exports.padStart = padStart;
|
||||
exports.radToDeg = radToDeg;
|
||||
exports.roundPad = roundPad;
|
||||
exports.wrap = wrap;
|
||||
@@ -0,0 +1,9 @@
|
||||
export function roundPad(v: number | string, decimalLength: number): string;
|
||||
export function padStart(v: number, totalLength: number, padString: string): string;
|
||||
export function padEnd(v: number, totalLength: number, padString: string): string;
|
||||
export function wrap(v: number, min: number, max: number): number;
|
||||
export function mapRange(value: number, inLow: number, inHigh: number, outLow: number, outHigh: number): number;
|
||||
export function degToRad(degrees: number): number;
|
||||
export function radToDeg(radians: number): number;
|
||||
export function damp(start: number, end: number, deltaTime: number, factor: number): number;
|
||||
export { snap, clamp, round, lerp } from "../core/helpers.js";
|
||||
@@ -0,0 +1,85 @@
|
||||
/**
|
||||
* Anime.js - utils - ESM
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
import { lerp } from '../core/helpers.js';
|
||||
export { clamp, round, snap } from '../core/helpers.js';
|
||||
|
||||
/**
|
||||
* Rounds a number to fixed decimal places
|
||||
* @param {Number|String} v - Value to round
|
||||
* @param {Number} decimalLength - Number of decimal places
|
||||
* @return {String}
|
||||
*/
|
||||
const roundPad = (v, decimalLength) => (+v).toFixed(decimalLength);
|
||||
|
||||
/**
|
||||
* Pads the start of a value with a string
|
||||
* @param {Number} v - Value to pad
|
||||
* @param {Number} totalLength - Target length
|
||||
* @param {String} padString - String to pad with
|
||||
* @return {String}
|
||||
*/
|
||||
const padStart = (v, totalLength, padString) => `${v}`.padStart(totalLength, padString);
|
||||
|
||||
/**
|
||||
* Pads the end of a value with a string
|
||||
* @param {Number} v - Value to pad
|
||||
* @param {Number} totalLength - Target length
|
||||
* @param {String} padString - String to pad with
|
||||
* @return {String}
|
||||
*/
|
||||
const padEnd = (v, totalLength, padString) => `${v}`.padEnd(totalLength, padString);
|
||||
|
||||
/**
|
||||
* Wraps a value within a range
|
||||
* @param {Number} v - Value to wrap
|
||||
* @param {Number} min - Minimum boundary
|
||||
* @param {Number} max - Maximum boundary
|
||||
* @return {Number}
|
||||
*/
|
||||
const wrap = (v, min, max) => (((v - min) % (max - min) + (max - min)) % (max - min)) + min;
|
||||
|
||||
/**
|
||||
* Maps a value from one range to another
|
||||
* @param {Number} value - Input value
|
||||
* @param {Number} inLow - Input range minimum
|
||||
* @param {Number} inHigh - Input range maximum
|
||||
* @param {Number} outLow - Output range minimum
|
||||
* @param {Number} outHigh - Output range maximum
|
||||
* @return {Number}
|
||||
*/
|
||||
const mapRange = (value, inLow, inHigh, outLow, outHigh) => outLow + ((value - inLow) / (inHigh - inLow)) * (outHigh - outLow);
|
||||
|
||||
/**
|
||||
* Converts degrees to radians
|
||||
* @param {Number} degrees - Angle in degrees
|
||||
* @return {Number}
|
||||
*/
|
||||
const degToRad = degrees => degrees * Math.PI / 180;
|
||||
|
||||
/**
|
||||
* Converts radians to degrees
|
||||
* @param {Number} radians - Angle in radians
|
||||
* @return {Number}
|
||||
*/
|
||||
const radToDeg = radians => radians * 180 / Math.PI;
|
||||
|
||||
/**
|
||||
* Frame rate independent damped lerp
|
||||
* Based on: https://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
|
||||
*
|
||||
* @param {Number} start - Starting value
|
||||
* @param {Number} end - Target value
|
||||
* @param {Number} deltaTime - Delta time in ms
|
||||
* @param {Number} factor - Interpolation factor in the range [0, 1]
|
||||
* @return {Number} The interpolated value
|
||||
*/
|
||||
const damp = (start, end, deltaTime, factor) => {
|
||||
return !factor ? start : factor === 1 ? end : lerp(start, end, 1 - Math.exp(-factor * deltaTime * .1));
|
||||
};
|
||||
|
||||
export { damp, degToRad, lerp, mapRange, padEnd, padStart, radToDeg, roundPad, wrap };
|
||||
@@ -0,0 +1,78 @@
|
||||
/**
|
||||
* Anime.js - utils - CJS
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* Generate a random number between optional min and max (inclusive) and decimal precision
|
||||
*
|
||||
* @callback RandomNumberGenerator
|
||||
* @param {Number} [min=0] - The minimum value (inclusive)
|
||||
* @param {Number} [max=1] - The maximum value (inclusive)
|
||||
* @param {Number} [decimalLength=0] - Number of decimal places to round to
|
||||
* @return {Number} A random number between min and max
|
||||
*/
|
||||
|
||||
/**
|
||||
* Generates a random number between min and max (inclusive) with optional decimal precision
|
||||
*
|
||||
* @type {RandomNumberGenerator}
|
||||
*/
|
||||
const random = (min = 0, max = 1, decimalLength = 0) => {
|
||||
const m = 10 ** decimalLength;
|
||||
return Math.floor((Math.random() * (max - min + (1 / m)) + min) * m) / m;
|
||||
};
|
||||
|
||||
let _seed = 0;
|
||||
|
||||
/**
|
||||
* Creates a seeded pseudorandom number generator function
|
||||
*
|
||||
* @param {Number} [seed] - The seed value for the random number generator
|
||||
* @param {Number} [seededMin=0] - The minimum default value (inclusive) of the returned function
|
||||
* @param {Number} [seededMax=1] - The maximum default value (inclusive) of the returned function
|
||||
* @param {Number} [seededDecimalLength=0] - Default number of decimal places to round to of the returned function
|
||||
* @return {RandomNumberGenerator} A function to generate a random number between optional min and max (inclusive) and decimal precision
|
||||
*/
|
||||
const createSeededRandom = (seed, seededMin = 0, seededMax = 1, seededDecimalLength = 0) => {
|
||||
let t = seed === undefined ? _seed++ : seed;
|
||||
return (min = seededMin, max = seededMax, decimalLength = seededDecimalLength) => {
|
||||
t += 0x6D2B79F5;
|
||||
t = Math.imul(t ^ t >>> 15, t | 1);
|
||||
t ^= t + Math.imul(t ^ t >>> 7, t | 61);
|
||||
const m = 10 ** decimalLength;
|
||||
return Math.floor(((((t ^ t >>> 14) >>> 0) / 4294967296) * (max - min + (1 / m)) + min) * m) / m;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Picks a random element from an array or a string
|
||||
*
|
||||
* @template T
|
||||
* @param {String|Array<T>} items - The array or string to pick from
|
||||
* @return {String|T} A random element from the array or character from the string
|
||||
*/
|
||||
const randomPick = items => items[random(0, items.length - 1)];
|
||||
|
||||
/**
|
||||
* Shuffles an array in-place using the Fisher-Yates algorithm
|
||||
* Adapted from https://bost.ocks.org/mike/shuffle/
|
||||
*
|
||||
* @param {Array} items - The array to shuffle (will be modified in-place)
|
||||
* @param {RandomNumberGenerator} [rnd] - Optional RNG matching the random() signature (defaults to random)
|
||||
* @return {Array} The same array reference, now shuffled
|
||||
*/
|
||||
const shuffle = (items, rnd = random) => {
|
||||
let m = items.length, t, i;
|
||||
while (m) { i = rnd(0, --m); t = items[m]; items[m] = items[i]; items[i] = t; }
|
||||
return items;
|
||||
};
|
||||
|
||||
exports.createSeededRandom = createSeededRandom;
|
||||
exports.random = random;
|
||||
exports.randomPick = randomPick;
|
||||
exports.shuffle = shuffle;
|
||||
@@ -0,0 +1,22 @@
|
||||
/**
|
||||
* Generate a random number between optional min and max (inclusive) and decimal precision
|
||||
*
|
||||
* @callback RandomNumberGenerator
|
||||
* @param {Number} [min=0] - The minimum value (inclusive)
|
||||
* @param {Number} [max=1] - The maximum value (inclusive)
|
||||
* @param {Number} [decimalLength=0] - Number of decimal places to round to
|
||||
* @return {Number} A random number between min and max
|
||||
*/
|
||||
/**
|
||||
* Generates a random number between min and max (inclusive) with optional decimal precision
|
||||
*
|
||||
* @type {RandomNumberGenerator}
|
||||
*/
|
||||
export const random: RandomNumberGenerator;
|
||||
export function createSeededRandom(seed?: number, seededMin?: number, seededMax?: number, seededDecimalLength?: number): RandomNumberGenerator;
|
||||
export function randomPick<T>(items: string | Array<T>): string | T;
|
||||
export function shuffle(items: any[], rnd?: RandomNumberGenerator): any[];
|
||||
/**
|
||||
* Generate a random number between optional min and max (inclusive) and decimal precision
|
||||
*/
|
||||
export type RandomNumberGenerator = (min?: number, max?: number, decimalLength?: number) => number;
|
||||
@@ -0,0 +1,73 @@
|
||||
/**
|
||||
* Anime.js - utils - ESM
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
/**
|
||||
* Generate a random number between optional min and max (inclusive) and decimal precision
|
||||
*
|
||||
* @callback RandomNumberGenerator
|
||||
* @param {Number} [min=0] - The minimum value (inclusive)
|
||||
* @param {Number} [max=1] - The maximum value (inclusive)
|
||||
* @param {Number} [decimalLength=0] - Number of decimal places to round to
|
||||
* @return {Number} A random number between min and max
|
||||
*/
|
||||
|
||||
/**
|
||||
* Generates a random number between min and max (inclusive) with optional decimal precision
|
||||
*
|
||||
* @type {RandomNumberGenerator}
|
||||
*/
|
||||
const random = (min = 0, max = 1, decimalLength = 0) => {
|
||||
const m = 10 ** decimalLength;
|
||||
return Math.floor((Math.random() * (max - min + (1 / m)) + min) * m) / m;
|
||||
};
|
||||
|
||||
let _seed = 0;
|
||||
|
||||
/**
|
||||
* Creates a seeded pseudorandom number generator function
|
||||
*
|
||||
* @param {Number} [seed] - The seed value for the random number generator
|
||||
* @param {Number} [seededMin=0] - The minimum default value (inclusive) of the returned function
|
||||
* @param {Number} [seededMax=1] - The maximum default value (inclusive) of the returned function
|
||||
* @param {Number} [seededDecimalLength=0] - Default number of decimal places to round to of the returned function
|
||||
* @return {RandomNumberGenerator} A function to generate a random number between optional min and max (inclusive) and decimal precision
|
||||
*/
|
||||
const createSeededRandom = (seed, seededMin = 0, seededMax = 1, seededDecimalLength = 0) => {
|
||||
let t = seed === undefined ? _seed++ : seed;
|
||||
return (min = seededMin, max = seededMax, decimalLength = seededDecimalLength) => {
|
||||
t += 0x6D2B79F5;
|
||||
t = Math.imul(t ^ t >>> 15, t | 1);
|
||||
t ^= t + Math.imul(t ^ t >>> 7, t | 61);
|
||||
const m = 10 ** decimalLength;
|
||||
return Math.floor(((((t ^ t >>> 14) >>> 0) / 4294967296) * (max - min + (1 / m)) + min) * m) / m;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Picks a random element from an array or a string
|
||||
*
|
||||
* @template T
|
||||
* @param {String|Array<T>} items - The array or string to pick from
|
||||
* @return {String|T} A random element from the array or character from the string
|
||||
*/
|
||||
const randomPick = items => items[random(0, items.length - 1)];
|
||||
|
||||
/**
|
||||
* Shuffles an array in-place using the Fisher-Yates algorithm
|
||||
* Adapted from https://bost.ocks.org/mike/shuffle/
|
||||
*
|
||||
* @param {Array} items - The array to shuffle (will be modified in-place)
|
||||
* @param {RandomNumberGenerator} [rnd] - Optional RNG matching the random() signature (defaults to random)
|
||||
* @return {Array} The same array reference, now shuffled
|
||||
*/
|
||||
const shuffle = (items, rnd = random) => {
|
||||
let m = items.length, t, i;
|
||||
while (m) { i = rnd(0, --m); t = items[m]; items[m] = items[i]; items[i] = t; }
|
||||
return items;
|
||||
};
|
||||
|
||||
export { createSeededRandom, random, randomPick, shuffle };
|
||||
@@ -0,0 +1,273 @@
|
||||
/**
|
||||
* Anime.js - utils - CJS
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
var consts = require('../core/consts.cjs');
|
||||
var helpers = require('../core/helpers.cjs');
|
||||
var parser = require('../easings/eases/parser.cjs');
|
||||
var position = require('../timeline/position.cjs');
|
||||
var values = require('../core/values.cjs');
|
||||
var targets = require('../core/targets.cjs');
|
||||
var random = require('./random.cjs');
|
||||
|
||||
/**
|
||||
* @import {
|
||||
* StaggerParams,
|
||||
* StaggerFunction,
|
||||
* JSTarget,
|
||||
* } from '../types/index.js'
|
||||
*/
|
||||
|
||||
/**
|
||||
* @import {
|
||||
* Spring,
|
||||
* } from '../easings/spring/index.js'
|
||||
*/
|
||||
|
||||
/**
|
||||
* @overload
|
||||
* @param {Number} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<Number>}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @overload
|
||||
* @param {String} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<String>}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @overload
|
||||
* @param {[Number, Number]} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<Number>}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @overload
|
||||
* @param {[String, String]} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<String>}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @param {Number|String|[Number, Number]|[String, String]} val The staggered value or range
|
||||
* @param {StaggerParams} [params] The stagger parameters
|
||||
* @return {StaggerFunction<Number|String>}
|
||||
*/
|
||||
const stagger = (val, params = {}) => {
|
||||
let values$1 = [];
|
||||
let maxValue = 0;
|
||||
let cachedOffset;
|
||||
let jitterSamples = null;
|
||||
const from = params.from;
|
||||
const reversed = params.reversed;
|
||||
const ease = params.ease;
|
||||
const hasEasing = !helpers.isUnd(ease);
|
||||
const hasSpring = hasEasing && !helpers.isUnd(/** @type {Spring} */(ease).ease);
|
||||
const staggerEase = hasSpring ? /** @type {Spring} */(ease).ease : hasEasing ? parser.parseEase(ease) : null;
|
||||
const grid = params.grid;
|
||||
const autoGrid = grid === true;
|
||||
const axis = params.axis;
|
||||
const customTotal = params.total;
|
||||
const fromFirst = helpers.isUnd(from) || from === 0 || from === 'first';
|
||||
const fromCenter = from === 'center';
|
||||
const fromLast = from === 'last';
|
||||
const fromRandom = from === 'random';
|
||||
const fromArr = helpers.isArr(from);
|
||||
const isRange = helpers.isArr(val);
|
||||
const useProp = params.use;
|
||||
const val1 = isRange ? helpers.parseNumber(val[0]) : helpers.parseNumber(val);
|
||||
const val2 = isRange ? helpers.parseNumber(val[1]) : 0;
|
||||
const unitMatch = consts.unitsExecRgx.exec((isRange ? val[1] : val) + consts.emptyString);
|
||||
const start = params.start || 0 + (isRange ? val1 : 0);
|
||||
const seed = params.seed;
|
||||
const hasSeed = !helpers.isUnd(seed) && seed !== false;
|
||||
const rng = hasSeed ? random.createSeededRandom(seed === true ? 0 : /** @type {Number} */(seed)) : random.random;
|
||||
const jitter = params.jitter;
|
||||
const hasJitter = !helpers.isUnd(jitter);
|
||||
const jitterIsArr = helpers.isArr(jitter);
|
||||
const jitterStart = jitterIsArr ? /** @type {[Number,Number]} */(jitter)[0] : /** @type {Number} */(jitter) || 0;
|
||||
const jitterEnd = jitterIsArr ? /** @type {[Number,Number]} */(jitter)[1] : /** @type {Number} */(jitter) || 0;
|
||||
let fromIndex = fromFirst ? 0 : helpers.isNum(from) ? from : 0;
|
||||
return (target, i, t, _, tl) => {
|
||||
const [ registeredTarget ] = targets.registerTargets(target);
|
||||
const total = helpers.isUnd(customTotal) ? t.length : customTotal;
|
||||
const customIndex = !helpers.isUnd(useProp) ? helpers.isFnc(useProp) ? useProp(registeredTarget, i, total) : values.getOriginalAnimatableValue(registeredTarget, useProp) : false;
|
||||
const customIdx = helpers.isNum(customIndex) || helpers.isStr(customIndex) && helpers.isNum(+customIndex) ? +customIndex : i;
|
||||
// Fall back to the natural index when the resolved value lands outside [0, total) so values[staggerIndex] never reads undefined.
|
||||
const staggerIndex = customIdx >= 0 && customIdx < total ? customIdx : i;
|
||||
if (fromCenter) fromIndex = (total - 1) / 2;
|
||||
if (fromLast) fromIndex = total - 1;
|
||||
if (!values$1.length) {
|
||||
if (autoGrid) {
|
||||
let hasPositions = true;
|
||||
let has3D = false;
|
||||
let minPosX = Infinity;
|
||||
let minPosY = Infinity;
|
||||
let minPosZ = Infinity;
|
||||
let maxPosX = -Infinity;
|
||||
let maxPosY = -Infinity;
|
||||
let maxPosZ = -Infinity;
|
||||
const pxArr = [];
|
||||
const pyArr = [];
|
||||
const pzArr = [];
|
||||
for (let index = 0; index < total; index++) {
|
||||
const el = t[index];
|
||||
let px = 0;
|
||||
let py = 0;
|
||||
let pz = 0;
|
||||
let found = false;
|
||||
if (el && helpers.isFnc(el.getBoundingClientRect)) {
|
||||
const rect = el.getBoundingClientRect();
|
||||
px = rect.left + rect.width / 2;
|
||||
py = rect.top + rect.height / 2;
|
||||
found = true;
|
||||
} else {
|
||||
const obj = /** @type {JSTarget} */(el);
|
||||
if (obj && helpers.isNum(obj.x) && helpers.isNum(obj.y)) {
|
||||
px = obj.x;
|
||||
py = obj.y;
|
||||
if (helpers.isNum(obj.z)) {
|
||||
pz = obj.z;
|
||||
has3D = true;
|
||||
}
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
hasPositions = false;
|
||||
break;
|
||||
}
|
||||
pxArr.push(px);
|
||||
pyArr.push(py);
|
||||
pzArr.push(pz);
|
||||
if (px < minPosX) minPosX = px;
|
||||
if (py < minPosY) minPosY = py;
|
||||
if (pz < minPosZ) minPosZ = pz;
|
||||
if (px > maxPosX) maxPosX = px;
|
||||
if (py > maxPosY) maxPosY = py;
|
||||
if (pz > maxPosZ) maxPosZ = pz;
|
||||
}
|
||||
if (hasPositions) {
|
||||
let fX = pxArr[0];
|
||||
let fY = pyArr[0];
|
||||
let fZ = pzArr[0];
|
||||
if (fromArr) {
|
||||
fX = minPosX + from[0] * (maxPosX - minPosX);
|
||||
fY = minPosY + from[1] * (maxPosY - minPosY);
|
||||
fZ = has3D ? minPosZ + (from.length >= 3 ? from[2] : 0.5) * (maxPosZ - minPosZ) : 0;
|
||||
} else if (fromCenter) {
|
||||
fX = (minPosX + maxPosX) / 2;
|
||||
fY = (minPosY + maxPosY) / 2;
|
||||
fZ = (minPosZ + maxPosZ) / 2;
|
||||
} else if (fromLast) {
|
||||
fX = pxArr[total - 1];
|
||||
fY = pyArr[total - 1];
|
||||
fZ = pzArr[total - 1];
|
||||
} else if (helpers.isNum(from)) {
|
||||
fX = pxArr[from];
|
||||
fY = pyArr[from];
|
||||
fZ = pzArr[from];
|
||||
}
|
||||
for (let index = 0; index < total; index++) {
|
||||
const distanceX = fX - pxArr[index];
|
||||
const distanceY = fY - pyArr[index];
|
||||
const distanceZ = fZ - pzArr[index];
|
||||
let value = helpers.sqrt(distanceX * distanceX + distanceY * distanceY + (has3D ? distanceZ * distanceZ : 0));
|
||||
if (axis === 'x') value = -distanceX;
|
||||
if (axis === 'y') value = -distanceY;
|
||||
if (axis === 'z') value = -distanceZ;
|
||||
values$1.push(value);
|
||||
}
|
||||
let minDist = Infinity;
|
||||
for (let index = 0; index < total; index++) {
|
||||
const absVal = helpers.abs(values$1[index]);
|
||||
if (absVal > 0 && absVal < minDist) minDist = absVal;
|
||||
}
|
||||
if (minDist > 0 && minDist < Infinity) {
|
||||
for (let index = 0; index < total; index++) {
|
||||
values$1[index] = values$1[index] / minDist;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (let index = 0; index < total; index++) {
|
||||
values$1.push(helpers.abs(fromIndex - index));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (let index = 0; index < total; index++) {
|
||||
if (!grid) {
|
||||
values$1.push(helpers.abs(fromIndex - index));
|
||||
} else {
|
||||
const dims = grid.length;
|
||||
const wh = grid[0] * grid[1];
|
||||
let fromX, fromY, fromZ;
|
||||
if (fromArr) {
|
||||
fromX = from[0] * (grid[0] - 1);
|
||||
fromY = from[1] * (grid[1] - 1);
|
||||
fromZ = dims === 3 ? (from.length >= 3 ? from[2] : 0.5) * (grid[2] - 1) : 0;
|
||||
} else if (fromCenter) {
|
||||
fromX = (grid[0] - 1) / 2;
|
||||
fromY = (grid[1] - 1) / 2;
|
||||
fromZ = dims === 3 ? (grid[2] - 1) / 2 : 0;
|
||||
} else {
|
||||
fromX = fromIndex % grid[0];
|
||||
fromY = helpers.floor(fromIndex / grid[0]) % grid[1];
|
||||
fromZ = dims === 3 ? helpers.floor(fromIndex / wh) : 0;
|
||||
}
|
||||
const toX = index % grid[0];
|
||||
const toY = helpers.floor(index / grid[0]) % grid[1];
|
||||
const toZ = dims === 3 ? helpers.floor(index / wh) : 0;
|
||||
const distanceX = fromX - toX;
|
||||
const distanceY = fromY - toY;
|
||||
const distanceZ = fromZ - toZ;
|
||||
let value = helpers.sqrt(distanceX * distanceX + distanceY * distanceY + (dims === 3 ? distanceZ * distanceZ : 0));
|
||||
if (axis === 'x') value = -distanceX;
|
||||
if (axis === 'y') value = -distanceY;
|
||||
if (axis === 'z') value = -distanceZ;
|
||||
values$1.push(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
maxValue = values$1[0];
|
||||
for (let k = 1; k < total; k++) if (values$1[k] > maxValue) maxValue = values$1[k];
|
||||
if (staggerEase || reversed) {
|
||||
for (let k = 0; k < total; k++) {
|
||||
let v = values$1[k];
|
||||
if (staggerEase) v = staggerEase(v / maxValue) * maxValue;
|
||||
if (reversed) v = axis ? -v : helpers.abs(maxValue - v);
|
||||
values$1[k] = v;
|
||||
}
|
||||
}
|
||||
if (hasJitter) {
|
||||
jitterSamples = new Array(total);
|
||||
for (let k = 0; k < total; k++) jitterSamples[k] = rng(-1, 1, 4);
|
||||
}
|
||||
if (fromRandom) values$1 = random.shuffle(values$1, rng);
|
||||
}
|
||||
const spacing = isRange ? (val2 - val1) / maxValue : val1;
|
||||
if (helpers.isUnd(cachedOffset)) {
|
||||
cachedOffset = tl ? position.parseTimelinePosition(tl, helpers.isUnd(params.start) ? tl.iterationDuration : start) : /** @type {Number} */(start);
|
||||
}
|
||||
/** @type {String|Number} */
|
||||
let output = cachedOffset + ((spacing * helpers.round(values$1[staggerIndex], 2)) || 0);
|
||||
if (hasJitter) {
|
||||
const progress = maxValue ? values$1[staggerIndex] / maxValue : 0;
|
||||
const mag = jitterStart + (jitterEnd - jitterStart) * progress;
|
||||
output = /** @type {Number} */(output) + jitterSamples[staggerIndex] * mag;
|
||||
}
|
||||
if (params.modifier) output = params.modifier(/** @type {Number} */(output));
|
||||
if (unitMatch) output = `${output}${unitMatch[2]}`;
|
||||
return output;
|
||||
}
|
||||
};
|
||||
|
||||
exports.stagger = stagger;
|
||||
@@ -0,0 +1,30 @@
|
||||
/**
|
||||
* @overload
|
||||
* @param {Number} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<Number>}
|
||||
*/
|
||||
export function stagger(val: number, params?: StaggerParams): StaggerFunction<number>;
|
||||
/**
|
||||
* @overload
|
||||
* @param {String} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<String>}
|
||||
*/
|
||||
export function stagger(val: string, params?: StaggerParams): StaggerFunction<string>;
|
||||
/**
|
||||
* @overload
|
||||
* @param {[Number, Number]} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<Number>}
|
||||
*/
|
||||
export function stagger(val: [number, number], params?: StaggerParams): StaggerFunction<number>;
|
||||
/**
|
||||
* @overload
|
||||
* @param {[String, String]} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<String>}
|
||||
*/
|
||||
export function stagger(val: [string, string], params?: StaggerParams): StaggerFunction<string>;
|
||||
import type { StaggerParams } from '../types/index.js';
|
||||
import type { StaggerFunction } from '../types/index.js';
|
||||
@@ -0,0 +1,271 @@
|
||||
/**
|
||||
* Anime.js - utils - ESM
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
import { unitsExecRgx, emptyString } from '../core/consts.js';
|
||||
import { isUnd, parseNumber, isFnc, isNum, sqrt, abs, floor, round, isArr, isStr } from '../core/helpers.js';
|
||||
import { parseEase } from '../easings/eases/parser.js';
|
||||
import { parseTimelinePosition } from '../timeline/position.js';
|
||||
import { getOriginalAnimatableValue } from '../core/values.js';
|
||||
import { registerTargets } from '../core/targets.js';
|
||||
import { createSeededRandom, random, shuffle } from './random.js';
|
||||
|
||||
/**
|
||||
* @import {
|
||||
* StaggerParams,
|
||||
* StaggerFunction,
|
||||
* JSTarget,
|
||||
* } from '../types/index.js'
|
||||
*/
|
||||
|
||||
/**
|
||||
* @import {
|
||||
* Spring,
|
||||
* } from '../easings/spring/index.js'
|
||||
*/
|
||||
|
||||
/**
|
||||
* @overload
|
||||
* @param {Number} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<Number>}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @overload
|
||||
* @param {String} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<String>}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @overload
|
||||
* @param {[Number, Number]} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<Number>}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @overload
|
||||
* @param {[String, String]} val
|
||||
* @param {StaggerParams} [params]
|
||||
* @return {StaggerFunction<String>}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @param {Number|String|[Number, Number]|[String, String]} val The staggered value or range
|
||||
* @param {StaggerParams} [params] The stagger parameters
|
||||
* @return {StaggerFunction<Number|String>}
|
||||
*/
|
||||
const stagger = (val, params = {}) => {
|
||||
let values = [];
|
||||
let maxValue = 0;
|
||||
let cachedOffset;
|
||||
let jitterSamples = null;
|
||||
const from = params.from;
|
||||
const reversed = params.reversed;
|
||||
const ease = params.ease;
|
||||
const hasEasing = !isUnd(ease);
|
||||
const hasSpring = hasEasing && !isUnd(/** @type {Spring} */(ease).ease);
|
||||
const staggerEase = hasSpring ? /** @type {Spring} */(ease).ease : hasEasing ? parseEase(ease) : null;
|
||||
const grid = params.grid;
|
||||
const autoGrid = grid === true;
|
||||
const axis = params.axis;
|
||||
const customTotal = params.total;
|
||||
const fromFirst = isUnd(from) || from === 0 || from === 'first';
|
||||
const fromCenter = from === 'center';
|
||||
const fromLast = from === 'last';
|
||||
const fromRandom = from === 'random';
|
||||
const fromArr = isArr(from);
|
||||
const isRange = isArr(val);
|
||||
const useProp = params.use;
|
||||
const val1 = isRange ? parseNumber(val[0]) : parseNumber(val);
|
||||
const val2 = isRange ? parseNumber(val[1]) : 0;
|
||||
const unitMatch = unitsExecRgx.exec((isRange ? val[1] : val) + emptyString);
|
||||
const start = params.start || 0 + (isRange ? val1 : 0);
|
||||
const seed = params.seed;
|
||||
const hasSeed = !isUnd(seed) && seed !== false;
|
||||
const rng = hasSeed ? createSeededRandom(seed === true ? 0 : /** @type {Number} */(seed)) : random;
|
||||
const jitter = params.jitter;
|
||||
const hasJitter = !isUnd(jitter);
|
||||
const jitterIsArr = isArr(jitter);
|
||||
const jitterStart = jitterIsArr ? /** @type {[Number,Number]} */(jitter)[0] : /** @type {Number} */(jitter) || 0;
|
||||
const jitterEnd = jitterIsArr ? /** @type {[Number,Number]} */(jitter)[1] : /** @type {Number} */(jitter) || 0;
|
||||
let fromIndex = fromFirst ? 0 : isNum(from) ? from : 0;
|
||||
return (target, i, t, _, tl) => {
|
||||
const [ registeredTarget ] = registerTargets(target);
|
||||
const total = isUnd(customTotal) ? t.length : customTotal;
|
||||
const customIndex = !isUnd(useProp) ? isFnc(useProp) ? useProp(registeredTarget, i, total) : getOriginalAnimatableValue(registeredTarget, useProp) : false;
|
||||
const customIdx = isNum(customIndex) || isStr(customIndex) && isNum(+customIndex) ? +customIndex : i;
|
||||
// Fall back to the natural index when the resolved value lands outside [0, total) so values[staggerIndex] never reads undefined.
|
||||
const staggerIndex = customIdx >= 0 && customIdx < total ? customIdx : i;
|
||||
if (fromCenter) fromIndex = (total - 1) / 2;
|
||||
if (fromLast) fromIndex = total - 1;
|
||||
if (!values.length) {
|
||||
if (autoGrid) {
|
||||
let hasPositions = true;
|
||||
let has3D = false;
|
||||
let minPosX = Infinity;
|
||||
let minPosY = Infinity;
|
||||
let minPosZ = Infinity;
|
||||
let maxPosX = -Infinity;
|
||||
let maxPosY = -Infinity;
|
||||
let maxPosZ = -Infinity;
|
||||
const pxArr = [];
|
||||
const pyArr = [];
|
||||
const pzArr = [];
|
||||
for (let index = 0; index < total; index++) {
|
||||
const el = t[index];
|
||||
let px = 0;
|
||||
let py = 0;
|
||||
let pz = 0;
|
||||
let found = false;
|
||||
if (el && isFnc(el.getBoundingClientRect)) {
|
||||
const rect = el.getBoundingClientRect();
|
||||
px = rect.left + rect.width / 2;
|
||||
py = rect.top + rect.height / 2;
|
||||
found = true;
|
||||
} else {
|
||||
const obj = /** @type {JSTarget} */(el);
|
||||
if (obj && isNum(obj.x) && isNum(obj.y)) {
|
||||
px = obj.x;
|
||||
py = obj.y;
|
||||
if (isNum(obj.z)) {
|
||||
pz = obj.z;
|
||||
has3D = true;
|
||||
}
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
hasPositions = false;
|
||||
break;
|
||||
}
|
||||
pxArr.push(px);
|
||||
pyArr.push(py);
|
||||
pzArr.push(pz);
|
||||
if (px < minPosX) minPosX = px;
|
||||
if (py < minPosY) minPosY = py;
|
||||
if (pz < minPosZ) minPosZ = pz;
|
||||
if (px > maxPosX) maxPosX = px;
|
||||
if (py > maxPosY) maxPosY = py;
|
||||
if (pz > maxPosZ) maxPosZ = pz;
|
||||
}
|
||||
if (hasPositions) {
|
||||
let fX = pxArr[0];
|
||||
let fY = pyArr[0];
|
||||
let fZ = pzArr[0];
|
||||
if (fromArr) {
|
||||
fX = minPosX + from[0] * (maxPosX - minPosX);
|
||||
fY = minPosY + from[1] * (maxPosY - minPosY);
|
||||
fZ = has3D ? minPosZ + (from.length >= 3 ? from[2] : 0.5) * (maxPosZ - minPosZ) : 0;
|
||||
} else if (fromCenter) {
|
||||
fX = (minPosX + maxPosX) / 2;
|
||||
fY = (minPosY + maxPosY) / 2;
|
||||
fZ = (minPosZ + maxPosZ) / 2;
|
||||
} else if (fromLast) {
|
||||
fX = pxArr[total - 1];
|
||||
fY = pyArr[total - 1];
|
||||
fZ = pzArr[total - 1];
|
||||
} else if (isNum(from)) {
|
||||
fX = pxArr[from];
|
||||
fY = pyArr[from];
|
||||
fZ = pzArr[from];
|
||||
}
|
||||
for (let index = 0; index < total; index++) {
|
||||
const distanceX = fX - pxArr[index];
|
||||
const distanceY = fY - pyArr[index];
|
||||
const distanceZ = fZ - pzArr[index];
|
||||
let value = sqrt(distanceX * distanceX + distanceY * distanceY + (has3D ? distanceZ * distanceZ : 0));
|
||||
if (axis === 'x') value = -distanceX;
|
||||
if (axis === 'y') value = -distanceY;
|
||||
if (axis === 'z') value = -distanceZ;
|
||||
values.push(value);
|
||||
}
|
||||
let minDist = Infinity;
|
||||
for (let index = 0; index < total; index++) {
|
||||
const absVal = abs(values[index]);
|
||||
if (absVal > 0 && absVal < minDist) minDist = absVal;
|
||||
}
|
||||
if (minDist > 0 && minDist < Infinity) {
|
||||
for (let index = 0; index < total; index++) {
|
||||
values[index] = values[index] / minDist;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (let index = 0; index < total; index++) {
|
||||
values.push(abs(fromIndex - index));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (let index = 0; index < total; index++) {
|
||||
if (!grid) {
|
||||
values.push(abs(fromIndex - index));
|
||||
} else {
|
||||
const dims = grid.length;
|
||||
const wh = grid[0] * grid[1];
|
||||
let fromX, fromY, fromZ;
|
||||
if (fromArr) {
|
||||
fromX = from[0] * (grid[0] - 1);
|
||||
fromY = from[1] * (grid[1] - 1);
|
||||
fromZ = dims === 3 ? (from.length >= 3 ? from[2] : 0.5) * (grid[2] - 1) : 0;
|
||||
} else if (fromCenter) {
|
||||
fromX = (grid[0] - 1) / 2;
|
||||
fromY = (grid[1] - 1) / 2;
|
||||
fromZ = dims === 3 ? (grid[2] - 1) / 2 : 0;
|
||||
} else {
|
||||
fromX = fromIndex % grid[0];
|
||||
fromY = floor(fromIndex / grid[0]) % grid[1];
|
||||
fromZ = dims === 3 ? floor(fromIndex / wh) : 0;
|
||||
}
|
||||
const toX = index % grid[0];
|
||||
const toY = floor(index / grid[0]) % grid[1];
|
||||
const toZ = dims === 3 ? floor(index / wh) : 0;
|
||||
const distanceX = fromX - toX;
|
||||
const distanceY = fromY - toY;
|
||||
const distanceZ = fromZ - toZ;
|
||||
let value = sqrt(distanceX * distanceX + distanceY * distanceY + (dims === 3 ? distanceZ * distanceZ : 0));
|
||||
if (axis === 'x') value = -distanceX;
|
||||
if (axis === 'y') value = -distanceY;
|
||||
if (axis === 'z') value = -distanceZ;
|
||||
values.push(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
maxValue = values[0];
|
||||
for (let k = 1; k < total; k++) if (values[k] > maxValue) maxValue = values[k];
|
||||
if (staggerEase || reversed) {
|
||||
for (let k = 0; k < total; k++) {
|
||||
let v = values[k];
|
||||
if (staggerEase) v = staggerEase(v / maxValue) * maxValue;
|
||||
if (reversed) v = axis ? -v : abs(maxValue - v);
|
||||
values[k] = v;
|
||||
}
|
||||
}
|
||||
if (hasJitter) {
|
||||
jitterSamples = new Array(total);
|
||||
for (let k = 0; k < total; k++) jitterSamples[k] = rng(-1, 1, 4);
|
||||
}
|
||||
if (fromRandom) values = shuffle(values, rng);
|
||||
}
|
||||
const spacing = isRange ? (val2 - val1) / maxValue : val1;
|
||||
if (isUnd(cachedOffset)) {
|
||||
cachedOffset = tl ? parseTimelinePosition(tl, isUnd(params.start) ? tl.iterationDuration : start) : /** @type {Number} */(start);
|
||||
}
|
||||
/** @type {String|Number} */
|
||||
let output = cachedOffset + ((spacing * round(values[staggerIndex], 2)) || 0);
|
||||
if (hasJitter) {
|
||||
const progress = maxValue ? values[staggerIndex] / maxValue : 0;
|
||||
const mag = jitterStart + (jitterEnd - jitterStart) * progress;
|
||||
output = /** @type {Number} */(output) + jitterSamples[staggerIndex] * mag;
|
||||
}
|
||||
if (params.modifier) output = params.modifier(/** @type {Number} */(output));
|
||||
if (unitMatch) output = `${output}${unitMatch[2]}`;
|
||||
return output;
|
||||
}
|
||||
};
|
||||
|
||||
export { stagger };
|
||||
@@ -0,0 +1,133 @@
|
||||
/**
|
||||
* Anime.js - utils - CJS
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - Julian Garnier
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
var globals = require('../core/globals.cjs');
|
||||
var consts = require('../core/consts.cjs');
|
||||
var helpers = require('../core/helpers.cjs');
|
||||
var targets = require('../core/targets.cjs');
|
||||
var styles = require('../core/styles.cjs');
|
||||
var values = require('../core/values.cjs');
|
||||
var units = require('../core/units.cjs');
|
||||
var composition = require('../waapi/composition.cjs');
|
||||
var composition$1 = require('../animation/composition.cjs');
|
||||
var animation = require('../animation/animation.cjs');
|
||||
|
||||
/**
|
||||
* @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$1 = targets.registerTargets(targetSelector);
|
||||
if (!targets$1.length) return;
|
||||
const [ target ] = targets$1;
|
||||
const tweenType = values.getTweenType(target, propName);
|
||||
const normalizePropName = styles.sanitizePropertyName(propName, target, tweenType);
|
||||
let originalValue = values.getOriginalAnimatableValue(target, normalizePropName);
|
||||
if (helpers.isUnd(unit)) {
|
||||
return originalValue;
|
||||
} else {
|
||||
values.decomposeRawValue(originalValue, values.decomposedOriginalValue);
|
||||
if (values.decomposedOriginalValue.t === consts.valueTypes.NUMBER || values.decomposedOriginalValue.t === consts.valueTypes.UNIT) {
|
||||
if (unit === false) {
|
||||
return values.decomposedOriginalValue.n;
|
||||
} else {
|
||||
const convertedValue = units.convertValueUnit(/** @type {DOMTarget} */(target), values.decomposedOriginalValue, /** @type {String} */(unit), false);
|
||||
return `${helpers.round(convertedValue.n, globals.globals.precision)}${convertedValue.u}`;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @param {TargetsParam} targets
|
||||
* @param {AnimationParams} parameters
|
||||
* @return {JSAnimation}
|
||||
*/
|
||||
const set = (targets, parameters) => {
|
||||
if (helpers.isUnd(parameters)) return;
|
||||
if (globals.globals.editor && globals.globals.editor.addSet) {
|
||||
return globals.globals.editor.addSet(targets, parameters);
|
||||
}
|
||||
parameters.duration = consts.minValue;
|
||||
// Do not overrides currently active tweens by default
|
||||
parameters.composition = values.setValue(parameters.composition, consts.compositionTypes.none);
|
||||
// Skip init() and force rendering by playing the animation
|
||||
return new animation.JSAnimation(targets, parameters, null, 0, true).resume();
|
||||
};
|
||||
|
||||
/**
|
||||
* @param {TargetsParam} targets
|
||||
* @param {Renderable|WAAPIAnimation} [renderable]
|
||||
* @param {String} [propertyName]
|
||||
* @return {TargetsArray}
|
||||
*/
|
||||
const remove = (targets$1, renderable, propertyName) => {
|
||||
const targetsArray = targets.parseTargets(targets$1);
|
||||
for (let i = 0, l = targetsArray.length; i < l; i++) {
|
||||
composition.removeWAAPIAnimation(
|
||||
/** @type {DOMTarget} */(targetsArray[i]),
|
||||
propertyName,
|
||||
renderable && /** @type {WAAPIAnimation} */(renderable).controlAnimation && /** @type {WAAPIAnimation} */(renderable),
|
||||
);
|
||||
}
|
||||
composition$1.removeTargetsFromRenderable(
|
||||
targetsArray,
|
||||
/** @type {Renderable} */(renderable),
|
||||
propertyName
|
||||
);
|
||||
return targetsArray;
|
||||
};
|
||||
|
||||
exports.$ = targets.registerTargets;
|
||||
exports.cleanInlineStyles = styles.cleanInlineStyles;
|
||||
exports.get = get;
|
||||
exports.remove = remove;
|
||||
exports.set = set;
|
||||
@@ -0,0 +1,126 @@
|
||||
/**
|
||||
* @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]
|
||||
*/
|
||||
export function get(targetSelector: DOMTargetSelector, propName: string): string;
|
||||
/**
|
||||
* @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]
|
||||
*/
|
||||
export function get(targetSelector: JSTargetsParam, propName: string): number | string;
|
||||
/**
|
||||
* @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]
|
||||
*/
|
||||
export function get(targetSelector: DOMTargetsParam, propName: string, unit: string): string;
|
||||
/**
|
||||
* @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]
|
||||
*/
|
||||
export function get(targetSelector: TargetsParam, propName: string, unit: boolean): number;
|
||||
export { registerTargets as $ };
|
||||
export function set(targets: TargetsParam, parameters: AnimationParams): JSAnimation;
|
||||
export function remove(targets: TargetsParam, renderable?: Renderable | WAAPIAnimation, propertyName?: string): TargetsArray;
|
||||
export { cleanInlineStyles } from "../core/styles.js";
|
||||
import type { DOMTargetSelector } from '../types/index.js';
|
||||
import type { JSTargetsParam } from '../types/index.js';
|
||||
import type { DOMTargetsParam } from '../types/index.js';
|
||||
import type { TargetsParam } from '../types/index.js';
|
||||
import { registerTargets } from '../core/targets.js';
|
||||
import type { AnimationParams } from '../types/index.js';
|
||||
import { JSAnimation } from '../animation/animation.js';
|
||||
import type { Renderable } from '../types/index.js';
|
||||
import type { WAAPIAnimation } from '../waapi/waapi.js';
|
||||
import type { TargetsArray } from '../types/index.js';
|
||||
@@ -0,0 +1,128 @@
|
||||
/**
|
||||
* Anime.js - utils - ESM
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - 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;
|
||||
if (globals.editor && globals.editor.addSet) {
|
||||
return globals.editor.addSet(targets, parameters);
|
||||
}
|
||||
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 };
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* Anime.js - utils - CJS
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - 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();
|
||||
};
|
||||
|
||||
/**
|
||||
* @template {Tickable | ((...args: any[]) => void) | void} T
|
||||
* @param {(...args: any[]) => T} constructor
|
||||
* @return {(...args: any[]) => T extends void ? () => void : T}
|
||||
*/
|
||||
const keepTime = constructor => {
|
||||
/** @type {Tickable} */
|
||||
let tracked;
|
||||
return /** @type {(...args: any[]) => T extends void ? () => void : T} */(/** @type {*} */((...args) => {
|
||||
let currentIteration, currentIterationProgress, reversed, alternate, startTime;
|
||||
if (tracked) {
|
||||
currentIteration = tracked.currentIteration;
|
||||
currentIterationProgress = tracked.iterationProgress;
|
||||
reversed = tracked.reversed;
|
||||
alternate = tracked._alternate;
|
||||
startTime = tracked._startTime;
|
||||
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;
|
||||
/** @type {Tickable} */(tracked)._startTime = startTime;
|
||||
}
|
||||
return cleanup || consts.noop;
|
||||
}));
|
||||
};
|
||||
|
||||
exports.keepTime = keepTime;
|
||||
exports.sync = sync;
|
||||
@@ -0,0 +1,5 @@
|
||||
export function sync(callback?: Callback<Timer>): Timer;
|
||||
export function keepTime<T extends Tickable | ((...args: any[]) => void) | void>(constructor: (...args: any[]) => T): (...args: any[]) => T extends void ? () => void : T;
|
||||
import { Timer } from '../timer/timer.js';
|
||||
import type { Callback } from '../types/index.js';
|
||||
import type { Tickable } from '../types/index.js';
|
||||
@@ -0,0 +1,57 @@
|
||||
/**
|
||||
* Anime.js - utils - ESM
|
||||
* @version v4.5.0
|
||||
* @license MIT
|
||||
* @copyright 2026 - 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();
|
||||
};
|
||||
|
||||
/**
|
||||
* @template {Tickable | ((...args: any[]) => void) | void} T
|
||||
* @param {(...args: any[]) => T} constructor
|
||||
* @return {(...args: any[]) => T extends void ? () => void : T}
|
||||
*/
|
||||
const keepTime = constructor => {
|
||||
/** @type {Tickable} */
|
||||
let tracked;
|
||||
return /** @type {(...args: any[]) => T extends void ? () => void : T} */(/** @type {*} */((...args) => {
|
||||
let currentIteration, currentIterationProgress, reversed, alternate, startTime;
|
||||
if (tracked) {
|
||||
currentIteration = tracked.currentIteration;
|
||||
currentIterationProgress = tracked.iterationProgress;
|
||||
reversed = tracked.reversed;
|
||||
alternate = tracked._alternate;
|
||||
startTime = tracked._startTime;
|
||||
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;
|
||||
/** @type {Tickable} */(tracked)._startTime = startTime;
|
||||
}
|
||||
return cleanup || noop;
|
||||
}));
|
||||
};
|
||||
|
||||
export { keepTime, sync };
|
||||
Reference in New Issue
Block a user