@cosmicdrift/kumiko-renderer 0.374.0 → 0.378.0

package/dist/web/app/tiptap-editor.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @runtime client
+//
+// tiptap-backed implementation behind RichContentEditor's lazy() boundary —
+// never import this file directly, tiptap must only load when a "rich"
+// collection is actually rendered. StarterKit covers bold/italic/lists/
+// headings, and its bundled Link extension autolinks on type/paste — no
+// link button, so no URL-prompt UI to build or test.
+import { EditorContent, useEditor, useEditorState } from "@tiptap/react";
+import StarterKit from "@tiptap/starter-kit";
+import { Bold as BoldIcon, Heading1, Heading2, Italic as ItalicIcon, List, ListOrdered, } from "lucide-react";
+import { useEffect } from "react";
+import { TextareaContentEditor, usePrimitives, useTranslation, VariableChips, } from "../../index.js";
+import { cn } from "../lib/cn.js";
+function Toolbar({ actions, disabled, }) {
+    const { Button } = usePrimitives();
+    return (_jsx("div", { className: "flex flex-wrap gap-1 border-b border-input p-1", children: actions.map((action) => (_jsx(Button, { type: "button", variant: action.isActive ? "primary" : "secondary", size: "icon", disabled: disabled, onClick: action.onClick, ariaLabel: action.label, children: _jsx(action.icon, { size: 16 }) }, action.label))) }));
+}
+export default function TiptapEditor({ id, value, onChange, variables, readOnly, }) {
+    const t = useTranslation();
+    // ponytail: rich = StarterKit's schema (bold/italic/lists/headings/links).
+    // Anything the schema doesn't model — <table>, <div>/<span>, style attrs,
+    // <img>, classes — is dropped on first parse (setContent below, and the
+    // initial `content: value` here). Upgrade if that ceiling is hit: add the
+    // matching tiptap extensions, or a raw-HTML mode for markup StarterKit
+    // can't represent.
+    const editor = useEditor({
+        extensions: [StarterKit],
+        content: value,
+        editable: !readOnly,
+        // Suspense (RichContentEditor's lazy boundary) speculatively mounts
+        // this component before committing it; immediate render would create
+        // an editor instance during that throwaway pass.
+        immediatelyRender: false,
+        // Caller-supplied id — the Field wrapping the editor (TextBlockEditor)
+        // associates its label via this id, see ContentEditorProps.id in
+        // content-editors.tsx.
+        editorProps: { attributes: { id } },
+        onUpdate: ({ editor: e }) => onChange(e.getHTML()),
+    });
+    // `useEditor` alone leaves `editor.isActive(...)` reads in the render body
+    // frozen on the last prop-driven render — @tiptap/react v3 defaults
+    // `shouldRerenderOnTransaction` to false, so a selection-only change (e.g.
+    // moving the cursor into bold text without typing) never triggers a
+    // re-render on its own. `useEditorState` subscribes to transactions itself
+    // and only re-renders when the selected slice of state actually changes.
+    const activeState = useEditorState({
+        editor,
+        selector: ({ editor: e }) => e === null
+            ? null
+            : {
+                bold: e.isActive("bold"),
+                italic: e.isActive("italic"),
+                heading1: e.isActive("heading", { level: 1 }),
+                heading2: e.isActive("heading", { level: 2 }),
+                bulletList: e.isActive("bulletList"),
+                orderedList: e.isActive("orderedList"),
+            },
+    });
+    // TextBlockEditor loads the entry's content asynchronously (by-slug query
+    // resolves after mount), so `value` arrives after useEditor already read
+    // its initial (empty) content once. Sync it in — guarded against
+    // clobbering in-flight typing by comparing against the editor's own HTML.
+    useEffect(() => {
+        if (editor && value !== editor.getHTML()) {
+            editor.commands.setContent(value, { emitUpdate: false });
+        }
+    }, [value, editor]);
+    useEffect(() => {
+        editor?.setEditable(!readOnly);
+    }, [readOnly, editor]);
+    if (!editor)
+        return (_jsx(TextareaContentEditor, { id: id, value: value, onChange: onChange, variables: variables, readOnly: readOnly }));
+    const actions = [
+        {
+            label: t("kumiko.contentEditor.bold"),
+            icon: BoldIcon,
+            isActive: activeState?.bold ?? false,
+            onClick: () => editor.chain().focus().toggleBold().run(),
+        },
+        {
+            label: t("kumiko.contentEditor.italic"),
+            icon: ItalicIcon,
+            isActive: activeState?.italic ?? false,
+            onClick: () => editor.chain().focus().toggleItalic().run(),
+        },
+        {
+            label: t("kumiko.contentEditor.heading1"),
+            icon: Heading1,
+            isActive: activeState?.heading1 ?? false,
+            onClick: () => editor.chain().focus().toggleHeading({ level: 1 }).run(),
+        },
+        {
+            label: t("kumiko.contentEditor.heading2"),
+            icon: Heading2,
+            isActive: activeState?.heading2 ?? false,
+            onClick: () => editor.chain().focus().toggleHeading({ level: 2 }).run(),
+        },
+        {
+            label: t("kumiko.contentEditor.bulletList"),
+            icon: List,
+            isActive: activeState?.bulletList ?? false,
+            onClick: () => editor.chain().focus().toggleBulletList().run(),
+        },
+        {
+            label: t("kumiko.contentEditor.orderedList"),
+            icon: ListOrdered,
+            isActive: activeState?.orderedList ?? false,
+            onClick: () => editor.chain().focus().toggleOrderedList().run(),
+        },
+    ];
+    const insertVariable = (name) => {
+        editor
+            .chain()
+            .focus()
+            .insertContent({ type: "text", text: `{{${name}}}` })
+            .run();
+    };
+    return (_jsxs("div", { className: "rounded-md border border-input bg-transparent", children: [_jsx(Toolbar, { actions: actions, disabled: readOnly }), _jsx(EditorContent, { editor: editor, className: cn("min-h-40 px-3 py-2 text-base outline-none md:text-sm", "[&_.ProseMirror]:min-h-40 [&_.ProseMirror]:outline-none", "[&_ul]:list-disc [&_ol]:list-decimal [&_ul]:pl-6 [&_ol]:pl-6", "[&_h1]:text-xl [&_h1]:font-bold [&_h2]:text-lg [&_h2]:font-bold", "[&_a]:underline [&_a]:text-primary", "[&_strong]:font-bold [&_em]:italic") }), variables.length > 0 && (_jsx("div", { className: "border-t border-input p-1", children: _jsx(VariableChips, { variables: variables, onInsert: insertVariable, disabled: readOnly }) }))] }));
+}

