@juxtui/ui 0.1.0

package/dist/components/input/JInput.vue.d.ts

@@ -0,0 +1,42 @@
+import type { FieldProps } from '../field/useField';
+export type InputSize = 'sm' | 'md' | 'lg';
+export interface InputProps extends FieldProps {
+    type?: string;
+    placeholder?: string;
+    size?: InputSize;
+    readonly?: boolean;
+    name?: string;
+    autocomplete?: string;
+}
+type __VLS_Props = InputProps;
+type __VLS_Slots = {
+    leading?: () => unknown;
+    trailing?: () => unknown;
+    label?: () => unknown;
+};
+type __VLS_ModelProps = {
+    modelValue?: string | number | null;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    /** The underlying `<input>` element. */
+    input: import("vue").Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    focus: () => void | undefined;
+    select: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number | null) => any) | undefined;
+}>, {
+    size: InputSize;
+    error: string | boolean;
+    type: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/JPortal.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    to?: string;
+};
+type __VLS_Slots = {
+    default?: () => unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    to: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/primitives/JSlot.d.ts

@@ -0,0 +1,8 @@
+import type { VNode } from 'vue';
+/**
+ * Internal: renders its first child element and merges its own attributes
+ * (ARIA, listeners, ids) onto it — no wrapper element.
+ */
+export declare const JSlot: import("vue").DefineComponent<{}, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/components/select/JSelect.vue.d.ts

@@ -0,0 +1,53 @@
+import type { FieldProps } from '../field/useField';
+export interface SelectOption<V = string | number> {
+    value: V;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+}
+export interface SelectProps<V> extends FieldProps {
+    /** Options as objects, or plain strings when value and label are the same. */
+    options: Array<SelectOption<V> | V>;
+    placeholder?: string;
+    size?: 'sm' | 'md' | 'lg';
+    /** Submits the value under this name in a form. */
+    name?: string;
+}
+declare const __VLS_export: <T extends string | number = string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<(SelectProps<T> & {
+        modelValue?: T | null;
+    }) & {
+        onClose?: (() => any) | undefined;
+        "onUpdate:modelValue"?: ((value: T | null) => any) | undefined;
+        onOpen?: (() => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<{
+        focus: () => void | undefined;
+        open: () => void;
+        close: () => void;
+    }>) => void;
+    attrs: any;
+    slots: {
+        option?: (props: {
+            option: SelectOption<T>;
+            selected: boolean;
+            active: boolean;
+        }) => unknown;
+        value?: (props: {
+            option: SelectOption<T>;
+        }) => unknown;
+        label?: () => unknown;
+    };
+    emit: (((evt: "close") => void) & ((evt: "open") => void)) & ((event: "update:modelValue", value: T | null) => void);
+}>) => import("vue").VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/switch/JSwitch.vue.d.ts

