@sophostechne/ui 0.18.2

package/dist/hooks/use-gpu-tier.js

@@ -0,0 +1,111 @@
+"use client";
+import { useStore } from "@nanostores/react";
+import { atom } from "nanostores";
+export const $gpuTier = atom(0);
+const SOFTWARE_PATTERNS = /swiftshader|llvmpipe|softpipe|software|microsoft basic/i;
+const LOW_END_PATTERNS = /intel.*hd|intel.*uhd|intel.*iris|mali|adreno\s?[1-5]|powervr|apple gpu/i;
+let detected = false;
+function detectGpuTier() {
+  if (detected || typeof window === "undefined") {
+    return;
+  }
+  detected = true;
+  if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) {
+    return;
+  }
+  let gl = null;
+  try {
+    const canvas = document.createElement("canvas");
+    gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+  } catch {
+    return;
+  }
+  if (!gl) {
+    return;
+  }
+  const ext = gl.getExtension("WEBGL_debug_renderer_info");
+  const renderer = String(
+    ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : gl.getParameter(gl.RENDERER)
+  );
+  if (SOFTWARE_PATTERNS.test(renderer)) {
+    gl.getExtension("WEBGL_lose_context")?.loseContext();
+    return;
+  }
+  if (LOW_END_PATTERNS.test(renderer)) {
+    $gpuTier.set(1);
+    gl.getExtension("WEBGL_lose_context")?.loseContext();
+    return;
+  }
+  $gpuTier.set(2);
+  runBenchmark(gl).then((fps) => $gpuTier.set(fps < 30 ? 1 : 2)).catch(() => $gpuTier.set(1)).finally(() => gl?.getExtension("WEBGL_lose_context")?.loseContext());
+}
+function scheduleDetection() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (typeof window.requestIdleCallback === "function") {
+    window.requestIdleCallback(() => detectGpuTier(), { timeout: 1e3 });
+  } else if (typeof window.requestAnimationFrame === "function") {
+    window.requestAnimationFrame(
+      () => window.requestAnimationFrame(() => detectGpuTier())
+    );
+  } else {
+    setTimeout(() => detectGpuTier(), 0);
+  }
+}
+scheduleDetection();
+function runBenchmark(gl) {
+  return new Promise((resolve) => {
+    const vs = gl.createShader(gl.VERTEX_SHADER);
+    const fs = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(
+      vs,
+      "attribute vec2 a;void main(){gl_Position=vec4(a,0,1);}"
+    );
+    gl.shaderSource(
+      fs,
+      "precision highp float;uniform float t;void main(){float v=0.;for(int i=0;i<64;i++)v+=sin(float(i)*t*.01);gl_FragColor=vec4(v*.001);}"
+    );
+    gl.compileShader(vs);
+    gl.compileShader(fs);
+    const prog = gl.createProgram();
+    gl.attachShader(prog, vs);
+    gl.attachShader(prog, fs);
+    gl.linkProgram(prog);
+    gl.useProgram(prog);
+    const buf = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+    gl.bufferData(
+      gl.ARRAY_BUFFER,
+      new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),
+      gl.STATIC_DRAW
+    );
+    const a = gl.getAttribLocation(prog, "a");
+    gl.enableVertexAttribArray(a);
+    gl.vertexAttribPointer(a, 2, gl.FLOAT, false, 0, 0);
+    const uT = gl.getUniformLocation(prog, "t");
+    let frames = 0;
+    const start = performance.now();
+    const tick = () => {
+      gl.uniform1f(uT, frames);
+      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+      gl.finish();
+      frames++;
+      if (performance.now() - start < 200) {
+        requestAnimationFrame(tick);
+      } else {
+        const elapsed = performance.now() - start;
+        gl.deleteProgram(prog);
+        gl.deleteShader(vs);
+        gl.deleteShader(fs);
+        gl.deleteBuffer(buf);
+        resolve(frames / elapsed * 1e3);
+      }
+    };
+    requestAnimationFrame(tick);
+  });
+}
+export function useGpuTier() {
+  return useStore($gpuTier);
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport { useStore } from '@nanostores/react'\nimport { atom } from 'nanostores'\n\n/**\n * Tiers:\n *  0 \u2014 no WebGL / software renderer / prefers-reduced-motion / WebGL ctx\n *      creation failed / detection not yet run\n *  1 \u2014 low-end GPU (integrated, mobile, or failed perf benchmark)\n *  2 \u2014 capable GPU (discrete / high-end integrated)\n *\n * The atom starts **pessimistic** (`0`) and the probe is scheduled to run\n * *after the first paint* (see `scheduleDetection` below), never synchronously\n * at module-evaluation time.\n *\n * Why pessimistic + deferred:\n *  - Every consumer gates its `<canvas>` / `THREE.WebGLRenderer` on `tier > 0`\n *    (or `=== 2`). Starting at `0` means a consumer reading `$gpuTier` during\n *    its first render never attempts to create a renderer before detection has\n *    run, so the `THREE.WebGLRenderer: Error creating WebGL context` crash on\n *    hardware where context creation fails cannot happen \u2014 the component\n *    renders its fallback and upgrades once detection resolves to a capable\n *    tier. (A previous version made the probe synchronous-at-module-load to\n *    dodge this crash; the pessimistic default removes the crash without that\n *    cost.)\n *  - Probing WebGL is *expensive* on software renderers: creating a context\n *    under SwiftShader / llvmpipe can block the main thread for hundreds of\n *    milliseconds. Running it synchronously at module load stalled first paint\n *    and produced a visible boot-time flash in apps that merely import this\n *    hook (e.g. the Hermes dashboard backdrop). Deferring past first paint\n *    keeps boot smooth; the tier just upgrades a frame or two later.\n *  - For SSR the server keeps the default `0` and the client's first render\n *    also reads `0`, so there is no hydration mismatch.\n */\nexport const $gpuTier = atom<GpuTier>(0)\n\nconst SOFTWARE_PATTERNS =\n  /swiftshader|llvmpipe|softpipe|software|microsoft basic/i\n\nconst LOW_END_PATTERNS =\n  /intel.*hd|intel.*uhd|intel.*iris|mali|adreno\\s?[1-5]|powervr|apple gpu/i\n\nlet detected = false\n\nfunction detectGpuTier() {\n  if (detected || typeof window === 'undefined') {\n    return\n  }\n\n  detected = true\n\n  // The atom already holds 0; the early returns below simply leave it there.\n  if (window.matchMedia('(prefers-reduced-motion: reduce)').matches) {\n    return\n  }\n\n  let gl: null | WebGLRenderingContext = null\n\n  try {\n    const canvas = document.createElement('canvas')\n    gl = (canvas.getContext('webgl') ||\n      canvas.getContext('experimental-webgl')) as null | WebGLRenderingContext\n  } catch {\n    // Some sandboxed / hardened contexts throw on getContext rather than\n    // returning null (e.g. certain corporate browser policies). Treat as\n    // \"no WebGL available\".\n    return\n  }\n\n  if (!gl) {\n    return\n  }\n\n  const ext = gl.getExtension('WEBGL_debug_renderer_info')\n  const renderer = String(\n    ext\n      ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL)\n      : gl.getParameter(gl.RENDERER)\n  )\n\n  if (SOFTWARE_PATTERNS.test(renderer)) {\n    gl.getExtension('WEBGL_lose_context')?.loseContext()\n\n    return\n  }\n\n  if (LOW_END_PATTERNS.test(renderer)) {\n    $gpuTier.set(1)\n    gl.getExtension('WEBGL_lose_context')?.loseContext()\n\n    return\n  }\n\n  $gpuTier.set(2)\n\n  runBenchmark(gl)\n    .then(fps => $gpuTier.set(fps < 30 ? 1 : 2))\n    .catch(() => $gpuTier.set(1))\n    .finally(() => gl?.getExtension('WEBGL_lose_context')?.loseContext())\n}\n\n/**\n * Run detection once, *after* the first paint so the (potentially expensive)\n * WebGL probe never blocks initial render. Prefer `requestIdleCallback` so the\n * probe yields to rendering and input; fall back to a double\n * `requestAnimationFrame` (guarantees at least one painted frame) and finally\n * `setTimeout` where neither exists.\n */\nfunction scheduleDetection() {\n  if (typeof window === 'undefined') {\n    return\n  }\n\n  if (typeof window.requestIdleCallback === 'function') {\n    window.requestIdleCallback(() => detectGpuTier(), { timeout: 1000 })\n  } else if (typeof window.requestAnimationFrame === 'function') {\n    window.requestAnimationFrame(() =>\n      window.requestAnimationFrame(() => detectGpuTier())\n    )\n  } else {\n    setTimeout(() => detectGpuTier(), 0)\n  }\n}\n\nscheduleDetection()\n\nfunction runBenchmark(gl: WebGLRenderingContext): Promise<number> {\n  return new Promise(resolve => {\n    const vs = gl.createShader(gl.VERTEX_SHADER)!\n    const fs = gl.createShader(gl.FRAGMENT_SHADER)!\n    gl.shaderSource(\n      vs,\n      'attribute vec2 a;void main(){gl_Position=vec4(a,0,1);}'\n    )\n    gl.shaderSource(\n      fs,\n      'precision highp float;uniform float t;void main(){float v=0.;for(int i=0;i<64;i++)v+=sin(float(i)*t*.01);gl_FragColor=vec4(v*.001);}'\n    )\n    gl.compileShader(vs)\n    gl.compileShader(fs)\n\n    const prog = gl.createProgram()!\n    gl.attachShader(prog, vs)\n    gl.attachShader(prog, fs)\n    gl.linkProgram(prog)\n    gl.useProgram(prog)\n\n    const buf = gl.createBuffer()\n    gl.bindBuffer(gl.ARRAY_BUFFER, buf)\n    gl.bufferData(\n      gl.ARRAY_BUFFER,\n      new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),\n      gl.STATIC_DRAW\n    )\n    const a = gl.getAttribLocation(prog, 'a')\n    gl.enableVertexAttribArray(a)\n    gl.vertexAttribPointer(a, 2, gl.FLOAT, false, 0, 0)\n\n    const uT = gl.getUniformLocation(prog, 't')\n    let frames = 0\n    const start = performance.now()\n\n    const tick = () => {\n      gl.uniform1f(uT, frames)\n      gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4)\n      gl.finish()\n      frames++\n\n      if (performance.now() - start < 200) {\n        requestAnimationFrame(tick)\n      } else {\n        const elapsed = performance.now() - start\n        gl.deleteProgram(prog)\n        gl.deleteShader(vs)\n        gl.deleteShader(fs)\n        gl.deleteBuffer(buf)\n        resolve((frames / elapsed) * 1000)\n      }\n    }\n\n    requestAnimationFrame(tick)\n  })\n}\n\nexport function useGpuTier() {\n  return useStore($gpuTier)\n}\n\ntype GpuTier = 0 | 1 | 2\n"],
  "mappings": "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",
  "names": []
}


package/dist/hooks/use-render-loop.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Visibility- and intersection-aware render-loop helper for the WebGL
+ * overlays.
+ *
+ * The overlays were previously running fragment shaders at 60fps for the
+ * entire lifetime of the page — including when the tab was hidden, the
+ * canvas had been scrolled out of view, or the user had been idle for
+ * hours. On retina laptops the compositor cost of mix-blend-mode on a
+ * full-viewport canvas plus continuous WebGL rasterisation is enough to
+ * keep the GPU hot indefinitely, which is what manifests as "fans go
+ * crazy after 2 hours of idle".
+ *
+ * `runRenderLoop` wraps a frame callback so that it:
+ *
+ *   1. Pauses entirely when `document.hidden` is true (background tab,
+ *      minimised window, screen locked).
+ *   2. Pauses when the canvas's bounding rect is offscreen (we tell
+ *      `IntersectionObserver` to look at the canvas itself).
+ *   3. Optionally caps the frame rate via a min-interval — the previous
+ *      `gpuTier === 1 ? setTimeout(loop, 100) : raf` trick is preserved
+ *      and extended so even tier-2 GPUs cap at e.g. 30fps for overlays
+ *      that don't need 60.
+ *
+ * The callback receives the *delta* time in seconds since the last call
+ * (so `uTime` advances correctly across pauses without ever skipping
+ * forward by hours).
+ */
+interface RunRenderLoopOptions {
+    /** Element to observe with IntersectionObserver. When fully out of
+     *  view, the loop pauses. Pass the canvas element itself. */
+    el: Element;
+    /** Min ms between frames. 0 = no cap (uses requestAnimationFrame).
+     *  Anything > 0 uses setTimeout-driven scheduling. */
+    minIntervalMs?: number;
+    /** Frame callback. Receives the elapsed seconds since the previous
+     *  *executed* frame (not since the previous scheduled frame), so
+     *  uniforms keyed off this value will not jump after a long pause. */
+    onFrame: (deltaSeconds: number) => void;
+}
+export declare function runRenderLoop({ el, minIntervalMs, onFrame }: RunRenderLoopOptions): () => void;
+export {};

