@hanzo/ui 5.3.33 → 5.3.35

package/dist/src/project/kanban.js

@@ -0,0 +1,259 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { closestCorners, DndContext, DragOverlay, PointerSensor, useSensor, useSensors, } from "@dnd-kit/core";
+import { arrayMove, SortableContext, useSortable, verticalListSortingStrategy, } from "@dnd-kit/sortable";
+import { CSS } from "@dnd-kit/utilities";
+import { cva } from "class-variance-authority";
+import { Calendar, Edit3, MoreHorizontal, Plus, Search, User, X, } from "lucide-react";
+import { cn } from "@hanzo/ui/lib/utils";
+import { Badge } from "@hanzo/ui/primitives/badge";
+import { Button } from "@hanzo/ui/primitives/button";
+import { Card, CardHeader } from "@hanzo/ui/primitives/card";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "@hanzo/ui/primitives/dialog";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger, } from "@hanzo/ui/primitives/dropdown-menu";
+import { Input } from "@hanzo/ui/primitives/input";
+import { Label } from "@hanzo/ui/primitives/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue, } from "@hanzo/ui/primitives/select";
+import { Textarea } from "@hanzo/ui/primitives/textarea";
+// Priority variants
+const priorityVariants = cva("inline-flex items-center rounded-full border px-2 py-0.5 text-xs font-semibold", {
+    variants: {
+        priority: {
+            low: "border-blue-200 bg-blue-50 text-blue-700 dark:border-blue-800 dark:bg-blue-900/20 dark:text-blue-400",
+            medium: "border-yellow-200 bg-yellow-50 text-yellow-700 dark:border-yellow-800 dark:bg-yellow-900/20 dark:text-yellow-400",
+            high: "border-orange-200 bg-orange-50 text-orange-700 dark:border-orange-800 dark:bg-orange-900/20 dark:text-orange-400",
+            urgent: "border-red-200 bg-red-50 text-red-700 dark:border-red-800 dark:bg-red-900/20 dark:text-red-400",
+        },
+    },
+    defaultVariants: {
+        priority: "low",
+    },
+});
+// Sortable Card Component
+function SortableCard({ card, onEdit, onDelete, }) {
+    const { attributes, listeners, setNodeRef, transform, transition, isDragging, } = useSortable({ id: card.id });
+    const style = {
+        transform: CSS.Transform.toString(transform),
+        transition,
+    };
+    return (_jsx("div", { ref: setNodeRef, style: style, ...attributes, ...listeners, className: cn("cursor-grab active:cursor-grabbing", isDragging && "opacity-50"), children: _jsx(KanbanCardComponent, { card: card, onEdit: onEdit, onDelete: onDelete }) }));
+}
+// Card Component
+function KanbanCardComponent({ card, onEdit, onDelete, }) {
+    return (_jsx(Card, { className: "mb-3 group hover:shadow-md transition-shadow", children: _jsx(CardHeader, { className: "pb-3", children: _jsx("div", { className: "flex items-start justify-between", children: _jsxs("div", { className: "flex-1 min-w-0", children: [_jsx("h4", { className: "font-medium text-sm leading-tight mb-2 break-words", children: card.title }), card.description && (_jsx("p", { className: "text-xs text-muted-foreground line-clamp-2 mb-2", children: card.description })), card.labels && card.labels.length > 0 && (_jsx("div", { className: "flex flex-wrap gap-1 mb-2", children: card.labels.map((label) => (_jsx(Badge, { variant: "outline", className: "text-xs h-5", style: {
+                                    backgroundColor: `${label.color}20`,
+                                    borderColor: label.color,
+                                    color: label.color,
+                                }, children: label.name }, label.id))) })), _jsxs("div", { className: "flex items-center justify-between text-xs", children: [_jsxs("div", { className: "flex items-center gap-2", children: [card.priority && (_jsx("span", { className: cn(priorityVariants({ priority: card.priority })), children: card.priority })), card.assignee && (_jsxs("div", { className: "flex items-center gap-1 text-muted-foreground", children: [_jsx(User, { className: "h-3 w-3" }), _jsx("span", { children: card.assignee })] }))] }), _jsxs("div", { className: "flex items-center gap-1", children: [card.dueDate && (_jsxs("div", { className: "flex items-center gap-1 text-muted-foreground", children: [_jsx(Calendar, { className: "h-3 w-3" }), _jsx("span", { children: new Date(card.dueDate).toLocaleDateString() })] })), _jsxs(DropdownMenu, { children: [_jsx(DropdownMenuTrigger, { asChild: true, children: _jsx(Button, { variant: "ghost", size: "icon", className: "h-6 w-6 opacity-0 group-hover:opacity-100 transition-opacity", children: _jsx(MoreHorizontal, { className: "h-3 w-3" }) }) }), _jsxs(DropdownMenuContent, { align: "end", children: [_jsxs(DropdownMenuItem, { onClick: () => onEdit(card), children: [_jsx(Edit3, { className: "h-4 w-4 mr-2" }), "Edit"] }), _jsxs(DropdownMenuItem, { onClick: () => onDelete(card.id), className: "text-destructive", children: [_jsx(X, { className: "h-4 w-4 mr-2" }), "Delete"] })] })] })] })] })] }) }) }) }));
+}
+// Column Component
+function KanbanColumnComponent({ column, onAddCard, onEditCard, onDeleteCard, }) {
+    const { setNodeRef } = useSortable({ id: column.id });
+    return (_jsxs("div", { ref: setNodeRef, className: "bg-muted/50 rounded-lg p-4 min-w-[280px] max-w-[280px] flex flex-col", children: [_jsxs("div", { className: "flex items-center justify-between mb-4", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx("h3", { className: "font-semibold text-sm", children: column.title }), _jsxs(Badge, { variant: "secondary", className: "text-xs", children: [column.cards.length, column.limit && `/${column.limit}`] })] }), _jsx(Button, { variant: "ghost", size: "icon", className: "h-8 w-8", onClick: () => onAddCard(column.id), children: _jsx(Plus, { className: "h-4 w-4" }) })] }), _jsx(SortableContext, { items: column.cards.map((card) => card.id), strategy: verticalListSortingStrategy, children: _jsx("div", { className: "flex-1 min-h-[200px]", children: column.cards.map((card) => (_jsx(SortableCard, { card: card, onEdit: onEditCard, onDelete: onDeleteCard }, card.id))) }) })] }));
+}
+// Card Form Dialog
+function CardFormDialog({ open, onOpenChange, card, onSave, labels, }) {
+    const [formData, setFormData] = React.useState({
+        title: card?.title || "",
+        description: card?.description || "",
+        priority: card?.priority || "low",
+        assignee: card?.assignee || "",
+        dueDate: card?.dueDate || "",
+        labels: card?.labels?.map((l) => l.id) || [],
+    });
+    const handleSubmit = (e) => {
+        e.preventDefault();
+        if (!formData.title.trim())
+            return;
+        onSave({
+            ...card,
+            ...formData,
+            labels: labels.filter((l) => formData.labels.includes(l.id)),
+            updatedAt: new Date().toISOString(),
+        });
+        onOpenChange(false);
+    };
+    React.useEffect(() => {
+        if (card) {
+            setFormData({
+                title: card.title,
+                description: card.description || "",
+                priority: card.priority || "low",
+                assignee: card.assignee || "",
+                dueDate: card.dueDate || "",
+                labels: card.labels?.map((l) => l.id) || [],
+            });
+        }
+        else {
+            setFormData({
+                title: "",
+                description: "",
+                priority: "low",
+                assignee: "",
+                dueDate: "",
+                labels: [],
+            });
+        }
+    }, [card]);
+    return (_jsx(Dialog, { open: open, onOpenChange: onOpenChange, children: _jsxs(DialogContent, { className: "max-w-md", children: [_jsxs(DialogHeader, { children: [_jsx(DialogTitle, { children: card ? "Edit Card" : "Create Card" }), _jsx(DialogDescription, { children: card
+                                ? "Update the card details below."
+                                : "Create a new card for your kanban board." })] }), _jsxs("form", { onSubmit: handleSubmit, className: "space-y-4", children: [_jsxs("div", { children: [_jsx(Label, { htmlFor: "title", children: "Title *" }), _jsx(Input, { id: "title", value: formData.title, onChange: (e) => setFormData((prev) => ({ ...prev, title: e.target.value })), placeholder: "Enter card title...", required: true })] }), _jsxs("div", { children: [_jsx(Label, { htmlFor: "description", children: "Description" }), _jsx(Textarea, { id: "description", value: formData.description, onChange: (e) => setFormData((prev) => ({
+                                        ...prev,
+                                        description: e.target.value,
+                                    })), placeholder: "Enter card description...", rows: 3 })] }), _jsxs("div", { className: "grid grid-cols-2 gap-4", children: [_jsxs("div", { children: [_jsx(Label, { htmlFor: "priority", children: "Priority" }), _jsxs(Select, { value: formData.priority, onValueChange: (value) => setFormData((prev) => ({ ...prev, priority: value })), children: [_jsx(SelectTrigger, { children: _jsx(SelectValue, {}) }), _jsxs(SelectContent, { children: [_jsx(SelectItem, { value: "low", children: "Low" }), _jsx(SelectItem, { value: "medium", children: "Medium" }), _jsx(SelectItem, { value: "high", children: "High" }), _jsx(SelectItem, { value: "urgent", children: "Urgent" })] })] })] }), _jsxs("div", { children: [_jsx(Label, { htmlFor: "assignee", children: "Assignee" }), _jsx(Input, { id: "assignee", value: formData.assignee, onChange: (e) => setFormData((prev) => ({ ...prev, assignee: e.target.value })), placeholder: "Assign to..." })] })] }), _jsxs("div", { children: [_jsx(Label, { htmlFor: "dueDate", children: "Due Date" }), _jsx(Input, { id: "dueDate", type: "date", value: formData.dueDate, onChange: (e) => setFormData((prev) => ({ ...prev, dueDate: e.target.value })) })] }), _jsxs(DialogFooter, { children: [_jsx(Button, { type: "button", variant: "outline", onClick: () => onOpenChange(false), children: "Cancel" }), _jsxs(Button, { type: "submit", children: [card ? "Update" : "Create", " Card"] })] })] })] }) }));
+}
+export function KanbanBoard({ board, onUpdateBoard, className, }) {
+    const [activeCard, setActiveCard] = React.useState(null);
+    const [searchQuery, setSearchQuery] = React.useState("");
+    const [cardFormOpen, setCardFormOpen] = React.useState(false);
+    const [editingCard, setEditingCard] = React.useState(undefined);
+    const [activeColumnId, setActiveColumnId] = React.useState("");
+    const sensors = useSensors(useSensor(PointerSensor, {
+        activationConstraint: {
+            distance: 8,
+        },
+    }));
+    // Filter cards based on search query
+    const filteredBoard = React.useMemo(() => {
+        if (!searchQuery.trim())
+            return board;
+        const filtered = {
+            ...board,
+            columns: board.columns.map((column) => ({
+                ...column,
+                cards: column.cards.filter((card) => card.title.toLowerCase().includes(searchQuery.toLowerCase()) ||
+                    card.description
+                        ?.toLowerCase()
+                        .includes(searchQuery.toLowerCase()) ||
+                    card.labels?.some((label) => label.name.toLowerCase().includes(searchQuery.toLowerCase()))),
+            })),
+        };
+        return filtered;
+    }, [board, searchQuery]);
+    const handleDragStart = (event) => {
+        const { active } = event;
+        const card = board.columns
+            .flatMap((col) => col.cards)
+            .find((card) => card.id === active.id);
+        setActiveCard(card || null);
+    };
+    const handleDragOver = (event) => {
+        const { active, over } = event;
+        if (!over)
+            return;
+        const activeId = active.id;
+        const overId = over.id;
+        // Find the containers
+        const activeContainer = findContainer(activeId);
+        const overContainer = findContainer(overId);
+        if (!activeContainer ||
+            !overContainer ||
+            activeContainer === overContainer) {
+            return;
+        }
+        // Move card between columns
+        const updatedBoard = { ...board };
+        const activeColumnIndex = updatedBoard.columns.findIndex((col) => col.id === activeContainer);
+        const overColumnIndex = updatedBoard.columns.findIndex((col) => col.id === overContainer);
+        const activeColumn = updatedBoard.columns[activeColumnIndex];
+        const overColumn = updatedBoard.columns[overColumnIndex];
+        const activeCardIndex = activeColumn.cards.findIndex((card) => card.id === activeId);
+        const [movedCard] = activeColumn.cards.splice(activeCardIndex, 1);
+        // Check column limit
+        if (overColumn.limit && overColumn.cards.length >= overColumn.limit) {
+            return;
+        }
+        overColumn.cards.push(movedCard);
+        onUpdateBoard(updatedBoard);
+    };
+    const handleDragEnd = (event) => {
+        const { active, over } = event;
+        setActiveCard(null);
+        if (!over)
+            return;
+        const activeId = active.id;
+        const overId = over.id;
+        const activeContainer = findContainer(activeId);
+        const overContainer = findContainer(overId);
+        if (!activeContainer || !overContainer)
+            return;
+        const activeColumnIndex = board.columns.findIndex((col) => col.id === activeContainer);
+        const activeColumn = board.columns[activeColumnIndex];
+        if (activeContainer === overContainer) {
+            // Reordering within the same column
+            const oldIndex = activeColumn.cards.findIndex((card) => card.id === activeId);
+            const newIndex = activeColumn.cards.findIndex((card) => card.id === overId);
+            if (oldIndex !== newIndex) {
+                const updatedBoard = { ...board };
+                updatedBoard.columns[activeColumnIndex].cards = arrayMove(activeColumn.cards, oldIndex, newIndex);
+                onUpdateBoard(updatedBoard);
+            }
+        }
+    };
+    const findContainer = (id) => {
+        // Check if it's a column
+        if (board.columns.some((col) => col.id === id)) {
+            return id;
+        }
+        // Find which column contains this card
+        return board.columns.find((col) => col.cards.some((card) => card.id === id))
+            ?.id;
+    };
+    const handleAddCard = (columnId) => {
+        setActiveColumnId(columnId);
+        setEditingCard(undefined);
+        setCardFormOpen(true);
+    };
+    const handleEditCard = (card) => {
+        setEditingCard(card);
+        setActiveColumnId("");
+        setCardFormOpen(true);
+    };
+    const handleSaveCard = (cardData) => {
+        const updatedBoard = { ...board };
+        if (editingCard) {
+            // Update existing card
+            const columnIndex = updatedBoard.columns.findIndex((col) => col.cards.some((card) => card.id === editingCard.id));
+            if (columnIndex !== -1) {
+                const cardIndex = updatedBoard.columns[columnIndex].cards.findIndex((card) => card.id === editingCard.id);
+                if (cardIndex !== -1) {
+                    updatedBoard.columns[columnIndex].cards[cardIndex] = {
+                        ...editingCard,
+                        ...cardData,
+                    };
+                }
+            }
+        }
+        else {
+            // Create new card
+            const columnIndex = updatedBoard.columns.findIndex((col) => col.id === activeColumnId);
+            if (columnIndex !== -1) {
+                const newCard = {
+                    id: `card-${Date.now()}`,
+                    title: cardData.title,
+                    description: cardData.description,
+                    labels: cardData.labels,
+                    priority: cardData.priority,
+                    assignee: cardData.assignee,
+                    dueDate: cardData.dueDate,
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString(),
+                };
+                updatedBoard.columns[columnIndex].cards.push(newCard);
+            }
+        }
+        onUpdateBoard(updatedBoard);
+    };
+    const handleDeleteCard = (cardId) => {
+        const updatedBoard = { ...board };
+        const columnIndex = updatedBoard.columns.findIndex((col) => col.cards.some((card) => card.id === cardId));
+        if (columnIndex !== -1) {
+            updatedBoard.columns[columnIndex].cards = updatedBoard.columns[columnIndex].cards.filter((card) => card.id !== cardId);
+            onUpdateBoard(updatedBoard);
+        }
+    };
+    return (_jsxs("div", { className: cn("flex flex-col h-full", className), children: [_jsxs("div", { className: "flex items-center justify-between p-4 border-b", children: [_jsx("h1", { className: "text-2xl font-bold", children: board.title }), _jsx("div", { className: "flex items-center gap-3", children: _jsxs("div", { className: "relative", children: [_jsx(Search, { className: "absolute left-3 top-1/2 transform -translate-y-1/2 h-4 w-4 text-muted-foreground" }), _jsx(Input, { placeholder: "Search cards...", value: searchQuery, onChange: (e) => setSearchQuery(e.target.value), className: "pl-9 w-64" })] }) })] }), _jsx("div", { className: "flex-1 overflow-x-auto", children: _jsx("div", { className: "h-full p-4", children: _jsxs(DndContext, { sensors: sensors, collisionDetection: closestCorners, onDragStart: handleDragStart, onDragOver: handleDragOver, onDragEnd: handleDragEnd, children: [_jsx("div", { className: "flex gap-6 h-full pb-4", children: filteredBoard.columns.map((column) => (_jsx(KanbanColumnComponent, { column: column, onAddCard: handleAddCard, onEditCard: handleEditCard, onDeleteCard: handleDeleteCard }, column.id))) }), _jsx(DragOverlay, { children: activeCard ? (_jsx(KanbanCardComponent, { card: activeCard, onEdit: () => { }, onDelete: () => { } })) : null })] }) }) }), _jsx(CardFormDialog, { open: cardFormOpen, onOpenChange: setCardFormOpen, card: editingCard, onSave: handleSaveCard, labels: board.labels })] }));
+}
+// Export default for registry
+export default KanbanBoard;

