ropav 0.0.8 → 0.0.10

package/dist/components/color-picker/types.d.ts

@@ -0,0 +1,39 @@
+export declare const colorPickerFormats: readonly ["hex", "hexa", "rgb", "rgba", "hsl", "hsla"];
+export declare const colorPickerSizes: readonly ["xs", "sm", "md", "lg", "xl"];
+export type ColorPickerFormat = (typeof colorPickerFormats)[number];
+export type ColorPickerSize = (typeof colorPickerSizes)[number];
+export interface ColorPickerSelection {
+    saturation: number;
+    value: number;
+    opacity?: number;
+}
+export type ColorPickerValue = string;
+export interface ColorPickerProps {
+    id?: string;
+    modelValue: ColorPickerValue;
+    format?: ColorPickerFormat;
+    size?: ColorPickerSize;
+    readonly?: boolean;
+    withPicker?: boolean;
+    swatches?: string[];
+    swatchesPerRow?: number;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+}
+export interface ColorPickerSaturationProps {
+    id?: string;
+    modelValue: ColorPickerSelection;
+    hue?: number;
+    readonly?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+}
+export type ColorPickerSliderVariant = 'hue' | 'opacity';
+export interface ColorPickerSliderProps {
+    variant: ColorPickerSliderVariant;
+    value?: number;
+    color?: string;
+    readonly?: boolean;
+}

package/dist/components/color-picker/useColorPickerDrag.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+export interface ColorPickerPointerCoordinates {
+    clientX: number;
+    clientY: number;
+}
+interface UseColorPickerDragOptions {
+    target: Ref<HTMLElement | null>;
+    focusTarget?: Ref<HTMLElement | null>;
+    readonly: () => boolean;
+    isGeometryValid: (rect: DOMRect) => boolean;
+    updateFromPointer: (pointer: ColorPickerPointerCoordinates, rect: DOMRect) => void;
+}
+export declare function useColorPickerDrag({ target, focusTarget, readonly, isGeometryValid, updateFromPointer, }: UseColorPickerDragOptions): {
+    onPointerDown: (event: PointerEvent) => void;
+};
+export {};

package/dist/components/color-picker/useColorPickerSwatches.d.ts

@@ -0,0 +1,21 @@
+import { CSSProperties } from 'vue';
+import { ColorPickerProps } from './types.js';
+type ColorPickerSwatchesProps = Readonly<Pick<ColorPickerProps, 'swatches' | 'swatchesPerRow'>>;
+interface UseColorPickerSwatchesOptions {
+    isSelected: (swatch: string) => boolean;
+    select: (swatch: string) => void;
+}
+export declare function useColorPickerSwatches(props: ColorPickerSwatchesProps, options: UseColorPickerSwatchesOptions): {
+    swatchesRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    normalizedSwatchesPerRow: import('vue').ComputedRef<number | undefined>;
+    validSwatches: import('vue').ComputedRef<string[]>;
+    swatchesStyle: import('vue').ComputedRef<CSSProperties | undefined>;
+    swatchSize: import('vue').ComputedRef<"100%" | "var(--_rp-color-picker-swatch-size)">;
+    isSwatchSelected: (index: number) => boolean;
+    getSwatchTabindex: (index: number) => 0 | -1;
+    selectSwatch: (swatch: string) => void;
+    onSwatchFocus: (index: number) => void;
+    onSwatchesFocusout: (event: FocusEvent) => void;
+    onSwatchKeydown: (event: KeyboardEvent, index: number) => void;
+};
+export {};

package/dist/components/color-picker/useColorPickerValue.d.ts

@@ -0,0 +1,15 @@
+import { ColorPickerHsvColor } from './color-picker-utils.js';
+import { ColorPickerProps, ColorPickerSelection, ColorPickerValue } from './types.js';
+type ColorPickerValueProps = Readonly<Pick<ColorPickerProps, 'modelValue' | 'format' | 'readonly'>>;
+export declare function useColorPickerValue(props: ColorPickerValueProps, emitUpdate: (value: ColorPickerValue) => void): {
+    selectedColor: import('vue').ComputedRef<ColorPickerHsvColor>;
+    saturationValue: import('vue').ComputedRef<ColorPickerSelection>;
+    opacityColor: import('vue').ComputedRef<string>;
+    showAlphaControls: import('vue').ComputedRef<boolean>;
+    updateSelection: (value: ColorPickerSelection) => void;
+    updateHue: (value: number) => void;
+    updateOpacity: (value: number) => void;
+    selectColor: (value: string) => void;
+    isColorSelected: (value: string) => boolean;
+};
+export {};

