@ssgoi/core 6.6.9 → 6.6.11

package/dist/multi-animation-ZFZBDBGr.js

@@ -0,0 +1,439 @@
+var S = Object.defineProperty;
+var F = (a, i, t) => i in a ? S(a, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[i] = t;
+var r = (a, i, t) => F(a, typeof i != "symbol" ? i + "" : i, t);
+class f {
+  constructor() {
+    /** Current playback rate (1 = realtime, 0 = paused, negative = backwards) */
+    r(this, "_playbackRate", 1);
+    /** Fired every frame with the most recent value. Optional. */
+    r(this, "onUpdate");
+    /** Fired once when the animation settles. */
+    r(this, "onComplete");
+  }
+  get playbackRate() {
+    return this._playbackRate;
+  }
+  set playbackRate(i) {
+    this._playbackRate = i;
+  }
+}
+const O = 0.01, V = 0.01, b = 0.05;
+function R(a) {
+  return new Promise((i) => {
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => {
+        i();
+      });
+    });
+  });
+}
+const T = 1e3 / 60, g = 1e3 / 30, k = g + 1;
+class w {
+  constructor() {
+    r(this, "drivers", /* @__PURE__ */ new Set());
+    r(this, "observers", /* @__PURE__ */ new Set());
+    r(this, "frameRequest", null);
+    r(this, "previousTimestamp", null);
+    r(this, "tick", (i) => {
+      this.frameRequest = null;
+      const t = this.previousTimestamp === null ? T : Math.max(0, i - this.previousTimestamp);
+      this.previousTimestamp = i;
+      const e = {
+        delta: Math.min(t, g),
+        rawDelta: t
+      };
+      this.runPhase(this.drivers, e), this.runPhase(this.observers, e), this.hasCallbacks() ? this.requestFrame() : this.previousTimestamp = null;
+    });
+  }
+  subscribe(i, t = "drive") {
+    const e = t === "drive" ? this.drivers : this.observers;
+    return e.add(i), this.requestFrame(), () => {
+      e.delete(i), this.stopIfIdle();
+    };
+  }
+  requestFrame() {
+    this.frameRequest !== null || !this.hasCallbacks() || (this.frameRequest = requestAnimationFrame(this.tick));
+  }
+  runPhase(i, t) {
+    for (const e of [...i])
+      i.has(e) && e(t);
+  }
+  hasCallbacks() {
+    return this.drivers.size > 0 || this.observers.size > 0;
+  }
+  stopIfIdle() {
+    this.hasCallbacks() || (this.frameRequest !== null && typeof cancelAnimationFrame < "u" && cancelAnimationFrame(this.frameRequest), this.frameRequest = null, this.previousTimestamp = null);
+  }
+}
+const y = new w(), p = 1e3 / 60, C = 2;
+class _ extends f {
+  constructor(t) {
+    super();
+    r(this, "element");
+    r(this, "integrator");
+    r(this, "styleFn");
+    r(this, "lowerBound");
+    r(this, "upperBound");
+    r(this, "currentValue");
+    r(this, "currentVelocity", 0);
+    r(this, "frames", []);
+    r(this, "waapi", null);
+    r(this, "runId", 0);
+    r(this, "waitingForStart", !1);
+    r(this, "startReady", !1);
+    r(this, "pendingFirstFrame");
+    r(this, "stopStartupClock", null);
+    r(this, "startupStableFrames", 0);
+    r(this, "running", !1);
+    r(this, "paused", !1);
+    r(this, "settled", !1);
+    r(this, "reversing", !1);
+    this.element = t.element, this.integrator = t.integrator, this.styleFn = t.style, this.lowerBound = t.lowerBound ?? 0, this.upperBound = t.upperBound ?? 1, this.currentValue = this.lowerBound, this.onUpdate = t.onUpdate, this.onComplete = t.onComplete;
+  }
+  play() {
+    if (this.reversing = !1, this.paused && this.waapi) {
+      if (this.paused = !1, this.running = !0, this.waitingForStart) {
+        this.startReady && this.startFramePacedPlayback(this.waapi);
+        return;
+      }
+      this.waapi.play();
+      return;
+    }
+    this.runToward(this.upperBound);
+  }
+  reverse() {
+    this.reversing = !0, this.runToward(this.lowerBound);
+  }
+  pause() {
+    var t, e;
+    this.running && (this.captureLiveState(), (t = this.waapi) == null || t.pause(), (e = this.stopStartupClock) == null || e.call(this), this.stopStartupClock = null, this.running = !1, this.paused = !0);
+  }
+  complete() {
+    var t;
+    this.clearWaapi(), this.running = !1, this.paused = !1, this.currentValue = this.upperBound, this.currentVelocity = 0, this.applyStyleAt(this.currentValue), this.settled = !0, (t = this.onComplete) == null || t.call(this);
+  }
+  /**
+   * Drop the WAAPI forwards-fill after the run has settled, letting inline
+   * styles govern the resting visual. Call only from `onComplete` (the run is
+   * already finished) — otherwise it cancels mid-flight. Unlike `complete()`,
+   * it writes no final frame, so a caller can reset the element to its natural
+   * state without the lingering fill clobbering it.
+   */
+  releaseFill() {
+    this.clearWaapi();
+  }
+  get isAnimating() {
+    return this.running;
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  get isComplete() {
+    return this.settled;
+  }
+  get isReversing() {
+    return this.reversing;
+  }
+  get progress() {
+    this.running && this.captureLiveState();
+    const t = this.upperBound - this.lowerBound;
+    if (t === 0) return 0;
+    const e = (this.currentValue - this.lowerBound) / t;
+    return e < 0 ? 0 : e > 1 ? 1 : e;
+  }
+  findTimeForProgress(t) {
+    if (this.frames.length < 2) return null;
+    const e = this.upperBound - this.lowerBound;
+    if (e === 0) return 0;
+    for (const s of this.frames)
+      if ((s.position - this.lowerBound) / e >= t) return s.time;
+    return this.frames[this.frames.length - 1].time;
+  }
+  get playbackRate() {
+    return super.playbackRate;
+  }
+  set playbackRate(t) {
+    super.playbackRate = t, this.waapi && (this.waapi.playbackRate = t);
+  }
+  getPose() {
+    return this.running && this.captureLiveState(), [
+      {
+        element: this.element,
+        value: this.currentValue,
+        velocity: this.currentVelocity
+      }
+    ];
+  }
+  getTimeline() {
+    const t = this.frames.map((e) => {
+      const s = e.position, n = this.lowerBound + this.upperBound - s;
+      return {
+        time: e.time,
+        value: e.position,
+        velocity: e.velocity,
+        style: this.styleFn(s, n)
+      };
+    });
+    return [{ element: this.element, frames: t }];
+  }
+  matchInto(t) {
+    const e = t.find((s) => s.element === this.element);
+    e && (this.currentValue = e.value, this.currentVelocity = e.velocity);
+  }
+  /* ───────────────────────────────────────────────────────── private */
+  runToward(t) {
+    var o;
+    if (this.running && this.captureLiveState(), this.clearWaapi(), this.running = !1, this.paused = !1, this.settled = !1, this.frames = A(
+      this.integrator,
+      this.currentValue,
+      t,
+      this.currentVelocity
+    ), this.frames.length === 0) {
+      this.currentValue = t, this.currentVelocity = 0, this.applyStyleAt(t), this.settled = !0, (o = this.onComplete) == null || o.call(this);
+      return;
+    }
+    const e = this.frames.map((c) => {
+      const d = c.position, v = this.lowerBound + this.upperBound - d;
+      return this.styleFn(d, v);
+    }), s = e[0], n = this.frames[this.frames.length - 1], h = n.time, u = ++this.runId, l = this.element.animate(e, {
+      duration: h,
+      fill: "both",
+      easing: "linear",
+      composite: "replace"
+    });
+    l.playbackRate = this.playbackRate, l.currentTime = 0, l.pause(), this.waapi = l, this.waitingForStart = !0, this.startReady = !1, this.pendingFirstFrame = s, this.running = !0, l.onfinish = () => {
+      var c;
+      !this.running || this.waapi !== l || (this.running = !1, this.settled = !0, this.currentValue = n.position, this.currentVelocity = 0, (c = this.onComplete) == null || c.call(this));
+    }, this.startWhenReady(l, u);
+  }
+  clearWaapi() {
+    var t, e;
+    this.runId++, (t = this.waapi) == null || t.cancel(), this.waapi = null, this.waitingForStart = !1, this.startReady = !1, this.pendingFirstFrame = void 0, (e = this.stopStartupClock) == null || e.call(this), this.stopStartupClock = null, this.startupStableFrames = 0;
+  }
+  captureLiveState() {
+    if (this.frames.length === 0) return;
+    const t = m(this.waapi);
+    if (t === null) return;
+    const { position: e, velocity: s } = P(this.frames, t);
+    this.currentValue = e, this.currentVelocity = s;
+  }
+  async startWhenReady(t, e) {
+    try {
+      await t.ready, typeof requestAnimationFrame < "u" && await R(this.element);
+    } catch {
+      return;
+    }
+    this.runId !== e || this.waapi !== t || (this.startReady = !0, !(!this.running || this.paused) && this.startFramePacedPlayback(t));
+  }
+  startFramePacedPlayback(t) {
+    if (!(this.waapi !== t || !this.waitingForStart || !this.startReady || this.stopStartupClock)) {
+      if (this.pendingFirstFrame)
+        for (const e of Object.keys(this.pendingFirstFrame))
+          this.element.style[e] = "";
+      if (this.pendingFirstFrame = void 0, typeof requestAnimationFrame > "u" || this.playbackRate < 0) {
+        this.handOffToWaapi(t);
+        return;
+      }
+      this.startupStableFrames = 0, this.stopStartupClock = y.subscribe((e) => {
+        this.advanceFramePacedStartup(t, e);
+      });
+    }
+  }
+  advanceFramePacedStartup(t, e) {
+    if (this.waapi !== t || !this.running || this.paused || !this.waitingForStart)
+      return;
+    const s = this.frames[this.frames.length - 1];
+    if (!s) return;
+    const n = m(t) ?? 0, h = Math.min(
+      s.time,
+      n + e.delta * Math.max(0, this.playbackRate)
+    );
+    if (t.currentTime = h, this.captureLiveState(), h >= s.time) {
+      this.finishFramePacedRun(t, s);
+      return;
+    }
+    e.rawDelta <= k ? this.startupStableFrames++ : this.startupStableFrames = 0, !(this.startupStableFrames < C) && this.handOffToWaapi(t);
+  }
+  handOffToWaapi(t) {
+    var e;
+    this.waapi !== t || !this.running || this.paused || ((e = this.stopStartupClock) == null || e.call(this), this.stopStartupClock = null, this.waitingForStart = !1, this.startReady = !1, this.startupStableFrames = 0, t.play());
+  }
+  finishFramePacedRun(t, e) {
+    var s, n;
+    this.waapi !== t || !this.running || ((s = this.stopStartupClock) == null || s.call(this), this.stopStartupClock = null, this.waitingForStart = !1, this.startReady = !1, this.startupStableFrames = 0, this.running = !1, this.settled = !0, this.currentValue = e.position, this.currentVelocity = 0, (n = this.onComplete) == null || n.call(this));
+  }
+  applyStyleAt(t) {
+    const e = this.lowerBound + this.upperBound - t, s = this.styleFn(t, e);
+    for (const [n, h] of Object.entries(s))
+      this.element.style[n] = typeof h == "number" ? String(h) : h;
+  }
+}
+function A(a, i, t, e) {
+  if (i === t && e === 0) return [];
+  const s = 600;
+  let n = { position: i, velocity: e }, h = 0;
+  const u = [];
+  for (let l = 0; l < s; l++) {
+    const o = l * p;
+    if (u.push({ time: o, position: n.position, velocity: n.velocity }), n = a.step(n, t, p / 1e3), a.isSettled(n, t)) {
+      if (h += p / 1e3, h >= b) {
+        u.push({
+          time: (l + 1) * p,
+          position: t,
+          velocity: 0
+        });
+        break;
+      }
+    } else
+      h = 0;
+  }
+  return u;
+}
+function P(a, i) {
+  if (a.length === 0) return { position: 0, velocity: 0 };
+  const t = a[0], e = a[a.length - 1];
+  if (i <= 0)
+    return { position: t.position, velocity: t.velocity };
+  if (i >= e.time)
+    return { position: e.position, velocity: e.velocity };
+  let s = 0, n = a.length - 1;
+  for (; s < n - 1; ) {
+    const o = s + n >> 1;
+    a[o].time <= i ? s = o : n = o;
+  }
+  const h = a[s], u = a[n], l = (i - h.time) / (u.time - h.time);
+  return {
+    position: h.position + (u.position - h.position) * l,
+    velocity: h.velocity + (u.velocity - h.velocity) * l
+  };
+}
+function m(a) {
+  const i = a == null ? void 0 : a.currentTime;
+  return typeof i == "number" ? i : null;
+}
+class M extends f {
+  constructor(t, e = {}) {
+    super();
+    r(this, "children");
+    r(this, "startAt");
+    r(this, "pendingComplete", 0);
+    r(this, "running", !1);
+    r(this, "pendingStartObservers", []);
+    this.children = t, (e.mode ?? "parallel") === "sequence" ? this.startAt = t.map((s, n) => n === 0 ? 0 : 1) : this.startAt = e.startAt ?? [];
+  }
+  play() {
+    this.startRun("play");
+  }
+  reverse() {
+    this.startRun("reverse");
+  }
+  pause() {
+    this.running = !1, this.clearPendingStartObservers();
+    for (const t of this.children) t.pause();
+  }
+  complete() {
+    var t;
+    this.running = !1, this.clearPendingStartObservers();
+    for (const e of this.children) e.complete();
+    (t = this.onComplete) == null || t.call(this);
+  }
+  get progress() {
+    if (this.children.length === 0) return 0;
+    let t = 0;
+    for (const e of this.children) t += e.progress;
+    return t / this.children.length;
+  }
+  getPose() {
+    return this.children.flatMap((t) => t.getPose());
+  }
+  getTimeline() {
+    return this.children.flatMap((t) => t.getTimeline());
+  }
+  matchInto(t) {
+  }
+  get isAnimating() {
+    return this.children.some((t) => t.isAnimating);
+  }
+  get isPaused() {
+    return this.children.some((t) => t.isPaused) && this.children.every((t) => t.isPaused || t.isComplete);
+  }
+  get isComplete() {
+    return this.children.every((t) => t.isComplete);
+  }
+  get isReversing() {
+    return this.children.some((t) => t.isReversing);
+  }
+  get playbackRate() {
+    return super.playbackRate;
+  }
+  set playbackRate(t) {
+    super.playbackRate = t;
+    for (const e of this.children) e.playbackRate = t;
+  }
+  /* ───────────────────────────────────────────────────────── private */
+  startRun(t) {
+    if (this.running && this.pause(), this.running = !0, this.pendingComplete = this.children.length, this.pendingComplete === 0) {
+      this.handleFinished();
+      return;
+    }
+    for (const e of this.children) {
+      const s = e.onComplete;
+      e.onComplete = () => {
+        s == null || s(), this.handleChildComplete();
+      };
+    }
+    this.scheduleStart(0, t);
+  }
+  // Chained start: play child `index`, then observe its actual progress before
+  // starting the next one. A wall-clock timeout starts counting before WAAPI's
+  // asynchronous startup has completed, so mount/layout delays can otherwise
+  // make a sequence or stagger run early. The shared frame scheduler evaluates
+  // observers after frame-paced drivers, matching the pose painted this frame.
+  scheduleStart(t, e) {
+    if (!this.running || t >= this.children.length) return;
+    this.children[t][e]();
+    const s = t + 1;
+    if (s >= this.children.length) return;
+    const n = this.startAt[s];
+    if (n === void 0 || n <= 0) {
+      this.scheduleStart(s, e);
+      return;
+    }
+    const h = this.children[t];
+    if (this.hasReachedThreshold(h, n, e)) {
+      this.scheduleStart(s, e);
+      return;
+    }
+    const u = y.subscribe(() => {
+      this.running && this.hasReachedThreshold(h, n, e) && (u(), this.pendingStartObservers = this.pendingStartObservers.filter(
+        (l) => l !== u
+      ), this.scheduleStart(s, e));
+    }, "observe");
+    this.pendingStartObservers.push(u);
+  }
+  hasReachedThreshold(t, e, s) {
+    return t.isComplete ? !0 : (s === "play" ? t.progress : 1 - t.progress) >= e;
+  }
+  clearPendingStartObservers() {
+    for (const t of this.pendingStartObservers) t();
+    this.pendingStartObservers = [];
+  }
+  handleChildComplete() {
+    this.pendingComplete--, this.pendingComplete <= 0 && this.handleFinished();
+  }
+  handleFinished() {
+    var t;
+    this.running = !1, this.clearPendingStartObservers(), (t = this.onComplete) == null || t.call(this);
+  }
+  findTimeForProgress(t) {
+    return null;
+  }
+}
+export {
+  f as A,
+  M,
+  O as P,
+  b as S,
+  V,
+  _ as W
+};

package/dist/transitions/drill/provider/crossfade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crossfade.d.ts","sourceRoot":"","sources":["../../../../src/lib/transitions/drill/provider/crossfade.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,aAAa,EACd,MAAM,UAAU,CAAC;AAsClB,wBAAgB,uBAAuB,IAAI,aAAa,CAKvD"}
+{"version":3,"file":"crossfade.d.ts","sourceRoot":"","sources":["../../../../src/lib/transitions/drill/provider/crossfade.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,aAAa,EACd,MAAM,UAAU,CAAC;AA0ClB,wBAAgB,uBAAuB,IAAI,aAAa,CAKvD"}

package/dist/transitions/drill/provider/parallax.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallax.d.ts","sourceRoot":"","sources":["../../../../src/lib/transitions/drill/provider/parallax.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,aAAa,EACd,MAAM,UAAU,CAAC;AAyClB,wBAAgB,sBAAsB,IAAI,aAAa,CAKtD"}
+{"version":3,"file":"parallax.d.ts","sourceRoot":"","sources":["../../../../src/lib/transitions/drill/provider/parallax.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,aAAa,EACd,MAAM,UAAU,CAAC;AAqClB,wBAAgB,sBAAsB,IAAI,aAAa,CAKtD"}

package/dist/transitions/sheet/provider/static.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../../../../src/lib/transitions/sheet/provider/static.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAY9C,wBAAgB,oBAAoB,IAAI,aAAa,CAUpD"}
+{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../../../../src/lib/transitions/sheet/provider/static.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAkB9C,wBAAgB,oBAAoB,IAAI,aAAa,CAUpD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ssgoi/core",
-  "version": "6.6.9",
+  "version": "6.6.11",
   "description": "Core animation engine for SSGOI - Native app-like page transitions with spring physics",
   "private": false,
   "type": "module",