package/dist/src/project/list.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare const List: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLUListElement> & React.RefAttributes<HTMLUListElement>>;
+declare const ListItem: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLLIElement> & React.RefAttributes<HTMLLIElement>>;
+export { List, ListItem };
+//# sourceMappingURL=list.d.ts.map

package/dist/src/project/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/project/list.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,QAAA,MAAM,IAAI,iHAKR,CAAA;AAGF,QAAA,MAAM,QAAQ,2GAKZ,CAAA;AAGF,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA"}

package/dist/src/project/list.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "@hanzo/ui/lib/utils";
+const List = React.forwardRef(({ className, ...props }, ref) => (_jsx("ul", { ref: ref, className: cn("space-y-2", className), ...props })));
+List.displayName = "List";
+const ListItem = React.forwardRef(({ className, ...props }, ref) => (_jsx("li", { ref: ref, className: cn("", className), ...props })));
+ListItem.displayName = "ListItem";
+export { List, ListItem };

package/dist/src/registry/api.d.ts

@@ -0,0 +1,38 @@
+import { RegistryItem, Registry } from "./index";
+/**
+ * Gets the full registry URL based on the registry name or URL provided
+ * @param registry - Registry name, URL, or file path
+ * @returns The complete registry URL
+ */
+export declare function getRegistryUrl(registry: string): string;
+/**
+ * Fetches a specific registry item by URL
+ * @param itemUrl - The URL of the item to fetch
+ * @param basePath - Base path for resolving imports
+ * @returns The registry item or null if not found
+ */
+export declare function getRegistryItem(itemUrl: string, basePath: string): Promise<RegistryItem | null>;
+/**
+ * Resolves an import path relative to a base path
+ * @param importPath - The import path to resolve
+ * @param basePath - The base path to resolve against
+ * @returns The resolved import path
+ */
+export declare function resolveImport(importPath: string, basePath: string): string;
+/**
+ * Fetches registry data from one or more paths
+ * @param paths - Array of registry paths to fetch
+ * @param options - Options for fetching the registry
+ * @returns Array of registry data
+ */
+export declare function fetchRegistry(paths: string[], options?: {
+    useCache?: boolean;
+}): Promise<Registry[]>;
+/**
+ * Gets the URL for a specific registry item
+ * @param itemName - The name of the registry item
+ * @param registryUrl - The base registry URL
+ * @returns The URL for the specific registry item
+ */
+export declare function getRegistryItemUrl(itemName: string, registryUrl: string): string;
+//# sourceMappingURL=api.d.ts.map