package/dist/web/app/toast-action-notifier.d.ts

@@ -0,0 +1,5 @@
+import { type ReactNode } from "react";
+/** Shows client-action outcomes as toasts; mount inside the ToastProvider. */
+export declare function ToastActionNotifier({ children }: {
+    readonly children: ReactNode;
+}): ReactNode;

package/dist/web/app/toast-action-notifier.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback } from "react";
+import { ActionNoticeProvider, useTranslation } from "../../index.js";
+import { useToast } from "../primitives/toast.js";
+/** Shows client-action outcomes as toasts; mount inside the ToastProvider. */
+export function ToastActionNotifier({ children }) {
+    const { toast } = useToast();
+    const t = useTranslation();
+    const notify = useCallback((notice) => {
+        if (notice.tone === "success") {
+            toast({ title: notice.text, variant: "ok" });
+            return;
+        }
+        toast({ title: t("kumiko.rowAction.failed"), description: notice.text, variant: "bad" });
+    }, [toast, t]);
+    return _jsx(ActionNoticeProvider, { notify: notify, children: children });
+}

package/dist/web/components/config-cascade.d.ts

@@ -0,0 +1,13 @@
+import type { ConfigCascade, ConfigScope } from "@cosmicdrift/kumiko-framework/engine";
+import type { ReactNode } from "react";
+type CascadeValueRenderer = (value: string | number | boolean) => ReactNode;
+type ConfigCascadeViewProps = {
+    readonly cascade: ConfigCascade;
+    readonly screenScope: ConfigScope;
+    readonly onReset?: (key: string, scope: ConfigScope) => void;
+    readonly qualifiedKey?: string;
+    readonly required?: boolean;
+    readonly renderValue?: CascadeValueRenderer;
+};
+export declare function ConfigCascadeView({ cascade, screenScope, onReset, qualifiedKey, required, renderValue, }: ConfigCascadeViewProps): ReactNode;
+export {};

