@wow-two-beta/ui-vue 0.0.2

package/dist/presentation/forms/chatComposer/ChatComposer.vue.d.ts

@@ -0,0 +1,74 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines which keypress submits a chat composer. */
+export declare const SubmitTrigger: {
+    /** Refers to plain Enter (Shift+Enter inserts a newline). */
+    readonly Enter: "enter";
+    /** Refers to Cmd/Ctrl+Enter (plain Enter inserts a newline). */
+    readonly ModEnter: "mod-enter";
+};
+export type SubmitTrigger = (typeof SubmitTrigger)[keyof typeof SubmitTrigger];
+export interface ChatComposerProps {
+    /** The text value, controlled — React's spelling, which wins when both are set. */
+    value?: string;
+    /** The text value, controlled. The `v-model` binding target. */
+    modelValue?: string;
+    /** The initial text when uncontrolled. */
+    defaultValue?: string;
+    /** The placeholder text. */
+    placeholder?: string;
+    /** The disabled state for the input + send button. */
+    isDisabled?: boolean;
+    /** The content rendered on the leading edge of the toolbar (e.g. attach button).
+     *  Fill the `leading` slot for richer content. */
+    leading?: string | number;
+    /** The content rendered between the leading slot and the send button.
+     *  Fill the `trailing` slot for richer content. */
+    trailing?: string | number;
+    /** The custom send button, replacing the default. Fill the `sendButton` slot for richer content. */
+    sendButton?: string | number;
+    /** The hidden state for the send button (e.g. when consumer renders a custom CTA). */
+    isSendButtonHidden?: boolean;
+    /** The submit trigger for the textarea. `enter` = Enter alone (default).
+     *  `mod-enter` = Cmd/Ctrl+Enter (Enter inserts a newline). */
+    submitOn?: SubmitTrigger;
+    /** The maximum textarea pixel height before scroll kicks in. Default `200`. */
+    maxHeight?: number;
+    /**
+     * The pass-through textarea attributes (`rows` is overridden).
+     *
+     * React typed this `Omit<TextareaHTMLAttributes, 'value' | 'defaultValue' | 'onChange'>`;
+     * it is a loose attribute bag here because the SFC prop resolver has to resolve the
+     * declared type at build time and cannot follow Vue's `TextareaHTMLAttributes` through a
+     * mapped `Omit`. Listener keys use Vue's spelling — `onKeydown`, not `onKeyDown`.
+     */
+    textareaProps?: Record<string, unknown>;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<ChatComposerProps, {
+    el: Readonly< ShallowRef<HTMLTextAreaElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    submit: (value: string) => any;
+    "value-change": (value: string) => any;
+    "update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly<ChatComposerProps> & Readonly<{
+    onSubmit?: ((value: string) => any) | undefined;
+    "onValue-change"?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    value: string;
+    placeholder: string;
+    isDisabled: boolean;
+    maxHeight: number;
+    modelValue: string;
+    isSendButtonHidden: boolean;
+    submitOn: SubmitTrigger;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    leading?(): unknown;
+    trailing?(): unknown;
+    sendButton?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1 @@
+export { default as ChatComposer, SubmitTrigger, type ChatComposerProps, } from './ChatComposer.vue';

package/dist/presentation/forms/checkbox/Checkbox.variants.d.ts

@@ -0,0 +1,133 @@
+import { VariantProps } from '../../../foundation/utils';
+import { TVReturnType } from 'tailwind-variants';
+import { TVConfig } from 'tailwind-variants/dist/config.js';
+/** Defines the checkbox visual surface style. */
+export declare const CheckboxVariant: {
+    /** Refers to an opaque, filled surface. */
+    readonly Solid: "solid";
+    /** Refers to a soft tinted surface. */
+    readonly Soft: "soft";
+    /** Refers to a bordered, transparent surface. */
+    readonly Outline: "outline";
+    /** Refers to a borderless, transparent surface. */
+    readonly Ghost: "ghost";
+    /** Refers to a glass surface. */
+    readonly Glass: "glass";
+    /** Refers to a glass surface with a hairline border. */
+    readonly GlassSurface: "glass-surface";
+};
+export type CheckboxVariant = (typeof CheckboxVariant)[keyof typeof CheckboxVariant];
+export declare const checkboxVariants: TVReturnType<{
+    variant: {
+        solid: string;
+        soft: string;
+        outline: string;
+        ghost: string;
+        glass: string;
+        'glass-surface': string;
+    };
+    tone: {
+        primary: string;
+        neutral: string;
+        danger: string;
+        success: string;
+        warning: string;
+    };
+}, undefined, "pointer-events-none grid h-full w-full place-items-center rounded-sm border transition-colors peer-focus-visible:ring-2 peer-focus-visible:ring-ring peer-focus-visible:ring-offset-1 peer-disabled:opacity-50", TVConfig<{
+    variant: {
+        solid: string;
+        soft: string;
+        outline: string;
+        ghost: string;
+        glass: string;
+        'glass-surface': string;
+    };
+    tone: {
+        primary: string;
+        neutral: string;
+        danger: string;
+        success: string;
+        warning: string;
+    };
+}, {
+    variant: {
+        solid: string;
+        soft: string;
+        outline: string;
+        ghost: string;
+        glass: string;
+        'glass-surface': string;
+    };
+    tone: {
+        primary: string;
+        neutral: string;
+        danger: string;
+        success: string;
+        warning: string;
+    };
+}>, {
+    variant: {
+        solid: string;
+        soft: string;
+        outline: string;
+        ghost: string;
+        glass: string;
+        'glass-surface': string;
+    };
+    tone: {
+        primary: string;
+        neutral: string;
+        danger: string;
+        success: string;
+        warning: string;
+    };
+}, undefined, TVReturnType<{
+    variant: {
+        solid: string;
+        soft: string;
+        outline: string;
+        ghost: string;
+        glass: string;
+        'glass-surface': string;
+    };
+    tone: {
+        primary: string;
+        neutral: string;
+        danger: string;
+        success: string;
+        warning: string;
+    };
+}, undefined, "pointer-events-none grid h-full w-full place-items-center rounded-sm border transition-colors peer-focus-visible:ring-2 peer-focus-visible:ring-ring peer-focus-visible:ring-offset-1 peer-disabled:opacity-50", TVConfig<{
+    variant: {
+        solid: string;
+        soft: string;
+        outline: string;
+        ghost: string;
+        glass: string;
+        'glass-surface': string;
+    };
+    tone: {
+        primary: string;
+        neutral: string;
+        danger: string;
+        success: string;
+        warning: string;
+    };
+}, {
+    variant: {
+        solid: string;
+        soft: string;
+        outline: string;
+        ghost: string;
+        glass: string;
+        'glass-surface': string;
+    };
+    tone: {
+        primary: string;
+        neutral: string;
+        danger: string;
+        success: string;
+        warning: string;
+    };
+}>, unknown, unknown, undefined>>;
+export type CheckboxVariants = VariantProps<typeof checkboxVariants>;

package/dist/presentation/forms/checkbox/Checkbox.vue.d.ts

@@ -0,0 +1,48 @@
+import { ColorProp, ColorTone, SizePreset, SizeUnion } from '../../../foundation/utils';
+import { CheckboxVariant } from './Checkbox.variants';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export type CheckboxSizePreset = Extract<SizePreset, 'xs' | 'sm' | 'md' | 'lg' | 'xl'>;
+export interface CheckboxProps {
+    /** The size — preset (`xs|sm|md|lg|xl`) → box + icon scale · raw number/string → square inline · object → explicit dims. See `SizeUnion`. */
+    size?: SizeUnion<CheckboxSizePreset>;
+    /** The visual surface style. */
+    variant?: CheckboxVariant;
+    /** The semantic tone palette. */
+    tone?: ColorTone;
+    /** The tristate visual state — input stays unchecked but renders as a dash with the same checked-state styling. */
+    isIndeterminate?: boolean;
+    /** The per-instance color override (string seed or slot object) — overrides the active `tone`'s theme tokens locally. */
+    color?: ColorProp;
+    /** The checked state, controlled — React's spelling, which wins when both are set. */
+    checked?: boolean;
+    /** The checked state, controlled. The `v-model` binding target. */
+    modelValue?: boolean;
+    /** The initial checked state when uncontrolled. */
+    defaultChecked?: boolean;
+    /** 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<CheckboxProps, {
+    el: Readonly< ShallowRef<HTMLInputElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (checked: boolean) => any;
+    "update:modelValue": (checked: boolean) => any;
+}, string, PublicProps, Readonly<CheckboxProps> & Readonly<{
+    "onValue-change"?: ((checked: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((checked: boolean) => any) | undefined;
+}>, {
+    size: SizeUnion<CheckboxSizePreset>;
+    disabled: boolean;
+    tone: ColorTone;
+    variant: CheckboxVariant;
+    required: boolean;
+    modelValue: boolean;
+    isIndeterminate: boolean;
+    checked: boolean;
+    defaultChecked: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as Checkbox, type CheckboxProps } from './Checkbox.vue';
+export { CheckboxVariant, type CheckboxVariants } from './Checkbox.variants';

package/dist/presentation/forms/checkboxField/CheckboxField.vue.d.ts

@@ -0,0 +1,35 @@
+import { CheckboxProps } from '../checkbox';
+import { DefineComponent, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface CheckboxFieldProps extends CheckboxProps {
+    /** The right-side label. Fill the `label` slot instead for richer content. */
+    label?: string | number;
+    /** The smaller helper / description below. Fill the `description` slot for richer content. */
+    description?: string | number;
+    /**
+     * The wrap-element class (the `<label>`).
+     *
+     * React put `className` on the inner `Checkbox` and `wrapperClassName` on the `<label>`;
+     * that split is preserved, so Vue's `class` fallthrough attr reaches the CHECKBOX, not
+     * the root. Style the wrapper through this prop.
+     */
+    wrapperClassName?: string;
+    /**
+     * The key this item contributes to a surrounding `CheckboxGroup`'s selection.
+     *
+     * React read it off the cloned child (`ChildLike.value`); here the group provides a
+     * context and this prop is what the item registers under. Ignored outside a group.
+     */
+    value?: string;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<CheckboxFieldProps, {
+    el: ComputedRef<HTMLInputElement | null>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<CheckboxFieldProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    label?(): unknown;
+    description?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

package/dist/presentation/forms/checkboxGroup/CheckboxGroup.vue.d.ts

@@ -0,0 +1,39 @@
+import { Orientation } from '../../../foundation/utils';
+import { DefineComponent, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface CheckboxGroupProps {
+    /** The group legend (label-equivalent for fieldset). Fill the `legend` slot for richer content. */
+    legend?: string | number;
+    /** The selected values, controlled — React's spelling, which wins when both are set. */
+    value?: ReadonlyArray<string>;
+    /** The selected values, controlled. The `v-model` binding target. */
+    modelValue?: ReadonlyArray<string>;
+    /** The initial values (uncontrolled). */
+    defaultValue?: ReadonlyArray<string>;
+    /** The disabled state for the whole group. */
+    isDisabled?: boolean;
+    /** The layout direction. Default `vertical`. */
+    orientation?: Orientation;
+    /** The group's id. Auto-filled from `FormControl` context when omitted. */
+    id?: string;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<CheckboxGroupProps, {
+    el: ComputedRef<HTMLFieldSetElement | null>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (value: readonly string[]) => any;
+    "update:modelValue": (value: readonly string[]) => any;
+}, string, PublicProps, Readonly<CheckboxGroupProps> & Readonly<{
+    "onValue-change"?: ((value: readonly string[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: readonly string[]) => any) | undefined;
+}>, {
+    orientation: Orientation;
+    isDisabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    default(): unknown;
+    legend?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/presentation/forms/checkboxGroup/CheckboxGroupContext.d.ts

@@ -0,0 +1,14 @@
+import { InjectionKey } from 'vue';
+export interface CheckboxGroupContextValue {
+    /** Whether `value` is currently selected. */
+    readonly isSelected: (value: string | undefined) => boolean;
+    /** Toggles `value` in or out of the selection. */
+    readonly toggle: (value: string | undefined) => void;
+    /** The group-level disabled flag, cascaded to every item. */
+    readonly isDisabled: () => boolean | undefined;
+    /** The group-level invalid flag, cascaded to every item. */
+    readonly isInvalid: () => boolean;
+}
+export declare const CheckboxGroupKey: InjectionKey<CheckboxGroupContextValue>;
+/** Reads the surrounding `CheckboxGroup`, or `null` when the item stands alone. */
+export declare function useCheckboxGroup(): CheckboxGroupContextValue | null;

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

@@ -0,0 +1,2 @@
+export { default as CheckboxGroup, type CheckboxGroupProps } from './CheckboxGroup.vue';
+export { useCheckboxGroup, CheckboxGroupKey, type CheckboxGroupContextValue } from './CheckboxGroupContext';

package/dist/presentation/forms/choiceCard/ChoiceCard.vue.d.ts

@@ -0,0 +1,35 @@
+import { Size } from '../../../foundation/utils';
+import { RadioProps } from '../radio';
+import { DefineComponent, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface ChoiceCardProps extends Omit<RadioProps, 'size'> {
+    /** The card title. Fill the `label` slot instead for richer content. */
+    label?: string | number;
+    /** The description under the title. Fill the `description` slot for richer content. */
+    description?: string | number;
+    /** The optional icon rendered beside the label. Fill the `icon` slot with the icon element. */
+    icon?: string | number;
+    /** The card size. Default `md`. */
+    size?: Size;
+    /**
+     * The key this item contributes to a surrounding `RadioGroup`'s selection.
+     *
+     * React read it off the cloned child (`ChildLike.value`); here the group provides a
+     * context and this prop is what the item registers under. Ignored outside a group.
+     */
+    value?: string;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<ChoiceCardProps, {
+    el: ComputedRef<HTMLInputElement | null>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ChoiceCardProps> & Readonly<{}>, {
+    size: Size;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    label?(): unknown;
+    description?(): unknown;
+    icon?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

package/dist/presentation/forms/codeEditor/CodeEditor.vue.d.ts

@@ -0,0 +1,50 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface CodeEditorProps {
+    /** The source text, controlled — React's spelling, which wins when both are set. */
+    value?: string;
+    /** The source text, controlled. The `v-model` binding target. */
+    modelValue?: string;
+    /** The initial source text when uncontrolled. */
+    defaultValue?: string;
+    /** The forward-compat hint; unused by this first-gen component. */
+    language?: string;
+    /** The number of spaces one indent step inserts. Default `2`. */
+    tabSize?: number;
+    /** Whether indenting inserts a tab character instead of `tabSize` spaces. Default `false`. */
+    isTabIndented?: boolean;
+    /** The invalid surface override. Falls back to the surrounding form control's `isInvalid`. */
+    isInvalid?: boolean;
+    /** The CSS minHeight on the surface (default `12rem`). */
+    minHeight?: string;
+    /** 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 read-only state — React's spelling. Falls back to the form control's `isReadOnly`. */
+    readOnly?: boolean;
+    /** The DOM spelling of {@link CodeEditorProps.readOnly}, which wins when both are set. */
+    readonly?: boolean;
+    /** The required state. Falls back to the surrounding form control's `isRequired`. */
+    required?: boolean;
+}
+declare const _default: DefineComponent<CodeEditorProps, {
+    el: Readonly< ShallowRef<HTMLTextAreaElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (value: string) => any;
+    "update:modelValue": (value: string) => any;
+}, string, PublicProps, Readonly<CodeEditorProps> & Readonly<{
+    "onValue-change"?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    value: string;
+    required: boolean;
+    isInvalid: boolean;
+    minHeight: string;
+    tabSize: number;
+    modelValue: string;
+    readOnly: boolean;
+    readonly: boolean;
+    isTabIndented: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

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

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

package/dist/presentation/forms/colorArea/ColorArea.vue.d.ts

@@ -0,0 +1,40 @@
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** The saturation / value pair a `ColorArea` commits. */
+export interface ColorAreaChange {
+    saturation: number;
+    value: number;
+}
+export interface ColorAreaProps {
+    /** The hue the square is tinted with (0–360). */
+    hue?: number;
+    /** The saturation, controlled (0–1). The `v-model:saturation` binding target. */
+    saturation?: number;
+    /** The initial saturation when uncontrolled. */
+    defaultSaturation?: number;
+    /** The brightness/value, controlled (0–1). The `v-model:value` binding target. */
+    value?: number;
+    /** The initial value when uncontrolled. */
+    defaultValue?: number;
+    /** The arrow-key increment. `PageUp`/`PageDown` move ten steps. */
+    step?: number;
+    /** The disabled state. Falls back to the surrounding form control's `isDisabled`. */
+    isDisabled?: boolean;
+    /** The control's id. Auto-filled from `FormControl` context when omitted. */
+    id?: string;
+}
+declare const _default: DefineComponent<ColorAreaProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (next: ColorAreaChange) => any;
+    "update:value": (value: number) => any;
+    "update:saturation": (value: number) => any;
+}, string, PublicProps, Readonly<ColorAreaProps> & Readonly<{
+    "onValue-change"?: ((next: ColorAreaChange) => any) | undefined;
+    "onUpdate:value"?: ((value: number) => any) | undefined;
+    "onUpdate:saturation"?: ((value: number) => any) | undefined;
+}>, {
+    hue: number;
+    step: number;
+    isDisabled: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1 @@
+export { default as ColorArea, type ColorAreaProps, type ColorAreaChange, } from './ColorArea.vue';

package/dist/presentation/forms/colorField/ColorField.vue.d.ts

@@ -0,0 +1,44 @@
+import { InputSize, InputState, InputBorder, InputRing } from '../InputStyles';
+import { SwatchShape } from '../colorSwatch';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+export interface ColorFieldProps {
+    /** The control size. */
+    size?: InputSize;
+    /** The validity surface. */
+    state?: InputState;
+    /** The border weight. */
+    border?: InputBorder;
+    /** The focus-ring weight. */
+    ring?: InputRing;
+    /** The committed hex, controlled — React's spelling, which wins when both are set. */
+    value?: string | null;
+    /** The committed hex, controlled. The `v-model` binding target. */
+    modelValue?: string | null;
+    /** The initial hex when uncontrolled. */
+    defaultValue?: string | null;
+    /** The swatch outline shape shown inside the field. */
+    swatchShape?: SwatchShape;
+    /** Whether a committed hex keeps its alpha channel (`#RRGGBBAA`). */
+    hasAlpha?: boolean;
+    /** 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<ColorFieldProps, {
+    el: Readonly< ShallowRef<HTMLInputElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (value: string | null) => any;
+    "update:modelValue": (value: string | null) => any;
+}, string, PublicProps, Readonly<ColorFieldProps> & Readonly<{
+    "onValue-change"?: ((value: string | null) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
+}>, {
+    disabled: boolean;
+    required: boolean;
+    swatchShape: SwatchShape;
+    hasAlpha: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

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

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

package/dist/presentation/forms/colorPicker/ColorPicker.vue.d.ts

@@ -0,0 +1,62 @@
+import { ColorSwatchSize } from '../colorSwatch';
+import { DefineComponent, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines which built-in trigger a color picker renders. */
+export declare const ColorPickerTriggerVariant: {
+    /** Refers to a swatch plus hex-value text in a framed button. */
+    readonly Full: "full";
+    /** Refers to a bare interactive swatch, no text. */
+    readonly Swatch: "swatch";
+    /** Refers to hex-value text only, no swatch. */
+    readonly Value: "value";
+};
+export type ColorPickerTriggerVariant = (typeof ColorPickerTriggerVariant)[keyof typeof ColorPickerTriggerVariant];
+export interface ColorPickerProps {
+    /** The selected hex, controlled — React's spelling, which wins when both are set. */
+    value?: string | null;
+    /** The selected hex, controlled. The `v-model` binding target. */
+    modelValue?: string | null;
+    /** The initial hex when uncontrolled. Default `#3b82f6`. */
+    defaultValue?: string | null;
+    /** Whether the committed hex keeps its alpha channel, and the alpha slider renders. */
+    hasAlpha?: boolean;
+    /** The preset palette rendered under the panel; omitted or empty hides the row. */
+    presets?: ReadonlyArray<string>;
+    /** The size step the built-in trigger's swatch renders at. */
+    triggerSize?: ColorSwatchSize;
+    /**
+     * The built-in trigger to render (ignored when the `trigger` slot is filled):
+     * - `full` *(default)* — swatch + hex-value text, framed button.
+     * - `swatch` — a bare interactive swatch, no text (compact toolbars, tiles).
+     * - `value` — hex-value text only, no swatch (dense / code contexts).
+     */
+    triggerVariant?: ColorPickerTriggerVariant;
+    /** The disabled state. Falls back to the surrounding form control's `isDisabled`. */
+    isDisabled?: boolean;
+    /** The hidden input's name — renders a form-submittable mirror of the hex. */
+    name?: string;
+    /** The trigger id; falls back to a surrounding `<Field>`'s control id. */
+    id?: string;
+}
+declare const _default: __VLS_WithSlots< DefineComponent<ColorPickerProps, {
+    el: ComputedRef<HTMLElement | null>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (value: string | null) => any;
+    "update:modelValue": (value: string | null) => any;
+}, string, PublicProps, Readonly<ColorPickerProps> & Readonly<{
+    "onValue-change"?: ((value: string | null) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    defaultValue: string | null;
+    hasAlpha: boolean;
+    triggerSize: ColorSwatchSize;
+    triggerVariant: ColorPickerTriggerVariant;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, {
+    trigger?(): unknown;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1 @@
+export { default as ColorPicker, ColorPickerTriggerVariant, type ColorPickerProps, } from './ColorPicker.vue';

package/dist/presentation/forms/colorSlider/ColorSlider.vue.d.ts

@@ -0,0 +1,47 @@
+import { HSV } from '../ColorExtensions';
+import { DefineComponent, ShallowRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+/** Defines which HSV/alpha channel a color slider drives. */
+export declare const ColorChannel: {
+    /** Refers to the hue channel (0–360°). */
+    readonly Hue: "hue";
+    /** Refers to the saturation channel (0–1). */
+    readonly Saturation: "saturation";
+    /** Refers to the value/brightness channel (0–1). */
+    readonly Value: "value";
+    /** Refers to the alpha/opacity channel (0–1). */
+    readonly Alpha: "alpha";
+};
+export type ColorChannel = (typeof ColorChannel)[keyof typeof ColorChannel];
+export interface ColorSliderProps {
+    /** The channel the track drives. */
+    channel?: ColorChannel;
+    /** The channel value, controlled — React's spelling, which wins when both are set. */
+    value?: number;
+    /** The channel value, controlled. The `v-model` binding target. */
+    modelValue?: number;
+    /** The initial value when uncontrolled. */
+    defaultValue?: number;
+    /** The surrounding color the non-hue gradients are built from. */
+    color?: HSV;
+    /** The arrow-key increment. Defaults to `1` for hue, `0.01` otherwise. */
+    step?: number;
+    /** The disabled state. Falls back to the surrounding form control's `isDisabled`. */
+    isDisabled?: boolean;
+    /** The control's id. Auto-filled from `FormControl` context when omitted. */
+    id?: string;
+}
+export declare function channelMax(channel: ColorChannel): number;
+export declare function defaultStep(channel: ColorChannel): number;
+declare const _default: DefineComponent<ColorSliderProps, {
+    el: Readonly< ShallowRef<HTMLDivElement | null>>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "value-change": (value: number) => any;
+    "update:modelValue": (value: number) => any;
+}, string, PublicProps, Readonly<ColorSliderProps> & Readonly<{
+    "onValue-change"?: ((value: number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    channel: ColorChannel;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;