@orioncactuscorp/ui 1.0.0

package/dist/utils/spring/solver.js

@@ -0,0 +1,78 @@
+import { DEFAULT_SETTLING_STEP as v, DEFAULT_MAX_SAMPLES as D, DEFAULT_SAMPLES_PER_RESPONSE as R } from "./constants.js";
+import { getDampingRatio as m, getNaturalResponseDuration as w } from "./model.js";
+import { assertNonNegative as y, assertFinite as p } from "./validation.js";
+const g = (t, s, o, r, a) => {
+  const n = Math.sqrt(s.stiffness / s.mass), e = m(s), c = o - r;
+  if (e < 1) {
+    const i = n * Math.sqrt(1 - e * e), l = (a + e * n * c) / i, u = Math.exp(-e * n * t), b = c * Math.cos(i * t) + l * Math.sin(i * t), A = -c * i * Math.sin(i * t) + l * i * Math.cos(i * t);
+    return {
+      value: r + u * b,
+      velocity: u * (A - e * n * b)
+    };
+  }
+  if (Math.abs(e - 1) < 1e-4) {
+    const i = a + n * c, l = Math.exp(-n * t), u = c + i * t;
+    return {
+      value: r + u * l,
+      velocity: (i - n * u) * l
+    };
+  }
+  const h = Math.sqrt(e * e - 1), f = -n * (e - h), M = -n * (e + h), S = (a - M * c) / (f - M), E = c - S, d = Math.exp(f * t), x = Math.exp(M * t);
+  return {
+    value: r + S * d + E * x,
+    velocity: S * f * d + E * M * x
+  };
+}, L = (t, {
+  time: s,
+  from: o = 0,
+  target: r = 1,
+  initialVelocity: a = 0
+}) => (y("time", s), p("from", o), p("target", r), p("initialVelocity", a), g(s, t, o, r, a)), N = (t, s, o) => {
+  const r = Math.max(
+    1,
+    Math.ceil(o.stabilityWindow / v)
+  );
+  let a = 0;
+  for (let n = 0; n <= Math.ceil(o.maxDuration / v); n += 1) {
+    const e = n * v, c = g(
+      e,
+      t,
+      0,
+      1,
+      s
+    ).value, h = g(
+      e + v,
+      t,
+      0,
+      1,
+      s
+    ).value;
+    if (Math.abs(c - 1) < o.epsilon && Math.abs(h - c) < o.epsilon) {
+      if (a += 1, a >= r)
+        return Math.max(0, e - o.stabilityWindow);
+    } else
+      a = 0;
+  }
+  throw new RangeError(
+    `Spring did not settle within ${o.maxDuration} seconds.`
+  );
+}, T = (t, s, o) => {
+  if (t !== void 0 && t !== "auto") {
+    if (!Number.isInteger(t) || t < 2)
+      throw new RangeError(
+        "samples must be an integer greater than or equal to 2."
+      );
+    return t;
+  }
+  const r = w(s), a = Math.max(1, o / r);
+  return Math.min(
+    D,
+    Math.ceil(R * a)
+  );
+};
+export {
+  L as evaluateSpringState,
+  T as resolveSampleCount,
+  N as resolveSettlingDuration,
+  g as resolveSpringState
+};

package/dist/utils/spring/static.js

@@ -0,0 +1,76 @@
+import { DEFAULT_EPSILON as $, DEFAULT_STABILITY_WINDOW as A, DEFAULT_MAX_DURATION as V } from "./constants.js";
+import { round as g, formatNumber as D, formatSeconds as b, formatDelay as N } from "./format.js";
+import { createPhysicalModel as P, createSpringModel as T, createPresetModel as _ } from "./model.js";
+import { resolveSettlingDuration as I, resolveSampleCount as L, resolveSpringState as W, evaluateSpringState as E } from "./solver.js";
+import { assertPositive as S, assertNonNegative as F } from "./validation.js";
+const c = ({
+  model: t,
+  sampling: i
+}) => {
+  const l = i.epsilon ?? $, p = i.stabilityWindow ?? A, u = i.maxDuration ?? V;
+  S("epsilon", l), F("stabilityWindow", p), S("maxDuration", u);
+  const r = I(
+    t.parameters,
+    t.initialVelocity,
+    {
+      epsilon: l,
+      stabilityWindow: p,
+      maxDuration: u
+    }
+  ), n = L(
+    i.samples,
+    t.parameters,
+    r
+  ), m = Array.from({ length: n + 1 }, (e, a) => {
+    const f = a / n, y = r * f;
+    return {
+      offset: g(f, 6),
+      value: a === 0 ? 0 : a === n ? 1 : g(
+        W(
+          y,
+          t.parameters,
+          0,
+          1,
+          t.initialVelocity
+        ).value,
+        4
+      )
+    };
+  }), s = `linear(${m.map(
+    (e) => `${D(e.value, 4)} ${D(e.offset * 100, 2)}%`
+  ).join(", ")})`, o = b(r), v = t.perceptualDuration === void 0 ? void 0 : r / t.perceptualDuration;
+  return {
+    timingFunction: s,
+    settlingDuration: o,
+    settlingDurationSeconds: r,
+    perceptualDurationSeconds: t.perceptualDuration,
+    durationScale: v,
+    response: t.response,
+    bounce: t.bounce,
+    mass: t.parameters.mass,
+    stiffness: t.parameters.stiffness,
+    damping: t.parameters.damping,
+    dampingRatio: t.dampingRatio,
+    initialVelocity: t.initialVelocity,
+    samples: m,
+    evaluate: (e) => E(t.parameters, {
+      ...e,
+      initialVelocity: e.initialVelocity ?? t.initialVelocity
+    }),
+    transition: (e, a) => a === void 0 ? `${e} ${o} ${s}` : `${e} ${o} ${s} ${N(a)}`
+  };
+}, w = (t, i) => c({
+  model: _(t, i),
+  sampling: i
+}), O = (t) => c({
+  model: T(t),
+  sampling: t
+}), x = (t) => c({
+  model: P(t),
+  sampling: t
+});
+export {
+  x as createPhysicalSpring,
+  w as createPresetSpring,
+  O as createSpring
+};

