@synopackageland/ui 0.4.2 → 0.5.3

package/dist/components/primitives/affix/Affix.vue.d.ts

@@ -0,0 +1,40 @@
+import { CSSProperties } from 'vue';
+import { AffixFix } from './affixPosition';
+/**
+ * Pins its content to the near edge of a scrolling boundary while that section
+ * is on screen — a toolbar that stays visible inside a long list, or a footbar
+ * that waits at the bottom until the reader reaches it.
+ */
+type __VLS_Props = {
+    /**
+     * Lazy getter for the boundary element, e.g. `() => scrollEl`. Called on
+     * every measurement, so a `v-if` target that is not mounted yet is fine.
+     * Without it the browser viewport is the boundary.
+     */
+    target?: () => HTMLElement | null | undefined;
+    /** Extra scroll containers to listen to (nested scrollers, portalled ones). */
+    scrollContainers?: HTMLElement[];
+    offsetTop?: number;
+    offsetBottom?: number;
+    /** `top` pins as the content scrolls past; `bottom` pins a footbar. */
+    fix?: AffixFix;
+    innerClass?: string;
+    innerStyle?: CSSProperties;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    offsetTop: number;
+    offsetBottom: number;
+    fix: AffixFix;
+}, {}, {}, {}, 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/affix/affixPosition.d.ts

@@ -0,0 +1,35 @@
+export type AffixFix = 'top' | 'bottom';
+/** Viewport-relative edges of the boundary element. */
+export type AffixContainerRect = {
+    top: number;
+    bottom: number;
+};
+/** Viewport-relative box of the element, as laid out before any affixing. */
+export type AffixElementRect = {
+    top: number;
+    bottom: number;
+    left: number;
+    width: number;
+};
+export type AffixOptions = {
+    fix: AffixFix;
+    offsetTop: number;
+    offsetBottom: number;
+};
+/** Where the element belongs this frame: in flow, or pinned with a fixed box. */
+export type AffixPlacement = {
+    affixed: boolean;
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+};
+/**
+ * Decides whether the content is still at its natural place or has to be pinned
+ * to a boundary, and where that boundary is now. Pure geometry: the component
+ * feeds it real measurements, tests feed it their own.
+ */
+export declare function computeAffix(geometry: {
+    container: AffixContainerRect;
+    element: AffixElementRect;
+}, options: AffixOptions): AffixPlacement;

package/dist/components/primitives/breadcrumb/Breadcrumb.vue.d.ts

