@nastechai-research/ui 0.13.2

package/dist/ui/components/scramble.js

@@ -0,0 +1,63 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+const CHARS = '.,\xB7-\u2500~+:;=*\u03C0""\u2510\u250C\u2518\u2534\u252C\u2557\u2554\u255D\u255A\u256C\u2560\u2563\u2569\u2566\u2551\u2591\u2592\u2593\u2588\u2584\u2580\u258C\u2590\u25A0!?&#$@0123456789*';
+export function Scramble({
+  children,
+  dur = 666,
+  spread = 1,
+  target
+}) {
+  const text = String(children);
+  const len = text.length;
+  const [display, setDisplay] = useState(text);
+  const frame = useRef(null);
+  const waves = useRef([]);
+  useEffect(() => {
+    const el = target?.current;
+    if (!el) {
+      return;
+    }
+    const animate = () => {
+      const t = Date.now();
+      waves.current = waves.current.filter((w) => t - w.time < dur);
+      if (!waves.current.length) {
+        setDisplay(text);
+        frame.current = null;
+        return;
+      }
+      setDisplay(
+        text.split("").map((c, i) => {
+          if (c === " ") {
+            return c;
+          }
+          for (const w of waves.current) {
+            const age = t - w.time;
+            const rad = Math.min(age / dur, 1) * (Math.max(w.pos, len - w.pos - 1) + 5) / spread;
+            const dist = Math.abs(i - w.pos);
+            const int = rad - dist;
+            if (dist <= rad && int > 0 && int <= 3) {
+              return CHARS[(dist * 3 + (age / 40 | 0)) % CHARS.length];
+            }
+          }
+          return c;
+        }).join("")
+      );
+      frame.current = requestAnimationFrame(animate);
+    };
+    const onEnter = () => {
+      waves.current.push({ pos: len >> 1, time: Date.now() });
+      frame.current ??= requestAnimationFrame(animate);
+    };
+    el.addEventListener("mouseenter", onEnter);
+    return () => {
+      el.removeEventListener("mouseenter", onEnter);
+      frame.current && cancelAnimationFrame(frame.current);
+    };
+  }, [target, text, len, dur, spread]);
+  useEffect(() => {
+    setDisplay(text);
+  }, [text]);
+  return /* @__PURE__ */ jsx(Fragment, { children: display });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/segmented.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from 'react';
+export declare function Segmented<T extends string>({ className, onChange, options, size, value }: SegmentedProps<T>): import("react").JSX.Element;
+export declare function FilterGroup({ children, className, label }: FilterGroupProps): import("react").JSX.Element;
+interface FilterGroupProps {
+    children: ReactNode;
+    className?: string;
+    label: string;
+}
+interface SegmentedOption<T extends string> {
+    label: string;
+    value: T;
+}
+interface SegmentedProps<T extends string> {
+    className?: string;
+    onChange: (value: T) => void;
+    options: SegmentedOption<T>[];
+    size?: 'md' | 'sm';
+    value: T;
+}
+export {};

package/dist/ui/components/segmented.js

@@ -0,0 +1,51 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cn } from "../../utils/index.js";
+export function Segmented({
+  className,
+  onChange,
+  options,
+  size = "sm",
+  value
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "inline-flex border border-midground/15 bg-background/30",
+        className
+      ),
+      role: "radiogroup",
+      children: options.map((opt) => {
+        const active = opt.value === value;
+        return /* @__PURE__ */ jsx(
+          "button",
+          {
+            "aria-checked": active,
+            className: cn(
+              "font-mondwest text-display tracking-[0.1em]",
+              "transition-colors cursor-pointer whitespace-nowrap",
+              "border-r border-midground/15 last:border-r-0",
+              "focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-midground/30",
+              size === "sm" && "h-7 px-2.5 text-xs",
+              size === "md" && "h-8 px-3 text-xs",
+              active ? "bg-midground text-background" : "text-text-secondary hover:bg-midground/10 hover:text-midground"
+            ),
+            onClick: () => onChange(opt.value),
+            role: "radio",
+            type: "button",
+            children: opt.label
+          },
+          opt.value
+        );
+      })
+    }
+  );
+}
+export function FilterGroup({ children, className, label }) {
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex items-center gap-2", className), children: [
+    /* @__PURE__ */ jsx("span", { className: "font-mondwest text-display text-xs tracking-[0.12em] text-text-tertiary", children: label }),
+    children
+  ] });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/select.d.ts

