@weng-lab/visualization 2.6.0-beta.1 → 2.7.0-beta.0

package/dist/visualization.es298.js

@@ -1,7 +1,75 @@
-function t(n) {
-  n.duration = 0, n.type = "keyframes";
+import { fillWildcards as y } from "./visualization.es357.js";
+import { removeNonTranslationalTransform as p } from "./visualization.es356.js";
+import { frame as c } from "./visualization.es333.js";
+const l = /* @__PURE__ */ new Set();
+let f = !1, d = !1, m = !1;
+function u() {
+  if (d) {
+    const a = Array.from(l).filter((e) => e.needsMeasurement), s = new Set(a.map((e) => e.element)), r = /* @__PURE__ */ new Map();
+    s.forEach((e) => {
+      const t = p(e);
+      t.length && (r.set(e, t), e.render());
+    }), a.forEach((e) => e.measureInitialState()), s.forEach((e) => {
+      e.render();
+      const t = r.get(e);
+      t && t.forEach(([n, i]) => {
+        e.getValue(n)?.set(i);
+      });
+    }), a.forEach((e) => e.measureEndState()), a.forEach((e) => {
+      e.suspendedScrollY !== void 0 && window.scrollTo(0, e.suspendedScrollY);
+    });
+  }
+  d = !1, f = !1, l.forEach((a) => a.complete(m)), l.clear();
+}
+function h() {
+  l.forEach((a) => {
+    a.readKeyframes(), a.needsMeasurement && (d = !0);
+  });
+}
+function S() {
+  m = !0, h(), u(), m = !1;
+}
+class g {
+  constructor(s, r, e, t, n, i = !1) {
+    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...s], this.onComplete = r, this.name = e, this.motionValue = t, this.element = n, this.isAsync = i;
+  }
+  scheduleResolve() {
+    this.state = "scheduled", this.isAsync ? (l.add(this), f || (f = !0, c.read(h), c.resolveKeyframes(u))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: s, name: r, element: e, motionValue: t } = this;
+    if (s[0] === null) {
+      const n = t?.get(), i = s[s.length - 1];
+      if (n !== void 0)
+        s[0] = n;
+      else if (e && r) {
+        const o = e.readValue(r, i);
+        o != null && (s[0] = o);
+      }
+      s[0] === void 0 && (s[0] = i), t && n === void 0 && t.set(s[0]);
+    }
+    y(s);
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete(s = !1) {
+    this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, s), l.delete(this);
+  }
+  cancel() {
+    this.state === "scheduled" && (l.delete(this), this.state = "pending");
+  }
+  resume() {
+    this.state === "pending" && this.scheduleResolve();
+  }
 }
 export {
-  t as makeAnimationInstant
+  g as KeyframeResolver,
+  S as flushKeyframeResolvers
 };
 //# sourceMappingURL=visualization.es298.js.map

