@nastechai-research/ui 0.13.2

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/nous-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';

package/dist/index.js

@@ -0,0 +1,107 @@
+export { AnimatedCount, useAnimatedCount } from "./ui/components/animated-count.js";
+export { AsciiSkeleton, Scramble as AsciiScramble } from "./ui/components/ascii.js";
+export { Badge } from "./ui/components/badge.js";
+export { BottomSheet } from "./ui/components/bottom-sheet.js";
+export { NousGirlBadge } from "./ui/components/badges/nous-girl.js";
+export { BlendMode, useBlendMode, withBlendMode } from "./ui/components/blend-mode.js";
+export { Blink } from "./ui/components/blink.js";
+export { Button } from "./ui/components/button.js";
+export { Card, CardContent, CardDescription, CardHeader, CardTitle } from "./ui/components/card.js";
+export { Checkbox } from "./ui/components/checkbox.js";
+export { CommandBlock, CopyButton } from "./ui/components/command-block.js";
+export { ConfirmDialog } from "./ui/components/confirm-dialog.js";
+export { Cursor } from "./ui/components/cursor.js";
+export { DropdownMenu } from "./ui/components/dropdown-menu.js";
+export { FitText } from "./ui/components/fit-text/index.js";
+export { BarChart, LineChart } from "./ui/components/graphs/index.js";
+export { Cell, Grid } from "./ui/components/grid/index.js";
+export { HoverBg } from "./ui/components/hover-bg.js";
+export * as Icons from "./ui/components/icons/index.js";
+export { DiscordIcon } from "./ui/components/icons/discord.js";
+export { GitHubIcon } from "./ui/components/icons/github.js";
+export { ImageDistortion } from "./ui/components/image-distortion.js";
+export { Input } from "./ui/components/input.js";
+export { Label } from "./ui/components/label.js";
+export { LevaClient } from "./ui/components/leva-client.js";
+export { ListItem } from "./ui/components/list-item.js";
+export {
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogOverlay,
+  DialogPortal,
+  DialogTitle,
+  DialogTrigger
+} from "./ui/components/dialog.js";
+export { FilterGroup, Segmented } from "./ui/components/segmented.js";
+export { Switch } from "./ui/components/switch.js";
+export { Tabs, TabsList, TabsTrigger } from "./ui/components/tabs.js";
+export { Poster } from "./ui/components/poster.js";
+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/index.js";
+export { Progress } from "./ui/components/progress.js";
+export { SceneCanvas } from "./ui/components/scene-canvas.js";
+export { Scramble } from "./ui/components/scramble.js";
+export { Select, SelectOption } from "./ui/components/select.js";
+export { SelectionSwitcher } from "./ui/components/selection-switcher.js";
+export { Separator } from "./ui/components/separator.js";
+export { Spinner } from "./ui/components/spinner.js";
+export { Stats } from "./ui/components/stats.js";
+export { TerminalDemo } from "./ui/components/terminal-demo.js";
+export { ThemeToggle } from "./ui/components/theme-toggle.js";
+export { TierCard } from "./ui/components/tier-card.js";
+export { Toast } from "./ui/components/toast.js";
+export { TV } from "./ui/components/tv.js";
+export { Watchlist } from "./ui/components/watchlist.js";
+export { Typography } from "./ui/components/typography/index.js";
+export { H1 } from "./ui/components/typography/h1.js";
+export { H2 } from "./ui/components/typography/h2.js";
+export { Legend } from "./ui/components/typography/legend.js";
+export { Small } from "./ui/components/typography/small.js";
+export { BasicPage } from "./ui/basic-page.js";
+export { Header } from "./ui/header.js";
+export { Footer } from "./ui/footer.js";
+export { Socials } from "./ui/components/socials.js";
+export { LayoutWrapper } from "./ui/layout-wrapper.js";
+export {
+  FONT_SANS,
+  FONT_MONO,
+  FONT_RULES_COMPRESSED,
+  FONT_RULES_EXPANDED,
+  FONT_MONDWEST
+} from "./fonts.js";
+export { cn, clamp, smoothstep, hexToVec3, truncate, stripWpStyles } from "./utils/index.js";
+export { polyRef } from "./utils/index.js";
+export { hexToRgb, rgbToHex, colorDodge, colorMix } from "./utils/color.js";
+export { useBelowBreakpoint } from "./hooks/use-below-breakpoint.js";
+export { useCappedFrame } from "./hooks/use-capped-frame.js";
+export { useConfirmDelete } from "./hooks/use-confirm-delete.js";
+export { useCssVarDims } from "./hooks/use-css-var-dims.js";
+export { $gpuTier, useGpuTier } from "./hooks/use-gpu-tier.js";
+export {
+  useSmoothControls,
+  getControlAtom,
+  setControlValue
+} from "./hooks/use-smooth-controls.js";
+export { useToast } from "./hooks/use-toast.js";
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["export { AnimatedCount, useAnimatedCount } from './ui/components/animated-count'\nexport { AsciiSkeleton, Scramble as AsciiScramble } from './ui/components/ascii'\nexport { Badge } from './ui/components/badge'\nexport { BottomSheet } from './ui/components/bottom-sheet'\nexport { NousGirlBadge } from './ui/components/badges/nous-girl'\nexport { BlendMode, useBlendMode, withBlendMode } from './ui/components/blend-mode'\nexport type { BlendModeProps } from './ui/components/blend-mode'\nexport { Blink } from './ui/components/blink'\nexport { Button } from './ui/components/button'\nexport { Card, CardContent, CardDescription, CardHeader, CardTitle } from './ui/components/card'\nexport { Checkbox } from './ui/components/checkbox'\nexport { CommandBlock, CopyButton } from './ui/components/command-block'\nexport { ConfirmDialog } from './ui/components/confirm-dialog'\nexport { Cursor } from './ui/components/cursor'\nexport { DropdownMenu } from './ui/components/dropdown-menu'\nexport { FitText } from './ui/components/fit-text'\nexport { BarChart, LineChart } from './ui/components/graphs'\nexport { Cell, Grid } from './ui/components/grid'\nexport { HoverBg } from './ui/components/hover-bg'\nexport * as Icons from './ui/components/icons'\nexport { DiscordIcon } from './ui/components/icons/discord'\nexport { GitHubIcon } from './ui/components/icons/github'\nexport { ImageDistortion } from './ui/components/image-distortion'\nexport type { AutoPlayPattern } from './ui/components/image-distortion'\nexport { Input } from './ui/components/input'\nexport { Label } from './ui/components/label'\nexport { LevaClient } from './ui/components/leva-client'\nexport { ListItem } from './ui/components/list-item'\nexport {\n  Dialog,\n  DialogClose,\n  DialogContent,\n  DialogDescription,\n  DialogFooter,\n  DialogHeader,\n  DialogOverlay,\n  DialogPortal,\n  DialogTitle,\n  DialogTrigger\n} from './ui/components/dialog'\nexport { FilterGroup, Segmented } from './ui/components/segmented'\nexport { Switch } from './ui/components/switch'\nexport { Tabs, TabsList, TabsTrigger } from './ui/components/tabs'\nexport { Poster } from './ui/components/poster'\nexport type {\n  PosterAspect,\n  PosterProps,\n  PosterVariant\n} from './ui/components/poster'\nexport {\n  applyLens,\n  BLEND_MODES,\n  LENSES,\n  LENS_0,\n  LENS_5I,\n  lens0,\n  lens5i,\n  toggleLens,\n  $lightMode\n} from './ui/components/overlays'\nexport {\n  Glitch,\n  Greys,\n  Lens,\n  Noise,\n  Overlays,\n  Vignette\n} from './ui/components/overlays'\nexport type { LensPreset } from './ui/components/overlays'\nexport { Progress } from './ui/components/progress'\nexport { SceneCanvas } from './ui/components/scene-canvas'\nexport { Scramble } from './ui/components/scramble'\nexport { Select, SelectOption } from './ui/components/select'\nexport { SelectionSwitcher } from './ui/components/selection-switcher'\nexport { Separator } from './ui/components/separator'\nexport { Spinner } from './ui/components/spinner'\nexport { Stats } from './ui/components/stats'\nexport { TerminalDemo } from './ui/components/terminal-demo'\nexport type { TerminalDemoStep } from './ui/components/terminal-demo'\nexport { ThemeToggle } from './ui/components/theme-toggle'\nexport { TierCard } from './ui/components/tier-card'\nexport { Toast } from './ui/components/toast'\nexport type { TierCardPrice, TierCardProps } from './ui/components/tier-card'\nexport { TV } from './ui/components/tv'\nexport { Watchlist } from './ui/components/watchlist'\n\nexport { Typography } from './ui/components/typography'\nexport type { TypographyProps } from './ui/components/typography'\nexport { H1 } from './ui/components/typography/h1'\nexport { H2 } from './ui/components/typography/h2'\nexport { Legend } from './ui/components/typography/legend'\nexport { Small } from './ui/components/typography/small'\n\nexport { BasicPage } from './ui/basic-page'\nexport { Header } from './ui/header'\nexport type { HeaderLink, HeaderProps, HeaderSocial } from './ui/header'\nexport { Footer } from './ui/footer'\nexport type {\n  FooterGroup,\n  FooterLink,\n  FooterProps\n} from './ui/footer'\nexport { Socials } from './ui/components/socials'\nexport type { SocialLink } from './ui/components/socials'\nexport { LayoutWrapper } from './ui/layout-wrapper'\n\nexport {\n  FONT_SANS,\n  FONT_MONO,\n  FONT_RULES_COMPRESSED,\n  FONT_RULES_EXPANDED,\n  FONT_MONDWEST\n} from './fonts'\n\nexport { cn, clamp, smoothstep, hexToVec3, truncate, stripWpStyles } from './utils'\nexport { polyRef } from './utils'\nexport type { PolyComponent, PolyProps, PolyRef } from './utils'\nexport { hexToRgb, rgbToHex, colorDodge, colorMix } from './utils/color'\n\nexport { useBelowBreakpoint } from './hooks/use-below-breakpoint'\nexport { useCappedFrame } from './hooks/use-capped-frame'\nexport { useConfirmDelete } from './hooks/use-confirm-delete'\nexport { useCssVarDims } from './hooks/use-css-var-dims'\nexport { $gpuTier, useGpuTier } from './hooks/use-gpu-tier'\nexport {\n  useSmoothControls,\n  getControlAtom,\n  setControlValue\n} from './hooks/use-smooth-controls'\nexport { useToast } from './hooks/use-toast'\n"],
  "mappings": "AAAA,SAAS,eAAe,wBAAwB;AAChD,SAAS,eAAe,YAAY,qBAAqB;AACzD,SAAS,aAAa;AACtB,SAAS,mBAAmB;AAC5B,SAAS,qBAAqB;AAC9B,SAAS,WAAW,cAAc,qBAAqB;AAEvD,SAAS,aAAa;AACtB,SAAS,cAAc;AACvB,SAAS,MAAM,aAAa,iBAAiB,YAAY,iBAAiB;AAC1E,SAAS,gBAAgB;AACzB,SAAS,cAAc,kBAAkB;AACzC,SAAS,qBAAqB;AAC9B,SAAS,cAAc;AACvB,SAAS,oBAAoB;AAC7B,SAAS,eAAe;AACxB,SAAS,UAAU,iBAAiB;AACpC,SAAS,MAAM,YAAY;AAC3B,SAAS,eAAe;AACxB,YAAY,WAAW;AACvB,SAAS,mBAAmB;AAC5B,SAAS,kBAAkB;AAC3B,SAAS,uBAAuB;AAEhC,SAAS,aAAa;AACtB,SAAS,aAAa;AACtB,SAAS,kBAAkB;AAC3B,SAAS,gBAAgB;AACzB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,aAAa,iBAAiB;AACvC,SAAS,cAAc;AACvB,SAAS,MAAM,UAAU,mBAAmB;AAC5C,SAAS,cAAc;AAMvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,gBAAgB;AACzB,SAAS,mBAAmB;AAC5B,SAAS,gBAAgB;AACzB,SAAS,QAAQ,oBAAoB;AACrC,SAAS,yBAAyB;AAClC,SAAS,iBAAiB;AAC1B,SAAS,eAAe;AACxB,SAAS,aAAa;AACtB,SAAS,oBAAoB;AAE7B,SAAS,mBAAmB;AAC5B,SAAS,gBAAgB;AACzB,SAAS,aAAa;AAEtB,SAAS,UAAU;AACnB,SAAS,iBAAiB;AAE1B,SAAS,kBAAkB;AAE3B,SAAS,UAAU;AACnB,SAAS,UAAU;AACnB,SAAS,cAAc;AACvB,SAAS,aAAa;AAEtB,SAAS,iBAAiB;AAC1B,SAAS,cAAc;AAEvB,SAAS,cAAc;AAMvB,SAAS,eAAe;AAExB,SAAS,qBAAqB;AAE9B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,IAAI,OAAO,YAAY,WAAW,UAAU,qBAAqB;AAC1E,SAAS,eAAe;AAExB,SAAS,UAAU,UAAU,YAAY,gBAAgB;AAEzD,SAAS,0BAA0B;AACnC,SAAS,sBAAsB;AAC/B,SAAS,wBAAwB;AACjC,SAAS,qBAAqB;AAC9B,SAAS,UAAU,kBAAkB;AACrC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,gBAAgB;",
  "names": []
}