package/dist/web/components/config-cascade.js

@@ -0,0 +1,155 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId, useState } from "react";
+import { usePrimitives, useTranslation } from "../../index.js";
+import { Icon } from "../icons.js";
+import { cn } from "../lib/cn.js";
+const SOURCE_I18N_KEY = {
+    "user-row": "kumiko.config.source.user",
+    "tenant-row": "kumiko.config.source.tenant",
+    "system-row": "kumiko.config.source.system",
+    "app-override": "kumiko.config.source.appOverride",
+    computed: "kumiko.config.source.computed",
+    default: "kumiko.config.source.default",
+    missing: "kumiko.config.source.missing",
+};
+// Fallback-Reihenfolge der Cascade, spezifischste Quelle zuerst.
+// Index-Vergleich gegen die Screen-Scope-Quelle entscheidet, welche
+// Ebenen ein Nicht-Operator sehen darf.
+const SOURCE_ORDER = [
+    "user-row",
+    "tenant-row",
+    "system-row",
+    "app-override",
+    "computed",
+    "default",
+    "missing",
+];
+function formatValue(value, hasValue, t, renderValue) {
+    if (!hasValue || value === undefined)
+        return t("kumiko.config.cascade.noValue");
+    if (renderValue !== undefined)
+        return renderValue(value);
+    if (typeof value === "boolean")
+        return t(value ? "kumiko.config.cascade.on" : "kumiko.config.cascade.off");
+    return String(value);
+}
+// The origin sentence interpolates the fallback value, which can be a node (a
+// select's option label resolved by a query), so the translated template is
+// split at a marker instead of interpolating a string.
+const VALUE_MARKER = "\u0000";
+function interpolateValue(template, value) {
+    const markerIndex = template.indexOf(VALUE_MARKER);
+    if (markerIndex === -1)
+        return template;
+    return (_jsxs(_Fragment, { children: [template.slice(0, markerIndex), value, template.slice(markerIndex + VALUE_MARKER.length)] }));
+}
+function scopeToSource(scope) {
+    if (scope === "user")
+        return "user-row";
+    if (scope === "tenant")
+        return "tenant-row";
+    return "system-row";
+}
+function toDisplayLevels(levels, screenScopeSource) {
+    // System-Screens sind Operator-Sicht — volle Cascade inkl.
+    // app-override/computed/default bleibt sichtbar.
+    if (screenScopeSource === "system-row") {
+        return levels.map((level) => ({ level, badgeSource: level.source }));
+    }
+    const scopeIdx = SOURCE_ORDER.indexOf(screenScopeSource);
+    const own = levels.filter((l) => SOURCE_ORDER.indexOf(l.source) <= scopeIdx);
+    const higher = levels.filter((l) => SOURCE_ORDER.indexOf(l.source) > scopeIdx);
+    // Genau eine Fallback-Zeile: die aktive höhere Ebene (deren Wert der
+    // User effektiv bekommt), sonst der deklarierte Default/Missing.
+    const fallback = higher.find((l) => l.isActive) ??
+        higher.find((l) => l.source === "default" || l.source === "missing");
+    const ownRows = own.map((level) => ({ level, badgeSource: level.source }));
+    if (fallback === undefined)
+        return ownRows;
+    return [
+        ...ownRows,
+        {
+            level: fallback,
+            badgeSource: "default",
+            // Ein durchgängiger Begriff "Standard" (DE) / "Default" (EN) — derselbe
+            // Key wie das Feld-Label-Badge (kumiko.config.source.default), damit
+            // Badge + Cascade-Disclosure NICHT zwei verschiedene Wörter zeigen
+            // (Bug-Bash 3 #11). Der Screen-Scope kann die Operator-Ebenen
+            // (System/Override/Computed) weder setzen noch zurücksetzen, deshalb
+            // erscheinen sie hier neutral als "Standard".
+            badgeLabelKey: "kumiko.config.source.default",
+        },
+    ];
+}
+const OWN_LEVEL_ORIGIN_KEY = {
+    tenant: "kumiko.config.cascade.origin.tenant",
+    user: "kumiko.config.cascade.origin.user",
+    system: "kumiko.config.cascade.origin.system",
+};
+// A missing or empty default reads as "Default is ." — drop the clause instead.
+const OWN_LEVEL_ORIGIN_NO_DEFAULT_KEY = {
+    tenant: "kumiko.config.cascade.originNoDefault.tenant",
+    user: "kumiko.config.cascade.originNoDefault.user",
+    system: "kumiko.config.cascade.originNoDefault.system",
+};
+export function ConfigCascadeView({ cascade, screenScope, onReset, qualifiedKey, required = false, renderValue, }) {
+    const t = useTranslation();
+    const { Button } = usePrimitives();
+    const [expanded, setExpanded] = useState(false);
+    const panelId = useId();
+    // Safety net: callers should already filter malformed cascades, but
+    // a missing levels-array (e.g. from a partial mock) shouldn't crash
+    // the screen.
+    if (!Array.isArray(cascade?.levels))
+        return null;
+    const screenScopeSource = scopeToSource(screenScope);
+    const displayLevels = toDisplayLevels(cascade.levels, screenScopeSource);
+    const activeDisplay = displayLevels.find((d) => d.level.isActive);
+    const hasOverride = activeDisplay?.level.source === screenScopeSource;
+    // Aufklappbar nur wenn das Panel echten Mehrwert bringt: ein eigener
+    // Override (→ Reset) oder mehr als eine Ebene MIT Wert. Leere Ebenen
+    // (z.B. die ungesetzte tenant-row eines reinen Default-Felds) zählen
+    // nicht — sonst wäre ein Feld, das nur seinen Standard zeigt, fälschlich
+    // aufklappbar und das Panel nur eine Wiederholung des Triggers.
+    const valuedLevels = displayLevels.filter((d) => d.level.hasValue);
+    const expandable = hasOverride || valuedLevels.length > 1;
+    const isUnset = activeDisplay === undefined || !activeDisplay.level.hasValue;
+    // The value the field falls back to if this level is reset: the next level
+    // below the active one that holds a value.
+    const activeIndex = activeDisplay === undefined ? -1 : displayLevels.indexOf(activeDisplay);
+    const fallbackLevel = displayLevels.slice(activeIndex + 1).find((d) => d.level.hasValue)?.level;
+    const fallbackValue = fallbackLevel === undefined || fallbackLevel.value === ""
+        ? undefined
+        : formatValue(fallbackLevel.value, true, t, renderValue);
+    const origin = hasOverride
+        ? {
+            text: fallbackValue === undefined
+                ? t(OWN_LEVEL_ORIGIN_NO_DEFAULT_KEY[screenScope])
+                : interpolateValue(t(OWN_LEVEL_ORIGIN_KEY[screenScope], { value: VALUE_MARKER }), fallbackValue),
+            className: "text-status-active",
+        }
+        : isUnset
+            ? required
+                ? {
+                    text: t("kumiko.config.cascade.notSetRequired"),
+                    className: "text-status-bad",
+                }
+                : {
+                    text: t("kumiko.config.cascade.noValue"),
+                    className: "text-muted-foreground",
+                }
+            : {
+                text: screenScope === "system"
+                    ? t(SOURCE_I18N_KEY[activeDisplay.badgeSource])
+                    : t("kumiko.config.cascade.origin.default"),
+                className: "text-muted-foreground",
+            };
+    return (_jsxs("div", { className: "flex flex-col gap-1 text-xs", "data-testid": "config-cascade", children: [_jsxs("div", { className: "flex flex-wrap items-center gap-x-1 gap-y-1", children: [_jsx("span", { className: cn("inline-flex items-center gap-1.5", origin.className), children: origin.text }), hasOverride && onReset !== undefined && qualifiedKey !== undefined ? (_jsx(Button, { variant: "ghost", size: "sm", onClick: () => onReset(qualifiedKey, screenScope), testId: "config-cascade-reset", className: "h-auto px-1.5 py-0.5 text-xs text-muted-foreground hover:bg-transparent hover:text-foreground", children: t(screenScope === "system"
+                            ? "kumiko.config.cascade.resetToApp"
+                            : "kumiko.config.cascade.resetTo") })) : null] }), expandable && (cascade.levels.length > 2 || screenScope === "system") ? (_jsxs("button", { type: "button", onClick: () => setExpanded((v) => !v), "aria-expanded": expanded, ...(expanded && { "aria-controls": panelId }), className: "inline-flex cursor-pointer items-center gap-1 self-start rounded-sm text-muted-foreground outline-none hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring", children: [_jsx(Icon, { name: "chevron-right", className: cn("size-3.5 transition-transform motion-reduce:transition-none", expanded && "rotate-90") }), t(expanded ? "kumiko.config.cascade.hideLevels" : "kumiko.config.cascade.showLevels")] })) : null, expanded && expandable && (cascade.levels.length > 2 || screenScope === "system") ? (_jsx("ul", { id: panelId, className: "flex flex-col gap-0.5 border-l border-border pl-3", children: displayLevels.map((display) => (_jsx(CascadeLevelRow, { display: display, ...(renderValue !== undefined && { renderValue }) }, display.level.source))) })) : null] }));
+}
+function CascadeLevelRow({ display, renderValue, }) {
+    const t = useTranslation();
+    const { level } = display;
+    return (_jsxs("li", { className: cn("flex items-baseline gap-3", level.isActive ? "text-foreground" : "text-muted-foreground"), children: [_jsx("span", { className: "w-28 shrink-0", children: t(display.badgeLabelKey ?? SOURCE_I18N_KEY[display.badgeSource]) }), _jsx("span", { className: cn(level.isActive && "font-medium"), children: formatValue(level.value, level.hasValue, t, renderValue) }), level.isActive ? (_jsx("span", { className: "text-primary", children: t("kumiko.config.cascade.activeMarker") })) : null] }));
+}