package/dist/components/color-swatch/color-swatch.d.ts

@@ -0,0 +1,21 @@
+import { ColorSwatchProps } from './types.js';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<ColorSwatchProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: {};
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/color-swatch/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ColorSwatch } from './color-swatch.js';
+export type { ColorSwatchProps, ColorSwatchSize } from './types.js';

package/dist/components/color-swatch/index.js

@@ -0,0 +1,2 @@
+import { t as color_swatch_default } from "../../color-swatch.js";
+export { color_swatch_default as ColorSwatch };

package/dist/components/color-swatch/types.d.ts

@@ -0,0 +1,6 @@
+export type ColorSwatchSize = string | number;
+export interface ColorSwatchProps {
+    color: string;
+    size?: ColorSwatchSize;
+    ariaLabel?: string;
+}

package/dist/components/color-swatch/useColorSwatchColor.d.ts

@@ -0,0 +1,5 @@
+export declare function getColorSwatchForeground(color: string): "var(--rp-color-white)" | "var(--rp-color-black)";
+export declare function getColorSwatchOverlay(color: string): {
+    stroke: string;
+    shadow: string;
+};

package/dist/components/dropdown-menu/dropdown-menu-items.d.ts

@@ -1,15 +1,24 @@
-import { PropType } from 'vue';
-import { DropdownMenuRenderedItem } from './types';
+import { PropType, VNode } from 'vue';
+import { DropdownMenuItem } from './types.js';
+import { DropdownMenuRenderContext } from './useDropdownMenuRenderItems.js';
 declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    context: {
+        readonly type: PropType<DropdownMenuRenderContext>;
+        readonly required: true;
+    };
     items: {
-        type: PropType<DropdownMenuRenderedItem[]>;
+        type: PropType<DropdownMenuItem[]>;
         required: true;
     };
-}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+}>, () => VNode<import('vue').RendererNode, import('vue').RendererElement, {
     [key: string]: any;
-}>[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    context: {
+        readonly type: PropType<DropdownMenuRenderContext>;
+        readonly required: true;
+    };
     items: {
-        type: PropType<DropdownMenuRenderedItem[]>;
+        type: PropType<DropdownMenuItem[]>;
         required: true;
     };
 }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/dropdown-menu/dropdown-menu-utils.d.ts

@@ -1,4 +1,4 @@
-import { DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuOpenOptions, DropdownMenuPlacement } from './types';
+import { DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuOpenOptions, DropdownMenuPlacement } from './types.js';
 export declare const DEFAULT_PLACEMENT: DropdownMenuPlacement;
 export declare const DEFAULT_FOCUS_TARGET: DropdownMenuFocusTarget;
 export type ItemPath = DropdownMenuItemPath;

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

@@ -1,8 +1,8 @@
-import { DropdownMenuItem, DropdownMenuItemSlotProps, DropdownMenuProps, DropdownMenuSlotProps } from './types';
+import { DropdownMenuItem, DropdownMenuItemSlotProps, DropdownMenuProps, DropdownMenuSlotProps } from './types.js';
 declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<DropdownMenuProps & {
-        onSelect?: ((item: DropdownMenuItem) => any) | undefined;
         "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        onSelect?: ((item: DropdownMenuItem) => any) | undefined;
     }> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
     } ? P : {});
@@ -13,7 +13,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
         item?(props: DropdownMenuItemSlotProps): unknown;
         empty?(): unknown;
     };
