@nastechai-research/ui 0.18.2

package/dist/ui/components/leva-client.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Leva } from "leva";
+import { useEffect, useState } from "react";
+export function LevaClient() {
+  const [hidden, setHidden] = useState(true);
+  useEffect(() => {
+    setHidden(!new URLSearchParams(window.location.search).has("dev"));
+  }, []);
+  return /* @__PURE__ */ jsx(Leva, { ...{ hidden } });
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiJ3VzZSBjbGllbnQnXG5cbmltcG9ydCB7IExldmEgfSBmcm9tICdsZXZhJ1xuaW1wb3J0IHsgdXNlRWZmZWN0LCB1c2VTdGF0ZSB9IGZyb20gJ3JlYWN0J1xuXG5leHBvcnQgZnVuY3Rpb24gTGV2YUNsaWVudCgpIHtcbiAgY29uc3QgW2hpZGRlbiwgc2V0SGlkZGVuXSA9IHVzZVN0YXRlKHRydWUpXG5cbiAgdXNlRWZmZWN0KCgpID0+IHtcbiAgICBzZXRIaWRkZW4oIW5ldyBVUkxTZWFyY2hQYXJhbXMod2luZG93LmxvY2F0aW9uLnNlYXJjaCkuaGFzKCdkZXYnKSlcbiAgfSwgW10pXG5cbiAgcmV0dXJuIDxMZXZhIHsuLi57IGhpZGRlbiB9fSAvPlxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjtBQVlTO0FBVlQsU0FBUyxZQUFZO0FBQ3JCLFNBQVMsV0FBVyxnQkFBZ0I7QUFFN0IsZ0JBQVMsYUFBYTtBQUMzQixRQUFNLENBQUMsUUFBUSxTQUFTLElBQUksU0FBUyxJQUFJO0FBRXpDLFlBQVUsTUFBTTtBQUNkLGNBQVUsQ0FBQyxJQUFJLGdCQUFnQixPQUFPLFNBQVMsTUFBTSxFQUFFLElBQUksS0FBSyxDQUFDO0FBQUEsRUFDbkUsR0FBRyxDQUFDLENBQUM7QUFFTCxTQUFPLG9CQUFDLFFBQU0sR0FBRyxFQUFFLE9BQU8sR0FBRztBQUMvQjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/ui/components/list-item.d.ts

@@ -0,0 +1,6 @@
+import { type ButtonHTMLAttributes } from 'react';
+export declare const ListItem: import("react").ForwardRefExoticComponent<ListItemProps & import("react").RefAttributes<HTMLButtonElement>>;
+interface ListItemProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    active?: boolean;
+}
+export {};

package/dist/ui/components/list-item.js

@@ -0,0 +1,27 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { cn } from "../../utils/index.js";
+export const ListItem = forwardRef(
+  function ListItem2({ active = false, children, className, type = "button", ...props }, ref) {
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        className: cn(
+          "group relative flex w-full items-center gap-2 px-3 py-2 text-left",
+          "font-courier text-sm transition-colors cursor-pointer",
+          "focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-midground/30",
+          "disabled:cursor-not-allowed disabled:text-text-disabled",
+          active ? "bg-midground/10 text-midground" : "text-text-secondary hover:text-midground hover:bg-midground/5",
+          className
+        ),
+        "data-active": active || void 0,
+        ref,
+        type,
+        ...props,
+        children
+      }
+    );
+  }
+);
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/overlays/blend-modes.d.ts

@@ -0,0 +1 @@
+export declare const BLEND_MODES: React.CSSProperties["mixBlendMode"][];

package/dist/ui/components/overlays/blend-modes.js