package/dist/web/components/config-source-badge.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigScope, ConfigValueSource } from "@cosmicdrift/kumiko-framework/engine";
+import type { ReactNode } from "react";
+export declare function ConfigSourceBadge({ source, screenScope, }: {
+    readonly source: ConfigValueSource;
+    readonly screenScope?: ConfigScope;
+}): ReactNode;

package/dist/web/components/config-source-badge.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useTranslation } from "../../index.js";
+import { cn } from "../lib/cn.js";
+const SOURCE_LABEL_KEY = {
+    "user-row": "kumiko.config.source.user",
+    "tenant-row": "kumiko.config.source.tenant",
+    "system-row": "kumiko.config.source.system",
+    "app-override": "kumiko.config.source.appOverride",
+    computed: "kumiko.config.source.computed",
+    default: "kumiko.config.source.default",
+    missing: "kumiko.config.source.missing",
+};
+// Two states only: set on a scope row (accent) vs. inherited/default (neutral);
+// a missing value is the one status colour.
+const ROW_SOURCES = new Set([
+    "user-row",
+    "tenant-row",
+    "system-row",
+]);
+function badgeToneClass(source) {
+    if (source === "missing")
+        return "bg-status-bad-surface text-status-bad";
+    return ROW_SOURCES.has(source) ? "bg-primary/10 text-primary" : "bg-muted text-muted-foreground";
+}
+const SOURCE_ORDER = [
+    "user-row",
+    "tenant-row",
+    "system-row",
+    "app-override",
+    "computed",
+    "default",
+    "missing",
+];
+function scopeToSource(scope) {
+    if (scope === "user")
+        return "user-row";
+    if (scope === "tenant")
+        return "tenant-row";
+    return "system-row";
+}
+export function ConfigSourceBadge({ source, screenScope, }) {
+    const t = useTranslation();
+    // Gleiche Kollaps-Regel wie toDisplayLevels (config-cascade.tsx):
+    // Operator-Quellen oberhalb des Screen-Scopes erscheinen für Nicht-
+    // Operator-Screens als neutrales "Vorgabe"-Badge — sonst leakte das
+    // Badge die System-Quelle, die die Cascade-View bewusst versteckt.
+    let effective = source;
+    if (screenScope !== undefined && screenScope !== "system") {
+        const scopeIdx = SOURCE_ORDER.indexOf(scopeToSource(screenScope));
+        if (SOURCE_ORDER.indexOf(source) > scopeIdx && source !== "missing") {
+            effective = "default";
+        }
+    }
+    return (_jsx("span", { "data-testid": "config-source-badge", className: cn("ml-1.5 inline-flex items-center whitespace-nowrap rounded px-1.5 text-[11px] font-medium leading-[18px]", badgeToneClass(effective)), children: t(SOURCE_LABEL_KEY[effective]) }));
+}

