@xtia/timeline 1.1.5 → 1.1.6

package/internal/timeline.d.ts

@@ -48,8 +48,8 @@ export declare class Timeline {
     apply(handler: () => void): UnsubscribeFunc;
     private _progression;
     /**
-     * Listenable: emits a progression value (0..1) when the Timeline's internal
-     * position changes, and when the Timeline's total duration is extended
+     * Listenable: emits a progression value (0..1), representing progression through the entire Timeline,
+     * when the Timeline's internal position changes, and when the Timeline's total duration is extended
      */
     get progression(): RangeProgression;
     constructor();
@@ -102,10 +102,9 @@ export declare class Timeline {
      */
     range(start: number | TimelinePoint, duration: number): TimelineRange;
     /**
-     * Creates an observable range from position 0 to the Timeline's **current** final position
+     * Defines a range from position 0 to the Timeline's **current** final position
      */
     range(): TimelineRange;
-    private getWrappedPosition;
     /**
      * Seeks the Timeline to a specified position, triggering in order any point and range subscriptions between its current and new positions
      * @param toPosition
@@ -123,6 +122,7 @@ export declare class Timeline {
     seek(toPosition: number | TimelinePoint, durationMs: number, easer?: Easer | keyof typeof easers): Promise<void>;
     seek(toPosition: number | TimelinePoint, duration: Period, easer?: Easer | keyof typeof easers): Promise<void>;
     private seekDirect;
+    private seekWrapped;
     private seekPoints;
     private seekRanges;
     private sortEntries;

package/internal/timeline.js

@@ -40,8 +40,8 @@ export class Timeline {
         return this._frameEvents.listen(handler);
     }
     /**
-     * Listenable: emits a progression value (0..1) when the Timeline's internal
-     * position changes, and when the Timeline's total duration is extended
+     * Listenable: emits a progression value (0..1), representing progression through the entire Timeline,
+     * when the Timeline's internal position changes, and when the Timeline's total duration is extended
      */
     get progression() {
         if (this._progression === null) {
@@ -161,22 +161,6 @@ export class Timeline {
         const range = new TimelineRange(addHandler, this, startPoint, endPoint);
         return range;
     }
-    getWrappedPosition(n) {
-        if (this.endAction.type !== EndAction.wrap)
-            return n;
-        const wrapAt = this.endAction.at?.position ?? 0;
-        if (wrapAt == 0)
-            return n % this._endPosition;
-        if (n <= this._endPosition)
-            return n;
-        const loopStart = wrapAt;
-        const segment = this._endPosition - loopStart;
-        if (segment <= 0)
-            return Math.min(n, this._endPosition);
-        const overflow = n - this._endPosition;
-        const remainder = overflow % segment;
-        return loopStart + remainder;
-    }
     seek(to, duration, easer) {
         const durationMs = typeof duration == "object"
             ? duration.asMilliseconds
@@ -216,31 +200,65 @@ export class Timeline {
         const fromPosition = this._currentTime;
         if (toPosition === fromPosition)
             return;
-        const loopingTo = this.getWrappedPosition(toPosition);
-        const loopingFrom = this.getWrappedPosition(fromPosition);
-        let virtualFrom = loopingFrom;
-        let virtualTo = loopingTo;
         const direction = toPosition > fromPosition ? 1 : -1;
         if (direction !== this.currentSortDirection)
             this.sortEntries(direction);
-        if (direction === 1 && loopingTo < loopingFrom) {
-            virtualFrom = loopingFrom - this._endPosition;
-        }
-        else if (direction === -1 && loopingTo > loopingFrom) {
-            virtualFrom = loopingFrom + this._endPosition;
-        }
         this.seeking = true;
-        this._currentTime = virtualFrom;
         try {
-            this.seekPoints(virtualTo);
-            this.seekRanges(virtualTo);
+            // use wrapping logic?
+            if (this.endAction.type === EndAction.wrap && (fromPosition > this._endPosition || toPosition > this._endPosition)) {
+                this.seekWrapped(toPosition);
+            }
+            else {
+                this.seekPoints(toPosition);
+                this.seekRanges(toPosition);
+            }
         }
         catch (e) {
             this.pause();
             throw e;
         }
+        finally {
+            this.seeking = false;
+        }
+        this._currentTime = toPosition;
+    }
+    seekWrapped(toPosition) {
+        const fromPosition = this._currentTime;
+        const timelineEnd = this._endPosition;
+        const wrapAt = "at" in this.endAction ? this.endAction.at.position : 0;
+        const loopLen = timelineEnd - wrapAt;
+        const getWrappedPosition = (pos) => ((pos - wrapAt) % loopLen + loopLen) % loopLen + wrapAt;
+        const realDelta = toPosition - fromPosition;
+        const direction = realDelta >= 0 ? 1 : -1;
+        let remaining = Math.abs(realDelta);
+        let virtualFrom = getWrappedPosition(fromPosition);
+        while (remaining > 0) {
+            let virtualTo;
+            if (direction > 0) {
+                const wrapSize = timelineEnd - virtualFrom;
+                virtualTo = remaining <= wrapSize
+                    ? virtualFrom + remaining
+                    : timelineEnd;
+            }
+            else {
+                const wrapSize = virtualFrom - wrapAt;
+                virtualTo = remaining <= wrapSize
+                    ? virtualFrom - remaining
+                    : wrapAt;
+            }
+            this._currentTime = virtualFrom;
+            this.seekPoints(virtualTo);
+            remaining -= Math.abs(virtualTo - virtualFrom);
+            if (remaining > 0) {
+                virtualFrom = direction > 0 ? wrapAt : timelineEnd;
+            }
+            else {
+                virtualFrom = virtualTo;
+            }
+        }
+        this.seekRanges(getWrappedPosition(toPosition));
         this._currentTime = toPosition;
-        this.seeking = false;
     }
     seekPoints(to) {
         const from = this._currentTime;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtia/timeline",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "repository": {
     "url": "https://github.com/tiadrop/timeline",
     "type": "github"