iryx-ui 0.2.0 → 0.4.0

package/dist/components/NumberInput.vue.d.ts

@@ -0,0 +1,63 @@
+export interface NumberInputProps {
+    /** Smallest allowed value, as a decimal string. */
+    min?: string;
+    /** Largest allowed value, as a decimal string. */
+    max?: string;
+    /** Amount the stepper adds or subtracts, as a decimal string. */
+    step?: string;
+    /** Fixed decimal places. Values are rounded half-up to this scale. */
+    precision?: number;
+    /**
+     * Locale used for the *display* only — `sl` shows `1.234,56`. The model
+     * stays canonical (`"1234.56"`) whatever the locale.
+     */
+    locale?: string;
+    /** Show the stacked increment/decrement controls. */
+    stepper?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    /** Mark the field as invalid — styles the border and ring red. */
+    invalid?: boolean;
+    id?: string;
+    /** Accessible names for the stepper controls — override for non-English apps. */
+    incrementLabel?: string;
+    decrementLabel?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ step: 'px-2' }`. */
+    ui?: {
+        root?: string;
+        input?: string;
+        stepper?: string;
+        step?: string;
+    };
+}
+type __VLS_Props = NumberInputProps;
+type __VLS_ModelProps = {
+    /**
+     * The model is a decimal **string**, never a number.
+     *
+     * Money in a finance app is computed with decimal arithmetic; coercing to a
+     * float here would silently lose precision before the value ever reached the
+     * caller. An empty string means "no value".
+     */
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    unstyled: boolean;
+    step: string;
+    invalid: boolean;
+    stepper: boolean;
+    incrementLabel: string;
+    decrementLabel: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Pagination.vue.d.ts

@@ -0,0 +1,57 @@
+export interface PaginationProps {
+    /** Total number of records, not pages. */
+    total?: number;
+    itemsPerPage?: number;
+    /** How many pages to show either side of the current one. */
+    siblingCount?: number;
+    /** Keep the first and last page visible however far away they are. */
+    showEdges?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    /** Accessible names — override for non-English apps. */
+    prevLabel?: string;
+    nextLabel?: string;
+    label?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ item: 'rounded-full' }`. */
+    ui?: {
+        root?: string;
+        list?: string;
+        item?: string;
+        ellipsis?: string;
+    };
+}
+type __VLS_Props = PaginationProps;
+type __VLS_ModelProps = {
+    'page'?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_20: {}, __VLS_45: {};
+type __VLS_Slots = {} & {
+    prev?: (props: typeof __VLS_20) => any;
+} & {
+    next?: (props: typeof __VLS_45) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:page": (value: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:page"?: ((value: number) => any) | undefined;
+}>, {
+    unstyled: boolean;
+    label: string;
+    total: number;
+    itemsPerPage: number;
+    siblingCount: number;
+    showEdges: boolean;
+    prevLabel: string;
+    nextLabel: 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/Progress.vue.d.ts

@@ -0,0 +1,52 @@
+export interface ProgressProps {
+    /** Current value. `null` (or `indeterminate`) means unknown duration. */
+    modelValue?: number | null;
+    max?: number;
+    variant?: 'primary' | 'success' | 'warning' | 'danger' | 'info';
+    size?: 'sm' | 'md' | 'lg';
+    /** Unknown duration — animates instead of tracking a value. */
+    indeterminate?: boolean;
+    /** Text shown above the track. */
+    label?: string;
+    /** Show the value beside the label. Defaults to a percentage. */
+    showValue?: boolean;
+    /**
+     * Format the displayed value and the accessible label. Override for
+     * non-percentage units or non-English locales.
+     */
+    formatValue?: (value: number, max: number) => string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ track: 'h-4' }`. */
+    ui?: {
+        root?: string;
+        header?: string;
+        label?: string;
+        value?: string;
+        track?: string;
+        indicator?: string;
+    };
+}
+declare var __VLS_1: {}, __VLS_3: {
+    value: number | null;
+    percent: number;
+    formatted: string;
+};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_1) => any;
+} & {
+    value?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ProgressProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ProgressProps> & Readonly<{}>, {
+    unstyled: boolean;
+    max: 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/Separator.vue.d.ts

@@ -0,0 +1,36 @@
+export interface SeparatorProps {
+    orientation?: 'horizontal' | 'vertical';
+    /** Text shown in the middle of the rule. */
+    label?: string;
+    /**
+     * Purely visual, so it is hidden from assistive tech. Set false when the
+     * rule genuinely divides sections of content.
+     */
+    decorative?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ line: 'bg-primary' }`. */
+    ui?: {
+        root?: string;
+        line?: string;
+        label?: string;
+    };
+}
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<SeparatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SeparatorProps> & Readonly<{}>, {
+    unstyled: boolean;
+    orientation: "horizontal" | "vertical";
+    decorative: boolean;
+}, {}, {}, {}, 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/Skeleton.vue.d.ts

@@ -0,0 +1,20 @@
+export interface SkeletonProps {
+    /** Render as a different element or component. */
+    as?: string;
+    variant?: 'text' | 'rect' | 'circle';
+    /** Repeat as stacked lines. Useful for paragraphs of placeholder copy. */
+    lines?: number;
+    /** Accessible description of what is loading. */
+    label?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+}
+declare const __VLS_export: import("vue").DefineComponent<SkeletonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SkeletonProps> & Readonly<{}>, {
+    as: string;
+    unstyled: boolean;
+    label: string;
+    lines: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Stat.vue.d.ts

@@ -0,0 +1,57 @@
+export interface StatProps {
+    /** Render as a different element or component. */
+    as?: string;
+    label?: string;
+    value?: string | number;
+    /** Change since the previous period. Sign picks the colour and the arrow. */
+    delta?: number;
+    /**
+     * Override the colour of the delta. Useful when down is the good direction —
+     * falling costs, for example — since the sign alone cannot tell.
+     */
+    trend?: 'up' | 'down' | 'neutral';
+    /** Secondary text under the value. */
+    hint?: string;
+    size?: 'sm' | 'md' | 'lg';
+    /**
+     * Format the delta. Defaults to a signed percentage; override for other
+     * units or locales.
+     */
+    formatDelta?: (delta: number) => string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ value: 'text-4xl' }`. */
+    ui?: {
+        root?: string;
+        label?: string;
+        value?: string;
+        delta?: string;
+        hint?: string;
+        row?: string;
+    };
+}
+declare var __VLS_8: {}, __VLS_10: {}, __VLS_12: {
+    trend: "neutral" | "up" | "down";
+}, __VLS_19: {};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_8) => any;
+} & {
+    default?: (props: typeof __VLS_10) => any;
+} & {
+    delta?: (props: typeof __VLS_12) => any;
+} & {
+    hint?: (props: typeof __VLS_19) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<StatProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<StatProps> & Readonly<{}>, {
+    as: string;
+    unstyled: boolean;
+}, {}, {}, {}, 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/Stepper.vue.d.ts

@@ -0,0 +1,61 @@
+export interface StepperItemOption {
+    title: string;
+    description?: string;
+    disabled?: boolean;
+}
+export interface StepperProps {
+    items?: (StepperItemOption | string)[];
+    orientation?: 'horizontal' | 'vertical';
+    /**
+     * Require steps to be completed in order.
+     *
+     * Off by default, because when on, a later step cannot be reached until the
+     * ones before it are marked complete — which makes plain `v-model`
+     * increments silently do nothing. Turn it on only if you are driving
+     * navigation through the stepper's own triggers.
+     */
+    linear?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ indicator: 'size-10' }`. */
+    ui?: {
+        root?: string;
+        item?: string;
+        trigger?: string;
+        indicator?: string;
+        content?: string;
+        title?: string;
+        description?: string;
+        separator?: string;
+    };
+}
+type __VLS_Props = StepperProps;
+type __VLS_ModelProps = {
+    /** Steps are 1-indexed, matching how they read to a user. */
+    modelValue?: number;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_26: {
+    step: number;
+    item: StepperItemOption;
+};
+type __VLS_Slots = {} & {
+    indicator?: (props: typeof __VLS_26) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+    unstyled: boolean;
+    linear: boolean;
+}, {}, {}, {}, 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.vue.d.ts

@@ -0,0 +1,63 @@
+import type { IconLike } from '../composables/icon';
+export interface TabsItem {
+    label: string;
+    /** Identifies the tab. Defaults to the label. */
+    value?: string;
+    icon?: IconLike;
+    disabled?: boolean;
+}
+export interface TabsProps {
+    items?: (TabsItem | string)[];
+    variant?: 'solid' | 'line';
+    orientation?: 'horizontal' | 'vertical';
+    /**
+     * Keep inactive panels mounted. Useful when a panel holds form state that
+     * should survive switching away.
+     */
+    keepMounted?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ list: 'w-full' }`. */
+    ui?: {
+        root?: string;
+        list?: string;
+        indicator?: string;
+        trigger?: string;
+        content?: string;
+    };
+}
+type __VLS_Props = TabsProps;
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_19: {}, __VLS_27: {
+    item: TabsItem;
+}, __VLS_34: {}, __VLS_43: string, __VLS_44: {
+    item: TabsItem;
+};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_43>]?: (props: typeof __VLS_44) => any;
+} & {
+    list?: (props: typeof __VLS_19) => any;
+} & {
+    trigger?: (props: typeof __VLS_27) => any;
+} & {
+    default?: (props: typeof __VLS_34) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    unstyled: boolean;
+}, {}, {}, {}, 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/Toaster.vue.d.ts

@@ -0,0 +1,28 @@
+export interface ToasterProps {
+    position?: 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+    /** Default milliseconds before auto-dismiss; a toast's own `duration` wins. */
+    duration?: number;
+    /** Accessible name for each dismiss button — override for non-English apps. */
+    closeLabel?: string;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ viewport: 'sm:max-w-md' }`. */
+    ui?: {
+        viewport?: string;
+        root?: string;
+        icon?: string;
+        content?: string;
+        title?: string;
+        description?: string;
+        action?: string;
+        close?: string;
+    };
+}
+declare const __VLS_export: import("vue").DefineComponent<ToasterProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ToasterProps> & Readonly<{}>, {
+    closeLabel: string;
+    unstyled: boolean;
+    duration: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/Tooltip.vue.d.ts

@@ -0,0 +1,49 @@
+export interface TooltipProps {
+    /** Tooltip text. Ignored when the `content` slot is used. */
+    text?: string;
+    side?: 'top' | 'right' | 'bottom' | 'left';
+    align?: 'start' | 'center' | 'end';
+    sideOffset?: number;
+    /** Milliseconds to hover before it opens. */
+    delay?: number;
+    /** Render the little pointer against the trigger. */
+    arrow?: boolean;
+    disabled?: boolean;
+    /** Skip built-in classes; you take over styling entirely. */
+    unstyled?: boolean;
+    class?: string;
+    /** Override classes per slot, e.g. `{ content: 'max-w-sm' }`. */
+    ui?: {
+        content?: string;
+        arrow?: string;
+    };
+}
+type __VLS_Props = TooltipProps;
+type __VLS_ModelProps = {
+    'open'?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_20: {}, __VLS_34: {};
+type __VLS_Slots = {} & {
+    trigger?: (props: typeof __VLS_20) => any;
+} & {
+    content?: (props: typeof __VLS_34) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    unstyled: boolean;
+    side: "top" | "right" | "bottom" | "left";
+    sideOffset: number;
+    delay: 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/index.d.ts

@@ -1,14 +1,30 @@
 export { default as Alert } from './Alert.vue';
 export { default as App } from './App.vue';
 export { default as Badge } from './Badge.vue';
+export { default as Breadcrumb } from './Breadcrumb.vue';
 export { default as Button } from './Button.vue';
+export { default as ButtonGroup } from './ButtonGroup.vue';
 export { default as Card } from './Card.vue';
 export { default as Checkbox } from './Checkbox.vue';
+export { default as ConfirmDialog } from './ConfirmDialog.vue';
+export { default as Dialog } from './Dialog.vue';
+export { default as DropdownMenu } from './DropdownMenu.vue';
+export { default as EmptyState } from './EmptyState.vue';
 export { default as Form } from './Form.vue';
 export { default as FormField } from './FormField.vue';
 export { default as Input } from './Input.vue';
 export { default as Label } from './Label.vue';
+export { default as NumberInput } from './NumberInput.vue';
+export { default as Pagination } from './Pagination.vue';
+export { default as Progress } from './Progress.vue';
 export { default as RadioGroup } from './RadioGroup.vue';
 export { default as Select } from './Select.vue';
+export { default as Separator } from './Separator.vue';
+export { default as Skeleton } from './Skeleton.vue';
+export { default as Stat } from './Stat.vue';
+export { default as Stepper } from './Stepper.vue';
 export { default as Switch } from './Switch.vue';
+export { default as Tabs } from './Tabs.vue';
 export { default as Textarea } from './Textarea.vue';
+export { default as Toaster } from './Toaster.vue';
+export { default as Tooltip } from './Tooltip.vue';

package/dist/composables/button-group.d.ts

@@ -0,0 +1,12 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+export type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/** Context a `ButtonGroup` exposes to the buttons it wraps. */
+export interface ButtonGroupContext {
+    size: ComputedRef<ButtonSize | undefined>;
+}
+export declare const buttonGroupContextKey: InjectionKey<ButtonGroupContext>;
+/**
+ * Access the enclosing `ButtonGroup`, if any. Buttons use this to pick up a
+ * shared size, so it only has to be set once on the group.
+ */
+export declare function useButtonGroup(): ButtonGroupContext | undefined;

package/dist/composables/confirm.d.ts

@@ -0,0 +1,36 @@
+export interface ConfirmOptions {
+    title: string;
+    description?: string;
+    /** Text for the confirming button. Supply your own for non-English apps. */
+    confirmLabel?: string;
+    /** Text for the dismissing button. Supply your own for non-English apps. */
+    cancelLabel?: string;
+    /** Style the confirming button as destructive. */
+    danger?: boolean;
+}
+/** An open request, plus the resolver its promise is waiting on. */
+export interface ConfirmRequest extends ConfirmOptions {
+    id: number;
+    resolve: (confirmed: boolean) => void;
+}
+/** Internal: the request `<IConfirmDialog>` should currently render. */
+export declare function useConfirmState(): import("vue").ShallowRef<ConfirmRequest | null, ConfirmRequest | null>;
+/** Settle the open request and clear it. */
+export declare function resolveConfirm(confirmed: boolean): void;
+export interface ConfirmApi {
+    /** Resolves `true` if the user confirms, `false` if they cancel or dismiss. */
+    confirm: (options: ConfirmOptions | string) => Promise<boolean>;
+}
+/**
+ * Promise-based confirmation for destructive actions.
+ *
+ * Requires a single `<IConfirmDialog />` mounted somewhere in the app —
+ * typically just inside `<IApp>`.
+ *
+ * ```ts
+ * const { confirm } = useConfirm()
+ * if (await confirm({ title: 'Delete draft?', danger: true }))
+ *   await remove()
+ * ```
+ */
+export declare function useConfirm(): ConfirmApi;

package/dist/composables/decimal.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Decimal-string arithmetic, exact by construction.
+ *
+ * Money is stored and computed as decimal strings — `0.1 + 0.2` in binary
+ * floating point is `0.30000000000000004`, which silently corrupts a total.
+ * Everything here scales to integers and uses `BigInt`, so a value only ever
+ * round-trips through `Number` if the caller asks for it.
+ */
+interface Decimal {
+    /** Unscaled value: `1234.56` at scale 2 is `123456n`. */
+    units: bigint;
+    /** Number of decimal places. */
+    scale: number;
+}
+/** Parse a canonical decimal string (`-1234.56`). Returns undefined if invalid. */
+export declare function parseDecimal(value: string): Decimal | undefined;
+/** Render a Decimal back to a canonical string. */
+export declare function formatDecimal({ units, scale }: Decimal): string;
+/** `-1` if a < b, `0` if equal, `1` if a > b. */
+export declare function compareDecimals(a: string, b: string): number;
+/** Exact addition. `addDecimals('0.1', '0.2')` is `'0.3'`, not `'0.30000000000000004'`. */
+export declare function addDecimals(a: string, b: string): string | undefined;
+/** Round half-up to a fixed number of decimal places. */
+export declare function roundDecimal(value: string, precision: number): string | undefined;
+/** Constrain a value to a range, comparing exactly. */
+export declare function clampDecimal(value: string, min?: string, max?: string): string;
+/** Whether a string is a well-formed decimal. */
+export declare function isDecimal(value: string): boolean;
+/** The separators a locale uses, e.g. `.`/`,` for `en`, `,`/`.` for `sl`. */
+export declare function localeSeparators(locale: string): {
+    decimal: string;
+    group: string;
+};
+/**
+ * Render a canonical decimal for display, e.g. `"1234.56"` as `1.234,56` in
+ * `sl`. Formatting goes through the digits, never `Number`, so a value too
+ * large for a float still displays exactly.
+ */
+export declare function formatForLocale(value: string, locale: string, precision?: number): string;
+/**
+ * Render a canonical decimal for *editing*: the locale's decimal separator,
+ * but no grouping.
+ *
+ * Editing must not show the canonical `1234.56` in a locale where `.` groups
+ * digits — parsing that back would read it as `123456`.
+ */
+export declare function toEditable(value: string, locale?: string): string;
+/**
+ * Turn typed input into a canonical decimal, accepting the locale's
+ * separators. `1.234,56` in `sl` becomes `1234.56`.
+ */
+export declare function parseFromLocale(input: string, locale: string): string | undefined;
+export {};

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

@@ -0,0 +1,22 @@
+import type { IconLike } from './icon';
+export interface DropdownMenuItemOption {
+    label: string;
+    /** Leading icon component. */
+    icon?: IconLike;
+    disabled?: boolean;
+    /** Style the item as destructive. */
+    danger?: boolean;
+    /** Run when the item is chosen. Omit on an entry that opens a submenu. */
+    onSelect?: () => void;
+    /** Nested entries. Turns this item into a submenu trigger. */
+    items?: DropdownMenuEntry[];
+}
+/**
+ * One row of a menu.
+ *
+ * `'-'` renders a separator. An option with `items` opens a submenu, and one
+ * with neither `items` nor `onSelect` is a non-interactive group label.
+ */
+export type DropdownMenuEntry = DropdownMenuItemOption | '-';
+export declare function isSeparator(entry: DropdownMenuEntry): entry is '-';
+export declare function isSubmenu(entry: DropdownMenuItemOption): boolean;

package/dist/composables/icon.d.ts

@@ -0,0 +1,10 @@
+import type { IconArray } from '@hugeicons/vue';
+import type { Component } from 'vue';
+/**
+ * Anything that can be rendered as an icon.
+ *
+ * Hugeicons ships icons as data arrays rather than components, so both forms
+ * are accepted: pass a Hugeicons export, or any component that renders an SVG.
+ */
+export type IconLike = Component | IconArray;
+export declare function isIconArray(icon: IconLike): icon is IconArray;