package/dist/utils/spring/validation.js

@@ -0,0 +1,19 @@
+const r = (e, t) => {
+  if (!Number.isFinite(t))
+    throw new TypeError(`${e} must be a finite number.`);
+}, n = (e, t) => {
+  if (r(e, t), t <= 0)
+    throw new RangeError(`${e} must be greater than 0.`);
+}, o = (e, t) => {
+  if (r(e, t), t < 0)
+    throw new RangeError(`${e} must be greater than or equal to 0.`);
+}, s = (e) => {
+  if (r("bounce", e), e <= -1 || e >= 1)
+    throw new RangeError("bounce must be greater than -1 and less than 1.");
+};
+export {
+  r as assertFinite,
+  o as assertNonNegative,
+  n as assertPositive,
+  s as validateBounce
+};

package/dist/utils/spring/value.js

@@ -0,0 +1,65 @@
+import { assertFinite as h } from "./validation.js";
+const b = (t) => Array.from({ length: t }, () => 0), p = (t) => [...t], u = (t, f, o) => {
+  if (f.length !== o)
+    throw new RangeError(`${t} must have ${o} values.`);
+  f.forEach((m, a) => {
+    h(`${t}[${a}]`, m);
+  });
+}, w = (t) => {
+  if (typeof t == "number")
+    return h("value", t), {
+      dimension: 1,
+      toVector: (r, e) => {
+        if (typeof r != "number")
+          throw new TypeError(`${e} must be a number.`);
+        return h(e, r), [r];
+      },
+      fromVector: (r) => (u("value", r, 1), r[0])
+    };
+  if (Array.isArray(t)) {
+    const r = t.length;
+    if (r === 0)
+      throw new RangeError("value must contain at least one number.");
+    return u("value", t, r), {
+      dimension: r,
+      toVector: (e, n) => {
+        if (!Array.isArray(e))
+          throw new TypeError(`${n} must be an array.`);
+        return u(n, e, r), [...e];
+      },
+      fromVector: (e) => (u("value", e, r), [...e])
+    };
+  }
+  const o = Object.keys(t).sort();
+  if (o.length === 0)
+    throw new RangeError("value must contain at least one numeric property.");
+  const m = (r, e) => {
+    if (typeof r != "object" || r === null || Array.isArray(r))
+      throw new TypeError(`${e} must be an object.`);
+    const n = Object.keys(r).sort();
+    if (n.length !== o.length || n.some((s, c) => s !== o[c]))
+      throw new RangeError(`${e} must match the initial value shape.`);
+  }, a = (r, e) => {
+    m(r, e);
+    const n = r;
+    return o.map((s) => {
+      const c = n[s];
+      if (typeof c != "number")
+        throw new TypeError(`${e}.${s} must be a number.`);
+      return h(`${e}.${s}`, c), c;
+    });
+  };
+  return a(t, "value"), {
+    dimension: o.length,
+    toVector: a,
+    fromVector: (r) => (u("value", r, o.length), o.reduce(
+      (n, s, c) => (n[s] = r[c], n),
+      {}
+    ))
+  };
+};
+export {
+  p as cloneVector,
+  w as createValueAdapter,
+  b as createZeroVector
+};

package/dist/utils/spring.d.ts

@@ -0,0 +1,2 @@
+export * from '../ui/src/utils/spring'
+export {}

package/dist/utils/spring.js

@@ -0,0 +1,14 @@
+import { createSpringAnimator as p } from "./spring/animator.js";
+import { createPhysicalSpring as t, createSpring as e, createPresetSpring as o } from "./spring/static.js";
+const a = {
+  smooth: (r) => o("smooth", r),
+  snappy: (r) => o("snappy", r),
+  bouncy: (r) => o("bouncy", r),
+  spring: e,
+  physical: t,
+  createAnimator: p
+};
+export {
+  p as createSpringAnimator,
+  a as ocSpring
+};