package/dist/src/registry/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../src/registry/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAKpE;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBvD;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAoC9B;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAc1E;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,GACnC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAyCrB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAGhF"}

package/dist/src/registry/api.js

@@ -0,0 +1,129 @@
+import { registryItemSchema } from "./index";
+const registryCache = new Map();
+/**
+ * Gets the full registry URL based on the registry name or URL provided
+ * @param registry - Registry name, URL, or file path
+ * @returns The complete registry URL
+ */
+export function getRegistryUrl(registry) {
+    // Check if registry is a full URL
+    if (registry.startsWith("http")) {
+        return registry;
+    }
+    // Default to Hanzo registry if REGISTRY_BASE_URL is defined, otherwise use hanzo
+    const baseUrl = process.env.REGISTRY_BASE_URL || "https://ui.hanzo.com/registry";
+    // Check if registry is a path to a JSON file
+    if (registry.endsWith(".json")) {
+        return `${baseUrl}/${registry}`;
+    }
+    // Assume registry is a registry style
+    return `${baseUrl}/${registry}/registry.json`;
+}
+/**
+ * Fetches a specific registry item by URL
+ * @param itemUrl - The URL of the item to fetch
+ * @param basePath - Base path for resolving imports
+ * @returns The registry item or null if not found
+ */
+export async function getRegistryItem(itemUrl, basePath) {
+    try {
+        const response = await fetch(itemUrl);
+        if (!response.ok) {
+            console.error(`Failed to fetch registry item from ${itemUrl}: ${response.status} ${response.statusText}`);
+            return null;
+        }
+        const item = await response.json();
+        const validatedItem = registryItemSchema.safeParse(item);
+        if (!validatedItem.success) {
+            console.error(`Invalid registry item format: ${JSON.stringify(validatedItem.error)}`);
+            return null;
+        }
+        // Process and resolve file paths
+        if (validatedItem.data.files) {
+            for (const file of validatedItem.data.files) {
+                if (!file.content) {
+                    continue;
+                }
+                // If the file has a target, we resolve it from the target
+                if (file.target) {
+                    file.target = resolveImport(file.target, basePath);
+                }
+            }
+        }
+        return validatedItem.data;
+    }
+    catch (error) {
+        console.error(`Error fetching registry item: ${error}`);
+        return null;
+    }
+}
+/**
+ * Resolves an import path relative to a base path
+ * @param importPath - The import path to resolve
+ * @param basePath - The base path to resolve against
+ * @returns The resolved import path
+ */
+export function resolveImport(importPath, basePath) {
+    const importParts = importPath?.split("/");
+    // Check if it's a relative import
+    if (importPath.startsWith(".")) {
+        return [basePath.replace(/^@/, ""), ...importParts].filter(Boolean).join("/");
+    }
+    // Check if it's a scope package
+    if (importParts?.[0]?.startsWith("@")) {
+        return importPath;
+    }
+    return importPath;
+}
+/**
+ * Fetches registry data from one or more paths
+ * @param paths - Array of registry paths to fetch
+ * @param options - Options for fetching the registry
+ * @returns Array of registry data
+ */
+export async function fetchRegistry(paths, options = {}) {
+    options = {
+        useCache: true,
+        ...options,
+    };
+    try {
+        const results = await Promise.all(paths.map(async (path) => {
+            const url = getRegistryUrl(path);
+            // Check cache first if caching is enabled
+            if (options.useCache && registryCache.has(url)) {
+                return registryCache.get(url);
+            }
+            // Store the promise in the cache before awaiting if caching is enabled
+            const fetchPromise = (async () => {
+                const response = await fetch(url);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch registry from ${url}. ${response.status} ${response.statusText}`);
+                }
+                return response.json();
+            })();
+            if (options.useCache) {
+                registryCache.set(url, fetchPromise);
+            }
+            return fetchPromise;
+        }));
+        return results;
+    }
+    catch (error) {
+        console.error(`Error fetching registry: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Gets the URL for a specific registry item
+ * @param itemName - The name of the registry item
+ * @param registryUrl - The base registry URL
+ * @returns The URL for the specific registry item
+ */
+export function getRegistryItemUrl(itemName, registryUrl) {
+    const registryBaseUrl = registryUrl.replace(/\/registry\.json$/, "");
+    return `${registryBaseUrl}/r/${itemName}.json`;
+}
+// Support CommonJS
+if (typeof module !== 'undefined') {
+    module.exports = { getRegistryUrl, getRegistryItem, resolveImport, fetchRegistry, getRegistryItemUrl };
+}