animejs 4.3.2 → 4.3.4

package/dist/bundles/anime.esm.js

@@ -1,6 +1,6 @@
 /**
  * Anime.js - ESM bundle
- * @version v4.3.2
+ * @version v4.3.4
  * @license MIT
  * @copyright 2026 - Julian Garnier
  */
@@ -205,7 +205,8 @@
  * @property {String} property
  * @property {Target} target
  * @property {String|Number} _value
- * @property {Function|null} _func
+ * @property {Function|null} _toFunc
+ * @property {Function|null} _fromFunc
  * @property {EasingFunction} _ease
  * @property {Array.<Number>} _fromNumbers
  * @property {Array.<Number>} _toNumbers
@@ -536,6 +537,7 @@
  * @property {Callback<ScrollObserver>} [onEnterBackward]
  * @property {Callback<ScrollObserver>} [onLeaveBackward]
  * @property {Callback<ScrollObserver>} [onUpdate]
+ * @property {Callback<ScrollObserver>} [onResize]
  * @property {Callback<ScrollObserver>} [onSyncComplete]
  */
 
@@ -801,7 +803,7 @@ const globals = {
 
 const devTools = isBrowser && win.AnimeJSDevTools;
 
-const globalVersions = { version: '4.3.2', engine: null };
+const globalVersions = { version: '4.3.4', engine: null };
 
 if (isBrowser) {
   if (!win.AnimeJS) win.AnimeJS = [];
@@ -3271,6 +3273,7 @@ const fromTargetObject = createDecomposedValueTargetObject();
 const toTargetObject = createDecomposedValueTargetObject();
 const inlineStylesStore = {};
 const toFunctionStore = { func: null };
+const fromFunctionStore = { func: null };
 const keyframesTargetArray = [null];
 const fastSetValuesArray = [null, null];
 /** @type {TweenKeyValue} */
@@ -3512,6 +3515,7 @@ class JSAnimation extends Timer {
             }
 
             toFunctionStore.func = null;
+            fromFunctionStore.func = null;
 
             const computedToValue = getFunctionValue(key.to, target, ti, tl, toFunctionStore);
 
@@ -3572,7 +3576,7 @@ class JSAnimation extends Timer {
 
             // Decompose values
             if (isFromToValue) {
-              decomposeRawValue(isFromToArray ? getFunctionValue(tweenToValue[0], target, ti, tl) : tweenFromValue, fromTargetObject);
+              decomposeRawValue(isFromToArray ? getFunctionValue(tweenToValue[0], target, ti, tl, fromFunctionStore) : tweenFromValue, fromTargetObject);
               decomposeRawValue(isFromToArray ? getFunctionValue(tweenToValue[1], target, ti, tl, toFunctionStore) : tweenToValue, toTargetObject);
               // Needed to force an inline style registration
               const originalValue = getOriginalAnimatableValue(target, propName, tweenType, inlineStylesStore);
@@ -3689,7 +3693,8 @@ class JSAnimation extends Timer {
               property: propName,
               target: target,
               _value: null,
-              _func: toFunctionStore.func,
+              _toFunc: toFunctionStore.func,
+              _fromFunc: fromFunctionStore.func,
               _ease: parseEase(tweenEasing),
               _fromNumbers: cloneArray(fromTargetObject.d),
               _toNumbers: cloneArray(toTargetObject.d),
@@ -3847,18 +3852,29 @@ class JSAnimation extends Timer {
    */
   refresh() {
     forEachChildren(this, (/** @type {Tween} */tween) => {
-      const tweenFunc = tween._func;
-      if (tweenFunc) {
-        const ogValue = getOriginalAnimatableValue(tween.target, tween.property, tween._tweenType);
-        decomposeRawValue(ogValue, decomposedOriginalValue);
-        // TODO: Check for from / to Array based values here,
-        decomposeRawValue(tweenFunc(), toTargetObject);
-        tween._fromNumbers = cloneArray(decomposedOriginalValue.d);
-        tween._fromNumber = decomposedOriginalValue.n;
-        tween._toNumbers = cloneArray(toTargetObject.d);
-        tween._strings = cloneArray(toTargetObject.s);
-        // Make sure to apply relative operators https://github.com/juliangarnier/anime/issues/1025
-        tween._toNumber = toTargetObject.o ? getRelativeValue(decomposedOriginalValue.n, toTargetObject.n, toTargetObject.o) : toTargetObject.n;
+      const toFunc = tween._toFunc;
+      const fromFunc = tween._fromFunc;
+      if (toFunc || fromFunc) {
+        if (fromFunc) {
+          decomposeRawValue(fromFunc(), fromTargetObject);
+          if (fromTargetObject.u !== tween._unit && tween.target[isDomSymbol]) {
+            convertValueUnit(/** @type {DOMTarget} */(tween.target), fromTargetObject, tween._unit, true);
+          }
+          tween._fromNumbers = cloneArray(fromTargetObject.d);
+          tween._fromNumber = fromTargetObject.n;
+        } else if (toFunc) {
+          // When only toFunc exists, get from value from target
+          decomposeRawValue(getOriginalAnimatableValue(tween.target, tween.property, tween._tweenType), decomposedOriginalValue);
+          tween._fromNumbers = cloneArray(decomposedOriginalValue.d);
+          tween._fromNumber = decomposedOriginalValue.n;
+        }
+        if (toFunc) {
+          decomposeRawValue(toFunc(), toTargetObject);
+          tween._toNumbers = cloneArray(toTargetObject.d);
+          tween._strings = cloneArray(toTargetObject.s);
+          // Make sure to apply relative operators https://github.com/juliangarnier/anime/issues/1025
+          tween._toNumber = toTargetObject.o ? getRelativeValue(tween._fromNumber, toTargetObject.n, toTargetObject.o) : toTargetObject.n;
+        }
       }
     });
     // This forces setter animations to render once
@@ -4291,6 +4307,10 @@ class Timeline extends Timer {
     if (isUnd(synced) || synced && isUnd(synced.pause)) return this;
     synced.pause();
     const duration = +(/** @type {globalThis.Animation} */(synced).effect ? /** @type {globalThis.Animation} */(synced).effect.getTiming().duration : /** @type {Tickable} */(synced).duration);
+    // Forces WAAPI Animation to persist; otherwise, they will stop syncing on finish.
+    if (!isUnd(synced) && !isUnd(/** @type {WAAPIAnimation} */(synced).persist)) {
+      /** @type {WAAPIAnimation} */(synced).persist = true;
+    }
     return this.add(synced, { currentTime: [0, duration], duration, delay: 0, ease: 'linear', playbackEase: 'linear' }, position);
   }
 
@@ -4357,8 +4377,8 @@ class Timeline extends Timer {
    * @return {this}
    */
   refresh() {
-    forEachChildren(this, (/** @type {JSAnimation} */child) => {
-      if (child.refresh) child.refresh();
+    forEachChildren(this, (/** @type {JSAnimation|Timer} */child) => {
+      if (/** @type {JSAnimation} */(child).refresh) /** @type {JSAnimation} */(child).refresh();
     });
     return this;
   }
@@ -4368,7 +4388,7 @@ class Timeline extends Timer {
    */
   revert() {
     super.revert();
-    forEachChildren(this, (/** @type {JSAnimation} */child) => child.revert, true);
+    forEachChildren(this, (/** @type {JSAnimation|Timer} */child) => child.revert, true);
     return cleanInlineStyles(this);
   }
 
@@ -6465,6 +6485,7 @@ class ScrollContainer {
     this.updateBounds();
     forEachChildren(this, (/** @type {ScrollObserver} */child) => {
       child.refresh();
+      child.onResize(child);
       if (child._debug) {
         child.debug();
       }
@@ -6676,6 +6697,8 @@ class ScrollObserver {
     /** @type {Callback<ScrollObserver>} */
     this.onUpdate = parameters.onUpdate || noop;
     /** @type {Callback<ScrollObserver>} */
+    this.onResize = parameters.onResize || noop;
+    /** @type {Callback<ScrollObserver>} */
     this.onSyncComplete = parameters.onSyncComplete || noop;
     /** @type {Boolean} */
     this.reverted = false;
@@ -6739,7 +6762,9 @@ class ScrollObserver {
       linked.pause();
       this.linked = linked;
       // Forces WAAPI Animation to persist; otherwise, they will stop syncing on finish.
-      if (!isUnd(/** @type {WAAPIAnimation} */(linked))) /** @type {WAAPIAnimation} */(linked).persist = true;
+      if (!isUnd(linked) && !isUnd(/** @type {WAAPIAnimation} */(linked).persist)) {
+        /** @type {WAAPIAnimation} */(linked).persist = true;
+      }
       // Try to use a target of the linked object if no target parameters specified
       if (!this._params.target) {
         /** @type {HTMLElement} */
@@ -6941,12 +6966,11 @@ class ScrollObserver {
     // let offsetX = 0;
     // let offsetY = 0;
     // let $offsetParent = $el;
-    /** @type {Element} */
     if (linked) {
       linkedTime = linked.currentTime;
       linked.seek(0, true);
     }
-    /* Old implementation to get offset and targetSize before fixing https://github.com/juliangarnier/anime/issues/1021
+    // Old implementation to get offset and targetSize before fixing https://github.com/juliangarnier/anime/issues/1021
     // const isContainerStatic = get(container.element, 'position') === 'static' ? set(container.element, { position: 'relative '}) : false;
     // while ($el && $el !== container.element && $el !== doc.body) {
     //   const isSticky = get($el, 'position') === 'sticky' ?