ropav 0.0.8 → 0.0.9

package/dist/components/avatar/avatar.d.ts

@@ -0,0 +1,24 @@
+import { AvatarProps } from './types';
+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<AvatarProps & {
+        onLoad?: ((event: Event) => any) | undefined;
+        onError?: ((event: Event) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: ((evt: "load", event: Event) => void) & ((evt: "error", event: Event) => 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/avatar/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Avatar } from './avatar';
+export { avatarColors, avatarRadiuses, avatarSizes, avatarVariants } from './types';
+export type { AvatarColor, AvatarProps, AvatarRadius, AvatarSize, AvatarVariant } from './types';

package/dist/components/avatar/index.js

@@ -0,0 +1,2 @@
+import { a as avatar_default, i as avatarVariants, n as avatarRadiuses, r as avatarSizes, t as avatarColors } from "../../avatar.js";
+export { avatar_default as Avatar, avatarColors, avatarRadiuses, avatarSizes, avatarVariants };

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

@@ -0,0 +1,20 @@
+import { ComponentColorValue } from '../../utils/componentColors';
+export declare const avatarColors: readonly ["dark", "gray", "red", "pink", "grape", "violet", "indigo", "blue", "cyan", "teal", "green", "lime", "yellow", "orange"];
+export declare const avatarSizes: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const avatarRadiuses: readonly ["none", "xs", "sm", "md", "lg", "xl", "full"];
+export declare const avatarVariants: readonly ["solid", "subtle", "surface", "outline"];
+export type AvatarColor = ComponentColorValue;
+export type AvatarSize = (typeof avatarSizes)[number];
+export type AvatarRadius = (typeof avatarRadiuses)[number];
+export type AvatarVariant = (typeof avatarVariants)[number];
+export interface AvatarProps {
+    src?: string | null;
+    alt?: string;
+    ariaLabel?: string;
+    name?: string;
+    variant?: AvatarVariant;
+    color?: AvatarColor;
+    autoContrast?: boolean;
+    size?: AvatarSize;
+    radius?: AvatarRadius;
+}

package/dist/components/avatar/useAvatarColor.d.ts

@@ -0,0 +1,3 @@
+import { CSSProperties } from 'vue';
+import { AvatarColor, AvatarVariant } from './types';
+export declare function getAvatarColorStyle(color: AvatarColor | undefined, variant: AvatarVariant | undefined, autoContrast: boolean | undefined): CSSProperties | undefined;

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

@@ -1,5 +1,5 @@
 import { ComponentColorValue } from '../../utils/componentColors';
-export declare const badgeColors: readonly ["primary", "secondary", "success", "warning", "danger", "info", "neutral"];
+export declare const badgeColors: readonly ["dark", "gray", "red", "pink", "grape", "violet", "indigo", "blue", "cyan", "teal", "green", "lime", "yellow", "orange"];
 export declare const badgeSizes: readonly ["xs", "sm", "md", "lg", "xl"];
 export declare const badgeRadiuses: readonly ["none", "xs", "sm", "md", "lg", "xl", "full"];
 export declare const badgeVariants: readonly ["solid", "subtle", "surface", "outline"];
@@ -10,6 +10,7 @@ export type BadgeVariant = (typeof badgeVariants)[number];
 export interface BadgeProps {
     variant?: BadgeVariant;
     color?: BadgeColor;
+    autoContrast?: boolean;
     size?: BadgeSize;
     radius?: BadgeRadius;
     ariaLabel?: string;

package/dist/components/badge/useBadgeColor.d.ts

@@ -1,8 +1,3 @@
-import { BadgeColor } from './types';
-export declare function getBadgeColorStyle(color: BadgeColor | undefined): {
-    '--_rp-badge-custom-color': string & {};
-    '--_rp-badge-custom-fg': string & {};
-    '--_rp-badge-custom-on': string;
-    '--_rp-badge-custom-subtle-bg': string;
-    '--_rp-badge-custom-border': string;
-} | undefined;
+import { CSSProperties } from 'vue';
+import { BadgeColor, BadgeVariant } from './types';
+export declare function getBadgeColorStyle(color: BadgeColor | undefined, variant: BadgeVariant | undefined, autoContrast: boolean | undefined): CSSProperties | undefined;

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

@@ -6,6 +6,7 @@ export type ButtonVariant = 'solid' | 'subtle' | 'surface' | 'outline' | 'ghost'
 export interface ButtonProps {
     variant?: ButtonVariant;
     color?: ButtonColor;
+    autoContrast?: boolean;
     size?: ButtonSize;
     radius?: ButtonRadius;
     type?: 'button' | 'submit' | 'reset';

package/dist/components/button/useButtonColor.d.ts

@@ -1,13 +1,3 @@
-import { ButtonColor } from './types';
-export declare function getButtonColorStyle(color: ButtonColor | undefined): {
-    '--_rp-button-custom-color': string & {};
-    '--_rp-button-custom-hover': string;
-    '--_rp-button-custom-active': string;
-    '--_rp-button-custom-on': string;
-    '--_rp-button-custom-subtle-bg': string;
-    '--_rp-button-custom-subtle-bg-hover': string;
-    '--_rp-button-custom-subtle-bg-active': string;
-    '--_rp-button-custom-border': string;
-    '--_rp-button-custom-border-hover': string;
-    '--_rp-button-custom-fg': string & {};
-} | undefined;
+import { CSSProperties } from 'vue';
+import { ButtonColor, ButtonVariant } from './types';
+export declare function getButtonColorStyle(color: ButtonColor | undefined, variant: ButtonVariant | undefined, autoContrast: boolean | undefined): CSSProperties | undefined;

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

@@ -0,0 +1,27 @@
+import { ButtonLinkProps } from './types';
+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<ButtonLinkProps> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        loading?: (props: {}) => any;
+    } & {
+        left?: (props: {}) => any;
+    } & {
+        default?: (props: {}) => any;
+    } & {
+        right?: (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/button-link/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ButtonLink } from './button-link';
+export type { ButtonLinkColor, ButtonLinkProps, ButtonLinkRadius, ButtonLinkSize, ButtonLinkTarget, ButtonLinkVariant, } from './types';

package/dist/components/button-link/index.js

@@ -0,0 +1,2 @@
+import { t as button_link_default } from "../../button-link.js";
+export { button_link_default as ButtonLink };

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

@@ -0,0 +1,20 @@
+import { ButtonColor, ButtonRadius, ButtonSize, ButtonVariant } from '../button/types';
+export type ButtonLinkColor = ButtonColor;
+export type ButtonLinkSize = ButtonSize;
+export type ButtonLinkRadius = ButtonRadius;
+export type ButtonLinkVariant = ButtonVariant;
+export type ButtonLinkTarget = '_self' | '_blank' | '_parent' | '_top' | (string & {});
+export interface ButtonLinkProps {
+    href?: string;
+    target?: ButtonLinkTarget;
+    rel?: string;
+    download?: string | boolean;
+    hreflang?: string;
+    variant?: ButtonLinkVariant;
+    color?: ButtonLinkColor;
+    autoContrast?: boolean;
+    size?: ButtonLinkSize;
+    radius?: ButtonLinkRadius;
+    disabled?: boolean;
+    loading?: boolean;
+}

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

@@ -9,6 +9,7 @@ export interface CheckboxProps {
     modelValue: boolean;
     variant?: CheckboxVariant;
     color?: CheckboxColor;
+    autoContrast?: boolean;
     size?: CheckboxSize;
     radius?: CheckboxRadius;
     disabled?: boolean;

package/dist/components/checkbox/useCheckbox.d.ts

@@ -1,10 +1,8 @@
+import { CSSProperties } from 'vue';
 import { CheckboxProps } from './types';
 export declare function useCheckbox(props: Readonly<CheckboxProps>, emitUpdate: (value: boolean) => void): {
     control: import('../../composables/useControlState').ControlState;
     rootClass: import('vue').ComputedRef<string[]>;
-    rootStyle: import('vue').ComputedRef<{
-        '--_rp-checkbox-custom-color': string & {};
-        '--_rp-checkbox-custom-on-color': string;
-    } | undefined>;
+    rootStyle: import('vue').ComputedRef<CSSProperties | undefined>;
     onChange: (e: Event) => void;
 };

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

@@ -0,0 +1,29 @@
+import { ColorInputProps } from './types';
+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<ColorInputProps & {
+        "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        left?: (props: {
+            color: string | undefined;
+            empty: boolean;
+        }) => any;
+    } & {
+        'eye-dropper-icon'?: (props: {}) => any;
+    };
+    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "update:modelValue", value: string) => 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/color-input/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ColorInput } from './color-input';
+export type { ColorInputProps } from './types';

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

@@ -0,0 +1,2 @@
+import { t as color_input_default } from "../../color-input.js";
+export { color_input_default as ColorInput };

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

@@ -0,0 +1,34 @@
+import { InputHTMLAttributes } from 'vue';
+import { ColorPickerFormat, ColorPickerValue } from '../color-picker/types';
+import { InputRadius, InputSize } from '../input/types';
+import { PopoverPlacement } from '../popover/types';
+export interface ColorInputProps {
+    id?: string;
+    name?: string;
+    modelValue: ColorPickerValue;
+    format?: ColorPickerFormat;
+    size?: InputSize;
+    radius?: InputRadius;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    disallowInput?: boolean;
+    swatchesOnly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    valid?: boolean;
+    ariaLabel?: string;
+    describedby?: string;
+    labelledby?: string;
+    inputAttrs?: InputHTMLAttributes;
+    validateColor?: boolean;
+    invalidColorMessage?: string;
+    swatches?: string[];
+    swatchesPerRow?: number;
+    placement?: PopoverPlacement;
+    open?: boolean;
+    popoverId?: string;
+    pickerAriaLabel?: string;
+    withEyeDropper?: boolean;
+    eyeDropperAriaLabel?: string;
+}

package/dist/components/color-input/useColorInput.d.ts

@@ -0,0 +1,27 @@
+import { ColorPickerValue } from '../color-picker/types';
+import { ColorInputProps } from './types';
+interface UseColorInputEmitters {
+    modelValue: (value: ColorPickerValue) => void;
+    open: (value: boolean) => void;
+}
+export declare function useColorInput(props: Readonly<ColorInputProps>, emit: UseColorInputEmitters): {
+    onInputUpdate: (nextValue: ColorPickerValue) => void;
+    onPickerUpdate: (nextValue: ColorPickerValue) => void;
+    onOpenUpdate: (open: boolean) => void;
+    showEyeDropper: import('vue').ComputedRef<boolean>;
+    isPickingColor: import('vue').Ref<boolean, boolean>;
+    pickScreenColor: (closePicker: () => void) => Promise<void>;
+    getInputTriggerAttrs: (slotProps: unknown) => import('vue').InputHTMLAttributes;
+    rememberClose: (slotProps: import('../popover').PopoverSlotProps | import('../popover').PopoverContentSlotProps) => void;
+    onPickerKeydown: (event: KeyboardEvent, popover: import('../popover').PopoverContentSlotProps) => void;
+    onFocusOut: (event: FocusEvent) => void;
+    previewColor: import('vue').ComputedRef<string | undefined>;
+    hasValidSwatches: import('vue').ComputedRef<boolean>;
+    hasInvalidColor: import('vue').ComputedRef<boolean | undefined>;
+    isInvalid: import('vue').ComputedRef<boolean | undefined>;
+    colorValidationMessage: import('vue').ComputedRef<string | undefined>;
+    control: import('../../composables/useControlState').ControlState;
+    rootClass: import('vue').ComputedRef<string[]>;
+    popoverDisabled: import('vue').ComputedRef<boolean>;
+};
+export {};

package/dist/components/color-input/useColorInputEyeDropper.d.ts

@@ -0,0 +1,13 @@
+import { ColorPickerFormat, ColorPickerValue } from '../color-picker/types';
+interface UseColorInputEyeDropperOptions {
+    enabled: () => boolean;
+    disabled: () => boolean;
+    format: () => ColorPickerFormat;
+    update: (value: ColorPickerValue) => void;
+}
+export declare function useColorInputEyeDropper(options: UseColorInputEyeDropperOptions): {
+    showEyeDropper: import('vue').ComputedRef<boolean>;
+    isPickingColor: import('vue').Ref<boolean, boolean>;
+    pickScreenColor: (closePicker: () => void) => Promise<void>;
+};
+export {};

package/dist/components/color-input/useColorInputPopover.d.ts

@@ -0,0 +1,11 @@
+import { InputHTMLAttributes } from 'vue';
+import { PopoverContentSlotProps, PopoverSlotProps } from '../popover/types';
+import { ColorInputProps } from './types';
+declare function onPickerKeydown(event: KeyboardEvent, popover: PopoverContentSlotProps): void;
+export declare function useColorInputPopover(getInputAttrs: () => ColorInputProps['inputAttrs']): {
+    getInputTriggerAttrs: (slotProps: unknown) => InputHTMLAttributes;
+    rememberClose: (slotProps: PopoverSlotProps | PopoverContentSlotProps) => void;
+    onPickerKeydown: typeof onPickerKeydown;
+    onFocusOut: (event: FocusEvent) => void;
+};
+export {};

package/dist/components/color-input/useColorInputValue.d.ts

@@ -0,0 +1,8 @@
+import { ColorInputProps } from './types';
+export declare function useColorInputValue(props: Readonly<ColorInputProps>, isControlInvalid: () => boolean): {
+    previewColor: import('vue').ComputedRef<string | undefined>;
+    hasValidSwatches: import('vue').ComputedRef<boolean>;
+    hasInvalidColor: import('vue').ComputedRef<boolean | undefined>;
+    isInvalid: import('vue').ComputedRef<boolean | undefined>;
+    colorValidationMessage: import('vue').ComputedRef<string | undefined>;
+};

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

@@ -0,0 +1,21 @@
+import { ColorPickerSaturationProps, ColorPickerSelection } from './types';
+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<ColorPickerSaturationProps & {
+        "onUpdate:modelValue"?: ((value: ColorPickerSelection) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:modelValue", value: ColorPickerSelection) => 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/color-picker/color-picker-slider.d.ts

@@ -0,0 +1,21 @@
+import { ColorPickerSliderProps } from './types';
+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<ColorPickerSliderProps & {
+        "onUpdate:value"?: ((value: number) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (evt: "update:value", value: number) => 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/color-picker/color-picker-utils.d.ts

@@ -0,0 +1,23 @@
+import { ColorPickerFormat } from './types';
+export declare const DEFAULT_HUE = 0;
+export declare const HUE_MAX = 359;
+export declare const KEYBOARD_STEP = 1;
+export declare const KEYBOARD_LARGE_STEP = 10;
+export declare const DEFAULT_OPACITY = 100;
+export interface ColorPickerHsvColor {
+    hue: number;
+    saturation: number;
+    value: number;
+    opacity: number;
+}
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function clampPercent(value: number | undefined): number;
+export declare function normalizeHue(value: number | undefined): number;
+export declare function normalizeHueForColor(value: number | undefined): number;
+export declare function clampHue(value: number): number;
+export declare function clampOpacity(value: number | undefined): number;
+export declare function roundPercent(value: number): number;
+export declare function isColorPickerAlphaFormat(format: ColorPickerFormat): format is "hexa" | "rgba" | "hsla";
+export declare function parseColorPickerValue(value: string): ColorPickerHsvColor | undefined;
+export declare function formatColorPickerValue(color: ColorPickerHsvColor, format: ColorPickerFormat): string;
+export declare function getHsvCssColor(hue: number, saturation: number, value: number): string;

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

@@ -0,0 +1,23 @@
+import { ColorPickerProps } from './types';
+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<ColorPickerProps & {
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {}) => any;
+    };
+    emit: (evt: "update:modelValue", value: string) => 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/color-picker/index.d.ts

@@ -0,0 +1,3 @@
+export { default as ColorPicker } from './color-picker';
+export { colorPickerFormats, colorPickerSizes } from './types';
+export type { ColorPickerFormat, ColorPickerProps, ColorPickerSelection, ColorPickerSize, ColorPickerValue, } from './types';

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

@@ -0,0 +1,3 @@
+import { t as color_picker_default } from "../../color-picker.js";
+import { n as colorPickerSizes, t as colorPickerFormats } from "../../color-picker2.js";
+export { color_picker_default as ColorPicker, colorPickerFormats, colorPickerSizes };

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,11 @@
+import { Ref } from 'vue';
+interface UseColorPickerDragOptions {
+    target: Ref<HTMLElement | null>;
+    focusTarget?: Ref<HTMLElement | null>;
+    readonly: () => boolean;
+    updateFromPointer: (event: PointerEvent, target: HTMLElement) => void;
+}
+export declare function useColorPickerDrag({ target, focusTarget, readonly, 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';
+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';
+import { ColorPickerProps, ColorPickerSelection, ColorPickerValue } from './types';
+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';
+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';
+export type { ColorSwatchProps, ColorSwatchSize } from './types';

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.d.ts

@@ -1,8 +1,8 @@
 import { DropdownMenuItem, DropdownMenuItemSlotProps, DropdownMenuProps, DropdownMenuSlotProps } from './types';
 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/useDropdownMenu.d.ts

@@ -11,7 +11,7 @@ export declare function useDropdownMenu(props: Readonly<DropdownMenuProps>, emit
     visibleItems: import('vue').ComputedRef<DropdownMenuItem[]>;
     renderedItems: import('vue').ComputedRef<import('./types').DropdownMenuRenderedItem[]>;
     focusedIndex: import('vue').ComputedRef<number>;
-    focusedPath: import('vue').Ref<number[], import('./types').DropdownMenuItemPath | number[]>;
+    focusedPath: import('vue').Ref<number[], number[] | import('./types').DropdownMenuItemPath>;
     activeDescendantId: import('vue').ComputedRef<string | undefined>;
     rootClass: import('vue').ComputedRef<string[]>;
     contentClass: import('vue').ComputedRef<string[]>;

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

@@ -4,7 +4,7 @@ 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').DropdownMenuItemPath>;
     focusedIndex: import('vue').ComputedRef<number>;
     getItemsAtPath: (path: ItemPath) => DropdownMenuItem[];
     getItemAtPath: (path: ItemPath) => DropdownMenuItem | undefined;