@@ -0,0 +1,14 @@
+export const BLEND_MODES = [
+  "overlay",
+  "multiply",
+  "screen",
+  "difference",
+  "exclusion",
+  "color-dodge",
+  "color-burn",
+  "hard-light",
+  "soft-light",
+  "darken",
+  "lighten"
+];
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiZXhwb3J0IGNvbnN0IEJMRU5EX01PREVTID0gW1xuICAnb3ZlcmxheScsXG4gICdtdWx0aXBseScsXG4gICdzY3JlZW4nLFxuICAnZGlmZmVyZW5jZScsXG4gICdleGNsdXNpb24nLFxuICAnY29sb3ItZG9kZ2UnLFxuICAnY29sb3ItYnVybicsXG4gICdoYXJkLWxpZ2h0JyxcbiAgJ3NvZnQtbGlnaHQnLFxuICAnZGFya2VuJyxcbiAgJ2xpZ2h0ZW4nXG5dIGFzIHVua25vd24gYXMgUmVhY3QuQ1NTUHJvcGVydGllc1snbWl4QmxlbmRNb2RlJ11bXVxuIl0sCiAgIm1hcHBpbmdzIjogIkFBQU8sYUFBTSxjQUFjO0FBQUEsRUFDekI7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/ui/components/overlays/glitch.d.ts

@@ -0,0 +1,6 @@
+export declare function Glitch({ className, style }: GlitchProps): import("react").JSX.Element | null;
+interface GlitchProps {
+    className?: string;
+    style?: React.CSSProperties;
+}
+export {};

package/dist/ui/components/overlays/glitch.js

