create-principles-disciple 1.0.0 → 1.74.0

package/console/dist/ui/components/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/console/dist/ui/components/ui/input.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../../lib/utils.js";
+const Input = React.forwardRef(({ className, type, ...props }, ref) => {
+    return (_jsx("input", { type: type, className: cn("flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50", className), ref: ref, ...props }));
+});
+Input.displayName = "Input";
+export { Input };

package/console/dist/ui/components/ui/markdown.d.ts

@@ -0,0 +1,24 @@
+interface CodeBlockProps {
+    code: string;
+    language?: string;
+    className?: string;
+}
+export declare function CodeBlock({ code, language, className }: CodeBlockProps): import("react/jsx-runtime").JSX.Element;
+interface CollapsibleSectionProps {
+    title: string;
+    defaultOpen?: boolean;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function CollapsibleSection({ title, defaultOpen, children, className }: CollapsibleSectionProps): import("react/jsx-runtime").JSX.Element;
+interface MarkdownRendererProps {
+    content: string;
+    className?: string;
+}
+export declare function MarkdownRenderer({ content, className }: MarkdownRendererProps): import("react/jsx-runtime").JSX.Element;
+export declare function TruncatedText({ text, maxLines, className, }: {
+    text: string;
+    maxLines?: number;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/console/dist/ui/components/ui/markdown.js

@@ -0,0 +1,115 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { useTranslation } from "react-i18next";
+import { cn } from "../../../lib/utils.js";
+export function CodeBlock({ code, language, className }) {
+    const [copied, setCopied] = useState(false);
+    const handleCopy = useCallback(() => {
+        navigator.clipboard.writeText(code).then(() => {
+            setCopied(true);
+            setTimeout(() => setCopied(false), 2000);
+        }).catch(() => {
+            // clipboard API not available (e.g. non-HTTPS)
+        });
+    }, [code]);
+    return (_jsxs("div", { className: cn("relative group rounded-md border border-border overflow-hidden", className), children: [language && (_jsxs("div", { className: "flex items-center justify-between px-3 py-1 bg-muted/50 border-b border-border", children: [_jsx("span", { className: "text-[10px] text-muted-foreground uppercase", children: language }), _jsx("button", { onClick: handleCopy, className: "text-[10px] text-muted-foreground hover:text-foreground transition-colors flex items-center gap-1", children: copied ? "✓" : "Copy" })] })), !language && (_jsx("button", { onClick: handleCopy, className: "absolute top-1 right-1 text-[10px] text-muted-foreground hover:text-foreground transition-colors opacity-0 group-hover:opacity-100 px-1.5 py-0.5 rounded bg-muted/80", children: copied ? "✓" : "Copy" })), _jsx("pre", { className: "p-3 overflow-x-auto text-xs leading-relaxed", children: _jsx("code", { children: code }) })] }));
+}
+export function CollapsibleSection({ title, defaultOpen = false, children, className }) {
+    const [isOpen, setIsOpen] = useState(defaultOpen);
+    return (_jsxs("div", { className: cn("border border-border rounded-md overflow-hidden", className), children: [_jsxs("button", { onClick: () => setIsOpen(!isOpen), className: "w-full flex items-center justify-between px-4 py-2.5 bg-muted/30 hover:bg-muted/50 transition-colors text-sm font-medium", children: [_jsx("span", { children: title }), _jsx("span", { className: "text-xs text-muted-foreground", children: isOpen ? "▲" : "▼" })] }), isOpen && (_jsx("div", { className: "p-4", children: children }))] }));
+}
+function detectCodeBlocks(text) {
+    const parts = [];
+    const codeBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = codeBlockRegex.exec(text)) !== null) {
+        if (match.index > lastIndex) {
+            parts.push({ type: "text", content: text.slice(lastIndex, match.index) });
+        }
+        parts.push({ type: "code", language: match[1] || "", code: match[2].trimEnd() });
+        lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        parts.push({ type: "text", content: text.slice(lastIndex) });
+    }
+    return parts;
+}
+function renderInlineMarkdown(text) {
+    const nodes = [];
+    const regex = /(\*\*(.+?)\*\*)|(\*(.+?)\*)|(`(.+?)`)|(\[(.+?)\]\((.+?)\))/g;
+    let lastIndex = 0;
+    let match;
+    let key = 0;
+    while ((match = regex.exec(text)) !== null) {
+        if (match.index > lastIndex) {
+            nodes.push(text.slice(lastIndex, match.index));
+        }
+        if (match[1]) {
+            nodes.push(_jsx("strong", { children: match[2] }, key++));
+        }
+        else if (match[3]) {
+            nodes.push(_jsx("em", { children: match[4] }, key++));
+        }
+        else if (match[5]) {
+            nodes.push(_jsx("code", { className: "px-1.5 py-0.5 rounded bg-muted text-xs font-mono", children: match[6] }, key++));
+        }
+        else if (match[7]) {
+            nodes.push(_jsx("a", { href: match[9], target: "_blank", rel: "noopener noreferrer", className: "text-primary hover:underline", children: match[8] }, key++));
+        }
+        lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < text.length) {
+        nodes.push(text.slice(lastIndex));
+    }
+    return nodes.length > 0 ? nodes : [text];
+}
+function renderTextBlock(text) {
+    const lines = text.split("\n");
+    const nodes = [];
+    let key = 0;
+    let inList = false;
+    for (const line of lines) {
+        const headingMatch = line.match(/^(#{1,3})\s+(.+)/);
+        const listItemMatch = line.match(/^[-*]\s+(.+)/);
+        const numberedItemMatch = line.match(/^\d+\.\s+(.+)/);
+        if (inList && !listItemMatch && !numberedItemMatch) {
+            inList = false;
+        }
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const Tag = `h${level}`;
+            const sizeClass = level === 1 ? "text-lg" : level === 2 ? "text-base" : "text-sm";
+            nodes.push(_jsx(Tag, { className: cn("font-semibold mt-3 mb-1", sizeClass), children: renderInlineMarkdown(headingMatch[2]) }, key++));
+        }
+        else if (listItemMatch) {
+            inList = true;
+            nodes.push(_jsxs("div", { className: "flex items-start gap-2 ml-2", children: [_jsx("span", { className: "text-muted-foreground mt-0.5", children: "\u2022" }), _jsx("span", { className: "flex-1", children: renderInlineMarkdown(listItemMatch[1]) })] }, key++));
+        }
+        else if (numberedItemMatch) {
+            inList = true;
+            nodes.push(_jsxs("div", { className: "flex items-start gap-2 ml-2", children: [_jsx("span", { className: "text-muted-foreground text-xs tabular-nums", children: "\u2022" }), _jsx("span", { className: "flex-1", children: renderInlineMarkdown(numberedItemMatch[1]) })] }, key++));
+        }
+        else if (line.trim() === "") {
+            nodes.push(_jsx("div", { className: "h-2" }, key++));
+        }
+        else {
+            nodes.push(_jsx("p", { className: "text-sm leading-relaxed", children: renderInlineMarkdown(line) }, key++));
+        }
+    }
+    return nodes;
+}
+export function MarkdownRenderer({ content, className }) {
+    const parts = detectCodeBlocks(content);
+    return (_jsx("div", { className: cn("prose-sm max-w-none", className), children: parts.map((part, index) => {
+            if (part.type === "code") {
+                return _jsx(CodeBlock, { code: part.code, language: part.language }, index);
+            }
+            return _jsx("div", { children: renderTextBlock(part.content) }, index);
+        }) }));
+}
+export function TruncatedText({ text, maxLines = 3, className, }) {
+    const [expanded, setExpanded] = useState(false);
+    const { t } = useTranslation();
+    return (_jsxs("div", { className: className, children: [_jsx("div", { className: cn("transition-all duration-200", !expanded && "overflow-hidden"), style: !expanded ? { display: "-webkit-box", WebkitLineClamp: maxLines, WebkitBoxOrient: "vertical", overflow: "hidden" } : undefined, children: text }), text.length > 100 && (_jsx("button", { onClick: () => setExpanded(!expanded), className: "text-xs text-primary hover:underline mt-1", children: expanded ? t("pages:principles.showLess") : t("pages:principles.showMore") }))] }));
+}

package/console/dist/ui/components/ui/progress-bar.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+interface ProgressBarProps {
+    value: number;
+    max?: number;
+    showLabel?: boolean;
+    size?: "sm" | "md" | "lg";
+    className?: string;
+}
+export declare const ProgressBar: React.ForwardRefExoticComponent<ProgressBarProps & React.RefAttributes<HTMLDivElement>>;
+interface ValueScoreBarProps {
+    valueScore: number;
+    className?: string;
+}
+export declare function ValueScoreBar({ valueScore, className }: ValueScoreBarProps): import("react/jsx-runtime").JSX.Element;
+interface AdherenceBarProps {
+    adherenceRate: number;
+    className?: string;
+}
+export declare function AdherenceBar({ adherenceRate, className }: AdherenceBarProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/console/dist/ui/components/ui/progress-bar.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../../lib/utils.js";
+function getColorClass(value, max) {
+    const percentage = Math.min((value / max) * 100, 100);
+    if (percentage > 70)
+        return "bg-green-500";
+    if (percentage > 40)
+        return "bg-amber-500";
+    return "bg-red-500";
+}
+function getTextColorClass(value, max) {
+    const percentage = Math.min((value / max) * 100, 100);
+    if (percentage > 70)
+        return "text-green-600 dark:text-green-400";
+    if (percentage > 40)
+        return "text-amber-600 dark:text-amber-400";
+    return "text-red-600 dark:text-red-400";
+}
+const sizeClasses = {
+    sm: "h-1.5",
+    md: "h-2.5",
+    lg: "h-4",
+};
+export const ProgressBar = React.forwardRef(({ value, max = 100, showLabel = false, size = "md", className }, ref) => {
+    const percentage = Math.min(Math.max((value / max) * 100, 0), 100);
+    const colorClass = getColorClass(value, max);
+    const textColorClass = getTextColorClass(value, max);
+    return (_jsxs("div", { ref: ref, className: cn("flex items-center gap-2", className), children: [_jsx("div", { className: cn("flex-1 bg-muted rounded-full overflow-hidden", sizeClasses[size]), children: _jsx("div", { className: cn("h-full rounded-full transition-all duration-300", colorClass), style: { width: `${percentage}%` } }) }), showLabel && (_jsxs("span", { className: cn("text-xs font-medium tabular-nums min-w-[3ch]", textColorClass), children: [percentage.toFixed(0), "%"] }))] }));
+});
+ProgressBar.displayName = "ProgressBar";
+export function ValueScoreBar({ valueScore, className }) {
+    return (_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(ProgressBar, { value: valueScore, max: 100, size: "sm", className: "flex-1" }), _jsx("span", { className: cn("text-xs font-medium tabular-nums", getTextColorClass(valueScore, 100)), children: valueScore.toFixed(1) })] }));
+}
+export function AdherenceBar({ adherenceRate, className }) {
+    const percentage = adherenceRate;
+    return (_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(ProgressBar, { value: percentage, max: 100, size: "sm", className: "flex-1" }), _jsxs("span", { className: cn("text-xs font-medium tabular-nums", getTextColorClass(percentage, 100)), children: [percentage.toFixed(0), "%"] })] }));
+}

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

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/console/dist/ui/components/ui/select.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+import { Check, ChevronDown, ChevronUp } from "lucide-react";
+import { cn } from "../../../lib/utils.js";
+const Select = SelectPrimitive.Root;
+const SelectGroup = SelectPrimitive.Group;
+const SelectValue = SelectPrimitive.Value;
+const SelectTrigger = React.forwardRef(({ className, children, ...props }, ref) => (_jsxs(SelectPrimitive.Trigger, { ref: ref, className: cn("flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1", className), ...props, children: [children, _jsx(SelectPrimitive.Icon, { asChild: true, children: _jsx(ChevronDown, { className: "h-4 w-4 opacity-50" }) })] })));
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
+const SelectScrollUpButton = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.ScrollUpButton, { ref: ref, className: cn("flex cursor-default items-center justify-center py-1", className), ...props, children: _jsx(ChevronUp, { className: "h-4 w-4" }) })));
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName;
+const SelectScrollDownButton = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.ScrollDownButton, { ref: ref, className: cn("flex cursor-default items-center justify-center py-1", className), ...props, children: _jsx(ChevronDown, { className: "h-4 w-4" }) })));
+SelectScrollDownButton.displayName =
+    SelectPrimitive.ScrollDownButton.displayName;
+const SelectContent = React.forwardRef(({ className, children, position = "popper", ...props }, ref) => (_jsx(SelectPrimitive.Portal, { children: _jsxs(SelectPrimitive.Content, { ref: ref, className: cn("relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", position === "popper" &&
+            "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1", className), position: position, ...props, children: [_jsx(SelectScrollUpButton, {}), _jsx(SelectPrimitive.Viewport, { className: cn("p-1", position === "popper" &&
+                    "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"), children: children }), _jsx(SelectScrollDownButton, {})] }) })));
+SelectContent.displayName = SelectPrimitive.Content.displayName;
+const SelectLabel = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.Label, { ref: ref, className: cn("px-2 py-1.5 text-sm font-semibold", className), ...props })));
+SelectLabel.displayName = SelectPrimitive.Label.displayName;
+const SelectItem = React.forwardRef(({ className, children, ...props }, ref) => (_jsxs(SelectPrimitive.Item, { ref: ref, className: cn("relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className), ...props, children: [_jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: _jsx(SelectPrimitive.ItemIndicator, { children: _jsx(Check, { className: "h-4 w-4" }) }) }), _jsx(SelectPrimitive.ItemText, { children: children })] })));
+SelectItem.displayName = SelectPrimitive.Item.displayName;
+const SelectSeparator = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.Separator, { ref: ref, className: cn("-mx-1 my-1 h-px bg-muted", className), ...props })));
+SelectSeparator.displayName = SelectPrimitive.Separator.displayName;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

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

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Separator: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHRElement> & React.RefAttributes<HTMLHRElement>>;
+export { Separator };

package/console/dist/ui/components/ui/separator.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../../lib/utils.js";
+const Separator = React.forwardRef(({ className, ...props }, ref) => (_jsx("hr", { ref: ref, className: cn("border-border bg-border", className), ...props })));
+Separator.displayName = "Separator";
+export { Separator };

package/console/dist/ui/components/ui/sheet.d.ts

@@ -0,0 +1,25 @@
+import * as React from "react";
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+import { type VariantProps } from "class-variance-authority";
+declare const Sheet: React.FC<SheetPrimitive.DialogProps>;
+declare const SheetTrigger: React.ForwardRefExoticComponent<SheetPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetClose: React.ForwardRefExoticComponent<SheetPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SheetPortal: React.FC<SheetPrimitive.DialogPortalProps>;
+declare const SheetOverlay: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const sheetVariants: (props?: ({
+    side?: "top" | "right" | "bottom" | "left" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+interface SheetContentProps extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+declare const SheetContent: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SheetHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const SheetTitle: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const SheetDescription: React.ForwardRefExoticComponent<Omit<SheetPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Sheet, SheetPortal, SheetOverlay, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

package/console/dist/ui/components/ui/sheet.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import * as SheetPrimitive from "@radix-ui/react-dialog";
+import { cva } from "class-variance-authority";
+import { X } from "lucide-react";
+import { cn } from "../../../lib/utils.js";
+const Sheet = SheetPrimitive.Root;
+const SheetTrigger = SheetPrimitive.Trigger;
+const SheetClose = SheetPrimitive.Close;
+const SheetPortal = SheetPrimitive.Portal;
+const SheetOverlay = React.forwardRef(({ className, ...props }, ref) => (_jsx(SheetPrimitive.Overlay, { className: cn("fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0", className), ...props, ref: ref })));
+SheetOverlay.displayName = SheetPrimitive.Overlay.displayName;
+const sheetVariants = cva("fixed z-50 gap-4 bg-background p-6 shadow-lg transition ease-in-out data-[state=closed]:duration-300 data-[state=open]:duration-500 data-[state=open]:animate-in data-[state=closed]:animate-out", {
+    variants: {
+        side: {
+            top: "inset-x-0 top-0 border-b data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top",
+            bottom: "inset-x-0 bottom-0 border-t data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom",
+            left: "inset-y-0 left-0 h-full w-3/4 border-r data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left sm:max-w-sm",
+            right: "inset-y-0 right-0 h-full w-3/4 border-l data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right sm:max-w-sm",
+        },
+    },
+    defaultVariants: {
+        side: "right",
+    },
+});
+const SheetContent = React.forwardRef(({ side = "right", className, children, ...props }, ref) => (_jsxs(SheetPortal, { children: [_jsx(SheetOverlay, {}), _jsxs(SheetPrimitive.Content, { ref: ref, className: cn(sheetVariants({ side }), className), ...props, children: [_jsxs(SheetPrimitive.Close, { className: "absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-secondary", children: [_jsx(X, { className: "h-4 w-4" }), _jsx("span", { className: "sr-only", children: "Close" })] }), children] })] })));
+SheetContent.displayName = SheetPrimitive.Content.displayName;
+const SheetHeader = ({ className, ...props }) => (_jsx("div", { className: cn("flex flex-col gap-2 text-center sm:text-left", className), ...props }));
+SheetHeader.displayName = "SheetHeader";
+const SheetFooter = ({ className, ...props }) => (_jsx("div", { className: cn("flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2", className), ...props }));
+SheetFooter.displayName = "SheetFooter";
+const SheetTitle = React.forwardRef(({ className, ...props }, ref) => (_jsx(SheetPrimitive.Title, { ref: ref, className: cn("text-lg font-semibold text-foreground", className), ...props })));
+SheetTitle.displayName = SheetPrimitive.Title.displayName;
+const SheetDescription = React.forwardRef(({ className, ...props }, ref) => (_jsx(SheetPrimitive.Description, { ref: ref, className: cn("text-sm text-muted-foreground", className), ...props })));
+SheetDescription.displayName = SheetPrimitive.Description.displayName;
+export { Sheet, SheetPortal, SheetOverlay, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription, };

package/console/dist/ui/components/ui/skeleton.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

package/console/dist/ui/components/ui/skeleton.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from "../../../lib/utils.js";
+function Skeleton({ className, ...props }) {
+    return (_jsx("div", { className: cn("animate-pulse rounded-md bg-muted", className), ...props }));
+}
+export { Skeleton };

package/console/dist/ui/components/ui/sonner.d.ts

@@ -0,0 +1,3 @@
+import { type ToasterProps } from "sonner";
+declare const Toaster: ({ ...props }: ToasterProps) => import("react/jsx-runtime").JSX.Element;
+export { Toaster };

package/console/dist/ui/components/ui/sonner.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Toaster as Sonner } from "sonner";
+const Toaster = ({ ...props }) => {
+    return (_jsx(Sonner, { className: "toaster group", toastOptions: {
+            classNames: {
+                toast: "group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg",
+                description: "group-[.toast]:text-muted-foreground",
+                actionButton: "group-[.toast]:bg-primary group-[.toast]:text-primary-foreground",
+                cancelButton: "group-[.toast]:bg-muted group-[.toast]:text-muted-foreground",
+            },
+        }, ...props }));
+};
+export { Toaster };

package/console/dist/ui/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/console/dist/ui/components/ui/tooltip.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { cn } from "../../../lib/utils.js";
+const TooltipProvider = TooltipPrimitive.Provider;
+const Tooltip = TooltipPrimitive.Root;
+const TooltipTrigger = TooltipPrimitive.Trigger;
+const TooltipContent = React.forwardRef(({ className, sideOffset = 4, ...props }, ref) => (_jsx(TooltipPrimitive.Portal, { children: _jsx(TooltipPrimitive.Content, { ref: ref, sideOffset: sideOffset, className: cn("z-50 overflow-hidden rounded-md bg-primary px-3 py-1.5 text-xs text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className), ...props }) })));
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/console/dist/ui/hooks/useAutoRefresh.d.ts

@@ -0,0 +1,13 @@
+interface AutoRefreshState<T> {
+    data: T | null;
+    error: string | null;
+    loading: boolean;
+    refresh: () => void;
+    lastUpdated: string | null;
+}
+export declare function useAutoRefresh<T>(fetcher: () => Promise<{
+    success: boolean;
+    data?: T;
+    error?: string;
+}>, intervalMs?: number, enabled?: boolean): AutoRefreshState<T>;
+export {};

package/console/dist/ui/hooks/useAutoRefresh.js

@@ -0,0 +1,64 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+export function useAutoRefresh(fetcher, intervalMs = 30000, enabled = true) {
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [lastUpdated, setLastUpdated] = useState(null);
+    const timerRef = useRef(null);
+    const abortControllerRef = useRef(null);
+    const fetcherRef = useRef(fetcher);
+    fetcherRef.current = fetcher;
+    const mountedRef = useRef(true);
+    const refresh = useCallback(() => {
+        if (!mountedRef.current)
+            return;
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+        }
+        abortControllerRef.current = new AbortController();
+        setLoading(true);
+        setError(null);
+        fetcherRef
+            .current()
+            .then((result) => {
+            if (!mountedRef.current)
+                return;
+            if (result.success && result.data !== undefined) {
+                setData(result.data);
+                setError(null);
+            }
+            else {
+                setError(result.error ?? "Unknown error");
+            }
+            setLastUpdated(new Date().toISOString());
+            setLoading(false);
+        })
+            .catch((err) => {
+            if (!mountedRef.current)
+                return;
+            if (err instanceof Error && err.name === "AbortError")
+                return;
+            setError(err instanceof Error ? err.message : "Network error");
+            setLoading(false);
+        });
+    }, []);
+    useEffect(() => {
+        mountedRef.current = true;
+        if (!enabled)
+            return;
+        refresh();
+        timerRef.current = setInterval(refresh, intervalMs);
+        return () => {
+            mountedRef.current = false;
+            if (timerRef.current !== null) {
+                clearInterval(timerRef.current);
+                timerRef.current = null;
+            }
+            if (abortControllerRef.current) {
+                abortControllerRef.current.abort();
+                abortControllerRef.current = null;
+            }
+        };
+    }, [enabled, intervalMs, refresh]);
+    return { data, error, loading, refresh, lastUpdated };
+}

package/console/dist/ui/hooks/useBookmarks.d.ts

@@ -0,0 +1,6 @@
+export declare function useBookmarks(): {
+    bookmarks: string[];
+    toggleBookmark: (id: string) => void;
+    isBookmarked: (id: string) => boolean;
+    clearBookmarks: () => void;
+};

package/console/dist/ui/hooks/useBookmarks.js

@@ -0,0 +1,43 @@
+import { useState, useEffect, useCallback } from "react";
+const STORAGE_KEY = "pd-principles-bookmarks";
+function loadBookmarks() {
+    try {
+        const raw = localStorage.getItem(STORAGE_KEY);
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((item) => typeof item === "string");
+    }
+    catch {
+        return [];
+    }
+}
+function saveBookmarks(ids) {
+    try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(ids));
+    }
+    catch {
+        // ignore storage errors
+    }
+}
+export function useBookmarks() {
+    const [bookmarks, setBookmarks] = useState(() => loadBookmarks());
+    useEffect(() => {
+        saveBookmarks(bookmarks);
+    }, [bookmarks]);
+    const toggleBookmark = useCallback((id) => {
+        setBookmarks((prev) => {
+            if (prev.includes(id)) {
+                return prev.filter((b) => b !== id);
+            }
+            return [...prev, id];
+        });
+    }, []);
+    const isBookmarked = useCallback((id) => bookmarks.includes(id), [bookmarks]);
+    const clearBookmarks = useCallback(() => {
+        setBookmarks([]);
+    }, []);
+    return { bookmarks, toggleBookmark, isBookmarked, clearBookmarks };
+}

package/console/dist/ui/hooks/useDebounce.d.ts

@@ -0,0 +1,2 @@
+export declare function useDebounce<T>(value: T, delay: number): T;
+export declare function useDebouncedCallback<T extends (...args: Parameters<T>) => ReturnType<T>>(callback: T, delay: number): (...args: Parameters<T>) => void;

package/console/dist/ui/hooks/useDebounce.js

@@ -0,0 +1,32 @@
+import { useState, useEffect, useRef, useCallback } from "react";
+export function useDebounce(value, delay) {
+    const [debouncedValue, setDebouncedValue] = useState(value);
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            setDebouncedValue(value);
+        }, delay);
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [value, delay]);
+    return debouncedValue;
+}
+export function useDebouncedCallback(callback, delay) {
+    const timeoutRef = useRef(null);
+    const debouncedCallback = useCallback((...args) => {
+        if (timeoutRef.current !== null) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(() => {
+            callback(...args);
+        }, delay);
+    }, [callback, delay]);
+    useEffect(() => {
+        return () => {
+            if (timeoutRef.current !== null) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, []);
+    return debouncedCallback;
+}

package/console/dist/ui/hooks/useKeyboardNavigation.d.ts

@@ -0,0 +1,14 @@
+interface UseKeyboardNavigationOptions {
+    itemCount: number;
+    onSelect: (index: number) => void;
+    enabled?: boolean;
+}
+export declare function useKeyboardNavigation({ itemCount, onSelect, enabled, }: UseKeyboardNavigationOptions): {
+    resetSelection: () => void;
+    selectedIndex: number;
+};
+interface UseFocusSearchOptions {
+    enabled?: boolean;
+}
+export declare function useFocusSearch({ enabled }: UseFocusSearchOptions): void;
+export {};