package/dist/web/default-color-scheme.d.ts

@@ -0,0 +1,2 @@
+export type DefaultColorScheme = "auto" | "light" | "dark";
+export declare const DEFAULT_COLOR_SCHEME_VARIABLE = "--kumiko-default-color-scheme";

package/dist/web/default-color-scheme.js

@@ -0,0 +1,3 @@
+// Written by createThemePlugin, read by the browser tokens hook. A separate
+// module keeps tailwindcss/plugin out of the client bundle.
+export const DEFAULT_COLOR_SCHEME_VARIABLE = "--kumiko-default-color-scheme";

package/dist/web/icons.d.ts

@@ -0,0 +1,94 @@
+import type { NavIconKey } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { ReactNode } from "react";
+export type { NavIconKey } from "@cosmicdrift/kumiko-framework/ui-types";
+export declare const NAV_ICONS: {
+    readonly dashboard: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "layout-grid": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "book-open": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "clipboard-list": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly package: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly gauge: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly list: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly table: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly layers: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly building: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly calculator: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly wallet: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly coins: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "credit-card": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "piggy-bank": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly receipt: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly chart: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "bar-chart": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly trending: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly sparkles: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly wand: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly calendar: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly file: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly folder: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "folder-open": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly home: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly bell: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly shield: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "shield-check": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly send: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly settings: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly users: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly user: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly search: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly tag: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly key: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly link: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly palette: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly share: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly server: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly mail: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly lock: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly hash: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly download: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly upload: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly rocket: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly plus: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly languages: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly trash: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly x: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly check: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "arrow-left": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "arrow-right": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly copy: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly pencil: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly eye: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "eye-off": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly filter: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly refresh: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "more-horizontal": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "more-vertical": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "external-link": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "chevron-down": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "chevron-left": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "chevron-right": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "chevron-up": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly save: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly undo: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly archive: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly star: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly flag: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly clock: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "map-pin": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly phone: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly printer: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "alert-triangle": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly info: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "check-circle": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "x-circle": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly loader: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly mic: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly "circle-stop": import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly image: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly camera: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+    readonly headphones: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+};
+export declare function Icon({ name, className, }: {
+    readonly name: NavIconKey;
+    readonly className?: string;
+}): ReactNode;