@@ -0,0 +1,209 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import * as THREE from "three";
+import { $gpuTier, useGpuTier } from "../../../hooks/use-gpu-tier.js";
+import { runRenderLoop } from "../../../hooks/use-render-loop.js";
+import { useSmoothControls } from "../../../hooks/use-smooth-controls.js";
+import { cn } from "../../../utils/index.js";
+import { BLEND_MODES } from "./blend-modes.js";
+const vert = (
+  /*glsl*/
+  `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`
+);
+const frag = (
+  /*glsl*/
+  `
+  uniform float uTime, uAlpha, uIntensity, uChroma, uSpeed, uSparsity;
+  uniform vec3 uColor;
+  varying vec2 vUv;
+
+  float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
+
+  vec2 hash2(vec2 p) {
+    vec3 q = fract(vec3(p.xyx) * vec3(.1031, .1030, .0973));
+    q += dot(q, q.yzx + 33.33);
+    return fract((q.xx + q.yz) * q.zy);
+  }
+
+  float dither(vec2 p, float a) {
+    return step(mod(floor(p.x) + floor(p.y) * 2.0, 4.0) / 4.0, a);
+  }
+
+  void main() {
+    vec3 col = vec3(0.0);
+    float t = uTime * uSpeed;
+    float tSlow = floor(t / 3.0);
+    float dit = dither(gl_FragCoord.xy * 0.5, 0.7);
+
+    for (float i = 0.0; i < 6.0; i++) {
+      float seed = i * 137.3;
+      float epoch = floor((t + hash(vec2(seed, 77.7)) * 200.0) / (4.0 + hash(vec2(seed, 0.0)) * 6.0));
+      float life = fract((t + hash(vec2(seed, 77.7)) * 200.0) / (4.0 + hash(vec2(seed, 0.0)) * 6.0));
+
+      if (hash(vec2(epoch, seed)) > 1.0 - uSparsity * 0.7) continue;
+
+      vec2 center = vec2(hash(vec2(epoch, seed + 13.1)), hash(vec2(epoch, seed + 27.3)));
+      vec2 size = vec2(0.015 + hash(vec2(epoch, seed + 41.5)) * 0.08, 0.008 + hash(vec2(epoch, seed + 53.7)) * 0.04);
+      vec2 d = abs(vUv - center);
+
+      if (d.x < size.x && d.y < size.y) {
+        float fade = smoothstep(0.0, 0.05, life) * smoothstep(1.0, 0.95, life);
+        vec2 gUV = vUv + (hash2(vec2(epoch, seed + 200.0)) - 0.5) * 0.08 * uIntensity;
+        float shift = uChroma * 0.015 * (sin(t * 2.0 + hash(vec2(epoch, seed)) * 6.28) * 0.3 + 0.7);
+
+        col += uColor * vec3(
+          hash(gUV * 50.0 + vec2(shift, 0.0) + epoch),
+          hash(gUV * 50.0 + epoch),
+          hash(gUV * 50.0 - vec2(shift, 0.0) + epoch)
+        ) * dither(gl_FragCoord.xy * 0.5, fade * 0.8 + 0.2) * uIntensity * 0.7;
+      }
+    }
+
+    for (float i = 0.0; i < 12.0; i++) {
+      float seed = i * 211.7 + 1000.0;
+      float epoch = floor((t + hash(vec2(seed, 77.7)) * 150.0) / (3.0 + hash(vec2(seed, 0.0)) * 5.0));
+      float life = fract((t + hash(vec2(seed, 77.7)) * 150.0) / (3.0 + hash(vec2(seed, 0.0)) * 5.0));
+
+      if (hash(vec2(epoch, seed)) > 1.0 - uSparsity * 0.5) continue;
+
+      vec2 pos = vec2(hash(vec2(epoch, seed + 13.1)), hash(vec2(epoch, seed + 27.3)));
+      float px = 0.003 + hash(vec2(epoch, seed + 41.5)) * 0.008;
+
+      if (abs(vUv.x - pos.x) < px && abs(vUv.y - pos.y) < px) {
+        float fade = smoothstep(0.0, 0.1, life) * smoothstep(1.0, 0.9, life);
+        vec3 c = uColor;
+        float cs = hash(vec2(epoch, seed + 700.0));
+
+        if (cs < 0.2) c.r *= 1.8 * uChroma;
+        else if (cs < 0.4) c.b *= 1.8 * uChroma;
+
+        col += c * dither(gl_FragCoord.xy * 0.5, fade * 0.9) * uIntensity;
+      }
+    }
+
+    float tearSize = 25.0 + uSparsity * 10.0;
+    float tearThresh = 0.85 + uSparsity * 0.1;
+
+    float hY = floor(vUv.y * tearSize);
+    if (step(tearThresh, hash(vec2(hY, tSlow))) > 0.0) {
+      float shift = (hash(vec2(hY, tSlow + 50.0)) - 0.5) * 0.25 * uIntensity;
+      col += uColor * step(0.4, hash(vec2(vUv.x + shift, hY + tSlow))) * dit * uIntensity * 0.5;
+    }
+
+    float vX = floor(vUv.x * tearSize);
+    if (step(tearThresh, hash(vec2(vX, tSlow + 100.0))) > 0.0) {
+      float shift = (hash(vec2(vX, tSlow + 150.0)) - 0.5) * 0.25 * uIntensity;
+      col += uColor * step(0.4, hash(vec2(vX + tSlow, vUv.y + shift))) * dit * uIntensity * 0.5;
+    }
+
+    gl_FragColor = vec4(col * uAlpha, max(col.r, max(col.g, col.b)) * uAlpha);
+  }
+`
+);
+export function Glitch({ className, style }) {
+  const gpuTier = useGpuTier();
+  const c = useSmoothControls(
+    "Effects/Glitch",
+    {
+      alpha: { max: 2, min: 0, step: 0.01, value: 0.25 },
+      blend: { options: BLEND_MODES, value: "difference" },
+      chroma: { max: 3, min: 0, step: 0.01, value: 1.17 },
+      color: { value: "#ffe6cb" },
+      enabled: { value: true },
+      intensity: { max: 1, min: 0, step: 0.01, value: 0.59 },
+      sparsity: { max: 1, min: 0, step: 0.01, value: 0.21 },
+      speed: { max: 10, min: 0.1, step: 0.1, value: 1 }
+    },
+    { collapsed: true }
+  );
+  const ref = useRef(null);
+  const cRef = useRef(c);
+  cRef.current = c;
+  const enabled = c.enabled && gpuTier > 0;
+  useEffect(() => {
+    if (!ref.current || !enabled) {
+      return;
+    }
+    let renderer;
+    try {
+      renderer = new THREE.WebGLRenderer({
+        alpha: true,
+        canvas: ref.current
+      });
+    } catch {
+      $gpuTier.set(0);
+      return;
+    }
+    const camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    const geo = new THREE.PlaneGeometry(2, 2);
+    const scene = new THREE.Scene();
+    const mat = new THREE.ShaderMaterial({
+      fragmentShader: frag,
+      transparent: true,
+      uniforms: {
+        uAlpha: { value: c.alpha },
+        uChroma: { value: c.chroma },
+        uColor: { value: new THREE.Color(c.color) },
+        uIntensity: { value: c.intensity },
+        uSparsity: { value: c.sparsity },
+        uSpeed: { value: c.speed },
+        uTime: { value: 0 }
+      },
+      vertexShader: vert
+    });
+    scene.add(new THREE.Mesh(geo, mat));
+    const resize = () => {
+      renderer.setSize(innerWidth, innerHeight);
+      renderer.setPixelRatio(Math.min(devicePixelRatio, 1.5));
+    };
+    resize();
+    window.addEventListener("resize", resize);
+    let time = 0;
+    const minIntervalMs = gpuTier === 1 ? 100 : 33;
+    const dispose = runRenderLoop({
+      el: ref.current,
+      minIntervalMs,
+      onFrame: (deltaSeconds) => {
+        time += deltaSeconds;
+        const v = cRef.current;
+        mat.uniforms.uTime.value = time;
+        mat.uniforms.uAlpha.value = v.alpha;
+        mat.uniforms.uChroma.value = v.chroma;
+        mat.uniforms.uIntensity.value = v.intensity;
+        mat.uniforms.uSparsity.value = v.sparsity;
+        mat.uniforms.uSpeed.value = v.speed;
+        mat.uniforms.uColor.value.set(v.color);
+        renderer.render(scene, camera);
+      }
+    });
+    return () => {
+      window.removeEventListener("resize", resize);
+      dispose();
+      mat.dispose();
+      geo.dispose();
+      renderer.dispose();
+    };
+  }, [enabled, gpuTier]);
+  if (!enabled) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    "canvas",
+    {
+      className: cn("h-full w-full", className),
+      ref,
+      style: {
+        mixBlendMode: c.blend,
+        ...style
+      }
+    }
+  );
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport { useEffect, useRef } from 'react'\nimport * as THREE from 'three'\n\nimport { $gpuTier, useGpuTier } from '../../../hooks/use-gpu-tier'\nimport { runRenderLoop } from '../../../hooks/use-render-loop'\nimport { useSmoothControls } from '../../../hooks/use-smooth-controls'\nimport { cn } from '../../../utils'\n\nimport { BLEND_MODES } from './blend-modes'\n\nconst vert = /*glsl*/ `\n  varying vec2 vUv;\n  void main() {\n    vUv = uv;\n    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);\n  }\n`\n\nconst frag = /*glsl*/ `\n  uniform float uTime, uAlpha, uIntensity, uChroma, uSpeed, uSparsity;\n  uniform vec3 uColor;\n  varying vec2 vUv;\n\n  float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }\n\n  vec2 hash2(vec2 p) {\n    vec3 q = fract(vec3(p.xyx) * vec3(.1031, .1030, .0973));\n    q += dot(q, q.yzx + 33.33);\n    return fract((q.xx + q.yz) * q.zy);\n  }\n\n  float dither(vec2 p, float a) {\n    return step(mod(floor(p.x) + floor(p.y) * 2.0, 4.0) / 4.0, a);\n  }\n\n  void main() {\n    vec3 col = vec3(0.0);\n    float t = uTime * uSpeed;\n    float tSlow = floor(t / 3.0);\n    float dit = dither(gl_FragCoord.xy * 0.5, 0.7);\n\n    for (float i = 0.0; i < 6.0; i++) {\n      float seed = i * 137.3;\n      float epoch = floor((t + hash(vec2(seed, 77.7)) * 200.0) / (4.0 + hash(vec2(seed, 0.0)) * 6.0));\n      float life = fract((t + hash(vec2(seed, 77.7)) * 200.0) / (4.0 + hash(vec2(seed, 0.0)) * 6.0));\n\n      if (hash(vec2(epoch, seed)) > 1.0 - uSparsity * 0.7) continue;\n\n      vec2 center = vec2(hash(vec2(epoch, seed + 13.1)), hash(vec2(epoch, seed + 27.3)));\n      vec2 size = vec2(0.015 + hash(vec2(epoch, seed + 41.5)) * 0.08, 0.008 + hash(vec2(epoch, seed + 53.7)) * 0.04);\n      vec2 d = abs(vUv - center);\n\n      if (d.x < size.x && d.y < size.y) {\n        float fade = smoothstep(0.0, 0.05, life) * smoothstep(1.0, 0.95, life);\n        vec2 gUV = vUv + (hash2(vec2(epoch, seed + 200.0)) - 0.5) * 0.08 * uIntensity;\n        float shift = uChroma * 0.015 * (sin(t * 2.0 + hash(vec2(epoch, seed)) * 6.28) * 0.3 + 0.7);\n\n        col += uColor * vec3(\n          hash(gUV * 50.0 + vec2(shift, 0.0) + epoch),\n          hash(gUV * 50.0 + epoch),\n          hash(gUV * 50.0 - vec2(shift, 0.0) + epoch)\n        ) * dither(gl_FragCoord.xy * 0.5, fade * 0.8 + 0.2) * uIntensity * 0.7;\n      }\n    }\n\n    for (float i = 0.0; i < 12.0; i++) {\n      float seed = i * 211.7 + 1000.0;\n      float epoch = floor((t + hash(vec2(seed, 77.7)) * 150.0) / (3.0 + hash(vec2(seed, 0.0)) * 5.0));\n      float life = fract((t + hash(vec2(seed, 77.7)) * 150.0) / (3.0 + hash(vec2(seed, 0.0)) * 5.0));\n\n      if (hash(vec2(epoch, seed)) > 1.0 - uSparsity * 0.5) continue;\n\n      vec2 pos = vec2(hash(vec2(epoch, seed + 13.1)), hash(vec2(epoch, seed + 27.3)));\n      float px = 0.003 + hash(vec2(epoch, seed + 41.5)) * 0.008;\n\n      if (abs(vUv.x - pos.x) < px && abs(vUv.y - pos.y) < px) {\n        float fade = smoothstep(0.0, 0.1, life) * smoothstep(1.0, 0.9, life);\n        vec3 c = uColor;\n        float cs = hash(vec2(epoch, seed + 700.0));\n\n        if (cs < 0.2) c.r *= 1.8 * uChroma;\n        else if (cs < 0.4) c.b *= 1.8 * uChroma;\n\n        col += c * dither(gl_FragCoord.xy * 0.5, fade * 0.9) * uIntensity;\n      }\n    }\n\n    float tearSize = 25.0 + uSparsity * 10.0;\n    float tearThresh = 0.85 + uSparsity * 0.1;\n\n    float hY = floor(vUv.y * tearSize);\n    if (step(tearThresh, hash(vec2(hY, tSlow))) > 0.0) {\n      float shift = (hash(vec2(hY, tSlow + 50.0)) - 0.5) * 0.25 * uIntensity;\n      col += uColor * step(0.4, hash(vec2(vUv.x + shift, hY + tSlow))) * dit * uIntensity * 0.5;\n    }\n\n    float vX = floor(vUv.x * tearSize);\n    if (step(tearThresh, hash(vec2(vX, tSlow + 100.0))) > 0.0) {\n      float shift = (hash(vec2(vX, tSlow + 150.0)) - 0.5) * 0.25 * uIntensity;\n      col += uColor * step(0.4, hash(vec2(vX + tSlow, vUv.y + shift))) * dit * uIntensity * 0.5;\n    }\n\n    gl_FragColor = vec4(col * uAlpha, max(col.r, max(col.g, col.b)) * uAlpha);\n  }\n`\n\nexport function Glitch({ className, style }: GlitchProps) {\n  const gpuTier = useGpuTier()\n\n  const c = useSmoothControls(\n    'Effects/Glitch',\n    {\n      alpha: { max: 2, min: 0, step: 0.01, value: 0.25 },\n      blend: { options: BLEND_MODES, value: 'difference' },\n      chroma: { max: 3, min: 0, step: 0.01, value: 1.17 },\n      color: { value: '#ffe6cb' },\n      enabled: { value: true },\n      intensity: { max: 1, min: 0, step: 0.01, value: 0.59 },\n      sparsity: { max: 1, min: 0, step: 0.01, value: 0.21 },\n      speed: { max: 10, min: 0.1, step: 0.1, value: 1 }\n    },\n    { collapsed: true }\n  )\n\n  const ref = useRef<HTMLCanvasElement>(null)\n  const cRef = useRef(c)\n  cRef.current = c\n\n  const enabled = c.enabled && gpuTier > 0\n\n  useEffect(() => {\n    if (!ref.current || !enabled) {\n      return\n    }\n\n    let renderer: THREE.WebGLRenderer\n\n    try {\n      renderer = new THREE.WebGLRenderer({\n        alpha: true,\n        canvas: ref.current\n      })\n    } catch {\n      // See note in noise.tsx \u2014 eager gpu-tier detection should keep us\n      // out of here, but if the driver fails the renderer constructor\n      // anyway, downgrade so other overlays stop trying too.\n      $gpuTier.set(0)\n\n      return\n    }\n\n    const camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1)\n    const geo = new THREE.PlaneGeometry(2, 2)\n    const scene = new THREE.Scene()\n\n    const mat = new THREE.ShaderMaterial({\n      fragmentShader: frag,\n      transparent: true,\n      uniforms: {\n        uAlpha: { value: c.alpha },\n        uChroma: { value: c.chroma },\n        uColor: { value: new THREE.Color(c.color) },\n        uIntensity: { value: c.intensity },\n        uSparsity: { value: c.sparsity },\n        uSpeed: { value: c.speed },\n        uTime: { value: 0 }\n      },\n      vertexShader: vert\n    })\n\n    scene.add(new THREE.Mesh(geo, mat))\n\n    const resize = () => {\n      renderer.setSize(innerWidth, innerHeight)\n      // Cap DPR at 1.5 \u2014 at full retina (2x) the glitch shader is one\n      // of the heaviest fillrate consumers in the app, and the visual\n      // difference is tiny because it's a chromatic-noise effect.\n      renderer.setPixelRatio(Math.min(devicePixelRatio, 1.5))\n    }\n\n    resize()\n    window.addEventListener('resize', resize)\n\n    let time = 0\n\n    // gpu-tier 1 \u2192 ~10fps (legacy), gpu-tier 2 \u2192 ~30fps (was 60fps).\n    // Glitch is a background ambient effect; users won't notice 30 vs\n    // 60 but the GPU absolutely will.\n    const minIntervalMs = gpuTier === 1 ? 100 : 33\n\n    const dispose = runRenderLoop({\n      el: ref.current,\n      minIntervalMs,\n      onFrame: deltaSeconds => {\n        time += deltaSeconds\n\n        const v = cRef.current\n\n        mat.uniforms.uTime.value = time\n        mat.uniforms.uAlpha.value = v.alpha\n        mat.uniforms.uChroma.value = v.chroma\n        mat.uniforms.uIntensity.value = v.intensity\n        mat.uniforms.uSparsity.value = v.sparsity\n        mat.uniforms.uSpeed.value = v.speed\n        mat.uniforms.uColor.value.set(v.color)\n\n        renderer.render(scene, camera)\n      }\n    })\n\n    return () => {\n      window.removeEventListener('resize', resize)\n      dispose()\n\n      mat.dispose()\n      geo.dispose()\n      renderer.dispose()\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [enabled, gpuTier])\n\n  if (!enabled) {\n    return null\n  }\n\n  return (\n    <canvas\n      className={cn('h-full w-full', className)}\n      ref={ref}\n      style={{\n        mixBlendMode: c.blend as React.CSSProperties['mixBlendMode'],\n        ...style\n      }}\n    />\n  )\n}\n\ninterface GlitchProps {\n  className?: string\n  style?: React.CSSProperties\n}"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/overlays/greys.d.ts

@@ -0,0 +1,6 @@
+export declare function Greys({ className, style }: GreysProps): import("react").JSX.Element | null;
+interface GreysProps {
+    className?: string;
+    style?: React.CSSProperties;
+}
+export {};