@@ -0,0 +1,37 @@
+export interface SwitchProps {
+    label?: string;
+    description?: string;
+    disabled?: boolean;
+    size?: 'sm' | 'md';
+    /** Submits `value` under `name` in a form when on. */
+    name?: string;
+    value?: string;
+    id?: string;
+}
+type __VLS_Props = SwitchProps;
+type __VLS_Slots = {
+    default?: () => unknown;
+    description?: () => unknown;
+};
+type __VLS_ModelProps = {
+    modelValue?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    focus: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    size: "sm" | "md";
+    value: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/tabs/JTabs.vue.d.ts

@@ -0,0 +1,48 @@
+export interface TabItem {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+export interface TabsProps {
+    items: TabItem[];
+    /** `line` for page sections, `pill` for compact view switches. */
+    variant?: 'line' | 'pill';
+    size?: 'sm' | 'md';
+    /** Accessible name for the tab list. */
+    label?: string;
+    /** Stretch tabs to fill the width. */
+    fill?: boolean;
+}
+type __VLS_Props = TabsProps;
+type __VLS_Slots = {
+    /** Custom tab label. */
+    tab?: (props: {
+        item: TabItem;
+        selected: boolean;
+    }) => unknown;
+    /** Panels are named after each item's `value`. */
+    [value: string]: ((props: {
+        item: TabItem;
+        selected: boolean;
+    }) => unknown) | undefined;
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {
+    size: "sm" | "md";
+    variant: "line" | "pill";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/textarea/JTextarea.vue.d.ts

@@ -0,0 +1,38 @@
+import type { FieldProps } from '../field/useField';
+export interface TextareaProps extends FieldProps {
+    placeholder?: string;
+    rows?: number;
+    /** Grow with the content, up to `maxRows`. */
+    autoresize?: boolean;
+    maxRows?: number;
+    readonly?: boolean;
+    name?: string;
+}
+type __VLS_Props = TextareaProps;
+type __VLS_Slots = {
+    label?: () => unknown;
+};
+type __VLS_ModelProps = {
+    modelValue?: string | null;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    textarea: import("vue").Ref<HTMLTextAreaElement | null, HTMLTextAreaElement | null>;
+    focus: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
+}>, {
+    error: string | boolean;
+    rows: number;
+    maxRows: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/toast/JToastItem.vue.d.ts

@@ -0,0 +1,13 @@
+/** Internal: one toast. Owns its timer, swipe gesture and keyboard dismissal. */
+import type { Toast } from '../../composables/useToast';
+type __VLS_Props = {
+    toast: Toast;
+    paused: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    dismiss: (id: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDismiss?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/toast/JToaster.vue.d.ts

@@ -0,0 +1,18 @@
+export type ToasterPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+export interface ToasterProps {
+    position?: ToasterPosition;
+    /** How many toasts are visible at once. Extra toasts wait their turn. */
+    max?: number;
+    /** Shortcut that moves focus to the newest toast. */
+    hotkey?: string;
+    /** Accessible name for the notification region. */
+    label?: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<ToasterProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ToasterProps> & Readonly<{}>, {
+    label: string;
+    hotkey: string;
+    position: ToasterPosition;
+    max: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/tooltip/JTooltip.vue.d.ts

@@ -0,0 +1,24 @@
+export interface TooltipProps {
+    /** Tooltip text. Use the `content` slot for richer content. */
+    content?: string;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    /** Hover delay before opening, in ms. Keyboard focus opens immediately. */
+    delay?: number;
+    disabled?: boolean;
+}
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<TooltipProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TooltipProps> & Readonly<{}>, {
+    align: "start" | "center" | "end";
+    side: "top" | "right" | "bottom" | "left";
+    delay: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: () => unknown;
+    content?: () => unknown;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components.d.ts

@@ -0,0 +1,19 @@
+export { default as JAvatar } from './components/avatar/JAvatar.vue';
+export { default as JBadge } from './components/badge/JBadge.vue';
+export { default as JButton } from './components/button/JButton.vue';
+export { default as JCard } from './components/card/JCard.vue';
+export { default as JCheckbox } from './components/checkbox/JCheckbox.vue';
+export { default as JCommandPalette } from './components/command-palette/JCommandPalette.vue';
+export { default as JDialog } from './components/dialog/JDialog.vue';
+export { default as JDropdownMenu } from './components/dropdown-menu/JDropdownMenu.vue';
+export { default as JDropdownMenuItem } from './components/dropdown-menu/JDropdownMenuItem.vue';
+export { default as JDropdownMenuLabel } from './components/dropdown-menu/JDropdownMenuLabel.vue';
+export { default as JDropdownMenuSeparator } from './components/dropdown-menu/JDropdownMenuSeparator.vue';
+export { default as JDropdownMenuSub } from './components/dropdown-menu/JDropdownMenuSub.vue';
+export { default as JInput } from './components/input/JInput.vue';
+export { default as JSelect } from './components/select/JSelect.vue';
+export { default as JSwitch } from './components/switch/JSwitch.vue';
+export { default as JTabs } from './components/tabs/JTabs.vue';
+export { default as JTextarea } from './components/textarea/JTextarea.vue';
+export { default as JToaster } from './components/toast/JToaster.vue';
+export { default as JTooltip } from './components/tooltip/JTooltip.vue';

package/dist/composables/useFloating.d.ts

@@ -0,0 +1,28 @@
+import type { Placement } from '@floating-ui/dom';
+import type { CSSProperties, Ref } from 'vue';
+export type { Placement };
+export interface FloatingOptions {
+    placement?: Placement;
+    /** Gap between reference and floating element, in px. */
+    offset?: number | {
+        mainAxis?: number;
+        crossAxis?: number;
+    };
+    /** Make the floating element at least as wide as the reference. */
+    matchWidth?: boolean;
+    /** Padding kept from the viewport edge, in px. */
+    padding?: number;
+}
+/**
+ * Position a floating element next to a reference element and keep it there
+ * through scroll and resize. Coordinates are written to `left`/`top` so
+ * `transform` stays free for enter/leave motion.
+ */
+export declare function useFloating(reference: Ref<HTMLElement | null>, floating: Ref<HTMLElement | null>, options?: FloatingOptions | (() => FloatingOptions)): {
+    x: Ref<number, number>;
+    y: Ref<number, number>;
+    placement: Ref<Placement, Placement>;
+    side: import("vue").ComputedRef<"top" | "right" | "bottom" | "left">;
+    styles: import("vue").ComputedRef<CSSProperties>;
+    update: () => Promise<void>;
+};

package/dist/composables/useFocusTrap.d.ts

@@ -0,0 +1,12 @@
+import type { Ref } from 'vue';
+export interface FocusTrapOptions {
+    /** Element to focus when the trap activates. Falls back to the first focusable element, then the container. */
+    initialFocus?: () => HTMLElement | null | undefined;
+    /** Return focus to whatever was focused before activation. Defaults to true. */
+    restoreFocus?: boolean;
+}
+/**
+ * Keep keyboard focus inside `container` while `active` is true, and put it
+ * back where it came from afterwards.
+ */
+export declare function useFocusTrap(container: Ref<HTMLElement | null>, active: Ref<boolean>, options?: FocusTrapOptions): void;

package/dist/composables/useHotkey.d.ts

@@ -0,0 +1,10 @@
+import type { MaybeRefOrGetter } from 'vue';
+/**
+ * Parse a shortcut such as `mod+k`, `shift+/` or `alt+t`.
+ * `mod` is ⌘ on Apple platforms and Ctrl elsewhere.
+ */
+export declare function matchesHotkey(event: KeyboardEvent, hotkey: string): boolean;
+/** Human-readable parts of a shortcut, e.g. `mod+k` → `['⌘', 'K']`. */
+export declare function formatHotkey(hotkey: string): string[];
+/** Run `handler` whenever the shortcut is pressed anywhere on the page. */
+export declare function useHotkey(hotkey: MaybeRefOrGetter<string | false | undefined>, handler: (event: KeyboardEvent) => void): void;

package/dist/composables/useLayer.d.ts

@@ -0,0 +1,13 @@
+import type { Ref } from 'vue';
+export interface LayerOptions {
+    /** The layer is registered only while this is true. */
+    active: Ref<boolean>;
+    /** Elements that count as "inside" the layer. */
+    elements: () => Array<HTMLElement | null | undefined>;
+    onEscape?: (event: KeyboardEvent) => void;
+    /** Called when a pointer goes down outside every element of the top-most layer. */
+    onPointerDownOutside?: (event: PointerEvent) => void;
+}
+export declare function useLayer(options: LayerOptions): {
+    isTopLayer: () => boolean;
+};

package/dist/composables/useRecentCommands.d.ts

@@ -0,0 +1,19 @@
+export interface RecentCommandsOptions {
+    /** localStorage key. */
+    key?: string;
+    /** How many ids to remember. */
+    limit?: number;
+}
+/**
+ * Remembers which commands were used most recently, per browser.
+ * Pair `record(item.id)` in your select handler with `resolve(allItems)`
+ * to feed the palette's `recent` prop.
+ */
+export declare function useRecentCommands(options?: RecentCommandsOptions): {
+    ids: import("vue").Ref<string[], string[]>;
+    record: (id: string) => void;
+    clear: () => void;
+    resolve: <T extends {
+        id: string;
+    }>(items: T[]) => T[];
+};

package/dist/composables/useScrollLock.d.ts

@@ -0,0 +1,3 @@
+import type { Ref } from 'vue';
+/** Prevent the page behind an overlay from scrolling while `active` is true. */
+export declare function useScrollLock(active: Ref<boolean>): void;

package/dist/composables/useToast.d.ts

@@ -0,0 +1,93 @@
+export type ToastType = 'default' | 'success' | 'error' | 'warning' | 'info' | 'loading';
+export interface ToastAction {
+    label: string;
+    onClick: () => void;
+}
+export interface ToastOptions {
+    /** Reuse an id to replace an existing toast instead of stacking a new one. */
+    id?: string;
+    description?: string;
+    type?: ToastType;
+    /** Time on screen in ms. `Infinity` keeps it until dismissed. Loading toasts never expire. */
+    duration?: number;
+    action?: ToastAction;
+    /** Show the close button. Defaults to true. */
+    dismissible?: boolean;
+    onDismiss?: () => void;
+}
+export interface Toast {
+    id: string;
+    title: string;
+    description?: string;
+    type: ToastType;
+    duration: number;
+    action?: ToastAction;
+    dismissible: boolean;
+    onDismiss?: () => void;
+    /** Bumps whenever the toast changes, restarting its timer. */
+    version: number;
+}
+export declare const DEFAULT_TOAST_DURATION = 5000;
+declare function update(id: string, patch: Partial<ToastOptions> & {
+    title?: string;
+}): void;
+declare function dismiss(id?: string): void;
+type Message<T> = string | ((value: T) => string);
+interface PromiseMessages<T> {
+    loading: string;
+    success: Message<T>;
+    error: Message<unknown>;
+    description?: string;
+}
+declare function promise<T>(input: Promise<T> | (() => Promise<T>), messages: PromiseMessages<T>): Promise<T>;
+type Shortcut = (title: string, options?: Omit<ToastOptions, 'type'>) => string;
+export interface ToastFn {
+    (title: string, options?: ToastOptions): string;
+    success: Shortcut;
+    error: Shortcut;
+    warning: Shortcut;
+    info: Shortcut;
+    loading: Shortcut;
+    promise: typeof promise;
+    update: typeof update;
+    dismiss: typeof dismiss;
+}
+/** Show a toast. Works anywhere — inside or outside components. */
+export declare const toast: ToastFn;
+export declare function useToast(): {
+    toast: ToastFn;
+    dismiss: typeof dismiss;
+    update: typeof update;
+    toasts: readonly {
+        readonly id: string;
+        readonly title: string;
+        readonly description?: string | undefined;
+        readonly type: ToastType;
+        readonly duration: number;
+        readonly action?: {
+            readonly label: string;
+            readonly onClick: () => void;
+        } | undefined;
+        readonly dismissible: boolean;
+        readonly onDismiss?: (() => void) | undefined;
+        readonly version: number;
+    }[];
+};
+/** @internal Mutable access for JToaster and tests. */
+export declare const toastState: {
+    toasts: {
+        id: string;
+        title: string;
+        description?: string | undefined;
+        type: ToastType;
+        duration: number;
+        action?: {
+            label: string;
+            onClick: () => void;
+        } | undefined;
+        dismissible: boolean;
+        onDismiss?: (() => void) | undefined;
+        version: number;
+    }[];
+};
+export {};

package/dist/composables/useTypeahead.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Type-to-jump for lists. Characters typed in quick succession form a query;
+ * repeating the same letter cycles through matches.
+ */
+export declare function useTypeahead(timeout?: number): {
+    search: <T>(key: string, items: T[], getLabel: (item: T) => string, currentIndex: number) => number;
+    isSearching: () => boolean;
+};

package/dist/icons.d.ts

@@ -0,0 +1,18 @@
+import type { FunctionalComponent, SVGAttributes } from 'vue';
+type Icon = FunctionalComponent<SVGAttributes>;
+export declare const IconCheck: Icon;
+export declare const IconChevronDown: Icon;
+export declare const IconChevronUpDown: Icon;
+export declare const IconChevronRight: Icon;
+export declare const IconX: Icon;
+export declare const IconSearch: Icon;
+export declare const IconCircleCheck: Icon;
+export declare const IconCircleX: Icon;
+export declare const IconAlert: Icon;
+export declare const IconInfo: Icon;
+export declare const IconCornerDownLeft: Icon;
+/** The loading spinner used across Juxt. A quarter arc over a faint track. */
+export declare const Spinner: FunctionalComponent<{
+    size?: number;
+}>;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import './styles/index.css';
+export * from './components';
+export type { AvatarProps, AvatarStatus } from './components/avatar/JAvatar.vue';
+export type { BadgeProps, BadgeVariant } from './components/badge/JBadge.vue';
+export type { ButtonProps, ButtonSize, ButtonVariant } from './components/button/JButton.vue';
+export type { CardProps } from './components/card/JCard.vue';
+export type { CheckboxProps } from './components/checkbox/JCheckbox.vue';
+export type { CommandGroup, CommandItem, CommandPaletteProps } from './components/command-palette/JCommandPalette.vue';
+export { matchText } from './components/command-palette/search';
+export type { DialogProps } from './components/dialog/JDialog.vue';
+export type { DropdownMenuProps } from './components/dropdown-menu/JDropdownMenu.vue';
+export type { DropdownMenuItemProps } from './components/dropdown-menu/JDropdownMenuItem.vue';
+export type { DropdownMenuSubProps } from './components/dropdown-menu/JDropdownMenuSub.vue';
+export type { FieldProps } from './components/field/useField';
+export type { InputProps, InputSize } from './components/input/JInput.vue';
+export type { SelectOption, SelectProps } from './components/select/JSelect.vue';
+export type { SwitchProps } from './components/switch/JSwitch.vue';
+export type { TabItem, TabsProps } from './components/tabs/JTabs.vue';
+export type { TextareaProps } from './components/textarea/JTextarea.vue';
+export type { ToasterPosition, ToasterProps } from './components/toast/JToaster.vue';
+export type { TooltipProps } from './components/tooltip/JTooltip.vue';
+export { useFocusTrap } from './composables/useFocusTrap';
+export type { FocusTrapOptions } from './composables/useFocusTrap';
+export { formatHotkey, matchesHotkey, useHotkey } from './composables/useHotkey';
+export { useRecentCommands } from './composables/useRecentCommands';
+export type { RecentCommandsOptions } from './composables/useRecentCommands';
+export { useScrollLock } from './composables/useScrollLock';
+export { toast, useToast } from './composables/useToast';
+export type { Toast, ToastAction, ToastFn, ToastOptions, ToastType } from './composables/useToast';
+export { JuxtUI, JuxtUI as default } from './plugin';