package/dist/web/icons.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AlertTriangle, Archive, ArrowLeft, ArrowRight, BarChart3, Bell, BookOpen, Building, Calculator, CalendarDays, Camera, Check, CheckCircle2, ChevronDown, ChevronLeft, ChevronRight, ChevronUp, CircleStop, ClipboardList, Clock, Coins, Copy, CreditCard, Download, ExternalLink, Eye, EyeOff, FileText, Filter, Flag, Folder, FolderOpen, Gauge, Hash, Headphones, Home, ImageIcon, Info, KeyRound, Languages, Layers, LayoutDashboard, LayoutGrid, LineChart, Link, List, Loader2, Lock, Mail, MapPin, Mic, MoreHorizontal, MoreVertical, Package, Palette, Pencil, Phone, PiggyBank, Plus, Printer, Receipt, RefreshCw, Rocket, Save, Search, Send, Server, Settings, Share2, Shield, ShieldCheck, Sparkles, Star, Table, Tag, Trash2, TrendingUp, Undo2, Upload, User, Users, Wallet, Wand2, X, XCircle, } from "lucide-react";
+import { cn } from "./lib/cn.js";
+export const NAV_ICONS = {
+    dashboard: LayoutDashboard,
+    "layout-grid": LayoutGrid,
+    "book-open": BookOpen,
+    "clipboard-list": ClipboardList,
+    package: Package,
+    gauge: Gauge,
+    list: List,
+    table: Table,
+    layers: Layers,
+    building: Building,
+    calculator: Calculator,
+    wallet: Wallet,
+    coins: Coins,
+    "credit-card": CreditCard,
+    "piggy-bank": PiggyBank,
+    receipt: Receipt,
+    chart: LineChart,
+    "bar-chart": BarChart3,
+    trending: TrendingUp,
+    sparkles: Sparkles,
+    wand: Wand2,
+    calendar: CalendarDays,
+    file: FileText,
+    folder: Folder,
+    "folder-open": FolderOpen,
+    home: Home,
+    bell: Bell,
+    shield: Shield,
+    "shield-check": ShieldCheck,
+    send: Send,
+    settings: Settings,
+    users: Users,
+    user: User,
+    search: Search,
+    tag: Tag,
+    key: KeyRound,
+    link: Link,
+    palette: Palette,
+    share: Share2,
+    server: Server,
+    mail: Mail,
+    lock: Lock,
+    hash: Hash,
+    download: Download,
+    upload: Upload,
+    rocket: Rocket,
+    plus: Plus,
+    languages: Languages,
+    trash: Trash2,
+    x: X,
+    check: Check,
+    "arrow-left": ArrowLeft,
+    "arrow-right": ArrowRight,
+    copy: Copy,
+    pencil: Pencil,
+    eye: Eye,
+    "eye-off": EyeOff,
+    filter: Filter,
+    refresh: RefreshCw,
+    "more-horizontal": MoreHorizontal,
+    "more-vertical": MoreVertical,
+    "external-link": ExternalLink,
+    "chevron-down": ChevronDown,
+    "chevron-left": ChevronLeft,
+    "chevron-right": ChevronRight,
+    "chevron-up": ChevronUp,
+    save: Save,
+    undo: Undo2,
+    archive: Archive,
+    star: Star,
+    flag: Flag,
+    clock: Clock,
+    "map-pin": MapPin,
+    phone: Phone,
+    printer: Printer,
+    "alert-triangle": AlertTriangle,
+    info: Info,
+    "check-circle": CheckCircle2,
+    "x-circle": XCircle,
+    loader: Loader2,
+    mic: Mic,
+    "circle-stop": CircleStop,
+    image: ImageIcon,
+    camera: Camera,
+    headphones: Headphones,
+};
+// Widened alias for runtime lookups against the plain `string` icon keys
+// resolved-tree nodes carry — not the closed NavIconKey union NAV_ICONS
+// itself is typed against.
+const ICON_LOOKUP = NAV_ICONS;
+export function Icon({ name, className, }) {
+    const LucideIcon = Object.hasOwn(NAV_ICONS, name) ? ICON_LOOKUP[name] : undefined;
+    if (LucideIcon !== undefined)
+        return _jsx(LucideIcon, { "aria-hidden": "true", className: className });
+    return (_jsx("span", { "aria-hidden": "true", className: cn("text-xs", className), children: name }));
+}