@epoch32/visage 1.0.0 → 1.1.1

package/dist/style/parser.d.ts

@@ -0,0 +1,12 @@
+export interface ScopeOptions {
+    scopeId: string;
+    passToChildren?: boolean;
+}
+/**
+ * Scope a single CSS selector string with the given scope identifier
+ */
+export declare function scopeSelector(selector: string, options: ScopeOptions): string;
+/**
+ * Full CSS block scoping transformer
+ */
+export declare function scopeCSS(css: string, options: ScopeOptions): string;

package/dist/style/scale.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Visage Spatial Engine & Style Primitives
+ *
+ * Eliminates measurement fatigue, layout bugs, and manual viewport calculations.
+ * Standardizes on a crisp 4px spatial scale, semantic viewport intents,
+ * fluid clamp calculations, and typed visual design tokens.
+ */
+export declare const UNITLESS_PROPERTIES: Set<string>;
+export declare const DIMENSION_KEYWORDS: Record<string, string>;
+/**
+ * Resolves a spatial scale step or dimensional intent to a valid CSS measurement.
+ * Numbers map to the 4px engineering grid (1 = 4px, 2 = 8px, 4 = 16px, 8 = 32px).
+ *
+ * @example
+ * space(1)        // "4px"
+ * space(2)        // "8px"
+ * space(4)        // "16px"
+ * space(6)        // "24px"
+ * space("full")   // "100%"
+ * space("screen") // "100dvh"
+ */
+export declare function space(val: number | string | undefined | null): string;
+/**
+ * Resolves width, height, or grid sizing into valid CSS.
+ * Small numbers (<= 48) map to the 4px scale, while larger numbers (> 48)
+ * are treated as explicit pixel dimensions.
+ */
+export declare function resolveDimension(val: number | string | undefined | null): string;
+/**
+ * Explicit raw pixel measurement helper.
+ */
+export declare function px(val: number): string;
+/**
+ * Explicit rem measurement helper.
+ */
+export declare function rem(val: number): string;
+/**
+ * Explicit em measurement helper.
+ */
+export declare function em(val: number): string;
+/**
+ * Computes an optimal fluid clamp() expression.
+ * Eliminates the math nightmare of manual linear viewport interpolation slopes.
+ *
+ * @param minPx Minimum size in pixels at mobile viewport
+ * @param maxPx Maximum size in pixels at desktop viewport
+ * @param options Min/max viewport bounds (defaults to 375px mobile and 1280px desktop)
+ *
+ * @example
+ * fluid(16, 32)
+ * // clamp(16px, 9.38px + 1.77vw, 32px)
+ */
+export declare function fluid(minPx: number, maxPx: number, options?: {
+    minVw?: number;
+    maxVw?: number;
+}): string;
+export type ShadowVariant = "none" | "sm" | "md" | "lg" | "xl" | "soft" | "glow" | "inner";
+export declare const SHADOW_PRESETS: Record<ShadowVariant, string>;
+/**
+ * Returns typed box-shadow tokens designed for high-contrast optical depth.
+ */
+export declare function shadow(variant: ShadowVariant | string): string;
+export type RadiusVariant = "none" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | "full" | number;
+export declare const RADIUS_PRESETS: Record<string, string>;
+/**
+ * Returns typed border-radius tokens or scale numbers.
+ */
+export declare function radius(variant: RadiusVariant): string;
+export interface GlassOptions {
+    blur?: number | string;
+    tint?: string;
+    border?: string;
+}
+/**
+ * Generates tactile glassmorphism CSS styles with backdrop filters and frosted borders.
+ */
+export declare function glass(options?: GlassOptions): Record<string, string>;
+/**
+ * Formats a style property value for direct DOM binding or SSR generation.
+ * Handles automatic unit resolution, dimension keywords, and custom CSS variables.
+ */
+export declare function formatStyleProp(prop: string, val: any): string;

package/dist/template/index.d.ts

@@ -0,0 +1 @@
+export { html, template } from "./template";

package/dist/{src/template → template}/index.js