package/dist/ui/basic-page.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export declare function BasicPage({ children, subtitle, title }: BasicPageProps): import("react").JSX.Element;
+interface BasicPageProps extends React.PropsWithChildren {
+    subtitle?: string;
+    title?: ReactNode;
+}
+export {};

package/dist/ui/basic-page.js

@@ -0,0 +1,18 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Cell, Grid } from "./components/grid/index.js";
+import { Progress } from "./components/progress.js";
+import { H1 } from "./components/typography/h1.js";
+import { Small } from "./components/typography/small.js";
+export function BasicPage({ children, subtitle, title }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Grid, { children: /* @__PURE__ */ jsx(Cell, { children: /* @__PURE__ */ jsx(Progress, { value: 0 }) }) }),
+    /* @__PURE__ */ jsxs(Grid, { className: "lg:grid-cols-[max-content_1fr]", children: [
+      /* @__PURE__ */ jsx(Cell, { className: "-order-1", children: /* @__PURE__ */ jsxs("div", { className: "sticky top-4 flex flex-col gap-4", children: [
+        title ? /* @__PURE__ */ jsx(H1, { className: "-mb-2 pr-10 opacity-90", children: title }) : null,
+        subtitle ? /* @__PURE__ */ jsx(Small, { className: "opacity-60", children: subtitle }) : null
+      ] }) }),
+      /* @__PURE__ */ jsx(Cell, { className: "post bg-current/3", children })
+    ] })
+  ] });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/build.css

@@ -0,0 +1,4 @@
+@import "tailwindcss";
+@source "../";
+@import "./fonts.css";
+@import "./globals.css";

package/dist/ui/components/animated-count.d.ts

@@ -0,0 +1,10 @@
+export declare function useAnimatedCount(from: number, rate: number, ts?: Date, pausedAt?: Date): number;
+export declare function AnimatedCount({ damping, duration, pausedAt, rate, value }: Props): import("react").JSX.Element;
+interface Props {
+    damping?: number;
+    duration?: number;
+    pausedAt?: Date;
+    rate?: number;
+    value: number;
+}
+export {};