-    emit: ((evt: "select", item: DropdownMenuItem) => void) & ((evt: "update:open", value: boolean) => void);
+    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "select", item: DropdownMenuItem) => void);
 }>) => import('vue').VNode & {
     __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/components/dropdown-menu/index.d.ts

@@ -1,3 +1,3 @@
-export { default as DropdownMenu } from './dropdown-menu';
-export { useDropdownMenu } from './useDropdownMenu';
-export type { DropdownMenuCloseOptions, DropdownMenuContentProps, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuItemValue, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuRenderedItem, DropdownMenuSlotProps, DropdownMenuSubmenuProps, DropdownMenuTriggerProps, } from './types';
+export { default as DropdownMenu } from './dropdown-menu.js';
+export { useDropdownMenu } from './useDropdownMenu.js';
+export type { DropdownMenuCloseOptions, DropdownMenuContentProps, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemPath, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuItemValue, DropdownMenuOpenOptions, DropdownMenuPlacement, DropdownMenuProps, DropdownMenuRenderedItem, DropdownMenuSlotProps, DropdownMenuSubmenuProps, DropdownMenuTriggerProps, } from './types.js';

package/dist/components/dropdown-menu/useDropdownMenu.d.ts

@@ -1,4 +1,4 @@
-import { DropdownMenuContentProps, DropdownMenuItem, DropdownMenuProps, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types';
+import { DropdownMenuContentProps, DropdownMenuItem, DropdownMenuProps, DropdownMenuSlotProps, DropdownMenuTriggerProps } from './types.js';
 export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit?: {
     openChange?: (open: boolean) => void;
     select?: (item: DropdownMenuItem) => void;
@@ -9,24 +9,25 @@ export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit
     isVisible: import('vue').ComputedRef<boolean>;
     isEmpty: import('vue').ComputedRef<boolean>;
     visibleItems: import('vue').ComputedRef<DropdownMenuItem[]>;
-    renderedItems: import('vue').ComputedRef<import('./types').DropdownMenuRenderedItem[]>;
+    renderedItems: import('vue').ComputedRef<import('./types.js').DropdownMenuRenderedItem[]>;
+    renderContext: import('./useDropdownMenuRenderItems.js').DropdownMenuRenderContext;
     focusedIndex: import('vue').ComputedRef<number>;
-    focusedPath: import('vue').Ref<number[], import('./types').DropdownMenuItemPath | number[]>;
+    focusedPath: import('vue').Ref<number[], number[] | import('./types.js').DropdownMenuItemPath>;
     activeDescendantId: import('vue').ComputedRef<string | undefined>;
     rootClass: import('vue').ComputedRef<string[]>;
     contentClass: import('vue').ComputedRef<string[]>;
     triggerProps: import('vue').ComputedRef<DropdownMenuTriggerProps>;
     contentProps: import('vue').ComputedRef<DropdownMenuContentProps>;
     slotProps: import('vue').ComputedRef<DropdownMenuSlotProps>;
-    open: (options?: import('./types').DropdownMenuOpenOptions | import('./types').DropdownMenuFocusTarget) => void;
-    close: (options?: import('./types').DropdownMenuCloseOptions) => void;
+    open: (options?: import('./types.js').DropdownMenuOpenOptions | import('./types.js').DropdownMenuFocusTarget) => void;
+    close: (options?: import('./types.js').DropdownMenuCloseOptions) => void;
     toggle: () => void;
     selectItem: (item: DropdownMenuItem) => void;
-    openSubmenu: (path: import('./dropdown-menu-utils').ItemPath, focus?: import('./dropdown-menu-utils').SubmenuFocusTarget, point?: import('./dropdown-menu-utils').PointerPoint) => boolean;
-    closeSubmenu: (path: import('./dropdown-menu-utils').ItemPath) => boolean;
-    onItemMouseenter: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils').ItemPath, event?: MouseEvent) => void;
+    openSubmenu: (path: import('./dropdown-menu-utils.js').ItemPath, focus?: import('./dropdown-menu-utils.js').SubmenuFocusTarget, point?: import('./dropdown-menu-utils.js').PointerPoint) => boolean;
+    closeSubmenu: (path: import('./dropdown-menu-utils.js').ItemPath) => boolean;
+    onItemMouseenter: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils.js').ItemPath, event?: MouseEvent) => void;
     onTriggerKeydown: (event: KeyboardEvent) => void;
     onMenuKeydown: (event: KeyboardEvent) => void;
-    getItemProps: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils').ItemPath, focused?: boolean, disabled?: boolean) => import('./types').DropdownMenuItemProps;
-    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils').ItemPath, focused?: boolean, disabled?: boolean) => import('./types').DropdownMenuItemSlotProps;
+    getItemProps: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils.js').ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => import('./types.js').DropdownMenuItemProps;
+    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | import('./dropdown-menu-utils.js').ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => import('./types.js').DropdownMenuItemSlotProps;
 };

package/dist/components/dropdown-menu/useDropdownMenuDisclosure.d.ts

@@ -1,6 +1,6 @@
 import { Ref } from 'vue';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types';
-import { ItemPath } from './dropdown-menu-utils';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types.js';
+import { ItemPath } from './dropdown-menu-utils.js';
 type BooleanSource = Readonly<Ref<boolean>>;
 type UseDropdownMenuDisclosureOptions = {
     props: Readonly<DropdownMenuProps>;

package/dist/components/dropdown-menu/useDropdownMenuDom.d.ts

@@ -1,6 +1,6 @@
 import { Ref } from 'vue';
-import { DropdownMenuPlacement } from './types';
-import { ItemPath } from './dropdown-menu-utils';
+import { DropdownMenuPlacement } from './types.js';
+import { ItemPath } from './dropdown-menu-utils.js';
 type StringSource = {
     readonly value: string;
 };

package/dist/components/dropdown-menu/useDropdownMenuHoverIntent.d.ts

@@ -1,6 +1,6 @@
 import { Ref } from 'vue';
-import { DropdownMenuItem } from './types';
-import { ItemPath, PointerPoint } from './dropdown-menu-utils';
+import { DropdownMenuItem } from './types.js';
+import { ItemPath, PointerPoint } from './dropdown-menu-utils.js';
 export type SafeTriangle = [PointerPoint, PointerPoint, PointerPoint];
 type GetSafeTriangleOptions = {
     itemRect: DOMRect | null;

package/dist/components/dropdown-menu/useDropdownMenuInteractions.d.ts

@@ -1,6 +1,6 @@
 import { Ref } from 'vue';
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types';
-import { ItemPath, PointerPoint, SubmenuFocusTarget } from './dropdown-menu-utils';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuOpenOptions, DropdownMenuProps } from './types.js';
+import { ItemPath, PointerPoint, SubmenuFocusTarget } from './dropdown-menu-utils.js';
 type BooleanSource = Readonly<Ref<boolean>>;
 type DisclosureControls = {
     open: (options?: DropdownMenuOpenOptions | DropdownMenuFocusTarget) => void;

package/dist/components/dropdown-menu/useDropdownMenuNavigation.d.ts

@@ -1,10 +1,10 @@
-import { DropdownMenuFocusTarget, DropdownMenuItem } from './types';
-import { ItemPath } from './dropdown-menu-utils';
+import { DropdownMenuFocusTarget, DropdownMenuItem } from './types.js';
+import { ItemPath } from './dropdown-menu-utils.js';
 type DropdownMenuItemsSource = {
     readonly value: DropdownMenuItem[];
 };
 export declare function useDropdownMenuNavigation(items: DropdownMenuItemsSource): {
-    focusedPath: import('vue').Ref<number[], import('./types').DropdownMenuItemPath | number[]>;
+    focusedPath: import('vue').Ref<number[], number[] | import('./types.js').DropdownMenuItemPath>;
     focusedIndex: import('vue').ComputedRef<number>;
     getItemsAtPath: (path: ItemPath) => DropdownMenuItem[];
     getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;

package/dist/components/dropdown-menu/useDropdownMenuRenderItems.d.ts

@@ -1,5 +1,5 @@
-import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuRenderedItem } from './types';
-import { ItemPath } from './dropdown-menu-utils';
+import { DropdownMenuCloseOptions, DropdownMenuFocusTarget, DropdownMenuItem, DropdownMenuItemProps, DropdownMenuItemSlotProps, DropdownMenuRenderedItem, DropdownMenuSubmenuProps } from './types.js';
+import { ItemPath } from './dropdown-menu-utils.js';
 type DropdownMenuItemsSource = {
     readonly value: DropdownMenuItem[];
 };
@@ -17,9 +17,17 @@ type UseDropdownMenuRenderItemsOptions = {
     closeSubmenu: (path: ItemPath) => void;
     close: (options?: DropdownMenuCloseOptions) => void;
 };
+export interface DropdownMenuRenderContext {
+    isItemFocused: (indexOrPath: number | ItemPath) => boolean;
+    isSubmenuOpen: (path: ItemPath) => boolean;
+    getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemProps;
+    getSubmenuProps: (item: DropdownMenuItem, path: ItemPath, submenuOpen?: boolean) => DropdownMenuSubmenuProps;
+    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemSlotProps;
+}
 export declare function useDropdownMenuRenderItems({ items, getItemId, getSubmenuId, getMenuActiveDescendant, isItemFocused, isSubmenuOpen, activateItem, focusHoveredItem, selectItem, openSubmenu, closeSubmenu, close, }: UseDropdownMenuRenderItemsOptions): {
     renderedItems: import('vue').ComputedRef<DropdownMenuRenderedItem[]>;
-    getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean) => DropdownMenuItemProps;
-    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean) => DropdownMenuItemSlotProps;
+    renderContext: DropdownMenuRenderContext;
+    getItemProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemProps;
+    getItemSlotProps: (item: DropdownMenuItem, indexOrPath: number | ItemPath, focused?: boolean, disabled?: boolean, submenuOpen?: boolean) => DropdownMenuItemSlotProps;
 };
 export {};

package/dist/components/dropdown-menu/useDropdownSubmenus.d.ts

@@ -1,13 +1,13 @@
 import { Ref } from 'vue';
-import { DropdownMenuItem } from './types';
-import { ItemPath, SubmenuFocusTarget } from './dropdown-menu-utils';
+import { DropdownMenuItem } from './types.js';
+import { ItemPath, SubmenuFocusTarget } from './dropdown-menu-utils.js';
 type UseDropdownSubmenusOptions = {
     focusedPath: Ref<ItemPath>;
     getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;
     focusItem: (target: Exclude<SubmenuFocusTarget, false>, menuPath?: ItemPath) => boolean;
 };
 export declare function useDropdownSubmenus({ focusedPath, getItemAtPath, focusItem, }: UseDropdownSubmenusOptions): {
-    openSubmenuPath: Ref<number[], import('./types').DropdownMenuItemPath | number[]>;
+    openSubmenuPath: Ref<number[], number[] | import('./types.js').DropdownMenuItemPath>;
     resetSubmenus: () => void;
     isSubmenuOpen: (path: ItemPath) => boolean;
     closeSubmenusAfter: (menuPath: ItemPath) => void;

package/dist/components/field/field.d.ts

@@ -1,4 +1,4 @@
-import { FieldProps } from './types';
+import { FieldProps } from './types.js';
 declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<FieldProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;
@@ -15,7 +15,7 @@ declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup
             invalid: true | undefined;
             labelledby: string | undefined;
             describedby: string | undefined;
-            controlProps: import('./types').FieldControlProps;
+            controlProps: import('./types.js').FieldControlProps;
         }) => any;
     } & {
         description?: (props: {}) => any;

package/dist/components/field/index.d.ts

@@ -1,2 +1,2 @@
-export { default as Field } from './field';
-export type { FieldControlProps, FieldProps, FieldSlotProps } from './types';
+export { default as Field } from './field.js';
+export type { FieldControlProps, FieldProps, FieldSlotProps } from './types.js';

package/dist/components/field/types.d.ts

@@ -13,8 +13,6 @@ export interface FieldProps {
     id?: string;
     label?: string;
     description?: string;
-    message?: string;
-    error?: string;
     disabled?: boolean;
     required?: boolean;
     invalid?: boolean;

package/dist/components/field/useField.d.ts

@@ -1,11 +1,9 @@
-import { FieldControlProps, FieldProps } from './types';
+import { FieldControlProps, FieldProps } from './types.js';
 export declare function useField(props: Readonly<FieldProps>): {
     controlId: import('vue').ComputedRef<string>;
     labelId: import('vue').ComputedRef<string>;
     descriptionId: import('vue').ComputedRef<string>;
-    messageId: import('vue').ComputedRef<string>;
     isInvalid: import('vue').ComputedRef<boolean>;
-    messageText: import('vue').ComputedRef<string | undefined>;
     hasLabel: import('vue').ComputedRef<boolean>;
     hasDescription: import('vue').ComputedRef<boolean>;
     hasMessage: import('vue').ComputedRef<boolean>;

package/dist/components/icon-button/icon-button.d.ts

@@ -1,4 +1,4 @@
-import { IconButtonProps } from './types';
+import { IconButtonProps } from './types.js';
 declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<IconButtonProps> & (typeof globalThis extends {
         __VLS_PROPS_FALLBACK: infer P;

package/dist/components/icon-button/index.d.ts

@@ -1,2 +1,2 @@
-export { default as IconButton } from './icon-button';
-export type { IconButtonColor, IconButtonProps, IconButtonRadius, IconButtonSize, IconButtonVariant, } from './types';
+export { default as IconButton } from './icon-button.js';
+export type { IconButtonColor, IconButtonProps, IconButtonRadius, IconButtonSize, IconButtonVariant, } from './types.js';

package/dist/components/icon-button/types.d.ts

@@ -1,4 +1,4 @@
-import { ButtonColor, ButtonRadius, ButtonSize, ButtonVariant } from '../button/types';
+import { ButtonColor, ButtonRadius, ButtonSize, ButtonVariant } from '../button/types.js';
 export type IconButtonColor = ButtonColor;
 export type IconButtonSize = ButtonSize;
 export type IconButtonRadius = ButtonRadius;
@@ -7,6 +7,7 @@ export interface IconButtonProps {
     ariaLabel: string;
     variant?: IconButtonVariant;
     color?: IconButtonColor;
+    autoContrast?: boolean;
     size?: IconButtonSize;
     radius?: IconButtonRadius;
     type?: 'button' | 'submit' | 'reset';

package/dist/components/input/index.d.ts

@@ -1,2 +1,2 @@
-export { default as Input } from './input';
-export type { InputProps, InputRadius, InputSize } from './types';
+export { default as Input } from './input.js';
+export type { InputProps, InputRadius, InputSize } from './types.js';

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

@@ -1,4 +1,4 @@
-import { InputProps } from './types';
+import { InputProps } from './types.js';
 declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<InputProps & {
         "onUpdate:modelValue"?: ((value: string) => any) | undefined;

package/dist/components/input/types.d.ts

@@ -1,3 +1,4 @@
+import { InputHTMLAttributes } from 'vue';
 export type InputRadius = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export type InputSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 export interface InputProps {
@@ -16,4 +17,6 @@ export interface InputProps {
     ariaLabel?: string;
     describedby?: string;
     labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
 }

package/dist/components/input/useInput.d.ts

@@ -1,7 +1,7 @@
-import { InputProps } from './types';
+import { InputProps } from './types.js';
 export declare function useInput(props: Readonly<InputProps>, emitUpdate: (value: string) => void): {
     inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
-    control: import('../../composables/useControlState').ControlState;
+    control: import('../../composables/useControlState.js').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
     onInput: (e: Event) => void;
     focusInput: (e: MouseEvent) => void;

package/dist/components/modal/index.d.ts

@@ -1,2 +1,2 @@
-export { default as Modal } from './modal';
-export type { ModalInitialFocus, ModalPresetSize, ModalProps, ModalRole, ModalSize, ModalSlotProps, } from './types';
+export { default as Modal } from './modal.js';
+export type { ModalInitialFocus, ModalPresetSize, ModalProps, ModalRole, ModalSize, ModalSlotProps, } from './types.js';

package/dist/components/modal/modal.d.ts

@@ -1,4 +1,4 @@
-import { ModalProps } from './types';
+import { ModalProps } from './types.js';
 declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import('vue').PublicProps & __VLS_PrettifyLocal<ModalProps & {
         "onUpdate:open"?: ((value: boolean) => any) | undefined;

package/dist/components/modal/types.d.ts

@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-import { OverlayProps } from '../overlay/types';
+import { OverlayProps } from '../overlay/types.js';
 export type ModalPresetSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
 export type ModalSize = ModalPresetSize | (string & {});
 export type ModalRole = 'dialog' | 'alertdialog';

package/dist/components/modal/useModal.d.ts

@@ -1,5 +1,5 @@
 import { CSSProperties } from 'vue';
-import { ModalProps, ModalRole, ModalSlotProps } from './types';
+import { ModalProps, ModalRole, ModalSlotProps } from './types.js';
 export declare function useModal(props: Readonly<ModalProps>, emitOpenChange?: (open: boolean) => void): {
     panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
     modalId: import('vue').ComputedRef<string>;

package/dist/components/number-input/index.d.ts

@@ -0,0 +1,2 @@
+export { default as NumberInput } from './number-input.js';
+export type { NumberInputControlsPosition, NumberInputProps, NumberInputRadius, NumberInputSize, NumberInputTextAlign, NumberInputValue, } from './types.js';

package/dist/components/number-input/index.js

@@ -0,0 +1,2 @@
+import { t as number_input_default } from "../../number-input.js";
+export { number_input_default as NumberInput };

package/dist/components/number-input/number-input.d.ts

@@ -0,0 +1,29 @@
+import { NumberInputProps, NumberInputValue } from './types.js';
+declare const __VLS_export: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<NumberInputProps & {
+        "onUpdate:modelValue"?: ((value: NumberInputValue) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        'increment-icon'?: (props: {}) => any;
+    } & {
+        'decrement-icon'?: (props: {}) => any;
+    } & {
+        'increment-icon'?: (props: {}) => any;
+    } & {
+        'decrement-icon'?: (props: {}) => any;
+    };
+    emit: (evt: "update:modelValue", value: NumberInputValue) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/number-input/types.d.ts

@@ -0,0 +1,34 @@
+import { InputHTMLAttributes } from 'vue';
+import { InputRadius, InputSize } from '../input/types.js';
+export type NumberInputValue = number | null;
+export type NumberInputRadius = InputRadius;
+export type NumberInputSize = InputSize;
+export type NumberInputControlsPosition = 'left' | 'right' | 'split';
+export type NumberInputTextAlign = 'left' | 'center' | 'right';
+export interface NumberInputProps {
+    id?: string;
+    name?: string;
+    modelValue: NumberInputValue;
+    min?: number;
+    max?: number;
+    step?: number;
+    size?: NumberInputSize;
+    radius?: NumberInputRadius;
+    placeholder?: string;
+    controls?: boolean;
+    controlsPosition?: NumberInputControlsPosition;
+    textAlign?: NumberInputTextAlign;
+    clampOnBlur?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    valid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validationMessage?: string;
+    incrementLabel?: string;
+    decrementLabel?: string;
+}

package/dist/components/number-input/useNumberInput.d.ts

@@ -0,0 +1,31 @@
+import { InputHTMLAttributes } from 'vue';
+import { NumberInputControlsPosition, NumberInputProps, NumberInputTextAlign, NumberInputValue } from './types.js';
+export interface NumberInputBounds {
+    min: number | undefined;
+    max: number | undefined;
+}
+type StepDirection = -1 | 1;
+export type NumberInputControl = 'decrement' | 'increment';
+export declare function normalizeNumberInputBounds(min: number | undefined, max: number | undefined): NumberInputBounds;
+export declare function normalizeNumberInputStep(step: number | undefined): number;
+export declare function clampNumberInputValue(value: number, bounds: NumberInputBounds): number;
+export declare function stepNumberInputValue(value: NumberInputValue, direction: StepDirection, step: number, bounds: NumberInputBounds): number;
+export declare function parseNumberInputValue(value: string): NumberInputValue;
+export declare function normalizeNumberInputControlsPosition(position: NumberInputControlsPosition | undefined): NumberInputControlsPosition;
+export declare function normalizeNumberInputTextAlign(textAlign: NumberInputTextAlign | undefined): NumberInputTextAlign;
+export declare function useNumberInput(props: Readonly<NumberInputProps>, emitUpdate: (value: NumberInputValue) => void): {
+    control: import('../../composables/useControlState.js').ControlState;
+    rootClass: import('vue').ComputedRef<string[]>;
+    bounds: import('vue').ComputedRef<NumberInputBounds>;
+    nativeStep: import('vue').ComputedRef<number>;
+    nativeInputAttrs: import('vue').ComputedRef<InputHTMLAttributes>;
+    modelInputValue: import('vue').ComputedRef<string>;
+    leftControls: import('vue').ComputedRef<NumberInputControl[]>;
+    rightControls: import('vue').ComputedRef<NumberInputControl[]>;
+    canIncrement: import('vue').ComputedRef<boolean>;
+    canDecrement: import('vue').ComputedRef<boolean>;
+    increment: () => boolean;
+    decrement: () => boolean;
+    onInputUpdate: (value: string) => void;
+};
+export {};

package/dist/components/overlay/index.d.ts

@@ -1,2 +1,2 @@
-export { default as Overlay } from './overlay';
-export type { OverlayBlur, OverlayProps, OverlayZIndex } from './types';
+export { default as Overlay } from './overlay.js';
+export type { OverlayBlur, OverlayProps, OverlayZIndex } from './types.js';