@@ -431,10 +431,12 @@ class Signal {
   _value;
   _subscribers = new Set;
   _equals;
+  _onSet;
   version = 0;
-  constructor(initialValue, equals) {
+  constructor(initialValue, equals, onSet) {
     this._value = initialValue;
     this._equals = equals ?? Object.is;
+    this._onSet = onSet;
   }
   get() {
     if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
@@ -459,6 +461,9 @@ class Signal {
     }
     this._value = newValue;
     this.version++;
+    if (this._onSet) {
+      this._onSet(newValue);
+    }
     batch(() => {
       this.notify();
     });
@@ -484,11 +489,91 @@ class Signal {
     }
   }
 }
+function resolveStorage(storageOption) {
+  if (storageOption && typeof storageOption === "object") {
+    return storageOption;
+  }
+  if (storageOption === "session") {
+    try {
+      if (typeof sessionStorage !== "undefined")
+        return sessionStorage;
+    } catch {}
+    try {
+      if (typeof window !== "undefined" && window.sessionStorage) {
+        return window.sessionStorage;
+      }
+    } catch {}
+    try {
+      if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+        return globalThis.sessionStorage;
+      }
+    } catch {}
+    return null;
+  }
+  try {
+    if (typeof localStorage !== "undefined")
+      return localStorage;
+  } catch {}
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return window.localStorage;
+    }
+  } catch {}
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+      return globalThis.localStorage;
+    }
+  } catch {}
+  return null;
+}
 function signal(initialValue, optionsOrEquals) {
   const equals = typeof optionsOrEquals === "function" ? optionsOrEquals : optionsOrEquals?.equals;
   const isInternal = typeof optionsOrEquals === "object" ? optionsOrEquals?.internal : false;
   const customName = typeof optionsOrEquals === "object" ? optionsOrEquals?.name : undefined;
-  const s = new Signal(initialValue, equals);
+  const persistOption = typeof optionsOrEquals === "object" ? optionsOrEquals?.persist : undefined;
+  const persistConfig = persistOption ? typeof persistOption === "string" ? { key: persistOption } : persistOption : undefined;
+  let effectiveInitial = initialValue;
+  const storage = persistConfig ? resolveStorage(persistConfig.storage) : null;
+  const serialize = persistConfig?.serialize ?? JSON.stringify;
+  const deserialize = persistConfig?.deserialize ?? JSON.parse;
+  if (persistConfig && storage) {
+    try {
+      const stored = storage.getItem(persistConfig.key);
+      if (stored !== null) {
+        effectiveInitial = deserialize(stored);
+      }
+    } catch {}
+  }
+  let isSyncing = false;
+  const onSet = persistConfig && storage ? (val) => {
+    if (isSyncing)
+      return;
+    try {
+      storage.setItem(persistConfig.key, serialize(val));
+    } catch {}
+  } : undefined;
+  const s = new Signal(effectiveInitial, equals, onSet);
+  if (persistConfig && storage && (persistConfig.syncTabs ?? true) && typeof window !== "undefined" && typeof window.addEventListener === "function") {
+    const onStorage = (e) => {
+      if (e.key === persistConfig.key) {
+        try {
+          const nextVal = e.newValue !== null ? deserialize(e.newValue) : initialValue;
+          isSyncing = true;
+          try {
+            s.set(nextVal);
+          } finally {
+            isSyncing = false;
+          }
+        } catch {}
+      }
+    };
+    window.addEventListener("storage", onStorage);
+    if (currentScope) {
+      currentScope.addCleanup(() => {
+        window.removeEventListener("storage", onStorage);
+      });
+    }
+  }
   const accessor = (...args) => {
     if (args.length === 0) {
       return s.get();

package/dist/template/template.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Cache and clone pre-parsed HTML template strings with native browser cloneNode(true)
+ */
+export declare function template<T extends HTMLElement = HTMLElement>(htmlString: string): () => T;
+/**
+ * Tagged template literal for ultra-fast HTML string rendering with reactive signal bindings
+ */
+export declare function html(strings: TemplateStringsArray, ...values: any[]): HTMLElement | DocumentFragment;

package/dist/ui/accordion.d.ts

@@ -0,0 +1,81 @@
+import type { Child } from "../dom/render";
+export interface AccordionContextValue {
+    isExpanded: (value: string) => boolean;
+    toggleItem: (value: string) => void;
+    type: "single" | "multiple";
+    collapsible: boolean;
+}
+export declare const AccordionContext: import("..").Context<AccordionContextValue | null>;
+export declare function useAccordionContext(): AccordionContextValue | null;
+export interface AccordionItemData {
+    value: string;
+    trigger: Child | (() => Child);
+    content: Child | (() => Child);
+    disabled?: boolean | (() => boolean);
+}
+export interface AccordionBaseProps {
+    items?: AccordionItemData[];
+    itemClass?: any;
+    triggerClass?: any;
+    contentClass?: any;
+    as?: string;
+    class?: any;
+    style?: any;
+    children?: Child | (() => Child);
+    [key: string]: any;
+}
+export interface AccordionSingleProps extends AccordionBaseProps {
+    type: "single";
+    value?: () => string | undefined;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    collapsible?: boolean;
+}
+export interface AccordionMultipleProps extends AccordionBaseProps {
+    type: "multiple";
+    value?: () => string[] | undefined;
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+}
+export type AccordionProps = AccordionSingleProps | AccordionMultipleProps;
+export declare function AccordionRoot(props: AccordionProps): Child;
+export interface AccordionItemContextValue {
+    value: string;
+    itemId: string;
+}
+export declare const AccordionItemContext: import("..").Context<AccordionItemContextValue | null>;
+export declare function useAccordionItemContext(): AccordionItemContextValue | null;
+export interface AccordionItemProps {
+    value: string;
+    disabled?: boolean | (() => boolean);
+    as?: string;
+    class?: any;
+    style?: any;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function AccordionItem(props: AccordionItemProps): Child;
+export interface AccordionTriggerProps {
+    as?: string;
+    class?: any;
+    style?: any;
+    onClick?: (e: MouseEvent) => void;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function AccordionTrigger(props: AccordionTriggerProps): Child;
+export interface AccordionContentProps {
+    forceMount?: boolean;
+    as?: string;
+    class?: any;
+    style?: any;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function AccordionContent(props: AccordionContentProps): Child;
+export declare const Accordion: typeof AccordionRoot & {
+    Root: typeof AccordionRoot;
+    Item: typeof AccordionItem;
+    Trigger: typeof AccordionTrigger;
+    Content: typeof AccordionContent;
+};

package/dist/ui/command-dialog.d.ts

@@ -0,0 +1,10 @@
+import type { Child } from "../dom/render";
+import type { CommandProps } from "./command";
+export interface CommandDialogProps extends CommandProps {
+    open?: () => boolean | undefined;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    overlayClass?: any;
+    contentClass?: any;
+}
+export declare function CommandDialog(props: CommandDialogProps): Child;

package/dist/ui/command.d.ts

@@ -0,0 +1,103 @@
+import type { Child } from "../dom/render";
+import type { ReadonlySignal } from "../signals";
+import { CommandDialog, type CommandDialogProps } from "./command-dialog";
+export type { CommandDialogProps };
+export { CommandDialog };
+export interface CommandItemData {
+    value?: string;
+    label: Child | (() => Child);
+    icon?: Child | (() => Child);
+    shortcut?: string;
+    disabled?: boolean;
+    onSelect?: () => void;
+    keywords?: string[];
+    class?: any;
+}
+export interface CommandGroupData {
+    heading?: string;
+    items: CommandItemData[];
+}
+export interface CommandContextValue {
+    search: ReadonlySignal<string>;
+    setSearch: (query: string) => void;
+    activeValue: ReadonlySignal<string>;
+    setActiveValue: (val: string) => void;
+    filterMatches: (text: string, keywords?: string[]) => boolean;
+    commandId: string;
+}
+export declare const CommandContext: import("..").Context<CommandContextValue | null>;
+export declare function useCommandContext(): CommandContextValue | null;
+export interface CommandProps {
+    value?: () => string | undefined;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    search?: () => string | undefined;
+    onSearchChange?: (query: string) => void;
+    placeholder?: string;
+    groups?: CommandGroupData[];
+    items?: CommandItemData[];
+    emptyText?: string;
+    class?: any;
+    style?: any;
+    inputClass?: any;
+    listClass?: any;
+    itemClass?: any;
+    as?: string;
+    children?: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function CommandRoot(props: CommandProps): Child;
+export interface CommandInputProps {
+    placeholder?: string;
+    class?: any;
+    style?: any;
+    [key: string]: any;
+}
+export declare function CommandInput(props: CommandInputProps): Child;
+export interface CommandListProps {
+    as?: string;
+    class?: any;
+    style?: any;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function CommandList(props: CommandListProps): Child;
+export interface CommandEmptyProps {
+    as?: string;
+    class?: any;
+    style?: any;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function CommandEmpty(props: CommandEmptyProps): Child;
+export interface CommandGroupProps {
+    heading?: string;
+    as?: string;
+    class?: any;
+    style?: any;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function CommandGroup(props: CommandGroupProps): Child;
+export interface CommandItemProps {
+    value?: string;
+    shortcut?: string;
+    disabled?: boolean;
+    onSelect?: () => void;
+    keywords?: string[];
+    as?: string;
+    class?: any;
+    style?: any;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function CommandItem(props: CommandItemProps): Child;
+export declare const Command: typeof CommandRoot & {
+    Root: typeof CommandRoot;
+    Dialog: typeof CommandDialog;
+    Input: typeof CommandInput;
+    List: typeof CommandList;
+    Empty: typeof CommandEmpty;
+    Group: typeof CommandGroup;
+    Item: typeof CommandItem;
+};

package/dist/ui/data-table.d.ts

@@ -0,0 +1,38 @@
+import type { Child } from "../dom/render";
+export type SortDirection = "asc" | "desc" | null;
+export interface SortState {
+    column: string;
+    direction: SortDirection;
+}
+export interface ColumnDef<T = any> {
+    id: string;
+    header: Child | (() => Child);
+    accessorKey?: keyof T;
+    cell?: (row: T, index: number) => Child;
+    sortable?: boolean;
+    width?: string;
+    align?: "left" | "center" | "right";
+}
+export interface DataTableProps<T = any> {
+    data: T[] | (() => T[]);
+    columns: ColumnDef<T>[];
+    sort?: () => SortState | undefined;
+    onSortChange?: (sort: SortState) => void;
+    filter?: () => string | undefined;
+    selection?: "none" | "single" | "multi";
+    selectedKeys?: () => string[] | undefined;
+    onSelectionChange?: (keys: string[]) => void;
+    getRowId?: (row: T, index: number) => string;
+    pageSize?: number;
+    onRowClick?: (row: T, index: number) => void;
+    emptyText?: string;
+    class?: any;
+    style?: any;
+    tableClass?: any;
+    headerClass?: any;
+    rowClass?: any;
+    cellClass?: any;
+    paginationClass?: any;
+    [key: string]: any;
+}
+export declare function DataTable<T extends Record<string, any>>(props: DataTableProps<T>): Child;

package/dist/ui/dialog.d.ts

@@ -0,0 +1,102 @@
+import type { Child } from "../dom/render";
+import type { ReadonlySignal } from "../signals";
+export interface DialogContextValue {
+    open: ReadonlySignal<boolean>;
+    setOpen: (open: boolean) => void;
+    titleId: string;
+    descriptionId: string;
+    contentRef: {
+        current: HTMLElement | null;
+    };
+}
+export declare const DialogContext: import("..").Context<DialogContextValue | null>;
+export declare function useDialogContext(): DialogContextValue;
+export interface DialogProps {
+    open?: () => boolean | undefined;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    trigger?: Child | (() => Child);
+    title?: Child | (() => Child);
+    description?: Child | (() => Child);
+    footer?: Child | (() => Child);
+    triggerClass?: any;
+    overlayClass?: any;
+    contentClass?: any;
+    titleClass?: any;
+    descriptionClass?: any;
+    footerClass?: any;
+    portalled?: boolean;
+    children?: Child | (() => Child);
+}
+export declare function DialogRoot(props: DialogProps): Child;
+export interface DialogTriggerProps {
+    as?: string;
+    class?: any;
+    style?: any;
+    onClick?: (e: MouseEvent) => void;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function DialogTrigger(props: DialogTriggerProps): Child;
+export interface DialogPortalProps {
+    mount?: HTMLElement | null;
+    children: Child | (() => Child);
+}
+export declare function DialogPortal(props: DialogPortalProps): Child;
+export interface DialogOverlayProps {
+    as?: string;
+    portalled?: boolean;
+    mount?: HTMLElement | null;
+    class?: any;
+    style?: any;
+    onClick?: (e: MouseEvent) => void;
+    children?: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function DialogOverlay(props: DialogOverlayProps): Child;
+export interface DialogContentProps {
+    as?: string;
+    portalled?: boolean;
+    mount?: HTMLElement | null;
+    class?: any;
+    style?: any;
+    onKeyDown?: (e: KeyboardEvent) => void;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function DialogContent(props: DialogContentProps): Child;
+export interface DialogTitleProps {
+    as?: string;
+    class?: any;
+    style?: any;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function DialogTitle(props: DialogTitleProps): Child;
+export interface DialogDescriptionProps {
+    as?: string;
+    class?: any;
+    style?: any;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function DialogDescription(props: DialogDescriptionProps): Child;
+export interface DialogCloseProps {
+    as?: string;
+    class?: any;
+    style?: any;
+    onClick?: (e: MouseEvent) => void;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function DialogClose(props: DialogCloseProps): Child;
+export declare const Dialog: typeof DialogRoot & {
+    Root: typeof DialogRoot;
+    Trigger: typeof DialogTrigger;
+    Portal: typeof DialogPortal;
+    Overlay: typeof DialogOverlay;
+    Content: typeof DialogContent;
+    Title: typeof DialogTitle;
+    Description: typeof DialogDescription;
+    Close: typeof DialogClose;
+};

package/dist/ui/dropdown-menu.d.ts

@@ -0,0 +1,92 @@
+import type { Child } from "../dom/render";
+import { type ReadonlySignal } from "../signals";
+export interface DropdownMenuContextValue {
+    open: ReadonlySignal<boolean>;
+    setOpen: (open: boolean) => void;
+    triggerRef: {
+        current: HTMLElement | null;
+    };
+    contentRef: {
+        current: HTMLElement | null;
+    };
+    menuId: string;
+}
+export declare const DropdownMenuContext: import("..").Context<DropdownMenuContextValue | null>;
+export declare function useDropdownMenuContext(): DropdownMenuContextValue | null;
+export interface DropdownMenuItemData {
+    label?: Child | (() => Child);
+    icon?: Child | (() => Child);
+    disabled?: boolean | (() => boolean);
+    danger?: boolean;
+    separator?: boolean;
+    onSelect?: (e: Event) => void;
+    class?: any;
+}
+export interface DropdownMenuProps {
+    open?: () => boolean | undefined;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    trigger?: Child | (() => Child);
+    items?: DropdownMenuItemData[];
+    triggerClass?: any;
+    contentClass?: any;
+    itemClass?: any;
+    separatorClass?: any;
+    portalled?: boolean;
+    children?: Child | (() => Child);
+}
+export declare function DropdownMenuRoot(props: DropdownMenuProps): Child;
+export interface DropdownMenuTriggerProps {
+    as?: string;
+    class?: any;
+    style?: any;
+    onClick?: (e: MouseEvent) => void;
+    onKeyDown?: (e: KeyboardEvent) => void;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function DropdownMenuTrigger(props: DropdownMenuTriggerProps): Child;
+export interface DropdownMenuPortalProps {
+    mount?: HTMLElement | null;
+    children: Child | (() => Child);
+}
+export declare function DropdownMenuPortal(props: DropdownMenuPortalProps): Child;
+export interface DropdownMenuContentProps {
+    as?: string;
+    portalled?: boolean;
+    mount?: HTMLElement | null;
+    class?: any;
+    style?: any;
+    onKeyDown?: (e: KeyboardEvent) => void;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function DropdownMenuContent(props: DropdownMenuContentProps): Child;
+export interface DropdownMenuItemProps {
+    disabled?: boolean | (() => boolean);
+    closeOnSelect?: boolean;
+    as?: string;
+    class?: any;
+    style?: any;
+    onSelect?: (e: Event) => void;
+    onClick?: (e: MouseEvent) => void;
+    onKeyDown?: (e: KeyboardEvent) => void;
+    children: Child | (() => Child);
+    [key: string]: any;
+}
+export declare function DropdownMenuItem(props: DropdownMenuItemProps): Child;
+export interface DropdownMenuSeparatorProps {
+    as?: string;
+    class?: any;
+    style?: any;
+    [key: string]: any;
+}
+export declare function DropdownMenuSeparator(props: DropdownMenuSeparatorProps): Child;
+export declare const DropdownMenu: typeof DropdownMenuRoot & {
+    Root: typeof DropdownMenuRoot;
+    Trigger: typeof DropdownMenuTrigger;
+    Portal: typeof DropdownMenuPortal;
+    Content: typeof DropdownMenuContent;
+    Item: typeof DropdownMenuItem;
+    Separator: typeof DropdownMenuSeparator;
+};

package/dist/ui/icon.d.ts

@@ -0,0 +1,18 @@
+import type { Child } from "../dom/render";
+export type IconNode = [string, Record<string, any>][];
+export interface IconProps {
+    size?: number | string | (() => number | string);
+    color?: string | (() => string);
+    strokeWidth?: number | string | (() => number | string);
+    class?: any;
+    style?: any;
+    children?: Child | (() => Child);
+    [key: string]: any;
+}
+/**
+ * Creates a native Visage SVG component from a Lucide / SVG icon node definition
+ */
+export declare function createIcon(name: string, iconNode: IconNode): {
+    (props?: IconProps): Child;
+    displayName: string;
+};

package/dist/ui/index.d.ts

@@ -0,0 +1,14 @@
+export { Accordion, AccordionContent, AccordionItem, type AccordionItemProps, type AccordionMultipleProps, type AccordionProps, type AccordionSingleProps, AccordionTrigger, useAccordionContext, useAccordionItemContext } from "./accordion";
+export { Command, CommandDialog, type CommandDialogProps, CommandEmpty, CommandGroup, type CommandGroupData, CommandInput, type CommandInputProps, CommandItem, type CommandItemData, type CommandItemProps, CommandList, type CommandProps, useCommandContext } from "./command";
+export { type ColumnDef, DataTable, type DataTableProps, type SortDirection, type SortState } from "./data-table";
+export { Dialog, DialogClose, DialogContent, type DialogContentProps, DialogDescription, DialogOverlay, DialogPortal, type DialogProps, DialogTitle, DialogTrigger, useDialogContext } from "./dialog";
+export { DropdownMenu, DropdownMenuContent, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuPortal, type DropdownMenuProps, DropdownMenuSeparator, DropdownMenuTrigger, useDropdownMenuContext } from "./dropdown-menu";
+export { createIcon, type IconNode, type IconProps } from "./icon";
+export { type BaseLayoutProps, Center, type CenterProps, Grid, type GridProps, Row, type RowProps, Spacer, type SpacerProps, Stack, type StackProps } from "./layout";
+export { Popover, PopoverClose, PopoverContent, type PopoverContentProps, PopoverPortal, type PopoverProps, PopoverTrigger, usePopoverContext } from "./popover";
+export { Switch, type SwitchProps, SwitchThumb, type SwitchThumbProps } from "./switch";
+export { Tabs, TabsContent, type TabsContentProps, TabsList, type TabsProps, TabsTrigger, useTabsContext } from "./tabs";
+export type { ToastData, ToastManager, ToastOptions, ToastProps, ToastVariant } from "./toast";
+export { createToastManager, defaultToastManager, Toast, ToastClose, ToastDescription, ToastProvider, type ToastProviderProps, ToastTitle, ToastViewport, type ToastViewportProps, toast, useToast } from "./toast";
+export { Tooltip, TooltipContent, type TooltipContentProps, TooltipPortal, type TooltipProps, TooltipTrigger, useTooltipContext } from "./tooltip";
+export { createControllableSignal, createId, onClickOutside, trapFocus } from "./utils";