@wow-two-beta/ui-vue 0.0.2

package/dist/presentation/forms/currencyInput/index.d.ts

@@ -0,0 +1 @@
+export { default as CurrencyInput, type CurrencyInputProps } from './CurrencyInput.vue';

package/dist/presentation/forms/dateField/DateField.vue.d.ts

@@ -0,0 +1,42 @@
+import { Temporal } from 'temporal-polyfill';
+import { InputSize, InputState, InputBorder, InputRing } from '../InputStyles';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface DateFieldProps {
+    /** The control size. */
+    size?: InputSize;
+    /** The validity surface. */
+    state?: InputState;
+    /** The border weight. */
+    border?: InputBorder;
+    /** The focus-ring weight. */
+    ring?: InputRing;
+    /** The value, controlled. The `v-model` binding target. `null` is the cleared state. */
+    modelValue?: Temporal.PlainDate | null;
+    /** The value, controlled — React's spelling of `modelValue`, which wins when both are set. */
+    value?: Temporal.PlainDate | null;
+    /** The initial value when uncontrolled. */
+    defaultValue?: Temporal.PlainDate | null;
+    /** The earliest selectable date. */
+    min?: Temporal.PlainDate | null;
+    /** The latest selectable date. */
+    max?: Temporal.PlainDate | null;
+    /** The control's id. Auto-filled from `FormControl` context when omitted. */
+    id?: string;
+    /** The disabled state. Falls back to the surrounding form control's `isDisabled`. */
+    disabled?: boolean;
+    /** The required state. Falls back to the surrounding form control's `isRequired`. */
+    required?: boolean;
+}
+declare const _default: DefineComponent<DateFieldProps, {
+    el: Readonly< ShallowRef<HTMLInputElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (value: Temporal.PlainDate | null) => any;
+    "update:modelValue": (value: Temporal.PlainDate | null) => any;
+}, string, PublicProps, Readonly<DateFieldProps> & Readonly<{
+    "onValue-change"?: ((value: Temporal.PlainDate | null) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Temporal.PlainDate | null) => any) | undefined;
+}>, {
+    disabled: boolean;
+    required: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/forms/dateField/index.d.ts

@@ -0,0 +1 @@
+export { default as DateField, type DateFieldProps } from './DateField.vue';

package/dist/presentation/forms/datePicker/DatePicker.vue.d.ts

@@ -0,0 +1,53 @@
+import { Temporal } from 'temporal-polyfill';
+import { SelectSize } from '../select';
+import { InputState } from '../InputStyles';
+import { DefineComponent, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface DatePickerProps {
+    /** The selected date, controlled — React's spelling, which wins when both are set. */
+    value?: Temporal.PlainDate | null;
+    /** The selected date, controlled. The `v-model` binding target. */
+    modelValue?: Temporal.PlainDate | null;
+    /** The uncontrolled initial selection. */
+    defaultValue?: Temporal.PlainDate | null;
+    /** The empty-state text on the trigger. */
+    placeholder?: string;
+    /**
+     * The trigger's date formatter.
+     *
+     * Kept a PROP, not an emit: it RETURNS the rendered string, which an emit cannot do.
+     */
+    format?: (date: Temporal.PlainDate) => string;
+    /** The minimum selectable date. */
+    min?: Temporal.PlainDate | null;
+    /** The maximum selectable date. */
+    max?: Temporal.PlainDate | null;
+    /** The custom per-day disable predicate. Also a returning prop. */
+    isDisabled?: (date: Temporal.PlainDate) => boolean;
+    /** The invalid surface override. Falls back to the surrounding form control's `isInvalid`. */
+    isInvalid?: boolean;
+    /** The hidden input name; when set, a hidden input ships the ISO value with form submission. */
+    name?: string;
+    /** The trigger size. */
+    size?: SelectSize;
+    /** The validity surface. */
+    state?: InputState;
+    /** The trigger's id. Auto-filled from `FormControl` context when omitted. */
+    id?: string;
+    /** The disabled state. Falls back to the surrounding form control's `isDisabled`. */
+    disabled?: boolean;
+}
+declare const _default: DefineComponent<DatePickerProps, {
+    el: ComputedRef<HTMLElement | null>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (date: Temporal.PlainDate | null) => any;
+    "update:modelValue": (date: Temporal.PlainDate | null) => any;
+}, string, PublicProps, Readonly<DatePickerProps> & Readonly<{
+    "onValue-change"?: ((date: Temporal.PlainDate | null) => any) | undefined;
+    "onUpdate:modelValue"?: ((date: Temporal.PlainDate | null) => any) | undefined;
+}>, {
+    disabled: boolean;
+    format: (date: Temporal.PlainDate) => string;
+    placeholder: string;
+    isInvalid: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/forms/datePicker/index.d.ts

@@ -0,0 +1 @@
+export { default as DatePicker, type DatePickerProps } from './DatePicker.vue';

package/dist/presentation/forms/dateRangePicker/DateRangePicker.vue.d.ts

@@ -0,0 +1,54 @@
+import { Temporal } from 'temporal-polyfill';
+import { SelectSize } from '../select';
+import { InputState } from '../InputStyles';
+import { DateRange } from '../rangeCalendar';
+import { DefineComponent, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface DateRangePickerProps {
+    /** The selected range, controlled — React's spelling, which wins when both are set. */
+    value?: DateRange | null;
+    /** The selected range, controlled. The `v-model` binding target. */
+    modelValue?: DateRange | null;
+    /** The uncontrolled initial selection. */
+    defaultValue?: DateRange | null;
+    /** The empty-state text on the trigger. */
+    placeholder?: string;
+    /**
+     * The trigger's date formatter.
+     *
+     * Kept a PROP, not an emit: it RETURNS the rendered string, which an emit cannot do.
+     */
+    format?: (date: Temporal.PlainDate) => string;
+    /** The minimum selectable date. */
+    min?: Temporal.PlainDate | null;
+    /** The maximum selectable date. */
+    max?: Temporal.PlainDate | null;
+    /** The custom per-day disable predicate. Also a returning prop. */
+    isDisabled?: (date: Temporal.PlainDate) => boolean;
+    /** The invalid surface override. Falls back to the surrounding form control's `isInvalid`. */
+    isInvalid?: boolean;
+    /** The hidden input name; when set, two hidden inputs (`{name}_start`, `{name}_end`) ship the ISO values. */
+    name?: string;
+    /** The trigger size. */
+    size?: SelectSize;
+    /** The validity surface. */
+    state?: InputState;
+    /** The trigger's id. Auto-filled from `FormControl` context when omitted. */
+    id?: string;
+    /** The disabled state. Falls back to the surrounding form control's `isDisabled`. */
+    disabled?: boolean;
+}
+declare const _default: DefineComponent<DateRangePickerProps, {
+    el: ComputedRef<HTMLElement | null>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (range: DateRange | null) => any;
+    "update:modelValue": (range: DateRange | null) => any;
+}, string, PublicProps, Readonly<DateRangePickerProps> & Readonly<{
+    "onValue-change"?: ((range: DateRange | null) => any) | undefined;
+    "onUpdate:modelValue"?: ((range: DateRange | null) => any) | undefined;
+}>, {
+    disabled: boolean;
+    format: (date: Temporal.PlainDate) => string;
+    placeholder: string;
+    isInvalid: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/forms/dateRangePicker/index.d.ts

@@ -0,0 +1 @@
+export { default as DateRangePicker, type DateRangePickerProps } from './DateRangePicker.vue';

package/dist/presentation/forms/dateTimeField/DateTimeField.vue.d.ts

@@ -0,0 +1,42 @@
+import { Temporal } from 'temporal-polyfill';
+import { InputSize, InputState, InputBorder, InputRing } from '../InputStyles';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface DateTimeFieldProps {
+    /** The control size. */
+    size?: InputSize;
+    /** The validity surface. */
+    state?: InputState;
+    /** The border weight. */
+    border?: InputBorder;
+    /** The focus-ring weight. */
+    ring?: InputRing;
+    /** The value, controlled. The `v-model` binding target. `null` is the cleared state. */
+    modelValue?: Temporal.PlainDateTime | null;
+    /** The value, controlled — React's spelling of `modelValue`, which wins when both are set. */
+    value?: Temporal.PlainDateTime | null;
+    /** The initial value when uncontrolled. */
+    defaultValue?: Temporal.PlainDateTime | null;
+    /** The earliest selectable wall-clock instant. */
+    min?: Temporal.PlainDateTime | null;
+    /** The latest selectable wall-clock instant. */
+    max?: Temporal.PlainDateTime | null;
+    /** The control's id. Auto-filled from `FormControl` context when omitted. */
+    id?: string;
+    /** The disabled state. Falls back to the surrounding form control's `isDisabled`. */
+    disabled?: boolean;
+    /** The required state. Falls back to the surrounding form control's `isRequired`. */
+    required?: boolean;
+}
+declare const _default: DefineComponent<DateTimeFieldProps, {
+    el: Readonly< ShallowRef<HTMLInputElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (value: Temporal.PlainDateTime | null) => any;
+    "update:modelValue": (value: Temporal.PlainDateTime | null) => any;
+}, string, PublicProps, Readonly<DateTimeFieldProps> & Readonly<{
+    "onValue-change"?: ((value: Temporal.PlainDateTime | null) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Temporal.PlainDateTime | null) => any) | undefined;
+}>, {
+    disabled: boolean;
+    required: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/forms/dateTimeField/index.d.ts

@@ -0,0 +1 @@
+export { default as DateTimeField, type DateTimeFieldProps } from './DateTimeField.vue';

package/dist/presentation/forms/editable/Editable.vue.d.ts

@@ -0,0 +1,60 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface EditableProps {
+    /** The committed value, controlled — React's spelling, which wins when both are set. */
+    value?: string;
+    /** The committed value, controlled. The `v-model` binding target. */
+    modelValue?: string;
+    /** The initial committed value when uncontrolled. */
+    defaultValue?: string;
+    /** The edit-mode state, controlled — the house boolean spelling, which wins when both are set. */
+    isEditing?: boolean;
+    /** The edit-mode state, controlled. The `v-model:editing` binding target. */
+    editing?: boolean;
+    /** The initial edit-mode state when uncontrolled. Default `false`. */
+    defaultEditing?: boolean;
+    /** The preview text shown when the value is empty. */
+    placeholder?: string;
+    /** Whether blurring the input commits the draft. Default `true`. */
+    canSubmitOnBlur?: boolean;
+    /** Whether Enter commits the draft. Default `true`. */
+    canSubmitOnEnter?: boolean;
+    /** Whether Escape discards the draft. Default `true`. */
+    canCancelOnEscape?: boolean;
+    /** The disabled state. Default `false`. */
+    isDisabled?: boolean;
+    /** The read-only state. Default `false`. */
+    isReadOnly?: boolean;
+    /** The hidden input name; the hidden input emits the committed value. */
+    name?: string;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<EditableProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (value: string) => any;
+    "update:modelValue": (value: string) => any;
+    "update:editing": (editing: boolean) => any;
+    "editing-change": (editing: boolean) => any;
+}, string, PublicProps, Readonly<EditableProps> & Readonly<{
+    "onValue-change"?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onUpdate:editing"?: ((editing: boolean) => any) | undefined;
+    "onEditing-change"?: ((editing: boolean) => any) | undefined;
+}>, {
+    value: string;
+    placeholder: string;
+    isDisabled: boolean;
+    isReadOnly: boolean;
+    editing: boolean;
+    modelValue: string;
+    isEditing: boolean;
+    defaultEditing: boolean;
+    canSubmitOnBlur: boolean;
+    canSubmitOnEnter: boolean;
+    canCancelOnEscape: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/forms/editable/EditableCancel.vue.d.ts

@@ -0,0 +1,12 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: __VLS_WithSlots< DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLButtonElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
+    default?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/forms/editable/EditableContext.d.ts

@@ -0,0 +1,37 @@
+import { InjectionKey, ShallowRef } from 'vue';
+/**
+ * The seam between `Editable` and its `EditablePreview` / `EditableInput` /
+ * `EditableSubmit` / `EditableCancel` children.
+ *
+ * React attached those as `Editable.Preview` / `.Input` / `.Submit` / `.Cancel` statics over a
+ * `createContext`. An SFC's generated default export cannot carry statics cleanly, so they ship
+ * as sibling components and share state through provide/inject instead.
+ *
+ * Every field but the setters is a live getter — read them off the object, don't destructure.
+ */
+export interface EditableContextValue {
+    /** The committed value. */
+    readonly value: string;
+    /** The in-flight edit buffer. */
+    readonly draft: string;
+    setDraft: (value: string) => void;
+    /** Whether the input is showing instead of the preview. */
+    readonly isEditing: boolean;
+    setEditing: (editing: boolean) => void;
+    /** Commits the draft and leaves edit mode. */
+    submit: () => void;
+    /** Discards the draft and leaves edit mode. */
+    cancel: () => void;
+    /** The preview text shown when the value is empty. */
+    readonly placeholder: string;
+    readonly isDisabled: boolean;
+    readonly isReadOnly: boolean;
+    readonly canSubmitOnBlur: boolean;
+    readonly canSubmitOnEnter: boolean;
+    readonly canCancelOnEscape: boolean;
+    /** Holds the DOM node of the inner input — the focus/caret effect reads it. */
+    inputEl: ShallowRef<HTMLInputElement | null>;
+}
+export declare const EditableKey: InjectionKey<EditableContextValue>;
+/** Reads the surrounding editable context; throws when used outside an `<Editable>`. */
+export declare function useEditableContext(): EditableContextValue;

package/dist/presentation/forms/editable/EditableInput.vue.d.ts

@@ -0,0 +1,12 @@
+import { InputSize, InputState } from '../InputStyles';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface EditableInputProps {
+    /** The control size. */
+    size?: InputSize;
+    /** The validity surface. */
+    state?: InputState;
+}
+declare const _default: DefineComponent<EditableInputProps, {
+    el: ShallowRef<HTMLInputElement | null>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<EditableInputProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/forms/editable/EditablePreview.vue.d.ts

@@ -0,0 +1,7 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface EditablePreviewProps {
+}
+declare const _default: DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLSpanElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/presentation/forms/editable/EditableSubmit.vue.d.ts

@@ -0,0 +1,14 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface EditableButtonProps {
+}
+declare const _default: __VLS_WithSlots< DefineComponent<{}, {
+    el: Readonly< ShallowRef<HTMLButtonElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>, {
+    default?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/forms/editable/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Editable, type EditableProps } from './Editable.vue';
+export { default as EditableCancel } from './EditableCancel.vue';
+export { default as EditableInput, type EditableInputProps } from './EditableInput.vue';
+export { default as EditablePreview, type EditablePreviewProps } from './EditablePreview.vue';
+export { default as EditableSubmit, type EditableButtonProps, } from './EditableSubmit.vue';
+export { useEditableContext, type EditableContextValue } from './EditableContext';
+export { default } from './Editable.vue';

package/dist/presentation/forms/emailInput/EmailInput.vue.d.ts

@@ -0,0 +1,43 @@
+import { InputSize, InputState, InputBorder, InputRing } from '../InputStyles';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface EmailInputProps {
+    /** The control size. */
+    size?: InputSize;
+    /** The validity surface. */
+    state?: InputState;
+    /** The border weight. */
+    border?: InputBorder;
+    /** The focus-ring weight. */
+    ring?: InputRing;
+    /** The value, controlled. The `v-model` binding target. */
+    modelValue?: string | number;
+    /** The value, controlled — React's spelling of `modelValue`, which wins when both are set. */
+    value?: string | number;
+    /** The initial value when uncontrolled. */
+    defaultValue?: string | number;
+    /** The control's id. Auto-filled from `FormControl` context when omitted. */
+    id?: string;
+    /** The disabled state. Falls back to the surrounding form control's `isDisabled`. */
+    disabled?: boolean;
+    /** The required state. Falls back to the surrounding form control's `isRequired`. */
+    required?: boolean;
+    /** The read-only state — React's spelling. Falls back to the form control's `isReadOnly`. */
+    readOnly?: boolean;
+    /** The DOM spelling of {@link EmailInputProps.readOnly}, which wins when both are set. */
+    readonly?: boolean;
+}
+declare const _default: DefineComponent<EmailInputProps, {
+    el: Readonly< ShallowRef<HTMLInputElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (value: string) => any;
+    "update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly<EmailInputProps> & Readonly<{
+    "onValue-change"?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    required: boolean;
+    readOnly: boolean;
+    readonly: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/forms/emailInput/index.d.ts

@@ -0,0 +1 @@
+export { default as EmailInput, type EmailInputProps } from './EmailInput.vue';

package/dist/presentation/forms/emojiPicker/CategoryNav.vue.d.ts

@@ -0,0 +1,19 @@
+import { CategoryKey, CategoryNavVariant, EmojiPickerSize } from './EmojiPicker.variants';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines props for the horizontal category nav. */
+export interface CategoryNavProps {
+    /** The category-nav layout — segmented icon strip or labelled pills. */
+    readonly variant: CategoryNavVariant;
+    /** The active category. */
+    readonly active: CategoryKey;
+    /** The nav scale. */
+    readonly size: EmojiPickerSize;
+    /** The strip icon size in px. Default `round(nav * 0.8)` derived from the scale. */
+    readonly iconSize?: number;
+}
+declare const _default: DefineComponent<CategoryNavProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    select: (category: CategoryKey) => any;
+}, string, PublicProps, Readonly<CategoryNavProps> & Readonly<{
+    onSelect?: ((category: CategoryKey) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/forms/emojiPicker/EmojiGrid.vue.d.ts

@@ -0,0 +1,26 @@
+import { EmojiCatalogEntry } from '../../../domain/emoji';
+import { EmojiPickerSize, EmojiTileShape } from './EmojiPicker.variants';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines props for the emoji tile grid. */
+export interface EmojiGridProps {
+    /** The emoji to lay out, in order. */
+    readonly emojis: readonly EmojiCatalogEntry[];
+    /** The selected emoji's glyph, or `null`. */
+    readonly selectedGlyph: string | null;
+    /** The tile scale. */
+    readonly size: EmojiPickerSize;
+    /** The tile frame — rounded chip or circle. */
+    readonly shape: EmojiTileShape;
+    /** The muted hint shown when `emojis` is empty. */
+    readonly emptyLabel?: string;
+    /** The fixed viewport height, in tile rows; when set, the grid scrolls inside a constant-height box. */
+    readonly viewportRows?: number;
+    /** The scrollbar thumb color — any CSS color. Default `var(--color-border-strong)`. */
+    readonly scrollThumbColor?: string;
+}
+declare const _default: DefineComponent<EmojiGridProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    select: (entry: EmojiCatalogEntry) => any;
+}, string, PublicProps, Readonly<EmojiGridProps> & Readonly<{
+    onSelect?: ((entry: EmojiCatalogEntry) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/presentation/forms/emojiPicker/EmojiPicker.variants.d.ts

@@ -0,0 +1,77 @@
+import { SizePreset } from '../../../foundation/utils';
+import { IconAdapter } from '../../../foundation/icons';
+import { EmojiCategory } from '../../../domain/emoji';
+/** A uniform t-shirt scale, applied per picker element (search, category nav, tiles). */
+export type EmojiPickerSize = Extract<SizePreset, 'sm' | 'md' | 'lg'>;
+/** The picker's element scale applied wherever no per-element size is given. */
+export declare const DefaultPickerSize: EmojiPickerSize;
+/** Defines a picker element that can carry its own scale — the search box, the category nav, or the tiles. */
+export declare const PickerElement: {
+    /** Refers to the search input. */
+    readonly Search: "search";
+    /** Refers to the category nav. */
+    readonly Nav: "nav";
+    /** Refers to the emoji tiles. */
+    readonly Tile: "tile";
+};
+export type PickerElement = (typeof PickerElement)[keyof typeof PickerElement];
+/** A single scale for the whole picker, or a per-element override map — `search`/`nav`/`tile` as t-shirt scales plus `icon` as the strip icon size in px (a single dimension, so px rather than a scale). */
+export type EmojiPickerSizeInput = EmojiPickerSize | (Partial<Record<PickerElement, EmojiPickerSize>> & {
+    icon?: number;
+});
+/** Resolves the scale for one picker element — a uniform size applies to every element; a map falls back to `fallback` per element. Expandable to any element in `PickerElement`. */
+export declare function resolveElementSize(size: EmojiPickerSizeInput | undefined, element: PickerElement, fallback: EmojiPickerSize): EmojiPickerSize;
+/** Defines which category-navigation affordance the picker renders. */
+export declare const CategoryNavVariant: {
+    /** Refers to the segmented icon-strip layout. */
+    readonly Strip: "strip";
+    /** Refers to the labelled pill-row layout. */
+    readonly Pills: "pills";
+};
+export type CategoryNavVariant = (typeof CategoryNavVariant)[keyof typeof CategoryNavVariant];
+/** Defines how each emoji tile is framed — a rounded-rect chip or a circle. */
+export declare const EmojiTileShape: {
+    /** Refers to a rounded-rect chip frame. */
+    readonly Rounded: "rounded";
+    /** Refers to a circular frame. */
+    readonly Circle: "circle";
+};
+export type EmojiTileShape = (typeof EmojiTileShape)[keyof typeof EmojiTileShape];
+/** The default `StorageBroker` key the picker persists its most-recently-used emoji under. */
+export declare const EmojiRecentsKey = "wow-two-beta.emoji.recents";
+/** Defines the pixel geometry an `EmojiPickerSize` maps to for the rolled tile + nav elements. */
+export interface EmojiPickerSizeTokens {
+    /** The emoji tile's min edge, in px; the grid auto-fills columns at this width. */
+    readonly tile: number;
+    /** The emoji glyph's font size, in px. */
+    readonly glyph: number;
+    /** The category-nav control's edge, in px. */
+    readonly nav: number;
+    /** The inter-tile gap, in px. */
+    readonly gap: number;
+}
+/** Maps each `EmojiPickerSize` to its tile / glyph / nav / gap pixel geometry. */
+export declare const EmojiPickerSizes: Record<EmojiPickerSize, EmojiPickerSizeTokens>;
+/** The synthetic "recently used" bucket — nav index 0, backed by the MRU list rather than the catalog. */
+export declare const RecentCategory = "recent";
+/** A navigable picker section: the synthetic recents bucket or one real catalog category. */
+export type CategoryKey = typeof RecentCategory | EmojiCategory;
+/** Defines a category's nav presentation — its accessible label and glyph. */
+interface CategoryDisplay {
+    label: string;
+    Icon: IconAdapter;
+}
+/** The nav categories in display order — recents first, then the catalog's Telegram-order groups. */
+export declare const CategoryOrder: readonly CategoryKey[];
+/** Maps each nav category to its label + icon. */
+export declare const CategoryDisplays: Record<CategoryKey, CategoryDisplay>;
+/** The muted hints shown when a picker surface has no emoji to render. */
+export declare const EmojiEmptyLabels: {
+    /** Refers to the empty search-results hint. */
+    readonly search: "No matches.";
+    /** Refers to the empty recents hint. */
+    readonly recents: "Your picks show up here.";
+    /** Refers to the empty category hint. */
+    readonly category: "No emoji here yet.";
+};
+export {};

package/dist/presentation/forms/emojiPicker/EmojiPicker.vue.d.ts

@@ -0,0 +1,45 @@
+import { EmojiCatalogEntry } from '../../../domain/emoji';
+import { StorageBroker } from '../../../foundation/storage';
+import { CategoryNavVariant, EmojiPickerSizeInput, EmojiTileShape } from './EmojiPicker.variants';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines props for the emoji picker. */
+export interface EmojiPickerProps {
+    /** The current emoji catalog entry, or `null` for none. The `v-model` binding target. */
+    readonly modelValue?: EmojiCatalogEntry | null;
+    /** The current emoji catalog entry — React's spelling of `modelValue`, which wins when both are set. */
+    readonly value?: EmojiCatalogEntry | null;
+    /**
+     * The persistence contract backing the "recently used" list — required, so the picker stays pure and
+     * storage-agnostic. Plug `localStorageStorageBroker` for browser persistence, `memoryStorageBroker()` for a
+     * throwaway in-memory store, or a custom `StorageBroker` (Redux, IndexedDB, …).
+     */
+    readonly storage: StorageBroker;
+    /** The category-navigation affordance. Default `strip`. */
+    readonly categoryNavVariant?: CategoryNavVariant;
+    /** The element scale — one value for every element, or a per-element `{ search, nav, tile }`. Default `md`. */
+    readonly size?: EmojiPickerSizeInput;
+    /** The emoji-tile frame — rounded chip or circle. Default `rounded`. */
+    readonly tileShape?: EmojiTileShape;
+    /** The scrollable tile viewport's height, in tile rows. Default `6`. */
+    readonly rowsCount?: number;
+    /** The heading rendered above the picker. Default `Emoji`. */
+    readonly label?: string;
+    /** When `true` and no emoji has been used yet, opens on the first real category instead of the empty recents bucket. Default `false`. */
+    readonly showFirstCategoryWhenRecentsEmpty?: boolean;
+    /** The scrollbar thumb color for the tile viewport — any CSS color. Default `var(--color-border-strong)`. */
+    readonly scrollThumbColor?: string;
+}
+declare const _default: DefineComponent<EmojiPickerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (entry: EmojiCatalogEntry | null) => any;
+    "update:modelValue": (entry: EmojiCatalogEntry | null) => any;
+}, string, PublicProps, Readonly<EmojiPickerProps> & Readonly<{
+    "onValue-change"?: ((entry: EmojiCatalogEntry | null) => any) | undefined;
+    "onUpdate:modelValue"?: ((entry: EmojiCatalogEntry | null) => any) | undefined;
+}>, {
+    readonly label: string;
+    readonly showFirstCategoryWhenRecentsEmpty: boolean;
+    readonly categoryNavVariant: CategoryNavVariant;
+    readonly tileShape: EmojiTileShape;
+    readonly rowsCount: number;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;