package/dist/visualization.es298.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es298.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/utils/make-animation-instant.mjs"],"sourcesContent":["function makeAnimationInstant(options) {\n    options.duration = 0;\n    options.type = \"keyframes\";\n}\n\nexport { makeAnimationInstant };\n//# sourceMappingURL=make-animation-instant.mjs.map\n"],"names":["makeAnimationInstant","options"],"mappings":"AAAA,SAASA,EAAqBC,GAAS;AACnC,EAAAA,EAAQ,WAAW,GACnBA,EAAQ,OAAO;AACnB;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es298.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/keyframes/KeyframesResolver.mjs"],"sourcesContent":["import { fillWildcards } from './utils/fill-wildcards.mjs';\nimport { removeNonTranslationalTransform } from './utils/unit-conversion.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst toResolve = new Set();\nlet isScheduled = false;\nlet anyNeedsMeasurement = false;\nlet isForced = false;\nfunction measureAllKeyframes() {\n    if (anyNeedsMeasurement) {\n        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);\n        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));\n        const transformsToRestore = new Map();\n        /**\n         * Write pass\n         * If we're measuring elements we want to remove bounding box-changing transforms.\n         */\n        elementsToMeasure.forEach((element) => {\n            const removedTransforms = removeNonTranslationalTransform(element);\n            if (!removedTransforms.length)\n                return;\n            transformsToRestore.set(element, removedTransforms);\n            element.render();\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());\n        // Write\n        elementsToMeasure.forEach((element) => {\n            element.render();\n            const restore = transformsToRestore.get(element);\n            if (restore) {\n                restore.forEach(([key, value]) => {\n                    element.getValue(key)?.set(value);\n                });\n            }\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureEndState());\n        // Write\n        resolversToMeasure.forEach((resolver) => {\n            if (resolver.suspendedScrollY !== undefined) {\n                window.scrollTo(0, resolver.suspendedScrollY);\n            }\n        });\n    }\n    anyNeedsMeasurement = false;\n    isScheduled = false;\n    toResolve.forEach((resolver) => resolver.complete(isForced));\n    toResolve.clear();\n}\nfunction readAllKeyframes() {\n    toResolve.forEach((resolver) => {\n        resolver.readKeyframes();\n        if (resolver.needsMeasurement) {\n            anyNeedsMeasurement = true;\n        }\n    });\n}\nfunction flushKeyframeResolvers() {\n    isForced = true;\n    readAllKeyframes();\n    measureAllKeyframes();\n    isForced = false;\n}\nclass KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {\n        this.state = \"pending\";\n        /**\n         * Track whether this resolver is async. If it is, it'll be added to the\n         * resolver queue and flushed in the next frame. Resolvers that aren't going\n         * to trigger read/write thrashing don't need to be async.\n         */\n        this.isAsync = false;\n        /**\n         * Track whether this resolver needs to perform a measurement\n         * to resolve its keyframes.\n         */\n        this.needsMeasurement = false;\n        this.unresolvedKeyframes = [...unresolvedKeyframes];\n        this.onComplete = onComplete;\n        this.name = name;\n        this.motionValue = motionValue;\n        this.element = element;\n        this.isAsync = isAsync;\n    }\n    scheduleResolve() {\n        this.state = \"scheduled\";\n        if (this.isAsync) {\n            toResolve.add(this);\n            if (!isScheduled) {\n                isScheduled = true;\n                frame.read(readAllKeyframes);\n                frame.resolveKeyframes(measureAllKeyframes);\n            }\n        }\n        else {\n            this.readKeyframes();\n            this.complete();\n        }\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, name, element, motionValue } = this;\n        // If initial keyframe is null we need to read it from the DOM\n        if (unresolvedKeyframes[0] === null) {\n            const currentValue = motionValue?.get();\n            // TODO: This doesn't work if the final keyframe is a wildcard\n            const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n            if (currentValue !== undefined) {\n                unresolvedKeyframes[0] = currentValue;\n            }\n            else if (element && name) {\n                const valueAsRead = element.readValue(name, finalKeyframe);\n                if (valueAsRead !== undefined && valueAsRead !== null) {\n                    unresolvedKeyframes[0] = valueAsRead;\n                }\n            }\n            if (unresolvedKeyframes[0] === undefined) {\n                unresolvedKeyframes[0] = finalKeyframe;\n            }\n            if (motionValue && currentValue === undefined) {\n                motionValue.set(unresolvedKeyframes[0]);\n            }\n        }\n        fillWildcards(unresolvedKeyframes);\n    }\n    setFinalKeyframe() { }\n    measureInitialState() { }\n    renderEndStyles() { }\n    measureEndState() { }\n    complete(isForcedComplete = false) {\n        this.state = \"complete\";\n        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, isForcedComplete);\n        toResolve.delete(this);\n    }\n    cancel() {\n        if (this.state === \"scheduled\") {\n            toResolve.delete(this);\n            this.state = \"pending\";\n        }\n    }\n    resume() {\n        if (this.state === \"pending\")\n            this.scheduleResolve();\n    }\n}\n\nexport { KeyframeResolver, flushKeyframeResolvers };\n//# sourceMappingURL=KeyframesResolver.mjs.map\n"],"names":["toResolve","isScheduled","anyNeedsMeasurement","isForced","measureAllKeyframes","resolversToMeasure","resolver","elementsToMeasure","transformsToRestore","element","removedTransforms","removeNonTranslationalTransform","restore","key","value","readAllKeyframes","flushKeyframeResolvers","KeyframeResolver","unresolvedKeyframes","onComplete","name","motionValue","isAsync","frame","currentValue","finalKeyframe","valueAsRead","fillWildcards","isForcedComplete"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/visualization.es299.js

@@ -1,28 +1,39 @@
-class t {
-  constructor() {
-    this.updateFinished();
-  }
-  get finished() {
-    return this._finished;
-  }
-  updateFinished() {
-    this._finished = new Promise((i) => {
-      this.resolve = i;
-    });
-  }
-  notifyFinished() {
-    this.resolve();
+import { time as p } from "./visualization.es295.js";
+import { setStyle as c } from "./visualization.es318.js";
+import { JSAnimation as f } from "./visualization.es296.js";
+import { NativeAnimation as u } from "./visualization.es317.js";
+import { replaceTransitionType as d } from "./visualization.es312.js";
+import { replaceStringEasing as h } from "./visualization.es322.js";
+import { clamp as T } from "./visualization.es316.js";
+const o = 10;
+class N extends u {
+  constructor(t) {
+    h(t), d(t), super(t), t.startTime !== void 0 && t.autoplay !== !1 && (this.startTime = t.startTime), this.options = t;
   }
   /**
-   * Allows the animation to be awaited.
+   * WAAPI doesn't natively have any interruption capabilities.
    *
-   * @deprecated Use `finished` instead.
+   * Rather than read committed styles back out of the DOM, we can
+   * create a renderless JS animation and sample it twice to calculate
+   * its current value, "previous" value, and therefore allow
+   * Motion to calculate velocity for any subsequent animation.
    */
-  then(i, e) {
-    return this.finished.then(i, e);
+  updateMotionValue(t) {
+    const { motionValue: e, onUpdate: y, onComplete: A, element: m, ...l } = this.options;
+    if (!e)
+      return;
+    if (t !== void 0) {
+      e.set(t);
+      return;
+    }
+    const i = new f({
+      ...l,
+      autoplay: !1
+    }), a = Math.max(o, p.now() - this.startTime), n = T(0, o, a - o), r = i.sample(a).value, { name: s } = this.options;
+    m && s && c(m, s, r), e.setWithVelocity(i.sample(Math.max(0, a - n)).value, r, n), i.stop();
   }
 }
 export {
-  t as WithPromise
+  N as NativeAnimationExtended
 };
 //# sourceMappingURL=visualization.es299.js.map

package/dist/visualization.es299.js.map

@@ -1 +1 @@
-{"version":3,"file":"visualization.es299.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/utils/WithPromise.mjs"],"sourcesContent":["class WithPromise {\n    constructor() {\n        this.updateFinished();\n    }\n    get finished() {\n        return this._finished;\n    }\n    updateFinished() {\n        this._finished = new Promise((resolve) => {\n            this.resolve = resolve;\n        });\n    }\n    notifyFinished() {\n        this.resolve();\n    }\n    /**\n     * Allows the animation to be awaited.\n     *\n     * @deprecated Use `finished` instead.\n     */\n    then(onResolve, onReject) {\n        return this.finished.then(onResolve, onReject);\n    }\n}\n\nexport { WithPromise };\n//# sourceMappingURL=WithPromise.mjs.map\n"],"names":["WithPromise","resolve","onResolve","onReject"],"mappings":"AAAA,MAAMA,EAAY;AAAA,EACd,cAAc;AACV,SAAK,eAAc;AAAA,EACvB;AAAA,EACA,IAAI,WAAW;AACX,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,iBAAiB;AACb,SAAK,YAAY,IAAI,QAAQ,CAACC,MAAY;AACtC,WAAK,UAAUA;AAAA,IACnB,CAAC;AAAA,EACL;AAAA,EACA,iBAAiB;AACb,SAAK,QAAO;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,KAAKC,GAAWC,GAAU;AACtB,WAAO,KAAK,SAAS,KAAKD,GAAWC,CAAQ;AAAA,EACjD;AACJ;","x_google_ignoreList":[0]}
+{"version":3,"file":"visualization.es299.js","sources":["../../../node_modules/.pnpm/motion-dom@12.38.0/node_modules/motion-dom/dist/es/animation/NativeAnimationExtended.mjs"],"sourcesContent":["import { clamp } from 'motion-utils';\nimport { time } from '../frameloop/sync-time.mjs';\nimport { setStyle } from '../render/dom/style-set.mjs';\nimport { JSAnimation } from './JSAnimation.mjs';\nimport { NativeAnimation } from './NativeAnimation.mjs';\nimport { replaceTransitionType } from './utils/replace-transition-type.mjs';\nimport { replaceStringEasing } from './waapi/utils/unsupported-easing.mjs';\n\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\nclass NativeAnimationExtended extends NativeAnimation {\n    constructor(options) {\n        /**\n         * The base NativeAnimation function only supports a subset\n         * of Motion easings, and WAAPI also only supports some\n         * easing functions via string/cubic-bezier definitions.\n         *\n         * This function replaces those unsupported easing functions\n         * with a JS easing function. This will later get compiled\n         * to a linear() easing function.\n         */\n        replaceStringEasing(options);\n        /**\n         * Ensure we replace the transition type with a generator function\n         * before passing to WAAPI.\n         *\n         * TODO: Does this have a better home? It could be shared with\n         * JSAnimation.\n         */\n        replaceTransitionType(options);\n        super(options);\n        /**\n         * Only set startTime when the animation should autoplay.\n         * Setting startTime on a paused WAAPI animation unpauses it\n         * (per the WAAPI spec), which breaks autoplay: false.\n         */\n        if (options.startTime !== undefined && options.autoplay !== false) {\n            this.startTime = options.startTime;\n        }\n        this.options = options;\n    }\n    /**\n     * WAAPI doesn't natively have any interruption capabilities.\n     *\n     * Rather than read committed styles back out of the DOM, we can\n     * create a renderless JS animation and sample it twice to calculate\n     * its current value, \"previous\" value, and therefore allow\n     * Motion to calculate velocity for any subsequent animation.\n     */\n    updateMotionValue(value) {\n        const { motionValue, onUpdate, onComplete, element, ...options } = this.options;\n        if (!motionValue)\n            return;\n        if (value !== undefined) {\n            motionValue.set(value);\n            return;\n        }\n        const sampleAnimation = new JSAnimation({\n            ...options,\n            autoplay: false,\n        });\n        /**\n         * Use wall-clock elapsed time for sampling.\n         * Under CPU load, WAAPI's currentTime may not reflect actual\n         * elapsed time, causing incorrect sampling and visual jumps.\n         */\n        const sampleTime = Math.max(sampleDelta, time.now() - this.startTime);\n        const delta = clamp(0, sampleDelta, sampleTime - sampleDelta);\n        const current = sampleAnimation.sample(sampleTime).value;\n        /**\n         * Write the estimated value to inline style so it persists\n         * after cancel(), covering the async gap before the next\n         * animation starts.\n         */\n        const { name } = this.options;\n        if (element && name)\n            setStyle(element, name, current);\n        motionValue.setWithVelocity(sampleAnimation.sample(Math.max(0, sampleTime - delta)).value, current, delta);\n        sampleAnimation.stop();\n    }\n}\n\nexport { NativeAnimationExtended };\n//# sourceMappingURL=NativeAnimationExtended.mjs.map\n"],"names":["sampleDelta","NativeAnimationExtended","NativeAnimation","options","replaceStringEasing","replaceTransitionType","value","motionValue","onUpdate","onComplete","element","sampleAnimation","JSAnimation","sampleTime","time","delta","clamp","current","name","setStyle"],"mappings":";;;;;;;AAaA,MAAMA,IAAc;AACpB,MAAMC,UAAgCC,EAAgB;AAAA,EAClD,YAAYC,GAAS;AAUjB,IAAAC,EAAoBD,CAAO,GAQ3BE,EAAsBF,CAAO,GAC7B,MAAMA,CAAO,GAMTA,EAAQ,cAAc,UAAaA,EAAQ,aAAa,OACxD,KAAK,YAAYA,EAAQ,YAE7B,KAAK,UAAUA;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,kBAAkBG,GAAO;AACrB,UAAM,EAAE,aAAAC,GAAa,UAAAC,GAAU,YAAAC,GAAY,SAAAC,GAAS,GAAGP,EAAO,IAAK,KAAK;AACxE,QAAI,CAACI;AACD;AACJ,QAAID,MAAU,QAAW;AACrB,MAAAC,EAAY,IAAID,CAAK;AACrB;AAAA,IACJ;AACA,UAAMK,IAAkB,IAAIC,EAAY;AAAA,MACpC,GAAGT;AAAA,MACH,UAAU;AAAA,IACtB,CAAS,GAMKU,IAAa,KAAK,IAAIb,GAAac,EAAK,IAAG,IAAK,KAAK,SAAS,GAC9DC,IAAQC,EAAM,GAAGhB,GAAaa,IAAab,CAAW,GACtDiB,IAAUN,EAAgB,OAAOE,CAAU,EAAE,OAM7C,EAAE,MAAAK,MAAS,KAAK;AACtB,IAAIR,KAAWQ,KACXC,EAAST,GAASQ,GAAMD,CAAO,GACnCV,EAAY,gBAAgBI,EAAgB,OAAO,KAAK,IAAI,GAAGE,IAAaE,CAAK,CAAC,EAAE,OAAOE,GAASF,CAAK,GACzGJ,EAAgB,KAAI;AAAA,EACxB;AACJ;","x_google_ignoreList":[0]}