reka-ui 0.0.0 → 0.0.2

package/dist/DropdownMenu/DropdownMenuRoot.d.ts

@@ -0,0 +1,67 @@
+import { Ref } from 'vue';
+import { Direction } from '../shared/types';
+import { MenuEmits, MenuProps } from '../Menu';
+
+export interface DropdownMenuRootProps extends MenuProps {
+    /** The open state of the dropdown menu when it is initially rendered. Use when you do not need to control its open state. */
+    defaultOpen?: boolean;
+}
+export type DropdownMenuRootEmits = MenuEmits;
+export interface DropdownMenuRootContext {
+    open: Readonly<Ref<boolean>>;
+    onOpenChange: (open: boolean) => void;
+    onOpenToggle: () => void;
+    triggerId: string;
+    triggerElement: Ref<HTMLElement | undefined>;
+    contentId: string;
+    modal: Ref<boolean>;
+    dir: Ref<Direction>;
+}
+export declare const injectDropdownMenuRootContext: <T extends DropdownMenuRootContext | null | undefined = DropdownMenuRootContext>(fallback?: T | undefined) => T extends null ? DropdownMenuRootContext | null : DropdownMenuRootContext, provideDropdownMenuRootContext: (contextValue: DropdownMenuRootContext) => DropdownMenuRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DropdownMenuRootProps>, {
+    modal: boolean;
+    open: undefined;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (payload: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DropdownMenuRootProps>, {
+    modal: boolean;
+    open: undefined;
+}>>> & {
+    "onUpdate:open"?: ((payload: boolean) => any) | undefined;
+}, {
+    open: boolean;
+    modal: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/DropdownMenu/DropdownMenuSeparator.d.ts

@@ -0,0 +1,22 @@
+import { MenuSeparatorProps } from '../Menu';
+
+export interface DropdownMenuSeparatorProps extends MenuSeparatorProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuSeparatorProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DropdownMenuSeparatorProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/DropdownMenu/DropdownMenuSub.d.ts

@@ -0,0 +1,51 @@
+import { MenuSubEmits, MenuSubProps } from '../Menu';
+
+export type DropdownMenuSubEmits = MenuSubEmits;
+export interface DropdownMenuSubProps extends MenuSubProps {
+    /** The open state of the dropdown menu when it is initially rendered. Use when you do not need to control its open state. */
+    defaultOpen?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DropdownMenuSubProps>, {
+    open: undefined;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:open": (payload: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DropdownMenuSubProps>, {
+    open: undefined;
+}>>> & {
+    "onUpdate:open"?: ((payload: boolean) => any) | undefined;
+}, {
+    open: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Current open state */
+        open: boolean;
+    }) => any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/DropdownMenu/DropdownMenuSubContent.d.ts

@@ -0,0 +1,39 @@
+import { MenuSubContentEmits, MenuSubContentProps } from '../Menu';
+
+export type DropdownMenuSubContentEmits = MenuSubContentEmits;
+export interface DropdownMenuSubContentProps extends MenuSubContentProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuSubContentProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => void;
+    pointerDownOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent) => void;
+    focusOutside: (event: import('../DismissableLayer').FocusOutsideEvent) => void;
+    interactOutside: (event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => void;
+    openAutoFocus: (event: Event) => void;
+    closeAutoFocus: (event: Event) => void;
+    entryFocus: (event: Event) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DropdownMenuSubContentProps>>> & {
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: import('../DismissableLayer').PointerDownOutsideEvent | import('../DismissableLayer').FocusOutsideEvent) => any) | undefined;
+    onOpenAutoFocus?: ((event: Event) => any) | undefined;
+    onCloseAutoFocus?: ((event: Event) => any) | undefined;
+    onEntryFocus?: ((event: Event) => any) | undefined;
+}, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/DropdownMenu/DropdownMenuSubTrigger.d.ts

@@ -0,0 +1,22 @@
+import { MenuSubTriggerProps } from '../Menu';
+
+export interface DropdownMenuSubTriggerProps extends MenuSubTriggerProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<DropdownMenuSubTriggerProps>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<DropdownMenuSubTriggerProps>>>, {}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/DropdownMenu/DropdownMenuTrigger.d.ts

@@ -0,0 +1,38 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface DropdownMenuTriggerProps extends PrimitiveProps {
+    /** When `true`, prevents the user from interacting with item */
+    disabled?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DropdownMenuTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<DropdownMenuTriggerProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/DropdownMenu/index.d.ts

@@ -0,0 +1,16 @@
+export { default as DropdownMenuRoot, type DropdownMenuRootProps, type DropdownMenuRootEmits, } from './DropdownMenuRoot';
+export { default as DropdownMenuTrigger, type DropdownMenuTriggerProps, } from './DropdownMenuTrigger';
+export { default as DropdownMenuPortal, type DropdownMenuPortalProps, } from './DropdownMenuPortal';
+export { default as DropdownMenuContent, type DropdownMenuContentProps, type DropdownMenuContentEmits, } from './DropdownMenuContent';
+export { default as DropdownMenuArrow, type DropdownMenuArrowProps, } from './DropdownMenuArrow';
+export { default as DropdownMenuItem, type DropdownMenuItemProps, type DropdownMenuItemEmits, } from './DropdownMenuItem';
+export { default as DropdownMenuGroup, type DropdownMenuGroupProps, } from './DropdownMenuGroup';
+export { default as DropdownMenuSeparator, type DropdownMenuSeparatorProps, } from './DropdownMenuSeparator';
+export { default as DropdownMenuCheckboxItem, type DropdownMenuCheckboxItemProps, type DropdownMenuCheckboxItemEmits, } from './DropdownMenuCheckboxItem';
+export { default as DropdownMenuItemIndicator, type DropdownMenuItemIndicatorProps, } from './DropdownMenuItemIndicator';
+export { default as DropdownMenuLabel, type DropdownMenuLabelProps, } from './DropdownMenuLabel';
+export { default as DropdownMenuRadioGroup, type DropdownMenuRadioGroupProps, type DropdownMenuRadioGroupEmits, } from './DropdownMenuRadioGroup';
+export { default as DropdownMenuRadioItem, type DropdownMenuRadioItemProps, type DropdownMenuRadioItemEmits, } from './DropdownMenuRadioItem';
+export { default as DropdownMenuSub, type DropdownMenuSubProps, type DropdownMenuSubEmits, } from './DropdownMenuSub';
+export { default as DropdownMenuSubContent, type DropdownMenuSubContentProps, type DropdownMenuSubContentEmits, } from './DropdownMenuSubContent';
+export { default as DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, } from './DropdownMenuSubTrigger';

package/dist/Editable/EditableArea.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface EditableAreaProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableAreaProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableAreaProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Editable/EditableCancelTrigger.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface EditableCancelTriggerProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableCancelTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableCancelTriggerProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Editable/EditableEditTrigger.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface EditableEditTriggerProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableEditTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableEditTriggerProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Editable/EditableInput.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface EditableInputProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableInputProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableInputProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Editable/EditablePreview.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface EditablePreviewProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditablePreviewProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditablePreviewProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Editable/EditableRoot.d.ts

@@ -0,0 +1,172 @@
+import { Ref } from 'vue';
+import { PrimitiveProps } from '../Primitive';
+import { Direction } from '../shared/types';
+
+type ActivationMode = 'focus' | 'dblclick' | 'none';
+type SubmitMode = 'blur' | 'enter' | 'none' | 'both';
+type EditableRootContext = {
+    id: Ref<string | undefined>;
+    name: Ref<string | undefined>;
+    maxLength: Ref<number | undefined>;
+    disabled: Ref<boolean>;
+    modelValue: Ref<string | undefined>;
+    placeholder: Ref<{
+        edit: string;
+        preview: string;
+    }>;
+    isEditing: Ref<boolean>;
+    submitMode: Ref<SubmitMode>;
+    activationMode: Ref<ActivationMode>;
+    selectOnFocus: Ref<boolean>;
+    edit: () => void;
+    cancel: () => void;
+    submit: () => void;
+    inputRef: Ref<HTMLInputElement | undefined>;
+    startWithEditMode: Ref<boolean>;
+    isEmpty: Ref<boolean>;
+    readonly: Ref<boolean>;
+    autoResize: Ref<boolean>;
+};
+export interface EditableRootProps extends PrimitiveProps {
+    /** The default value of the editable field */
+    defaultValue?: string;
+    /** The value of the editable field */
+    modelValue?: string;
+    /** The placeholder for the editable field */
+    placeholder?: string | {
+        edit: string;
+        preview: string;
+    };
+    /** The reading direction of the calendar when applicable. <br> If omitted, inherits globally from `ConfigProvider` or assumes LTR (left-to-right) reading mode. */
+    dir?: Direction;
+    /** Whether the editable field is disabled */
+    disabled?: boolean;
+    /** Whether the editable field is read-only */
+    readonly?: boolean;
+    /** The activation event of the editable field */
+    activationMode?: ActivationMode;
+    /** Whether to select the text in the input when it is focused. */
+    selectOnFocus?: boolean;
+    /** The submit event of the editable field */
+    submitMode?: SubmitMode;
+    /** Whether to start with the edit mode active */
+    startWithEditMode?: boolean;
+    /** The maximum number of characters allowed */
+    maxLength?: number;
+    /** Whether the editable field should auto resize */
+    autoResize?: boolean;
+    /** The id of the field */
+    id?: string;
+    /** The name of the field */
+    name?: string;
+    /** When `true`, indicates that the user must set the value before the owning form can be submitted. */
+    required?: boolean;
+}
+export type EditableRootEmits = {
+    /** Event handler called whenever the model value changes */
+    'update:modelValue': [value: string];
+    /** Event handler called when a value is submitted */
+    'submit': [value: string | undefined];
+    /** Event handler called when the editable field changes state */
+    'update:state': [state: 'edit' | 'submit' | 'cancel'];
+};
+export declare const injectEditableRootContext: <T extends EditableRootContext | null | undefined = EditableRootContext>(fallback?: T | undefined) => T extends null ? EditableRootContext | null : EditableRootContext, provideEditableRootContext: (contextValue: EditableRootContext) => EditableRootContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableRootProps>, {
+    as: string;
+    disabled: boolean;
+    submitMode: string;
+    activationMode: string;
+    selectOnFocus: boolean;
+    placeholder: string;
+    autoResize: boolean;
+    required: boolean;
+}>, {
+    /** Function to submit the value of the editable */
+    submit: () => void;
+    /** Function to cancel the value of the editable */
+    cancel: () => void;
+    /** Function to set the editable in edit mode */
+    edit: () => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    submit: (value: string | undefined) => void;
+    "update:modelValue": (value: string) => void;
+    "update:state": (state: "cancel" | "submit" | "edit") => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableRootProps>, {
+    as: string;
+    disabled: boolean;
+    submitMode: string;
+    activationMode: string;
+    selectOnFocus: boolean;
+    placeholder: string;
+    autoResize: boolean;
+    required: boolean;
+}>>> & {
+    onSubmit?: ((value: string | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    "onUpdate:state"?: ((state: "cancel" | "submit" | "edit") => any) | undefined;
+}, {
+    disabled: boolean;
+    as: import('../Primitive').AsTag | import('vue').Component;
+    required: boolean;
+    placeholder: string | {
+        edit: string;
+        preview: string;
+    };
+    activationMode: ActivationMode;
+    selectOnFocus: boolean;
+    submitMode: SubmitMode;
+    autoResize: boolean;
+}, {}>, Readonly<{
+    default: (props: {
+        /** Whether the editable field is in edit mode */
+        isEditing: boolean;
+        /** The value of the editable field */
+        modelValue: string | undefined;
+        /** Whether the editable field is empty */
+        isEmpty: boolean;
+        /** Function to submit the value of the editable */
+        submit: () => void;
+        /** Function to cancel the value of the editable */
+        cancel: () => void;
+        /** Function to set the editable in edit mode */
+        edit: () => void;
+    }) => any;
+}> & {
+    default: (props: {
+        /** Whether the editable field is in edit mode */
+        isEditing: boolean;
+        /** The value of the editable field */
+        modelValue: string | undefined;
+        /** Whether the editable field is empty */
+        isEmpty: boolean;
+        /** Function to submit the value of the editable */
+        submit: () => void;
+        /** Function to cancel the value of the editable */
+        cancel: () => void;
+        /** Function to set the editable in edit mode */
+        edit: () => void;
+    }) => any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Editable/EditableSubmitTrigger.d.ts

@@ -0,0 +1,36 @@
+import { PrimitiveProps } from '../Primitive';
+
+export interface EditableSubmitTriggerProps extends PrimitiveProps {
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableSubmitTriggerProps>, {
+    as: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<EditableSubmitTriggerProps>, {
+    as: string;
+}>>>, {
+    as: import('../Primitive').AsTag | import('vue').Component;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Editable/index.d.ts

@@ -0,0 +1,7 @@
+export { default as EditableRoot, type EditableRootProps, type EditableRootEmits, } from './EditableRoot';
+export { default as EditableArea, type EditableAreaProps, } from './EditableArea';
+export { default as EditableInput, type EditableInputProps, } from './EditableInput';
+export { default as EditablePreview, type EditablePreviewProps, } from './EditablePreview';
+export { default as EditableSubmitTrigger, type EditableSubmitTriggerProps, } from './EditableSubmitTrigger';
+export { default as EditableCancelTrigger, type EditableCancelTriggerProps, } from './EditableCancelTrigger';
+export { default as EditableEditTrigger, type EditableEditTriggerProps, } from './EditableEditTrigger';

package/dist/FocusGuards/index.d.ts

@@ -0,0 +1 @@
+export { default as FocusGuards } from './FocusGuards';