@@ -0,0 +1,18 @@
+import { type CSSProperties, type ReactNode } from 'react';
+export declare function Select({ children, className, disabled, id, onValueChange, placeholder, style, value }: SelectProps): import("react").JSX.Element;
+export declare function SelectOption(_props: SelectOptionProps): null;
+interface SelectOptionProps {
+    children: ReactNode;
+    value: string;
+}
+interface SelectProps {
+    children?: ReactNode;
+    className?: string;
+    disabled?: boolean;
+    id?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    style?: CSSProperties;
+    value?: string;
+}
+export {};

package/dist/ui/components/select.js

@@ -0,0 +1,215 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import {
+  Children,
+  isValidElement,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { cn } from "../../utils/index.js";
+const TRIGGER_CN = "flex h-9 w-full items-center justify-between gap-2 border border-midground/15 bg-background/40 px-3 py-1 font-courier text-sm text-left text-midground transition-colors hover:border-midground/25 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-midground/30 focus-visible:border-midground/30 disabled:cursor-not-allowed disabled:opacity-50 cursor-pointer";
+const LISTBOX_CN = "absolute z-50 mt-1 w-full max-h-60 overflow-auto border border-midground/15 bg-background-base text-midground shadow-lg";
+export function Select({
+  children,
+  className,
+  disabled,
+  id,
+  onValueChange,
+  placeholder,
+  style,
+  value
+}) {
+  const [open, setOpen] = useState(false);
+  const [highlightedIndex, setHighlightedIndex] = useState(-1);
+  const containerRef = useRef(null);
+  const listRef = useRef(null);
+  const options = useMemo(() => collectOptions(children), [children]);
+  const selected = options.find((o) => o.value === value);
+  const displayLabel = selected?.label ?? placeholder ?? value ?? "";
+  const close = useCallback(() => {
+    setOpen(false);
+    setHighlightedIndex(-1);
+  }, []);
+  useEffect(() => {
+    if (!open) return;
+    const ac = new AbortController();
+    document.addEventListener(
+      "mousedown",
+      (e) => {
+        if (!containerRef.current?.contains(e.target)) close();
+      },
+      { signal: ac.signal }
+    );
+    return () => ac.abort();
+  }, [open, close]);
+  useEffect(() => {
+    if (!open || highlightedIndex < 0) return;
+    const el = listRef.current?.children[highlightedIndex];
+    el?.scrollIntoView({ block: "nearest" });
+  }, [open, highlightedIndex]);
+  const handleKeyDown = (e) => {
+    if (disabled) return;
+    switch (e.key) {
+      case "Enter":
+      case " ":
+        e.preventDefault();
+        if (!open) {
+          setOpen(true);
+          setHighlightedIndex(options.findIndex((o) => o.value === value));
+        } else if (highlightedIndex >= 0 && options[highlightedIndex]) {
+          onValueChange?.(options[highlightedIndex].value);
+          close();
+        }
+        break;
+      case "ArrowDown":
+        e.preventDefault();
+        if (!open) {
+          setOpen(true);
+          setHighlightedIndex(options.findIndex((o) => o.value === value));
+        } else {
+          setHighlightedIndex((i) => Math.min(i + 1, options.length - 1));
+        }
+        break;
+      case "ArrowUp":
+        e.preventDefault();
+        if (open) setHighlightedIndex((i) => Math.max(i - 1, 0));
+        break;
+      case "Home":
+        if (open) {
+          e.preventDefault();
+          setHighlightedIndex(0);
+        }
+        break;
+      case "End":
+        if (open) {
+          e.preventDefault();
+          setHighlightedIndex(options.length - 1);
+        }
+        break;
+      case "Escape":
+        e.preventDefault();
+        close();
+        break;
+    }
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn("relative", className),
+      id,
+      ref: containerRef,
+      style,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            "aria-expanded": open,
+            "aria-haspopup": "listbox",
+            className: TRIGGER_CN,
+            disabled,
+            onClick: () => !disabled && setOpen((o) => !o),
+            onKeyDown: handleKeyDown,
+            role: "combobox",
+            type: "button",
+            children: [
+              /* @__PURE__ */ jsx("span", { className: cn("truncate", !selected && "text-midground/50"), children: displayLabel }),
+              /* @__PURE__ */ jsx(
+                ChevronDownGlyph,
+                {
+                  className: cn(
+                    "size-3 shrink-0 text-midground/60 transition-transform",
+                    open && "rotate-180"
+                  )
+                }
+              )
+            ]
+          }
+        ),
+        open && /* @__PURE__ */ jsx("div", { className: LISTBOX_CN, ref: listRef, role: "listbox", children: options.map((opt, i) => {
+          const isSelected = opt.value === value;
+          const isHighlighted = i === highlightedIndex;
+          return /* @__PURE__ */ jsxs(
+            "div",
+            {
+              "aria-selected": isSelected,
+              className: cn(
+                "flex cursor-pointer items-center gap-2 px-3 py-2",
+                "font-courier text-sm transition-colors",
+                isHighlighted && "bg-midground/10",
+                isSelected ? "text-midground" : "text-midground/70"
+              ),
+              onClick: () => {
+                onValueChange?.(opt.value);
+                close();
+              },
+              onMouseEnter: () => setHighlightedIndex(i),
+              role: "option",
+              children: [
+                /* @__PURE__ */ jsx(
+                  CheckGlyph,
+                  {
+                    className: cn(
+                      "size-3 shrink-0",
+                      isSelected ? "opacity-100" : "opacity-0"
+                    )
+                  }
+                ),
+                /* @__PURE__ */ jsx("span", { className: "truncate", children: opt.label })
+              ]
+            },
+            opt.value
+          );
+        }) })
+      ]
+    }
+  );
+}
+export function SelectOption(_props) {
+  return null;
+}
+const ChevronDownGlyph = ({ className }) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    "aria-hidden": true,
+    className,
+    fill: "none",
+    stroke: "currentColor",
+    strokeLinecap: "square",
+    strokeWidth: 1.5,
+    viewBox: "0 0 12 12",
+    children: /* @__PURE__ */ jsx("path", { d: "M2.5 4.5 6 8l3.5-3.5" })
+  }
+);
+const CheckGlyph = ({ className }) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    "aria-hidden": true,
+    className,
+    fill: "none",
+    stroke: "currentColor",
+    strokeLinecap: "square",
+    strokeWidth: 1.5,
+    viewBox: "0 0 12 12",
+    children: /* @__PURE__ */ jsx("path", { d: "m2.5 6.5 2.5 2.5L9.5 3.5" })
+  }
+);
+function collectOptions(children) {
+  const out = [];
+  Children.forEach(children, (child) => {
+    if (!isValidElement(child)) return;
+    const el = child;
+    if (el.props.value !== void 0) {
+      out.push({
+        label: typeof el.props.children === "string" ? el.props.children : String(el.props.value),
+        value: String(el.props.value)
+      });
+    } else if (el.props.children) {
+      out.push(...collectOptions(el.props.children));
+    }
+  });
+  return out;
+}
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["'use client'\n\nimport {\n  Children,\n  isValidElement,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  type CSSProperties,\n  type KeyboardEvent,\n  type ReactElement,\n  type ReactNode\n} from 'react'\n\nimport { cn } from '../../utils'\n\nconst TRIGGER_CN =\n  'flex h-9 w-full items-center justify-between gap-2 ' +\n  'border border-midground/15 bg-background/40 px-3 py-1 ' +\n  'font-courier text-sm text-left text-midground transition-colors ' +\n  'hover:border-midground/25 ' +\n  'focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-midground/30 focus-visible:border-midground/30 ' +\n  'disabled:cursor-not-allowed disabled:opacity-50 ' +\n  'cursor-pointer'\n\nconst LISTBOX_CN =\n  'absolute z-50 mt-1 w-full max-h-60 overflow-auto ' +\n  'border border-midground/15 bg-background-base text-midground shadow-lg'\n\nexport function Select({\n  children,\n  className,\n  disabled,\n  id,\n  onValueChange,\n  placeholder,\n  style,\n  value\n}: SelectProps) {\n  const [open, setOpen] = useState(false)\n  const [highlightedIndex, setHighlightedIndex] = useState(-1)\n  const containerRef = useRef<HTMLDivElement>(null)\n  const listRef = useRef<HTMLDivElement>(null)\n\n  const options = useMemo(() => collectOptions(children), [children])\n  const selected = options.find(o => o.value === value)\n  const displayLabel = selected?.label ?? placeholder ?? value ?? ''\n\n  const close = useCallback(() => {\n    setOpen(false)\n    setHighlightedIndex(-1)\n  }, [])\n\n  useEffect(() => {\n    if (!open) return\n    const ac = new AbortController()\n    document.addEventListener(\n      'mousedown',\n      e => {\n        if (!containerRef.current?.contains(e.target as Node)) close()\n      },\n      { signal: ac.signal }\n    )\n    return () => ac.abort()\n  }, [open, close])\n\n  useEffect(() => {\n    if (!open || highlightedIndex < 0) return\n    const el = listRef.current?.children[highlightedIndex] as\n      | HTMLElement\n      | undefined\n    el?.scrollIntoView({ block: 'nearest' })\n  }, [open, highlightedIndex])\n\n  const handleKeyDown = (e: KeyboardEvent) => {\n    if (disabled) return\n    switch (e.key) {\n      case 'Enter':\n      case ' ':\n        e.preventDefault()\n        if (!open) {\n          setOpen(true)\n          setHighlightedIndex(options.findIndex(o => o.value === value))\n        } else if (highlightedIndex >= 0 && options[highlightedIndex]) {\n          onValueChange?.(options[highlightedIndex].value)\n          close()\n        }\n        break\n      case 'ArrowDown':\n        e.preventDefault()\n        if (!open) {\n          setOpen(true)\n          setHighlightedIndex(options.findIndex(o => o.value === value))\n        } else {\n          setHighlightedIndex(i => Math.min(i + 1, options.length - 1))\n        }\n        break\n      case 'ArrowUp':\n        e.preventDefault()\n        if (open) setHighlightedIndex(i => Math.max(i - 1, 0))\n        break\n      case 'Home':\n        if (open) {\n          e.preventDefault()\n          setHighlightedIndex(0)\n        }\n        break\n      case 'End':\n        if (open) {\n          e.preventDefault()\n          setHighlightedIndex(options.length - 1)\n        }\n        break\n      case 'Escape':\n        e.preventDefault()\n        close()\n        break\n    }\n  }\n\n  return (\n    <div\n      className={cn('relative', className)}\n      id={id}\n      ref={containerRef}\n      style={style}\n    >\n      <button\n        aria-expanded={open}\n        aria-haspopup=\"listbox\"\n        className={TRIGGER_CN}\n        disabled={disabled}\n        onClick={() => !disabled && setOpen(o => !o)}\n        onKeyDown={handleKeyDown}\n        role=\"combobox\"\n        type=\"button\"\n      >\n        <span className={cn('truncate', !selected && 'text-midground/50')}>\n          {displayLabel}\n        </span>\n\n        <ChevronDownGlyph\n          className={cn(\n            'size-3 shrink-0 text-midground/60 transition-transform',\n            open && 'rotate-180'\n          )}\n        />\n      </button>\n\n      {open && (\n        <div className={LISTBOX_CN} ref={listRef} role=\"listbox\">\n          {options.map((opt, i) => {\n            const isSelected = opt.value === value\n            const isHighlighted = i === highlightedIndex\n\n            return (\n              <div\n                aria-selected={isSelected}\n                className={cn(\n                  'flex cursor-pointer items-center gap-2 px-3 py-2',\n                  'font-courier text-sm transition-colors',\n                  isHighlighted && 'bg-midground/10',\n                  isSelected ? 'text-midground' : 'text-midground/70'\n                )}\n                key={opt.value}\n                onClick={() => {\n                  onValueChange?.(opt.value)\n                  close()\n                }}\n                onMouseEnter={() => setHighlightedIndex(i)}\n                role=\"option\"\n              >\n                <CheckGlyph\n                  className={cn(\n                    'size-3 shrink-0',\n                    isSelected ? 'opacity-100' : 'opacity-0'\n                  )}\n                />\n                <span className=\"truncate\">{opt.label}</span>\n              </div>\n            )\n          })}\n        </div>\n      )}\n    </div>\n  )\n}\n\n// Marker component \u2014 `Select` reads `value`/`children` from its tree.\n// Renders nothing on its own.\nexport function SelectOption(_props: SelectOptionProps) {\n  return null\n}\n\nconst ChevronDownGlyph = ({ className }: { className?: string }) => (\n  <svg\n    aria-hidden\n    className={className}\n    fill=\"none\"\n    stroke=\"currentColor\"\n    strokeLinecap=\"square\"\n    strokeWidth={1.5}\n    viewBox=\"0 0 12 12\"\n  >\n    <path d=\"M2.5 4.5 6 8l3.5-3.5\" />\n  </svg>\n)\n\nconst CheckGlyph = ({ className }: { className?: string }) => (\n  <svg\n    aria-hidden\n    className={className}\n    fill=\"none\"\n    stroke=\"currentColor\"\n    strokeLinecap=\"square\"\n    strokeWidth={1.5}\n    viewBox=\"0 0 12 12\"\n  >\n    <path d=\"m2.5 6.5 2.5 2.5L9.5 3.5\" />\n  </svg>\n)\n\nfunction collectOptions(children: ReactNode): SelectOptionData[] {\n  const out: SelectOptionData[] = []\n  Children.forEach(children, child => {\n    if (!isValidElement(child)) return\n    const el = child as ReactElement<{\n      children?: ReactNode\n      value?: unknown\n    }>\n    if (el.props.value !== undefined) {\n      out.push({\n        label:\n          typeof el.props.children === 'string'\n            ? el.props.children\n            : String(el.props.value),\n        value: String(el.props.value)\n      })\n    } else if (el.props.children) {\n      out.push(...collectOptions(el.props.children))\n    }\n  })\n  return out\n}\n\ninterface SelectOptionData {\n  label: string\n  value: string\n}\n\ninterface SelectOptionProps {\n  children: ReactNode\n  value: string\n}\n\ninterface SelectProps {\n  children?: ReactNode\n  className?: string\n  disabled?: boolean\n  id?: string\n  onValueChange?: (value: string) => void\n  placeholder?: string\n  style?: CSSProperties\n  value?: string\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/ui/components/selection-switcher.d.ts

@@ -0,0 +1 @@
+export declare function SelectionSwitcher(): null;

package/dist/ui/components/selection-switcher.js

@@ -0,0 +1,34 @@
+"use client";
+import { useEffect } from "react";
+const colors = [
+  "oklch(85% 0.12 330)",
+  "oklch(85% 0.12 300)",
+  "oklch(85% 0.12 270)",
+  "oklch(85% 0.12 230)",
+  "oklch(85% 0.12 180)",
+  "oklch(85% 0.12 150)",
+  "oklch(85% 0.12 120)",
+  "oklch(85% 0.12 90)",
+  "oklch(85% 0.12 60)",
+  "oklch(85% 0.12 30)",
+  "oklch(88% 0.10 80)"
+];
+export function SelectionSwitcher() {
+  useEffect(() => {
+    const ac = new AbortController();
+    const { signal } = ac;
+    let idx = 0;
+    const cycle = () => requestAnimationFrame(
+      () => document.documentElement.style.setProperty(
+        "--selection-bg",
+        colors[idx = (idx + 1) % colors.length]
+      )
+    );
+    const onKey = (e) => e.key.toLowerCase() === "a" && (e.metaKey || e.ctrlKey) && cycle();
+    document.addEventListener("selectstart", cycle, { signal });
+    document.addEventListener("keydown", onKey, { signal });
+    return () => ac.abort();
+  }, []);
+  return null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/separator.d.ts

@@ -0,0 +1,5 @@
+export declare function Separator({ className, orientation, ...props }: SeparatorProps): import("react").JSX.Element;
+interface SeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    orientation?: 'horizontal' | 'vertical';
+}
+export {};

package/dist/ui/components/separator.js

@@ -0,0 +1,22 @@
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../utils/index.js";
+export function Separator({
+  className,
+  orientation = "horizontal",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "aria-orientation": orientation,
+      role: "separator",
+      className: cn(
+        "shrink-0 bg-midground/15",
+        orientation === "horizontal" ? "h-px w-full" : "h-full w-px",
+        className
+      ),
+      ...props
+    }
+  );
+}
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiPHN0ZGluPiJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHsgY24gfSBmcm9tICcuLi8uLi91dGlscydcblxuZXhwb3J0IGZ1bmN0aW9uIFNlcGFyYXRvcih7XG4gIGNsYXNzTmFtZSxcbiAgb3JpZW50YXRpb24gPSAnaG9yaXpvbnRhbCcsXG4gIC4uLnByb3BzXG59OiBTZXBhcmF0b3JQcm9wcykge1xuICByZXR1cm4gKFxuICAgIDxkaXZcbiAgICAgIGFyaWEtb3JpZW50YXRpb249e29yaWVudGF0aW9ufVxuICAgICAgcm9sZT1cInNlcGFyYXRvclwiXG4gICAgICBjbGFzc05hbWU9e2NuKFxuICAgICAgICAnc2hyaW5rLTAgYmctbWlkZ3JvdW5kLzE1JyxcbiAgICAgICAgb3JpZW50YXRpb24gPT09ICdob3Jpem9udGFsJyA/ICdoLXB4IHctZnVsbCcgOiAnaC1mdWxsIHctcHgnLFxuICAgICAgICBjbGFzc05hbWVcbiAgICAgICl9XG4gICAgICB7Li4ucHJvcHN9XG4gICAgLz5cbiAgKVxufVxuXG5pbnRlcmZhY2UgU2VwYXJhdG9yUHJvcHMgZXh0ZW5kcyBSZWFjdC5IVE1MQXR0cmlidXRlczxIVE1MRGl2RWxlbWVudD4ge1xuICBvcmllbnRhdGlvbj86ICdob3Jpem9udGFsJyB8ICd2ZXJ0aWNhbCdcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQVFJO0FBUkosU0FBUyxVQUFVO0FBRVosZ0JBQVMsVUFBVTtBQUFBLEVBQ3hCO0FBQUEsRUFDQSxjQUFjO0FBQUEsRUFDZCxHQUFHO0FBQ0wsR0FBbUI7QUFDakIsU0FDRTtBQUFBLElBQUM7QUFBQTtBQUFBLE1BQ0Msb0JBQWtCO0FBQUEsTUFDbEIsTUFBSztBQUFBLE1BQ0wsV0FBVztBQUFBLFFBQ1Q7QUFBQSxRQUNBLGdCQUFnQixlQUFlLGdCQUFnQjtBQUFBLFFBQy9DO0FBQUEsTUFDRjtBQUFBLE1BQ0MsR0FBRztBQUFBO0FBQUEsRUFDTjtBQUVKOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/ui/components/shader.d.ts