package/dist/hooks/use-render-loop.js

@@ -0,0 +1,63 @@
+"use client";
+export function runRenderLoop({
+  el,
+  minIntervalMs = 0,
+  onFrame
+}) {
+  let running = true;
+  let visible = !document.hidden;
+  let inView = true;
+  let last = performance.now();
+  let raf = 0;
+  let timer;
+  const onVisibility = () => {
+    visible = !document.hidden;
+    if (visible) {
+      last = performance.now();
+      schedule();
+    }
+  };
+  const io = new IntersectionObserver(
+    (entries) => {
+      const wasInView = inView;
+      inView = entries.some((e) => e.isIntersecting);
+      if (!wasInView && inView) {
+        last = performance.now();
+        schedule();
+      }
+    },
+    { threshold: 0 }
+  );
+  io.observe(el);
+  document.addEventListener("visibilitychange", onVisibility);
+  const tick = () => {
+    if (!running) return;
+    if (!visible || !inView) {
+      return;
+    }
+    const now = performance.now();
+    const delta = (now - last) / 1e3;
+    last = now;
+    onFrame(delta);
+    schedule();
+  };
+  function schedule() {
+    if (!running || !visible || !inView) return;
+    if (minIntervalMs > 0) {
+      timer = setTimeout(tick, minIntervalMs);
+    } else {
+      raf = requestAnimationFrame(tick);
+    }
+  }
+  schedule();
+  return () => {
+    running = false;
+    io.disconnect();
+    document.removeEventListener("visibilitychange", onVisibility);
+    cancelAnimationFrame(raf);
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  };
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiJ3VzZSBjbGllbnQnXG5cbi8qKlxuICogVmlzaWJpbGl0eS0gYW5kIGludGVyc2VjdGlvbi1hd2FyZSByZW5kZXItbG9vcCBoZWxwZXIgZm9yIHRoZSBXZWJHTFxuICogb3ZlcmxheXMuXG4gKlxuICogVGhlIG92ZXJsYXlzIHdlcmUgcHJldmlvdXNseSBydW5uaW5nIGZyYWdtZW50IHNoYWRlcnMgYXQgNjBmcHMgZm9yIHRoZVxuICogZW50aXJlIGxpZmV0aW1lIG9mIHRoZSBwYWdlIFx1MjAxNCBpbmNsdWRpbmcgd2hlbiB0aGUgdGFiIHdhcyBoaWRkZW4sIHRoZVxuICogY2FudmFzIGhhZCBiZWVuIHNjcm9sbGVkIG91dCBvZiB2aWV3LCBvciB0aGUgdXNlciBoYWQgYmVlbiBpZGxlIGZvclxuICogaG91cnMuIE9uIHJldGluYSBsYXB0b3BzIHRoZSBjb21wb3NpdG9yIGNvc3Qgb2YgbWl4LWJsZW5kLW1vZGUgb24gYVxuICogZnVsbC12aWV3cG9ydCBjYW52YXMgcGx1cyBjb250aW51b3VzIFdlYkdMIHJhc3RlcmlzYXRpb24gaXMgZW5vdWdoIHRvXG4gKiBrZWVwIHRoZSBHUFUgaG90IGluZGVmaW5pdGVseSwgd2hpY2ggaXMgd2hhdCBtYW5pZmVzdHMgYXMgXCJmYW5zIGdvXG4gKiBjcmF6eSBhZnRlciAyIGhvdXJzIG9mIGlkbGVcIi5cbiAqXG4gKiBgcnVuUmVuZGVyTG9vcGAgd3JhcHMgYSBmcmFtZSBjYWxsYmFjayBzbyB0aGF0IGl0OlxuICpcbiAqICAgMS4gUGF1c2VzIGVudGlyZWx5IHdoZW4gYGRvY3VtZW50LmhpZGRlbmAgaXMgdHJ1ZSAoYmFja2dyb3VuZCB0YWIsXG4gKiAgICAgIG1pbmltaXNlZCB3aW5kb3csIHNjcmVlbiBsb2NrZWQpLlxuICogICAyLiBQYXVzZXMgd2hlbiB0aGUgY2FudmFzJ3MgYm91bmRpbmcgcmVjdCBpcyBvZmZzY3JlZW4gKHdlIHRlbGxcbiAqICAgICAgYEludGVyc2VjdGlvbk9ic2VydmVyYCB0byBsb29rIGF0IHRoZSBjYW52YXMgaXRzZWxmKS5cbiAqICAgMy4gT3B0aW9uYWxseSBjYXBzIHRoZSBmcmFtZSByYXRlIHZpYSBhIG1pbi1pbnRlcnZhbCBcdTIwMTQgdGhlIHByZXZpb3VzXG4gKiAgICAgIGBncHVUaWVyID09PSAxID8gc2V0VGltZW91dChsb29wLCAxMDApIDogcmFmYCB0cmljayBpcyBwcmVzZXJ2ZWRcbiAqICAgICAgYW5kIGV4dGVuZGVkIHNvIGV2ZW4gdGllci0yIEdQVXMgY2FwIGF0IGUuZy4gMzBmcHMgZm9yIG92ZXJsYXlzXG4gKiAgICAgIHRoYXQgZG9uJ3QgbmVlZCA2MC5cbiAqXG4gKiBUaGUgY2FsbGJhY2sgcmVjZWl2ZXMgdGhlICpkZWx0YSogdGltZSBpbiBzZWNvbmRzIHNpbmNlIHRoZSBsYXN0IGNhbGxcbiAqIChzbyBgdVRpbWVgIGFkdmFuY2VzIGNvcnJlY3RseSBhY3Jvc3MgcGF1c2VzIHdpdGhvdXQgZXZlciBza2lwcGluZ1xuICogZm9yd2FyZCBieSBob3VycykuXG4gKi9cblxuaW50ZXJmYWNlIFJ1blJlbmRlckxvb3BPcHRpb25zIHtcbiAgLyoqIEVsZW1lbnQgdG8gb2JzZXJ2ZSB3aXRoIEludGVyc2VjdGlvbk9ic2VydmVyLiBXaGVuIGZ1bGx5IG91dCBvZlxuICAgKiAgdmlldywgdGhlIGxvb3AgcGF1c2VzLiBQYXNzIHRoZSBjYW52YXMgZWxlbWVudCBpdHNlbGYuICovXG4gIGVsOiBFbGVtZW50XG4gIC8qKiBNaW4gbXMgYmV0d2VlbiBmcmFtZXMuIDAgPSBubyBjYXAgKHVzZXMgcmVxdWVzdEFuaW1hdGlvbkZyYW1lKS5cbiAgICogIEFueXRoaW5nID4gMCB1c2VzIHNldFRpbWVvdXQtZHJpdmVuIHNjaGVkdWxpbmcuICovXG4gIG1pbkludGVydmFsTXM/OiBudW1iZXJcbiAgLyoqIEZyYW1lIGNhbGxiYWNrLiBSZWNlaXZlcyB0aGUgZWxhcHNlZCBzZWNvbmRzIHNpbmNlIHRoZSBwcmV2aW91c1xuICAgKiAgKmV4ZWN1dGVkKiBmcmFtZSAobm90IHNpbmNlIHRoZSBwcmV2aW91cyBzY2hlZHVsZWQgZnJhbWUpLCBzb1xuICAgKiAgdW5pZm9ybXMga2V5ZWQgb2ZmIHRoaXMgdmFsdWUgd2lsbCBub3QganVtcCBhZnRlciBhIGxvbmcgcGF1c2UuICovXG4gIG9uRnJhbWU6IChkZWx0YVNlY29uZHM6IG51bWJlcikgPT4gdm9pZFxufVxuXG5leHBvcnQgZnVuY3Rpb24gcnVuUmVuZGVyTG9vcCh7XG4gIGVsLFxuICBtaW5JbnRlcnZhbE1zID0gMCxcbiAgb25GcmFtZVxufTogUnVuUmVuZGVyTG9vcE9wdGlvbnMpIHtcbiAgbGV0IHJ1bm5pbmcgPSB0cnVlXG4gIGxldCB2aXNpYmxlID0gIWRvY3VtZW50LmhpZGRlblxuICBsZXQgaW5WaWV3ID0gdHJ1ZVxuICBsZXQgbGFzdCA9IHBlcmZvcm1hbmNlLm5vdygpXG4gIGxldCByYWYgPSAwXG4gIGxldCB0aW1lcjogUmV0dXJuVHlwZTx0eXBlb2Ygc2V0VGltZW91dD4gfCB1bmRlZmluZWRcblxuICBjb25zdCBvblZpc2liaWxpdHkgPSAoKSA9PiB7XG4gICAgdmlzaWJsZSA9ICFkb2N1bWVudC5oaWRkZW5cblxuICAgIC8vIFdoZW4gd2UgY29tZSBiYWNrIGZyb20gYSBoaWRkZW4gdGFiLCByZXNldCB0aGUgY2xvY2sgc28gdGhlIG5leHRcbiAgICAvLyBmcmFtZSdzIGRlbHRhIGlzIH5vbmUgZnJhbWUsIG5vdCBcImhvdXJzIHNpbmNlIEkgd2FzIGhpZGRlblwiLlxuICAgIGlmICh2aXNpYmxlKSB7XG4gICAgICBsYXN0ID0gcGVyZm9ybWFuY2Uubm93KClcbiAgICAgIHNjaGVkdWxlKClcbiAgICB9XG4gIH1cblxuICBjb25zdCBpbyA9IG5ldyBJbnRlcnNlY3Rpb25PYnNlcnZlcihcbiAgICBlbnRyaWVzID0+IHtcbiAgICAgIGNvbnN0IHdhc0luVmlldyA9IGluVmlld1xuICAgICAgaW5WaWV3ID0gZW50cmllcy5zb21lKGUgPT4gZS5pc0ludGVyc2VjdGluZylcblxuICAgICAgaWYgKCF3YXNJblZpZXcgJiYgaW5WaWV3KSB7XG4gICAgICAgIGxhc3QgPSBwZXJmb3JtYW5jZS5ub3coKVxuICAgICAgICBzY2hlZHVsZSgpXG4gICAgICB9XG4gICAgfSxcbiAgICB7IHRocmVzaG9sZDogMCB9XG4gIClcblxuICBpby5vYnNlcnZlKGVsKVxuICBkb2N1bWVudC5hZGRFdmVudExpc3RlbmVyKCd2aXNpYmlsaXR5Y2hhbmdlJywgb25WaXNpYmlsaXR5KVxuXG4gIGNvbnN0IHRpY2sgPSAoKSA9PiB7XG4gICAgaWYgKCFydW5uaW5nKSByZXR1cm5cblxuICAgIGlmICghdmlzaWJsZSB8fCAhaW5WaWV3KSB7XG4gICAgICAvLyBEb24ndCByZXNjaGVkdWxlIFx1MjAxNCB3ZSdsbCBiZSByZS1raWNrZWQgYnkgdmlzaWJpbGl0eWNoYW5nZSBvciBJTy5cbiAgICAgIHJldHVyblxuICAgIH1cblxuICAgIGNvbnN0IG5vdyA9IHBlcmZvcm1hbmNlLm5vdygpXG4gICAgY29uc3QgZGVsdGEgPSAobm93IC0gbGFzdCkgLyAxMDAwXG4gICAgbGFzdCA9IG5vd1xuXG4gICAgb25GcmFtZShkZWx0YSlcbiAgICBzY2hlZHVsZSgpXG4gIH1cblxuICBmdW5jdGlvbiBzY2hlZHVsZSgpIHtcbiAgICBpZiAoIXJ1bm5pbmcgfHwgIXZpc2libGUgfHwgIWluVmlldykgcmV0dXJuXG5cbiAgICBpZiAobWluSW50ZXJ2YWxNcyA+IDApIHtcbiAgICAgIHRpbWVyID0gc2V0VGltZW91dCh0aWNrLCBtaW5JbnRlcnZhbE1zKVxuICAgIH0gZWxzZSB7XG4gICAgICByYWYgPSByZXF1ZXN0QW5pbWF0aW9uRnJhbWUodGljaylcbiAgICB9XG4gIH1cblxuICBzY2hlZHVsZSgpXG5cbiAgcmV0dXJuICgpID0+IHtcbiAgICBydW5uaW5nID0gZmFsc2VcbiAgICBpby5kaXNjb25uZWN0KClcbiAgICBkb2N1bWVudC5yZW1vdmVFdmVudExpc3RlbmVyKCd2aXNpYmlsaXR5Y2hhbmdlJywgb25WaXNpYmlsaXR5KVxuICAgIGNhbmNlbEFuaW1hdGlvbkZyYW1lKHJhZilcblxuICAgIGlmICh0aW1lciAhPT0gdW5kZWZpbmVkKSB7XG4gICAgICBjbGVhclRpbWVvdXQodGltZXIpXG4gICAgfVxuICB9XG59XG4iXSwKICAibWFwcGluZ3MiOiAiO0FBMkNPLGdCQUFTLGNBQWM7QUFBQSxFQUM1QjtBQUFBLEVBQ0EsZ0JBQWdCO0FBQUEsRUFDaEI7QUFDRixHQUF5QjtBQUN2QixNQUFJLFVBQVU7QUFDZCxNQUFJLFVBQVUsQ0FBQyxTQUFTO0FBQ3hCLE1BQUksU0FBUztBQUNiLE1BQUksT0FBTyxZQUFZLElBQUk7QUFDM0IsTUFBSSxNQUFNO0FBQ1YsTUFBSTtBQUVKLFFBQU0sZUFBZSxNQUFNO0FBQ3pCLGNBQVUsQ0FBQyxTQUFTO0FBSXBCLFFBQUksU0FBUztBQUNYLGFBQU8sWUFBWSxJQUFJO0FBQ3ZCLGVBQVM7QUFBQSxJQUNYO0FBQUEsRUFDRjtBQUVBLFFBQU0sS0FBSyxJQUFJO0FBQUEsSUFDYixhQUFXO0FBQ1QsWUFBTSxZQUFZO0FBQ2xCLGVBQVMsUUFBUSxLQUFLLE9BQUssRUFBRSxjQUFjO0FBRTNDLFVBQUksQ0FBQyxhQUFhLFFBQVE7QUFDeEIsZUFBTyxZQUFZLElBQUk7QUFDdkIsaUJBQVM7QUFBQSxNQUNYO0FBQUEsSUFDRjtBQUFBLElBQ0EsRUFBRSxXQUFXLEVBQUU7QUFBQSxFQUNqQjtBQUVBLEtBQUcsUUFBUSxFQUFFO0FBQ2IsV0FBUyxpQkFBaUIsb0JBQW9CLFlBQVk7QUFFMUQsUUFBTSxPQUFPLE1BQU07QUFDakIsUUFBSSxDQUFDLFFBQVM7QUFFZCxRQUFJLENBQUMsV0FBVyxDQUFDLFFBQVE7QUFFdkI7QUFBQSxJQUNGO0FBRUEsVUFBTSxNQUFNLFlBQVksSUFBSTtBQUM1QixVQUFNLFNBQVMsTUFBTSxRQUFRO0FBQzdCLFdBQU87QUFFUCxZQUFRLEtBQUs7QUFDYixhQUFTO0FBQUEsRUFDWDtBQUVBLFdBQVMsV0FBVztBQUNsQixRQUFJLENBQUMsV0FBVyxDQUFDLFdBQVcsQ0FBQyxPQUFRO0FBRXJDLFFBQUksZ0JBQWdCLEdBQUc7QUFDckIsY0FBUSxXQUFXLE1BQU0sYUFBYTtBQUFBLElBQ3hDLE9BQU87QUFDTCxZQUFNLHNCQUFzQixJQUFJO0FBQUEsSUFDbEM7QUFBQSxFQUNGO0FBRUEsV0FBUztBQUVULFNBQU8sTUFBTTtBQUNYLGNBQVU7QUFDVixPQUFHLFdBQVc7QUFDZCxhQUFTLG9CQUFvQixvQkFBb0IsWUFBWTtBQUM3RCx5QkFBcUIsR0FBRztBQUV4QixRQUFJLFVBQVUsUUFBVztBQUN2QixtQkFBYSxLQUFLO0FBQUEsSUFDcEI7QUFBQSxFQUNGO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/hooks/use-smooth-controls.d.ts

@@ -0,0 +1,16 @@
+import { useControls } from 'leva';
+import { type WritableAtom } from 'nanostores';
+export declare function useSmoothControls<T extends Record<string, any>>(label: string, initialArgs: T, options?: UseSmoothControlsOptions, dependencies?: Parameters<typeof useControls>[3]): { [K in keyof T]: T[K] extends {
+    value: infer V;
+} ? V : never; };
+export declare const getControlAtom: <T = any>(label: string, key: string) => undefined | WritableAtom<T>;
+export declare const setControlValue: <T = any>(label: string, key: string, value: T, options?: {
+    animate?: boolean;
+    duration?: number;
+}) => void;
+type UseSmoothControlsOptions = Parameters<typeof useControls>[2] & {
+    duration?: number;
+    onRandomize?: () => void;
+    onReset?: () => void;
+};
+export {};

package/dist/hooks/use-smooth-controls.js

@@ -0,0 +1,217 @@
+"use client";
+import gsap from "gsap";
+import { buttonGroup, useControls } from "leva";
+import { atom } from "nanostores";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+const atomRegistry = /* @__PURE__ */ new Map();
+const val = (v) => v && typeof v === "object" && "value" in v ? v.value : v;
+const isHex = (v) => /color/i.test(v?.type) || /^#[0-9a-f]{3,8}$/i.test(val(v));
+const randHex = () => `#${Math.floor(Math.random() * 16777215).toString(16).padStart(6, "0")}`;
+const randNum = (v) => typeof v === "object" && ("min" in v || "max" in v) ? gsap.utils.random(v.min ?? 0, v.max ?? 1, v.step ?? 0.01) : gsap.utils.random(0, 1);
+export function useSmoothControls(label, initialArgs, options, dependencies) {
+  const entries = useMemo(
+    () => Object.entries(initialArgs ?? {}),
+    [initialArgs]
+  );
+  const values = useMemo(
+    () => entries.filter(([, v]) => !/button|folder/i.test(v?.type)),
+    [entries]
+  );
+  const mountedRef = useRef(false);
+  const atoms = useMemo(() => {
+    const map = atomRegistry.get(label) ?? /* @__PURE__ */ new Map();
+    if (!atomRegistry.has(label)) {
+      atomRegistry.set(label, map);
+    }
+    const freshMount = !mountedRef.current;
+    entries.forEach(([k, v]) => {
+      if (v?.schema) {
+        Object.keys(v.schema).forEach((sk) => {
+          const key = `${k}.${sk}`;
+          if (!map.has(key)) {
+            map.set(key, atom(val(v.schema[sk])));
+          } else if (freshMount) {
+            map.get(key).set(val(v.schema[sk]));
+          }
+        });
+      } else if (!map.has(k)) {
+        map.set(k, atom(val(v)));
+      } else if (freshMount) {
+        map.get(k).set(val(v));
+      }
+    });
+    return map;
+  }, [label, entries]);
+  useEffect(() => {
+    mountedRef.current = true;
+  }, []);
+  const hydrate = useCallback(
+    () => Object.fromEntries(
+      entries.flatMap(
+        ([k, v]) => v?.schema ? Object.entries(v.schema).map(([k0, v0]) => [
+          k0,
+          atoms.get(`${k}.${k0}`)?.get() ?? val(v0)
+        ]) : [[k, atoms.get(k)?.get() ?? val(v)]]
+      )
+    ),
+    [entries, atoms]
+  );
+  const [args, update] = useState(hydrate);
+  const setRef = useRef(null);
+  const atomVals = useRef({});
+  const fromAtom = useRef(false);
+  const fromControl = useRef(/* @__PURE__ */ new Set());
+  useEffect(() => {
+    if (Object.keys(args).length !== Object.keys(initialArgs).length) {
+      update(hydrate);
+    }
+  }, [initialArgs, args]);
+  useEffect(() => {
+    if (!setRef.current) {
+      return;
+    }
+    const unsubs = [];
+    let ready = false;
+    const initTimeout = setTimeout(() => ready = true, 100);
+    const subscribe = (fullKey, updateFn) => {
+      const a = atoms.get(fullKey);
+      if (!a) {
+        return;
+      }
+      unsubs.push(
+        a.subscribe((v) => {
+          const prev = atomVals.current[fullKey];
+          atomVals.current[fullKey] = v;
+          if (setRef.current && ready && prev !== v && !fromControl.current.has(fullKey)) {
+            fromAtom.current = true;
+            try {
+              updateFn(v);
+            } catch {
+            }
+            setTimeout(() => fromAtom.current = false, 0);
+          }
+        })
+      );
+      atomVals.current[fullKey] = a.get();
+    };
+    entries.forEach(([k, v]) => {
+      if (v?.schema) {
+        Object.keys(v.schema).forEach((sk) => {
+          subscribe(`${k}.${sk}`, (v2) => {
+            try {
+              setRef.current({
+                [k]: { ...args[k] ?? {}, [sk]: v2 }
+              });
+            } catch {
+            }
+            update((st) => ({
+              ...st,
+              [k]: { ...st[k] ?? {}, [sk]: v2 }
+            }));
+          });
+        });
+      } else {
+        subscribe(k, (v2) => {
+          try {
+            setRef.current({ [k]: v2 });
+          } catch {
+          }
+          update((st) => ({ ...st, [k]: v2 }));
+        });
+      }
+    });
+    return () => {
+      clearTimeout(initTimeout);
+      unsubs.forEach((fn) => fn());
+    };
+  }, [label, entries, atoms, args]);
+  const onChange = (k, orig) => (e, k0) => {
+    if (fromAtom.current) {
+      return orig?.(e, k0);
+    }
+    const key = k0?.split(".")?.pop() ?? k;
+    const fullKey = k0 ?? k;
+    const a = atoms.get(fullKey);
+    fromControl.current.add(fullKey);
+    const sync = (v) => {
+      update((st) => ({ ...st, [key]: v }));
+      a?.set(v);
+      orig?.(v, k0);
+    };
+    if (typeof e === "number" && args[key] !== e) {
+      gsap.to(args, {
+        duration: options?.duration ?? 0.35,
+        ease: "circ.out",
+        [key]: e,
+        onComplete: () => void fromControl.current.delete(fullKey),
+        onUpdate: () => {
+          fromControl.current.add(fullKey);
+          sync(args[key]);
+          setTimeout(() => fromControl.current.delete(fullKey), 0);
+        }
+      });
+    } else {
+      sync(e);
+      setTimeout(() => fromControl.current.delete(fullKey), 0);
+    }
+  };
+  const [, set] = useControls(
+    label,
+    () => ({
+      ...Object.fromEntries(
+        entries.map(
+          ([k, v]) => v?.schema ? [
+            k,
+            {
+              ...v,
+              schema: Object.fromEntries(
+                Object.entries(v.schema).map(([sk, sv]) => [
+                  sk,
+                  { ...sv, onChange: onChange(k, sv?.onChange) }
+                ])
+              )
+            }
+          ] : [k, { ...v, onChange: onChange(k, v?.onChange) }]
+        )
+      ),
+      " ": buttonGroup({
+        flatten: () => void set(Object.fromEntries(values.map(([k]) => [k, 0]))),
+        randomize: () => {
+          set(
+            Object.fromEntries(
+              values.map(([k, v]) => [k, isHex(v) ? randHex() : randNum(v)])
+            )
+          );
+          options?.onRandomize?.();
+        },
+        reset: () => {
+          set(Object.fromEntries(values.map(([k, v]) => [k, val(v)])));
+          options?.onReset?.();
+        }
+      })
+    }),
+    { collapsed: true, ...options },
+    dependencies ?? []
+  );
+  setRef.current = set;
+  return args;
+}
+export const getControlAtom = (label, key) => atomRegistry.get(label)?.get(key);
+export const setControlValue = (label, key, value, options) => {
+  const a = getControlAtom(label, key);
+  if (!a) {
+    return;
+  }
+  if (options?.animate && typeof value === "number" && typeof a.get() === "number") {
+    const t = { v: a.get() };
+    gsap.to(t, {
+      duration: options.duration ?? 0.35,
+      ease: "circ.out",
+      onUpdate: () => a.set(t.v),
+      v: value
+    });
+  } else {
+    a.set(value);
+  }
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport gsap from 'gsap'\nimport { buttonGroup, useControls } from 'leva'\nimport { atom, type WritableAtom } from 'nanostores'\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react'\n\nconst atomRegistry = new Map<string, Map<string, WritableAtom<any>>>()\n\nconst val = (v: any) =>\n  v && typeof v === 'object' && 'value' in v ? v.value : v\n\nconst isHex = (v: any) =>\n  /color/i.test(v?.type) || /^#[0-9a-f]{3,8}$/i.test(val(v))\n\nconst randHex = () =>\n  `#${Math.floor(Math.random() * 0xffffff)\n    .toString(16)\n    .padStart(6, '0')}`\n\nconst randNum = (v: any) =>\n  typeof v === 'object' && ('min' in v || 'max' in v)\n    ? gsap.utils.random(v.min ?? 0, v.max ?? 1, v.step ?? 0.01)\n    : gsap.utils.random(0, 1)\n\nexport function useSmoothControls<T extends Record<string, any>>(\n  label: string,\n  initialArgs: T,\n  options?: UseSmoothControlsOptions,\n  dependencies?: Parameters<typeof useControls>[3]\n) {\n  type R = { [K in keyof T]: T[K] extends { value: infer V } ? V : never }\n\n  const entries = useMemo(\n    () => Object.entries(initialArgs ?? {}),\n    [initialArgs]\n  )\n\n  const values = useMemo(\n    () => entries.filter(([, v]) => !/button|folder/i.test(v?.type)),\n    [entries]\n  )\n\n  // Tracks whether this component instance has mounted yet. When a remount\n  // happens (e.g. Storybook changing a `key` prop to force a lens reset), we\n  // want the module-scoped atoms to be reseeded from the new `initialArgs` so\n  // the first paint reflects the newly-selected preset \u2014 not leftover values\n  // from the previous mount.\n  const mountedRef = useRef(false)\n\n  const atoms = useMemo(() => {\n    const map = atomRegistry.get(label) ?? new Map<string, WritableAtom<any>>()\n\n    if (!atomRegistry.has(label)) {\n      atomRegistry.set(label, map)\n    }\n\n    const freshMount = !mountedRef.current\n\n    entries.forEach(([k, v]) => {\n      if (v?.schema) {\n        Object.keys(v.schema).forEach(sk => {\n          const key = `${k}.${sk}`\n\n          if (!map.has(key)) {\n            map.set(key, atom(val(v.schema[sk])))\n          } else if (freshMount) {\n            map.get(key)!.set(val(v.schema[sk]))\n          }\n        })\n      } else if (!map.has(k)) {\n        map.set(k, atom(val(v)))\n      } else if (freshMount) {\n        map.get(k)!.set(val(v))\n      }\n    })\n\n    return map\n  }, [label, entries])\n\n  useEffect(() => {\n    mountedRef.current = true\n  }, [])\n\n  const hydrate = useCallback(\n    () =>\n      Object.fromEntries(\n        entries.flatMap(([k, v]) =>\n          v?.schema\n            ? Object.entries(v.schema).map(([k0, v0]: [string, any]) => [\n                k0,\n                atoms.get(`${k}.${k0}`)?.get() ?? val(v0)\n              ])\n            : [[k, atoms.get(k)?.get() ?? val(v)]]\n        )\n      ) as R,\n    [entries, atoms]\n  )\n\n  const [args, update] = useState<R>(hydrate)\n  const setRef = useRef<((values: Partial<R>) => void) | null>(null)\n  const atomVals = useRef<Record<string, any>>({})\n  const fromAtom = useRef(false)\n  const fromControl = useRef<Set<string>>(new Set())\n\n  useEffect(() => {\n    if (Object.keys(args).length !== Object.keys(initialArgs).length) {\n      update(hydrate)\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [initialArgs, args])\n\n  useEffect(() => {\n    if (!setRef.current) {\n      return\n    }\n\n    const unsubs: Array<() => void> = []\n    let ready = false\n    const initTimeout = setTimeout(() => (ready = true), 100)\n\n    const subscribe = (fullKey: string, updateFn: (v: any) => void) => {\n      const a = atoms.get(fullKey)\n\n      if (!a) {\n        return\n      }\n\n      unsubs.push(\n        a.subscribe(v => {\n          const prev = atomVals.current[fullKey]\n          atomVals.current[fullKey] = v\n\n          if (\n            setRef.current &&\n            ready &&\n            prev !== v &&\n            !fromControl.current.has(fullKey)\n          ) {\n            fromAtom.current = true\n\n            try {\n              updateFn(v)\n            } catch {\n              //\n            }\n\n            setTimeout(() => (fromAtom.current = false), 0)\n          }\n        })\n      )\n\n      atomVals.current[fullKey] = a.get()\n    }\n\n    entries.forEach(([k, v]) => {\n      if (v?.schema) {\n        Object.keys(v.schema).forEach(sk => {\n          subscribe(`${k}.${sk}`, v => {\n            try {\n              setRef.current!({\n                [k]: { ...((args[k] as any) ?? {}), [sk]: v }\n              } as Partial<R>)\n            } catch {\n              //\n            }\n\n            update(st => ({\n              ...st,\n              [k]: { ...((st[k] as any) ?? {}), [sk]: v }\n            }))\n          })\n        })\n      } else {\n        subscribe(k, v => {\n          try {\n            setRef.current!({ [k]: v } as Partial<R>)\n          } catch {\n            //\n          }\n\n          update(st => ({ ...st, [k]: v }))\n        })\n      }\n    })\n\n    return () => {\n      clearTimeout(initTimeout)\n      unsubs.forEach(fn => fn())\n    }\n  }, [label, entries, atoms, args])\n\n  const onChange =\n    (k: string, orig?: (e: any, k0?: string) => void) =>\n    (e: any, k0?: string) => {\n      if (fromAtom.current) {\n        return orig?.(e, k0)\n      }\n\n      const key = k0?.split('.')?.pop() ?? k\n      const fullKey = k0 ?? k\n      const a = atoms.get(fullKey)\n\n      fromControl.current.add(fullKey)\n\n      const sync = (v: any) => {\n        update(st => ({ ...st, [key]: v }))\n        a?.set(v)\n        orig?.(v, k0)\n      }\n\n      if (typeof e === 'number' && args[key] !== e) {\n        gsap.to(args, {\n          duration: options?.duration ?? 0.35,\n          ease: 'circ.out',\n          [key]: e,\n          onComplete: () => void fromControl.current.delete(fullKey),\n          onUpdate: () => {\n            fromControl.current.add(fullKey)\n            sync(args[key])\n            setTimeout(() => fromControl.current.delete(fullKey), 0)\n          }\n        })\n      } else {\n        sync(e)\n        setTimeout(() => fromControl.current.delete(fullKey), 0)\n      }\n    }\n\n  const [, set] = useControls(\n    label,\n    () => ({\n      ...Object.fromEntries(\n        entries.map(([k, v]) =>\n          v?.schema\n            ? [\n                k,\n                {\n                  ...v,\n                  schema: Object.fromEntries(\n                    Object.entries(v.schema).map(([sk, sv]: [string, any]) => [\n                      sk,\n                      { ...sv!, onChange: onChange(k, sv?.onChange) }\n                    ])\n                  )\n                }\n              ]\n            : [k, { ...v, onChange: onChange(k, v?.onChange) }]\n        )\n      ),\n\n      ' ': buttonGroup({\n        flatten: () =>\n          void set(Object.fromEntries(values.map(([k]) => [k, 0]))),\n        randomize: () => {\n          set(\n            Object.fromEntries(\n              values.map(([k, v]) => [k, isHex(v) ? randHex() : randNum(v)])\n            )\n          )\n          options?.onRandomize?.()\n        },\n        reset: () => {\n          set(Object.fromEntries(values.map(([k, v]) => [k, val(v)])))\n          options?.onReset?.()\n        }\n      })\n    }),\n    { collapsed: true, ...options },\n    dependencies ?? []\n  )\n\n  setRef.current = set\n\n  return args\n}\n\nexport const getControlAtom = <T = any>(\n  label: string,\n  key: string\n): undefined | WritableAtom<T> =>\n  atomRegistry.get(label)?.get(key) as undefined | WritableAtom<T>\n\nexport const setControlValue = <T = any>(\n  label: string,\n  key: string,\n  value: T,\n  options?: { animate?: boolean; duration?: number }\n) => {\n  const a = getControlAtom<T>(label, key)\n\n  if (!a) {\n    return\n  }\n\n  if (\n    options?.animate &&\n    typeof value === 'number' &&\n    typeof a.get() === 'number'\n  ) {\n    const t = { v: a.get() }\n\n    gsap.to(t, {\n      duration: options.duration ?? 0.35,\n      ease: 'circ.out',\n      onUpdate: () => a.set(t.v),\n      v: value\n    })\n  } else {\n    a.set(value)\n  }\n}\n\ntype UseSmoothControlsOptions = Parameters<typeof useControls>[2] & {\n  duration?: number\n  onRandomize?: () => void\n  onReset?: () => void\n}\n"],
  "mappings": "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",
  "names": ["v"]
}


package/dist/hooks/use-toast.d.ts

@@ -0,0 +1,7 @@
+export declare function useToast(duration?: number): {
+    showToast: (message: string, type: "error" | "success") => void;
+    toast: {
+        message: string;
+        type: "error" | "success";
+    } | null;
+};

package/dist/hooks/use-toast.js

@@ -0,0 +1,21 @@
+"use client";
+import { useCallback, useEffect, useRef, useState } from "react";
+export function useToast(duration = 3e3) {
+  const [toast, setToast] = useState(null);
+  const timerRef = useRef(null);
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, []);
+  const showToast = useCallback(
+    (message, type) => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      setToast({ message, type });
+      timerRef.current = setTimeout(() => setToast(null), duration);
+    },
+    [duration]
+  );
+  return { showToast, toast };
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiJ3VzZSBjbGllbnQnXG5cbmltcG9ydCB7IHVzZUNhbGxiYWNrLCB1c2VFZmZlY3QsIHVzZVJlZiwgdXNlU3RhdGUgfSBmcm9tICdyZWFjdCdcblxuZXhwb3J0IGZ1bmN0aW9uIHVzZVRvYXN0KGR1cmF0aW9uID0gMzAwMCkge1xuICBjb25zdCBbdG9hc3QsIHNldFRvYXN0XSA9IHVzZVN0YXRlPHtcbiAgICBtZXNzYWdlOiBzdHJpbmdcbiAgICB0eXBlOiAnZXJyb3InIHwgJ3N1Y2Nlc3MnXG4gIH0gfCBudWxsPihudWxsKVxuXG4gIGNvbnN0IHRpbWVyUmVmID0gdXNlUmVmPFJldHVyblR5cGU8dHlwZW9mIHNldFRpbWVvdXQ+IHwgbnVsbD4obnVsbClcblxuICB1c2VFZmZlY3QoKCkgPT4ge1xuICAgIHJldHVybiAoKSA9PiB7XG4gICAgICBpZiAodGltZXJSZWYuY3VycmVudCkgY2xlYXJUaW1lb3V0KHRpbWVyUmVmLmN1cnJlbnQpXG4gICAgfVxuICB9LCBbXSlcblxuICBjb25zdCBzaG93VG9hc3QgPSB1c2VDYWxsYmFjayhcbiAgICAobWVzc2FnZTogc3RyaW5nLCB0eXBlOiAnZXJyb3InIHwgJ3N1Y2Nlc3MnKSA9PiB7XG4gICAgICBpZiAodGltZXJSZWYuY3VycmVudCkgY2xlYXJUaW1lb3V0KHRpbWVyUmVmLmN1cnJlbnQpXG4gICAgICBzZXRUb2FzdCh7IG1lc3NhZ2UsIHR5cGUgfSlcbiAgICAgIHRpbWVyUmVmLmN1cnJlbnQgPSBzZXRUaW1lb3V0KCgpID0+IHNldFRvYXN0KG51bGwpLCBkdXJhdGlvbilcbiAgICB9LFxuICAgIFtkdXJhdGlvbl1cbiAgKVxuXG4gIHJldHVybiB7IHNob3dUb2FzdCwgdG9hc3QgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjtBQUVBLFNBQVMsYUFBYSxXQUFXLFFBQVEsZ0JBQWdCO0FBRWxELGdCQUFTLFNBQVMsV0FBVyxLQUFNO0FBQ3hDLFFBQU0sQ0FBQyxPQUFPLFFBQVEsSUFBSSxTQUdoQixJQUFJO0FBRWQsUUFBTSxXQUFXLE9BQTZDLElBQUk7QUFFbEUsWUFBVSxNQUFNO0FBQ2QsV0FBTyxNQUFNO0FBQ1gsVUFBSSxTQUFTLFFBQVMsY0FBYSxTQUFTLE9BQU87QUFBQSxJQUNyRDtBQUFBLEVBQ0YsR0FBRyxDQUFDLENBQUM7QUFFTCxRQUFNLFlBQVk7QUFBQSxJQUNoQixDQUFDLFNBQWlCLFNBQThCO0FBQzlDLFVBQUksU0FBUyxRQUFTLGNBQWEsU0FBUyxPQUFPO0FBQ25ELGVBQVMsRUFBRSxTQUFTLEtBQUssQ0FBQztBQUMxQixlQUFTLFVBQVUsV0FBVyxNQUFNLFNBQVMsSUFBSSxHQUFHLFFBQVE7QUFBQSxJQUM5RDtBQUFBLElBQ0EsQ0FBQyxRQUFRO0FBQUEsRUFDWDtBQUVBLFNBQU8sRUFBRSxXQUFXLE1BQU07QUFDNUI7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+export { AnimatedCount, useAnimatedCount } from './ui/components/animated-count';
+export { AsciiSkeleton, Scramble as AsciiScramble } from './ui/components/ascii';
+export { Badge } from './ui/components/badge';
+export { BottomSheet } from './ui/components/bottom-sheet';
+export { NousGirlBadge } from './ui/components/badges/sophos-girl';
+export { BlendMode, useBlendMode, withBlendMode } from './ui/components/blend-mode';
+export type { BlendModeProps } from './ui/components/blend-mode';
+export { Blink } from './ui/components/blink';
+export { Button } from './ui/components/button';
+export { Card, CardContent, CardDescription, CardHeader, CardTitle } from './ui/components/card';
+export { Checkbox } from './ui/components/checkbox';
+export { CommandBlock, CopyButton } from './ui/components/command-block';
+export { ConfirmDialog } from './ui/components/confirm-dialog';
+export { Cursor } from './ui/components/cursor';
+export { DropdownMenu } from './ui/components/dropdown-menu';
+export { FitText } from './ui/components/fit-text';
+export { BarChart, LineChart } from './ui/components/graphs';
+export { Cell, Grid } from './ui/components/grid';
+export { HoverBg } from './ui/components/hover-bg';
+export * as Icons from './ui/components/icons';
+export { DiscordIcon } from './ui/components/icons/discord';
+export { GitHubIcon } from './ui/components/icons/github';
+export { ImageDistortion } from './ui/components/image-distortion';
+export type { AutoPlayPattern } from './ui/components/image-distortion';
+export { Input } from './ui/components/input';
+export { Label } from './ui/components/label';
+export { LevaClient } from './ui/components/leva-client';
+export { ListItem } from './ui/components/list-item';
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger } from './ui/components/dialog';
+export { FilterGroup, Segmented } from './ui/components/segmented';
+export { Switch } from './ui/components/switch';
+export { Tabs, TabsList, TabsTrigger } from './ui/components/tabs';
+export { Poster } from './ui/components/poster';
+export type { PosterAspect, PosterProps, PosterVariant } from './ui/components/poster';
+export { applyLens, BLEND_MODES, LENSES, LENS_0, LENS_5I, lens0, lens5i, toggleLens, $lightMode } from './ui/components/overlays';
+export { Glitch, Greys, Lens, Noise, Overlays, Vignette } from './ui/components/overlays';
+export type { LensPreset } from './ui/components/overlays';
+export { Progress } from './ui/components/progress';
+export { SceneCanvas } from './ui/components/scene-canvas';
+export { Scramble } from './ui/components/scramble';
+export { Select, SelectOption } from './ui/components/select';
+export { SelectionSwitcher } from './ui/components/selection-switcher';
+export { Separator } from './ui/components/separator';
+export { Spinner } from './ui/components/spinner';
+export { Stats } from './ui/components/stats';
+export { TerminalDemo } from './ui/components/terminal-demo';
+export type { TerminalDemoStep } from './ui/components/terminal-demo';
+export { ThemeToggle } from './ui/components/theme-toggle';
+export { TierCard } from './ui/components/tier-card';
+export { Toast } from './ui/components/toast';
+export type { TierCardPrice, TierCardProps } from './ui/components/tier-card';
+export { TV } from './ui/components/tv';
+export { Watchlist } from './ui/components/watchlist';
+export { Typography } from './ui/components/typography';
+export type { TypographyProps } from './ui/components/typography';
+export { H1 } from './ui/components/typography/h1';
+export { H2 } from './ui/components/typography/h2';
+export { Legend } from './ui/components/typography/legend';
+export { Small } from './ui/components/typography/small';
+export { BasicPage } from './ui/basic-page';
+export { Header } from './ui/header';
+export type { HeaderLink, HeaderProps, HeaderSocial } from './ui/header';
+export { Footer } from './ui/footer';
+export type { FooterGroup, FooterLink, FooterProps } from './ui/footer';
+export { Socials } from './ui/components/socials';
+export type { SocialLink } from './ui/components/socials';
+export { LayoutWrapper } from './ui/layout-wrapper';
+export { FONT_SANS, FONT_MONO, FONT_RULES_COMPRESSED, FONT_RULES_EXPANDED, FONT_MONDWEST } from './fonts';
+export { cn, clamp, smoothstep, hexToVec3, truncate, stripWpStyles } from './utils';
+export { polyRef } from './utils';
+export type { PolyComponent, PolyProps, PolyRef } from './utils';
+export { hexToRgb, rgbToHex, colorDodge, colorMix } from './utils/color';
+export { useBelowBreakpoint } from './hooks/use-below-breakpoint';
+export { useCappedFrame } from './hooks/use-capped-frame';
+export { useConfirmDelete } from './hooks/use-confirm-delete';
+export { useCssVarDims } from './hooks/use-css-var-dims';
+export { $gpuTier, useGpuTier } from './hooks/use-gpu-tier';
+export { useSmoothControls, getControlAtom, setControlValue } from './hooks/use-smooth-controls';
+export { useToast } from './hooks/use-toast';