@@ -0,0 +1,38 @@
+import { BreadcrumbActionItem, BreadcrumbItem } from './types';
+export type { BreadcrumbActionItem, BreadcrumbItem };
+type __VLS_Props = {
+    items?: BreadcrumbItem[];
+    /**
+     * `true` opens the last level as a dropdown whose content comes from the
+     * `action-menu-dropdown` slot; an array renders the built-in menu, where
+     * `'-'` (or `{ type: 'menu-divider' }`) is a divider.
+     */
+    actionMenuItems?: boolean | BreadcrumbActionItem[];
+    /** Accessible name of the collapsed-trail control. */
+    collapsedLabel?: string;
+};
+declare function selectItem(item: BreadcrumbItem): void;
+declare var __VLS_84: {
+    items: BreadcrumbActionItem[];
+    select: typeof selectItem;
+};
+type __VLS_Slots = {} & {
+    'action-menu-dropdown'?: (props: typeof __VLS_84) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clickItem: (item: BreadcrumbItem) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClickItem?: ((item: BreadcrumbItem) => any) | undefined;
+}>, {
+    items: BreadcrumbItem[];
+    actionMenuItems: boolean | BreadcrumbActionItem[];
+    collapsedLabel: 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/breadcrumb/BreadcrumbCrumb.vue.d.ts

@@ -0,0 +1,13 @@
+type __VLS_Props = {
+    display: string;
+    /** The last level of the trail, announced as the current page. */
+    current?: boolean;
+    /** The level owns the action menu, so it shows a dropdown chevron. */
+    hasMenu?: boolean;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    current: boolean;
+    hasMenu: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/primitives/breadcrumb/collapse.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Width-driven collapsing for `Breadcrumb`, kept free of DOM measurements so
+ * the decision is unit-testable: the component only supplies px numbers.
+ *
+ * The first and the last crumb always stay visible. Middle crumbs are folded
+ * into the leading `…` menu, most recent first, while the visible trail still
+ * fits the container.
+ */
+export type BreadcrumbCollapseInput = {
+    /** Usable width of the breadcrumb container in px. */
+    containerWidth: number;
+    /** Natural width of every crumb, in trail order, in px. */
+    itemWidths: number[];
+    /** Width of one divider between two crumbs, in px. */
+    separatorWidth: number;
+    /** Width of the collapsed-trail (`…`) control, in px. */
+    ellipsisWidth: number;
+};
+export type BreadcrumbCollapse = {
+    /** Trailing crumbs (including the last) kept visible after the `…` control. */
+    visibleTailCount: number;
+    /** Middle crumbs folded into the `…` menu. */
+    hiddenCount: number;
+};
+export declare function resolveBreadcrumbCollapse(input: BreadcrumbCollapseInput): BreadcrumbCollapse;

package/dist/components/primitives/breadcrumb/types.d.ts

@@ -0,0 +1,14 @@
+/** One navigable level of a breadcrumb trail. */
+export type BreadcrumbItem = {
+    /** Visible text of the level. */
+    display: string;
+    /** Caller-owned identity, passed back through `clickItem`. */
+    id: string;
+};
+/** An entry of the last level's action menu: an item, or a divider (`'-'`). */
+export type BreadcrumbActionItem = BreadcrumbItem | '-' | {
+    type: 'menu-divider';
+};
+export declare function isActionDivider(entry: BreadcrumbActionItem): entry is '-' | {
+    type: 'menu-divider';
+};

package/dist/components/primitives/color-picker/ColorPicker.vue.d.ts

@@ -0,0 +1,70 @@
+export type ColorPickerFormat = 'hex' | 'rgb' | 'hsl' | 'hsv';
+export type ColorSwatch = {
+    value: string;
+    hex?: string;
+};
+type __VLS_Props = {
+    /** Current colour string, in the format selected by `colorFormat`. */
+    modelValue?: string;
+    colorFormat?: ColorPickerFormat;
+    /** Preview opacity (0–1) applied to the trigger swatch. */
+    alpha?: number;
+    /** Main palette. */
+    options?: string[];
+    /** Single-row palette above the main palette. */
+    commonOptions?: string[];
+    /** Extra palette, typically recent colours. */
+    customOptions?: string[];
+    /** Shows the button that emits `showcustom`. */
+    hasCustom?: boolean;
+    /** Drops custom colours that already exist in `options` or `commonOptions`. */
+    filterSameColor?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+    name?: string;
+    resetLabel?: string;
+    customLabel?: string;
+};
+declare function reset(): void;
+declare function showCustom(): void;
+declare function closeDropdown(): void;
+declare var __VLS_34: {}, __VLS_36: {}, __VLS_38: {};
+type __VLS_Slots = {} & {
+    'top-custom'?: (props: typeof __VLS_34) => any;
+} & {
+    'bottom-custom'?: (props: typeof __VLS_36) => any;
+} & {
+    bottom?: (props: typeof __VLS_38) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {
+    reset: typeof reset;
+    showCustom: typeof showCustom;
+    closeDropdown: typeof closeDropdown;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+    showcustom: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onShowcustom?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: string;
+    ariaLabel: string;
+    colorFormat: ColorPickerFormat;
+    alpha: number;
+    options: string[];
+    commonOptions: string[];
+    customOptions: string[];
+    hasCustom: boolean;
+    filterSameColor: boolean;
+    resetLabel: string;
+    customLabel: 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/color-picker/palette.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_COMMON_COLORS: string[];
+export declare const DEFAULT_OPTIONS: string[];

package/dist/components/primitives/combobox/Combobox.vue.d.ts

@@ -0,0 +1,33 @@
+import { SelectFieldProps, SelectOption } from '../select/internal/types';
+type __VLS_Props = Omit<SelectFieldProps, 'multiple' | 'modelValue' | 'defaultValue'> & {
+    modelValue?: string;
+    defaultValue?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (option: SelectOption) => any;
+    invalid: (text: string) => any;
+    "update:modelValue": (value: string) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    "update:loading": (loading: boolean) => any;
+    create: (value: string) => any;
+    "open-dropdown": () => any;
+    "close-dropdown": () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((option: SelectOption) => any) | undefined;
+    onInvalid?: ((text: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:loading"?: ((loading: boolean) => any) | undefined;
+    onCreate?: ((value: string) => any) | undefined;
+    "onOpen-dropdown"?: (() => any) | undefined;
+    "onClose-dropdown"?: (() => any) | undefined;
+}>, {
+    search: import('../../..').SelectSearch;
+    modelValue: string;
+    defaultValue: string;
+    editable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/primitives/date-picker/DatePicker.vue.d.ts

@@ -1,4 +1,6 @@
+import { DateFormat, TimeFormat } from './dateTime';
 type __VLS_Props = {
+    /** `YYYY-MM-DD` for date mode, `YYYY-MM-DDTHH:mm:ss` for `showTime` mode. Local wall-clock, no timezone. */
     modelValue?: string;
     placeholder?: string;
     locale?: string;
@@ -8,18 +10,54 @@ type __VLS_Props = {
     max?: string;
     clearable?: boolean;
     weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    ariaLabel?: string;
+    /** Additive: show a time picker under the calendar and emit a local date-time string. */
+    showTime?: boolean;
+    /** Additive: type the date directly instead of picking it. Cannot be combined with `showTime`. */
+    editable?: boolean;
+    /** Additive: an empty text field clears the value instead of reporting `required`. */
+    allowBlank?: boolean;
+    /** Additive: 24-hour clock for the time picker and its readout. */
+    enableHour24?: boolean;
+    /** Additive: when `showTime`, the time only counts once the add-time control is checked. */
+    timeOptional?: boolean;
+    /** Additive: initial state of the add-time control when the value carries no time. */
+    defaultTimeChecked?: boolean;
+    /** Additive: text format used by `editable` for display and parsing. */
+    dateFormat?: DateFormat;
+    /** Additive: readout format for the time portion. Defaults from `enableHour24`. */
+    timeFormat?: TimeFormat;
 };
 declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    invalid: (payload: {
+        reason: "format" | "required";
+        text: string;
+    }) => any;
     "update:modelValue": (value: string | undefined) => any;
+    change: (value: string | undefined) => any;
+    "select-date": (value: string) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onInvalid?: ((payload: {
+        reason: "format" | "required";
+        text: string;
+    }) => any) | undefined;
     "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+    onChange?: ((value: string | undefined) => any) | undefined;
+    "onSelect-date"?: ((value: string) => any) | undefined;
 }>, {
     disabled: boolean;
     placeholder: string;
-    locale: string;
     readonly: boolean;
+    editable: boolean;
     clearable: boolean;
+    locale: string;
     weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    showTime: boolean;
+    allowBlank: boolean;
+    enableHour24: boolean;
+    timeOptional: boolean;
+    defaultTimeChecked: boolean;
+    dateFormat: DateFormat;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/primitives/date-picker/dateTime.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Date/time text helpers shared by `DatePicker`.
+ *
+ * Contract (kept deliberately string-only so the pre-existing ISO date API stays intact):
+ *
+ * - A date-only value is `YYYY-MM-DD`.
+ * - A date-time value is `YYYY-MM-DDTHH:mm:ss` (optionally `YYYY-MM-DDTHH:mm`).
+ * - There is **no** timezone suffix. The value is a local wall-clock reading; it is never
+ *   converted to UTC and never shifted by the host offset. Callers that need an instant must
+ *   add their own zone information.
+ */
+export declare const DATE_FORMATS: readonly ["m/d/Y", "d/m/Y", "Y-m-d", "d.m.Y", "d-m-Y"];
+export declare const TIME_FORMATS: readonly ["h:mm a", "HH:mm"];
+export type DateFormat = (typeof DATE_FORMATS)[number];
+export type TimeFormat = (typeof TIME_FORMATS)[number];
+export interface DateTimeParts {
+    /** ISO date portion, `YYYY-MM-DD`. */
+    date: string;
+    /** 0-23 local hour. */
+    hours: number;
+    /** 0-59 local minute. */
+    minutes: number;
+    /** True when the input string carried an explicit time portion. */
+    hasTime: boolean;
+}
+/** Parse a supported ISO date or date-time string into its parts, or `undefined` when malformed. */
+export declare function parseDateTime(value?: string | null): DateTimeParts | undefined;
+/** Compose `YYYY-MM-DD` + local hours/minutes into a date-time string with zeroed seconds. */
+export declare function composeDateTime(date: string, hours: number, minutes: number): string;
+/**
+ * Render an ISO date using one of the supported text formats.
+ *
+ * `Y-m-d` is rendered ISO-like with padded month/day (`2026-04-15`); the other formats keep the
+ * unpadded month/day style used by the reference component (`4/15/2026`, `15.4.2026`).
+ */
+export declare function formatDateText(date: string, format: DateFormat): string;
+/** Parse user-typed text using one of the supported formats back into an ISO date, or `undefined`. */
+export declare function parseDateText(text: string, format: DateFormat): string | undefined;
+/** Render local hours/minutes in 12-hour (`h:mm a`) or 24-hour (`HH:mm`) form. */
+export declare function formatTimeText(hours: number, minutes: number, format: TimeFormat): string;
+/** Hour options for a time picker control. 24-hour mode yields 0-23, 12-hour mode yields 1-12. */
+export declare function hourOptions(enableHour24: boolean): number[];
+/** Minute options for a time picker control. */
+export declare function minuteOptions(): number[];

package/dist/components/primitives/dialog/Dialog.vue.d.ts

@@ -5,6 +5,8 @@ type __VLS_Props = {
     description?: string;
     width?: string;
     closeLabel?: string;
+    /** Hides the header close affordance for fixed-flow dialogs that own their dismiss path. */
+    showClose?: boolean;
 };
 declare var __VLS_14: {}, __VLS_62: {}, __VLS_64: {};
 type __VLS_Slots = {} & {
@@ -15,24 +17,25 @@ type __VLS_Slots = {} & {
     footer?: (props: typeof __VLS_64) => any;
 };
 declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:open": (value: boolean) => any;
     escapeKeyDown: (event: KeyboardEvent) => any;
     pointerDownOutside: (event: Event) => any;
     interactOutside: (event: Event) => any;
     openAutoFocus: (event: Event) => any;
     closeAutoFocus: (event: Event) => any;
+    "update:open": (value: boolean) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:open"?: ((value: boolean) => any) | undefined;
     onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
     onPointerDownOutside?: ((event: Event) => any) | undefined;
     onInteractOutside?: ((event: Event) => any) | undefined;
     onOpenAutoFocus?: ((event: Event) => any) | undefined;
     onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
 }>, {
     width: string;
-    open: boolean;
     defaultOpen: boolean;
+    open: boolean;
     closeLabel: string;
+    showClose: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/primitives/dropdown-menu/DropdownMenu.vue.d.ts

@@ -1,19 +1,14 @@
-export type DropdownMenuEntry = {
-    type?: 'item';
-    key: string;
-    label: string;
-    disabled?: boolean;
-    checked?: boolean;
-    danger?: boolean;
-    shortcut?: string;
-    submenu?: boolean;
-} | {
-    type: 'separator';
-    key: string;
-};
+import { DropdownMenuEntry } from './types';
+export type { DropdownMenuEntry } from './types';
 type __VLS_Props = {
     items: DropdownMenuEntry[];
     align?: 'start' | 'center' | 'end';
+    /** Controlled checked keys for `type: 'checkbox'` entries. */
+    checkedKeys?: string[];
+    /** Controlled value of the default radio group (`group` unset). */
+    radioValue?: string;
+    /** Controlled values of named radio groups, keyed by `group`. */
+    radioValues?: Record<string, string>;
 };
 declare var __VLS_14: {};
 type __VLS_Slots = {} & {
@@ -21,8 +16,18 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     select: (key: string) => any;
+    toggle: (key: string, checked: boolean) => any;
+    "update:checkedKeys": (value: string[]) => any;
+    "update:radioValue": (value: string) => any;
+    "update:radioValues": (value: Record<string, string>) => any;
+    radioSelect: (value: string, key: string, group: string) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onSelect?: ((key: string) => any) | undefined;
+    onToggle?: ((key: string, checked: boolean) => any) | undefined;
+    "onUpdate:checkedKeys"?: ((value: string[]) => any) | undefined;
+    "onUpdate:radioValue"?: ((value: string) => any) | undefined;
+    "onUpdate:radioValues"?: ((value: Record<string, string>) => any) | undefined;
+    onRadioSelect?: ((value: string, key: string, group: string) => any) | undefined;
 }>, {
     align: "start" | "center" | "end";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/components/primitives/dropdown-menu/DropdownMenuItems.vue.d.ts

@@ -0,0 +1,20 @@
+import { DropdownMenuEntry } from './types';
+type __VLS_Props = {
+    items: DropdownMenuEntry[];
+    checkedKeys?: string[];
+    radioValues?: Record<string, string>;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (key: string) => any;
+    radio: (value: string, key: string, group: string) => any;
+    toggle: (key: string, checked: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((key: string) => any) | undefined;
+    onRadio?: ((value: string, key: string, group: string) => any) | undefined;
+    onToggle?: ((key: string, checked: boolean) => any) | undefined;
+}>, {
+    checkedKeys: string[];
+    radioValues: Record<string, string>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/primitives/dropdown-menu/types.d.ts

@@ -0,0 +1,38 @@
+export type DropdownMenuSubEntry = {
+    type?: 'item';
+    key: string;
+    label: string;
+    disabled?: boolean;
+    /** Legacy visual check mark. Use `type: 'checkbox'` for a real, togglable item. */
+    checked?: boolean;
+    danger?: boolean;
+    shortcut?: string;
+    /** @deprecated A real submenu is rendered when `children` is present. */
+    submenu?: boolean;
+    /** Nested entries render as a submenu. */
+    children?: DropdownMenuEntry[];
+};
+export type DropdownMenuCheckboxEntry = {
+    type: 'checkbox';
+    key: string;
+    label: string;
+    disabled?: boolean;
+    danger?: boolean;
+    shortcut?: string;
+};
+export type DropdownMenuRadioEntry = {
+    type: 'radio';
+    key: string;
+    label: string;
+    value: string;
+    /** Radio entries that share a group are mutually exclusive. Defaults to the root group. */
+    group?: string;
+    disabled?: boolean;
+    danger?: boolean;
+    shortcut?: string;
+};
+export type DropdownMenuSeparatorEntry = {
+    type: 'separator';
+    key: string;
+};
+export type DropdownMenuEntry = DropdownMenuSubEntry | DropdownMenuCheckboxEntry | DropdownMenuRadioEntry | DropdownMenuSeparatorEntry;

package/dist/components/primitives/ghost/Ghost.vue.d.ts

@@ -0,0 +1,30 @@
+import { Component } from 'vue';
+export type GhostIconProps = {
+    component: Component;
+    props?: Record<string, unknown>;
+};
+export type GhostIcon = Component | GhostIconProps;
+type __VLS_Props = {
+    title?: string;
+    nums?: number | false;
+    icon?: GhostIcon | false;
+};
+declare var __VLS_1: {}, __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    title?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    title: string;
+    icon: GhostIcon | false;
+    nums: number | false;
+}, {}, {}, {}, 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/icon/Icon.vue.d.ts

@@ -0,0 +1,40 @@
+import { Component } from 'vue';
+import { IconSet, IconSize } from './icon';
+type __VLS_Props = {
+    /** Icon component to render, e.g. an `@lucide/vue` icon. */
+    svgIcon?: Component;
+    /** Registered icon name, for names only known at runtime. */
+    name?: string;
+    size?: IconSize;
+    /** Colour group; see ICON_SET_COLORS. */
+    svgIconSet?: IconSet;
+    disabled?: boolean;
+    /** Decorative by default: hidden from assistive technology. */
+    ariaHidden?: boolean;
+    /** Gives the icon a name, which makes it informative (`role="img"`). */
+    ariaLabel?: string;
+    /** Names the icon through an existing element, like `ariaLabel`. */
+    ariaLabelledby?: string;
+    /**
+     * Declares that this icon's click is a pointer-only shortcut for an action
+     * that is already reachable elsewhere. Keeps the icon decorative and
+     * suppresses the development warning below. No effect on the DOM.
+     */
+    redundant?: boolean;
+    /** Accepted for API compatibility; sprites are not resolved by this component. */
+    sprite?: boolean;
+};
+declare function focus(): void;
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {
+    focus: typeof focus;
+    el: Readonly<import('vue').ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: IconSize;
+    disabled: boolean;
+    svgIconSet: IconSet;
+    ariaHidden: boolean;
+    redundant: boolean;
+    sprite: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,19 @@
+/** Named sizes. `m` is the documented SVC default (24px). */
+export declare const ICON_SIZE_TOKENS: {
+    readonly sm: 16;
+    readonly m: 24;
+    readonly lg: 32;
+};
+export type IconSizeToken = keyof typeof ICON_SIZE_TOKENS;
+/** A named size, or an explicit `[width, height]` pair in pixels. */
+export type IconSize = IconSizeToken | [number, number];
+/**
+ * Colour groups. The first four mirror the documented SVC set names
+ * (`{tier}` / `{tier}-{intent}`); the semantic names are this library's
+ * additions for status colouring.
+ */
+export type IconSet = 'inherit' | 'primary' | 'secondary' | 'tertiary' | 'theme' | 'secondary-primary' | 'tertiary-secondary' | 'info' | 'success' | 'warning' | 'danger';
+export declare const ICON_SET_COLORS: Record<IconSet, string>;
+/** Resolves a size declaration to the pixel pair applied to the SVG. */
+export declare function resolveIconSize(size: IconSize): [number, number];
+export declare function iconSetColor(set: IconSet): string;

package/dist/components/primitives/icon/iconRegistry.d.ts

@@ -0,0 +1,9 @@
+import { Component } from 'vue';
+export interface IconRegistration {
+    name: string;
+    component: Component;
+}
+export declare function registerIcons(icons: IconRegistration[] | Record<string, Component>): void;
+export declare function getRegisteredIcon(name: string): Component | undefined;
+/** Test/teardown helper: drops every registration. */
+export declare function clearIconRegistry(): void;