@@ -0,0 +1,7 @@
+import { type ThreeElements } from '@react-three/fiber';
+import type { ReactNode } from 'react';
+export declare function Shader({ children, defines, depthTest, fragmentShader, uniforms, vertexShader, ...props }: ShaderProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+interface ShaderProps extends Omit<ThreeElements['mesh'], 'children'>, Pick<ThreeElements['shaderMaterial'], 'defines' | 'depthTest' | 'fragmentShader' | 'uniforms' | 'vertexShader'> {
+    children?: ((material: ReactNode) => ReactNode) | ReactNode;
+}
+export {};

package/dist/ui/components/shader.js

@@ -0,0 +1,60 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useThree } from "@react-three/fiber";
+import { useEffect, useRef } from "react";
+import * as THREE from "three";
+import { useCappedFrame } from "../../hooks/use-capped-frame.js";
+const defaultUniforms = {
+  uResolution: new THREE.Uniform(new THREE.Vector4()),
+  uTime: new THREE.Uniform(0)
+};
+export function Shader({
+  children,
+  defines,
+  depthTest,
+  fragmentShader,
+  uniforms,
+  vertexShader,
+  ...props
+}) {
+  const invalidate = useThree((st) => st.invalidate);
+  const { size, viewport } = useThree();
+  const isMobile = size.width < 1024;
+  const uniformsRef = useRef({
+    ...defaultUniforms,
+    ...uniforms ?? {}
+  });
+  useCappedFrame(
+    ({ clock }) => {
+      const w = size.width * viewport.dpr;
+      const h = size.height * viewport.dpr;
+      uniformsRef.current.uTime.value = clock.getElapsedTime();
+      uniformsRef.current.uResolution.value.copy(
+        new THREE.Vector4(w, h, w / h, viewport.dpr)
+      );
+    },
+    isMobile ? 0 : 80
+  );
+  useEffect(
+    () => void (uniforms && Object.assign(uniformsRef.current, uniforms)),
+    [uniforms]
+  );
+  useEffect(() => void (isMobile && invalidate(80)), [invalidate, isMobile]);
+  const materialProps = {
+    defines: defines ?? {},
+    depthTest,
+    fragmentShader,
+    side: THREE.DoubleSide,
+    transparent: true,
+    uniforms: uniformsRef.current,
+    vertexShader
+  };
+  if (typeof children === "function") {
+    return children(/* @__PURE__ */ jsx("shaderMaterial", { ...materialProps }));
+  }
+  return /* @__PURE__ */ jsxs("mesh", { ...props, children: [
+    children ?? /* @__PURE__ */ jsx("planeGeometry", {}),
+    /* @__PURE__ */ jsx("shaderMaterial", { ...materialProps })
+  ] });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/socials.d.ts

@@ -0,0 +1,20 @@
+export declare function Socials({ className, items, onNavigate, ...rest }: SocialsProps): import("react").JSX.Element;
+export interface SocialLink {
+    external?: boolean;
+    href: string;
+    icon: React.ComponentType<{
+        className?: string;
+    }>;
+    label: string;
+    onClick?: React.MouseEventHandler;
+}
+interface SocialsProps extends React.HTMLAttributes<HTMLDivElement> {
+    items: SocialLink[];
+    /**
+     * Called *in addition* to each link's `onClick` after a click — useful in
+     * mobile drawer / dialog contexts where clicking a link should also close
+     * the surrounding overlay.
+     */
+    onNavigate?: () => void;
+}
+export {};

package/dist/ui/components/socials.js

@@ -0,0 +1,21 @@
+import { jsx } from "react/jsx-runtime";
+import { cn } from "../../utils/index.js";
+export function Socials({ className, items, onNavigate, ...rest }) {
+  return /* @__PURE__ */ jsx("div", { className: cn("flex items-center gap-3", className), ...rest, children: items.map(({ external = true, href, icon: Icon, label, onClick }) => /* @__PURE__ */ jsx(
+    "a",
+    {
+      className: "opacity-60 transition-opacity hover:opacity-100",
+      href,
+      onClick: (e) => {
+        onClick?.(e);
+        onNavigate?.();
+      },
+      rel: external ? "noopener noreferrer" : void 0,
+      target: external ? "_blank" : void 0,
+      title: label,
+      children: /* @__PURE__ */ jsx(Icon, {})
+    },
+    label
+  )) });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/ui/components/spinner.d.ts

@@ -0,0 +1,20 @@
+import { type CSSProperties, type HTMLAttributes } from 'react';
+import { type BrailleSpinnerName } from 'unicode-animations';
+/**
+ * Braille unicode spinner. Renders the active frame of a `unicode-animations`
+ * sequence inside an inline `<span>`, advancing on the spinner's own interval.
+ *
+ * Inherits font color and font size from its parent — apply Tailwind utilities
+ * (e.g. `text-warning`, `text-base`) via `className` to style.
+ *
+ * Decorative by default. Pass `aria-label` (and optionally `role="status"`) when
+ * the spinner has no surrounding loading text and screen readers need to know
+ * something is loading.
+ */
+export declare function Spinner({ className, name, style, ...props }: SpinnerProps): import("react").JSX.Element;
+interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
+    className?: string;
+    name?: BrailleSpinnerName;
+    style?: CSSProperties;
+}
+export {};