yuyeon 0.3.4-beta.12 → 0.3.4-beta.14

package/types/src/composables/coordinate/levitation.d.ts

@@ -0,0 +1,7 @@
+import { CSSProperties, Ref } from 'vue';
+import { Rect } from '../../util/rect';
+import { CoordinateState } from './types';
+
+export declare function applyLevitation(props: any, state: CoordinateState, coordinate: Ref<Rect | undefined>, coordinateStyles: Ref<CSSProperties>): {
+    updateCoordinate: () => any;
+};

package/types/src/composables/coordinate/types.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+
+export interface CoordinateState {
+    contentEl: Ref<HTMLElement | undefined>;
+    base: Ref<HTMLElement | [x: number, y: number] | undefined>;
+    active: Ref<boolean>;
+}

package/types/src/composables/coordinate/utils/point.d.ts

@@ -0,0 +1,22 @@
+import { ParsedAnchor } from '../../../util/anchor';
+import { MutableRect } from '../../../util/rect';
+
+type Point = {
+    x: number;
+    y: number;
+};
+declare class As<T extends string> {
+    private as;
+}
+type ElementPoint = Point & As<'element'>;
+type ViewportPoint = Point & As<'viewport'>;
+type Offset = Point & As<'offset'>;
+/** Convert a point in local space to viewport space */
+export declare function elementToViewport(point: ElementPoint, offset: Offset | MutableRect): ViewportPoint;
+/** Convert a point in viewport space to local space */
+export declare function viewportToElement(point: ViewportPoint, offset: Offset | MutableRect): ElementPoint;
+/** Get the difference between two points */
+export declare function getOffset<T extends Point>(a: T, b: T): Offset;
+/** Convert an anchor object to a point in local space */
+export declare function anchorToPoint(anchor: ParsedAnchor, box: MutableRect): ViewportPoint;
+export {};

package/types/src/composables/date/factory.d.ts

@@ -0,0 +1,3 @@
+import { LocaleModule } from '../../i18n/types';
+
+export declare function constructAdapter(options: any, locale: LocaleModule): any;

package/types/src/composables/date/index.d.ts

@@ -0,0 +1,12 @@
+import { LocaleModule } from '../../i18n/types';
+import { DateInstance, DateOptions } from './types';
+
+export declare const YUYEON_DATE_KEY: unique symbol;
+export declare const YUYEON_DATE_OPTIONS_KEY: unique symbol;
+export declare function createDateModule(options: DateOptions, locale: LocaleModule): {
+    options: {
+        [x: string]: any;
+    };
+    instance: any;
+};
+export declare function useDate(): DateInstance;

package/types/src/composables/date/setting.d.ts

@@ -0,0 +1,5 @@
+import { DateOptions } from './types';
+
+export declare function configureOptions(options?: DateOptions): {
+    [x: string]: any;
+};

package/types/src/composables/date/types.d.ts

@@ -0,0 +1,13 @@
+import { DateAdapter } from '../../util/date/types';
+
+export interface DateOptions {
+    adapter: any;
+    locale: Record<string, any>;
+    formats?: Record<string, any>;
+}
+export interface DateInstanceType {
+    instanceType: unknown;
+}
+export interface DateInstance<T = DateInstanceType['instanceType']> extends DateAdapter<T> {
+    locale?: any;
+}

package/types/src/composables/defaults/index.d.ts

@@ -0,0 +1,11 @@
+import { MaybeRef } from 'vue';
+import { DefaultsModuleInstance, ProvideDefaultsOptions } from './types';
+
+export declare function createDefaultsModule(options?: DefaultsModuleInstance): import('vue').Ref<DefaultsModuleInstance, DefaultsModuleInstance>;
+export declare function useDefaultsModule(): import('vue').Ref<DefaultsModuleInstance, DefaultsModuleInstance>;
+export declare function provideDefaults(defaults?: MaybeRef<DefaultsModuleInstance | undefined>, options?: ProvideDefaultsOptions): import('vue').ComputedRef<DefaultsModuleInstance>;
+export declare function useSuperDefaults(props?: Record<string, any>, name?: string, defaults?: import('vue').Ref<DefaultsModuleInstance, DefaultsModuleInstance>): {
+    props: Record<string, any>;
+    provideSubDefaults: () => void;
+};
+export declare function useDefaults(props: undefined, name: string): Record<string, any>;

package/types/src/composables/defaults/share.d.ts

@@ -0,0 +1,4 @@
+import { InjectionKey, Ref } from 'vue';
+import { DefaultsModuleInstance } from './types';
+
+export declare const YUYEON_DEFAULTS_KEY: InjectionKey<Ref<DefaultsModuleInstance>>;

package/types/src/composables/defaults/types.d.ts

@@ -0,0 +1,12 @@
+import { MaybeRef } from 'vue';
+
+export type DefaultsModuleInstance = undefined | {
+    [key: string]: any;
+};
+export type DefaultsOptions = Partial<DefaultsModuleInstance>;
+export type ProvideDefaultsOptions = {
+    disabled?: MaybeRef<boolean | undefined>;
+    reset?: MaybeRef<number | string | undefined>;
+    root?: MaybeRef<boolean | string | undefined>;
+    scoped?: MaybeRef<boolean | undefined>;
+};

package/types/src/composables/dimension.d.ts

@@ -0,0 +1,54 @@
+import { ExtractPropTypes, PropType } from 'vue';
+
+declare const dimensionPropsOptions: {
+    minWidth: PropType<number | string>;
+    width: PropType<number | string>;
+    maxWidth: PropType<number | string>;
+    minHeight: PropType<number | string>;
+    height: PropType<number | string>;
+    maxHeight: PropType<number | string>;
+};
+export declare const pressDimensionPropsOptions: <Defaults extends {
+    minWidth?: unknown;
+    width?: unknown;
+    maxWidth?: unknown;
+    minHeight?: unknown;
+    height?: unknown;
+    maxHeight?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    minWidth: unknown extends Defaults["minWidth"] ? PropType<string | number> : {
+        type: PropType<unknown extends Defaults["minWidth"] ? string | number : NonNullable<string | number> | Defaults["minWidth"]>;
+        default: unknown extends Defaults["minWidth"] ? string | number : NonNullable<string | number> | Defaults["minWidth"];
+    };
+    width: unknown extends Defaults["width"] ? PropType<string | number> : {
+        type: PropType<unknown extends Defaults["width"] ? string | number : NonNullable<string | number> | Defaults["width"]>;
+        default: unknown extends Defaults["width"] ? string | number : NonNullable<string | number> | Defaults["width"];
+    };
+    maxWidth: unknown extends Defaults["maxWidth"] ? PropType<string | number> : {
+        type: PropType<unknown extends Defaults["maxWidth"] ? string | number : NonNullable<string | number> | Defaults["maxWidth"]>;
+        default: unknown extends Defaults["maxWidth"] ? string | number : NonNullable<string | number> | Defaults["maxWidth"];
+    };
+    minHeight: unknown extends Defaults["minHeight"] ? PropType<string | number> : {
+        type: PropType<unknown extends Defaults["minHeight"] ? string | number : NonNullable<string | number> | Defaults["minHeight"]>;
+        default: unknown extends Defaults["minHeight"] ? string | number : NonNullable<string | number> | Defaults["minHeight"];
+    };
+    height: unknown extends Defaults["height"] ? PropType<string | number> : {
+        type: PropType<unknown extends Defaults["height"] ? string | number : NonNullable<string | number> | Defaults["height"]>;
+        default: unknown extends Defaults["height"] ? string | number : NonNullable<string | number> | Defaults["height"];
+    };
+    maxHeight: unknown extends Defaults["maxHeight"] ? PropType<string | number> : {
+        type: PropType<unknown extends Defaults["maxHeight"] ? string | number : NonNullable<string | number> | Defaults["maxHeight"]>;
+        default: unknown extends Defaults["maxHeight"] ? string | number : NonNullable<string | number> | Defaults["maxHeight"];
+    };
+};
+export declare function useDimension(props: ExtractPropTypes<typeof dimensionPropsOptions>): {
+    dimensionStyles: import('vue').ComputedRef<{
+        minWidth: string | undefined;
+        width: string | undefined;
+        maxWidth: string | undefined;
+        minHeight: string | undefined;
+        height: string | undefined;
+        maxHeight: string | undefined;
+    }>;
+};
+export {};

package/types/src/composables/focus.d.ts

@@ -0,0 +1,30 @@
+import { ExtractPropTypes, PropType } from 'vue';
+
+declare const focusPropsOptions: {
+    focused: BooleanConstructor;
+    'onUpdate:focused': PropType<(v: boolean) => void>;
+};
+export declare const pressFocusPropsOptions: <Defaults extends {
+    focused?: unknown;
+    'onUpdate:focused'?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    focused: unknown extends Defaults["focused"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["focused"] ? boolean : boolean | Defaults["focused"]>;
+        default: unknown extends Defaults["focused"] ? boolean : boolean | Defaults["focused"];
+    };
+    'onUpdate:focused': unknown extends Defaults["onUpdate:focused"] ? PropType<(v: boolean) => void> : {
+        type: PropType<unknown extends Defaults["onUpdate:focused"] ? (v: boolean) => void : ((v: boolean) => void) | Defaults["onUpdate:focused"]>;
+        default: unknown extends Defaults["onUpdate:focused"] ? (v: boolean) => void : ((v: boolean) => void) | Defaults["onUpdate:focused"];
+    };
+};
+export declare function useFocus(props: ExtractPropTypes<typeof focusPropsOptions>, className: string): {
+    focused: import('vue').Ref<any, any> & {
+        readonly rxValue: any;
+    };
+    whenFocus: () => void;
+    whenBlur: () => void;
+    focusedClasses: import('vue').ComputedRef<{
+        [x: string]: any;
+    }>;
+};
+export {};

package/types/src/composables/form.d.ts

@@ -0,0 +1,132 @@
+import { ComputedRef, InjectionKey, PropType, Ref, VNode } from 'vue';
+import { EventProp } from '../util/component';
+import { ValidationProps } from './validation';
+
+export interface FormInput {
+    id: number | string;
+    vnode: VNode;
+    validate: () => Promise<any[]>;
+    isError: boolean | undefined | null;
+    errors: any[];
+}
+export interface InputValidationResult {
+    id: number | string;
+    vnode: VNode;
+    exposed: any;
+    errors: any[];
+}
+export interface FormValidationResult {
+    valid: boolean;
+    errors: InputValidationResult[];
+}
+export interface SubmitEventPromise extends SubmitEvent, Promise<FormValidationResult> {
+}
+export interface FormInstance {
+    register: (input: {
+        id: number | string;
+        vnode: VNode;
+        validate: () => Promise<any[]>;
+        resetValidation: () => Promise<void>;
+    }) => void;
+    unregister: (id: number | string) => void;
+    update: (id: number | string, isError: boolean | undefined | null, errors: any[]) => void;
+    inputs: Ref<FormInput[]>;
+    isDisabled: ComputedRef<boolean>;
+    isReadonly: ComputedRef<boolean>;
+    isLoading: ComputedRef<boolean>;
+    isValidating: Ref<boolean>;
+    isValid: Ref<boolean | null>;
+    validateOn: Ref<FormProps["validateOn"]>;
+}
+export declare const YUYEON_FORM_KEY: InjectionKey<FormInstance>;
+export interface FormProps {
+    readonly: boolean;
+    disabled: boolean;
+    loading: boolean;
+    modelValue: boolean | null;
+    "onUpdate:modelValue": EventProp<[boolean | null]> | undefined;
+    validateOn: ValidationProps["validateOn"];
+}
+export declare const pressFormPropsOptions: <Defaults extends {
+    readonly?: unknown;
+    disabled?: unknown;
+    loading?: unknown;
+    modelValue?: unknown;
+    validateOn?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    readonly: unknown extends Defaults["readonly"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["readonly"] ? boolean : boolean | Defaults["readonly"]>;
+        default: unknown extends Defaults["readonly"] ? boolean : boolean | Defaults["readonly"];
+    };
+    disabled: unknown extends Defaults["disabled"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["disabled"] ? boolean : boolean | Defaults["disabled"]>;
+        default: unknown extends Defaults["disabled"] ? boolean : boolean | Defaults["disabled"];
+    };
+    loading: unknown extends Defaults["loading"] ? BooleanConstructor : {
+        type: PropType<unknown extends Defaults["loading"] ? boolean : boolean | Defaults["loading"]>;
+        default: unknown extends Defaults["loading"] ? boolean : boolean | Defaults["loading"];
+    };
+    modelValue: unknown extends Defaults["modelValue"] ? {
+        type: PropType<boolean | null>;
+        default: null;
+    } : Omit<{
+        type: PropType<boolean | null>;
+        default: null;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["modelValue"] ? boolean | null : Defaults["modelValue"] | NonNullable<boolean | null>>;
+        default: unknown extends Defaults["modelValue"] ? boolean | null : Defaults["modelValue"] | NonNullable<boolean | null>;
+    };
+    validateOn: unknown extends Defaults["validateOn"] ? {
+        type: PropType<ValidationProps["validateOn"]>;
+        default: string;
+    } : Omit<{
+        type: PropType<ValidationProps["validateOn"]>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["validateOn"] ? string : string | Defaults["validateOn"]>;
+        default: unknown extends Defaults["validateOn"] ? string : string | Defaults["validateOn"];
+    };
+};
+export declare function createForm(props: FormProps): {
+    inputs: Ref<{
+        id: number | string;
+        vnode: VNode;
+        validate: () => Promise<any[]>;
+        isError: boolean | undefined | null;
+        errors: any[];
+    }[], FormInput[] | {
+        id: number | string;
+        vnode: VNode;
+        validate: () => Promise<any[]>;
+        isError: boolean | undefined | null;
+        errors: any[];
+    }[]>;
+    errors: Ref<{
+        id: number | string;
+        vnode: VNode;
+        exposed: any;
+        errors: any[];
+    }[], InputValidationResult[] | {
+        id: number | string;
+        vnode: VNode;
+        exposed: any;
+        errors: any[];
+    }[]>;
+    isValid: Ref<any, any> & {
+        readonly rxValue: any;
+    };
+    isDisabled: ComputedRef<boolean>;
+    isReadonly: ComputedRef<boolean>;
+    isLoading: ComputedRef<boolean>;
+    isValidating: import('vue').ShallowRef<boolean, boolean>;
+    validate: () => Promise<{
+        valid: boolean;
+        errors: {
+            id: number | string;
+            vnode: VNode;
+            exposed: any;
+            errors: any[];
+        }[];
+    }>;
+};
+export declare function useForm(): FormInstance | null;

package/types/src/composables/i18n/index.d.ts

@@ -0,0 +1,9 @@
+import { LocaleModule, LocaleOptions } from '../../i18n/types';
+import { RtlModule, RtlOptions, RtlProps } from './rtl';
+
+export declare function createI18nModule(options?: LocaleOptions & RtlOptions): {
+    localeModule: LocaleModule;
+    rtlModule: RtlModule;
+};
+export declare function useI18n(): LocaleModule & RtlModule;
+export declare function provideI18n(props: LocaleOptions & RtlProps): any;

package/types/src/composables/i18n/locale.d.ts

@@ -0,0 +1,3 @@
+import { LocaleOptions } from '../../i18n/types';
+
+export declare function createLocaleModule(options?: LocaleOptions): import('../../i18n/types').LocaleModule;

package/types/src/composables/i18n/rtl.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+import { LocaleModule } from '../../i18n/types';
+
+export declare const YUYEON_RTL_KEY: unique symbol;
+export interface RtlOptions {
+    rtlOptions: Record<string, boolean>;
+}
+export interface RtlProps {
+    rtl?: boolean;
+}
+export interface RtlModule {
+    rtl: Ref<boolean>;
+    rtlOptions: Ref<Record<string, boolean>>;
+    rtlClasses: Ref<string>;
+}
+export declare function createRtlModule(localeModule: LocaleModule, options?: RtlOptions): RtlModule;
+export declare function createRtlProvideValue(localeModule: LocaleModule, rtlOptions: RtlModule['rtlOptions'], props: RtlProps): RtlModule;
+export declare function useRtl(): {
+    rtl: any;
+    rtlClasses: any;
+};

package/types/src/composables/i18n/share.d.ts

@@ -0,0 +1 @@
+export declare const YUYEON_I18N_KEY: unique symbol;

package/types/src/composables/icon.d.ts

@@ -0,0 +1,79 @@
+import { HTMLAttributes, InjectionKey, PropType, Ref, SVGAttributes } from 'vue';
+import { JSXComponent } from '../types';
+
+type IconComponent = JSXComponent<IconProps> | JSXComponent<SVGAttributes | HTMLAttributes>;
+export type IconValue = string | (string | [path: string, opacity: number])[] | IconComponent | {
+    component: JSXComponent;
+    props?: any;
+} | {
+    alias: string;
+    iconProps?: any;
+};
+export declare const IconPropOption: PropType<IconValue>;
+type IconProps = {
+    tag: string;
+    icon?: IconValue;
+    disabled?: Boolean;
+};
+export interface IconSet {
+    component: IconComponent;
+}
+export declare const IconValue: PropType<IconValue>;
+export type IconModuleOptions = {
+    defaultSet?: string;
+    sets?: Record<string, IconSet>;
+    aliases?: Partial<Record<string, any>>;
+};
+export declare const pressIconPropsOptions: <Defaults extends {
+    icon?: unknown;
+    tag?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    icon: unknown extends Defaults["icon"] ? {
+        type: PropType<IconValue>;
+    } : Omit<{
+        type: PropType<IconValue>;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["icon"] ? IconValue : Defaults["icon"] | NonNullable<IconValue>>;
+        default: unknown extends Defaults["icon"] ? IconValue : Defaults["icon"] | NonNullable<IconValue>;
+    };
+    tag: unknown extends Defaults["tag"] ? {
+        type: StringConstructor;
+        required: true;
+    } : Omit<{
+        type: StringConstructor;
+        required: true;
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["tag"] ? string : string | Defaults["tag"]>;
+        default: unknown extends Defaults["tag"] ? string : string | Defaults["tag"];
+    };
+};
+export declare const YComponentIcon: import('vue').DefineComponent<{
+    icon: {
+        type: PropType<IconValue>;
+    };
+    tag: {
+        type: StringConstructor;
+        required: true;
+    };
+}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string>;
+export type YComponentIcon = InstanceType<typeof YComponentIcon>;
+export declare const YSvgIcon: import('vue').DefineComponent<{
+    icon: {
+        type: PropType<IconValue>;
+    };
+    tag: {
+        type: StringConstructor;
+        required: true;
+    };
+}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string>;
+export type YSvgIcon = InstanceType<typeof YSvgIcon>;
+export declare const YUYEON_ICON_KEY: InjectionKey<Required<IconModuleOptions>>;
+export declare function createIconModule(options?: IconModuleOptions): Required<IconModuleOptions>;
+type IconInstance = {
+    component: IconComponent;
+    icon?: IconValue;
+};
+export declare function useIcon(iconProp: Ref<IconValue | undefined>): {
+    iconData: import('vue').ComputedRef<IconInstance>;
+};
+export {};

package/types/src/composables/index.d.ts

@@ -0,0 +1,10 @@
+export * from './communication';
+export * from './date';
+export * from './resize-observer';
+export * from './component';
+export * from './focus';
+export * from './scope';
+export * from './timing';
+export * from './transition';
+export * from './vue-router';
+export * from './theme';

package/types/src/composables/layer-group.d.ts

@@ -0,0 +1,10 @@
+import { MaybeRef, ComponentInternalInstance } from 'vue';
+
+export declare const Y_LAYER_GROUP_CLASS_NAME = "y-layer-group";
+export declare function useLayerGroup(props: {
+    layerGroup?: MaybeRef<string | Element | undefined>;
+}): {
+    layerGroup: import('vue').ComputedRef<HTMLElement>;
+    layerGroupState: WeakMap<HTMLElement, Set<any>>;
+    getActiveLayers: () => ComponentInternalInstance[];
+};

package/types/src/composables/layout.d.ts

@@ -0,0 +1,10 @@
+import { InjectionKey } from 'vue';
+
+declare function register(): void;
+interface LayoutProvide {
+    register: typeof register;
+    unregister: (id: string) => void;
+}
+export declare const YUYEON_LAYOUT_KEY: InjectionKey<LayoutProvide>;
+export declare function initLayoutSystem(): void;
+export {};

package/types/src/composables/list-items.d.ts

@@ -0,0 +1,113 @@
+import { ExtractPropTypes } from 'vue';
+
+export interface ListItem<T = any> {
+    value: any;
+    text: string;
+    hide: boolean;
+    disabled: boolean;
+    props: {
+        [key: string]: any;
+        value: any;
+        text: string;
+    };
+    children?: ListItem<T>[];
+    raw: T;
+}
+declare const listItemsPropsOptions: {
+    returnItem: BooleanConstructor;
+    items: {
+        type: import('vue').PropType<any[]>;
+        default: () => never[];
+    };
+    itemKey: Omit<{
+        type: import('vue').PropType<string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    itemText: {
+        type: import('vue').PropType<string>;
+        default: string;
+    };
+    itemChildren: Omit<{
+        type: import('vue').PropType<boolean | string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import('vue').PropType<NonNullable<string | boolean>>;
+        default: NonNullable<string | boolean>;
+    };
+};
+type ListItemProps = ExtractPropTypes<typeof listItemsPropsOptions>;
+export declare const pressListItemsPropsOptions: <Defaults extends {
+    returnItem?: unknown;
+    items?: unknown;
+    itemKey?: unknown;
+    itemText?: unknown;
+    itemChildren?: unknown;
+} = {}>(defaults?: Defaults | undefined) => {
+    returnItem: unknown extends Defaults["returnItem"] ? BooleanConstructor : {
+        type: import('vue').PropType<unknown extends Defaults["returnItem"] ? boolean : boolean | Defaults["returnItem"]>;
+        default: unknown extends Defaults["returnItem"] ? boolean : boolean | Defaults["returnItem"];
+    };
+    items: unknown extends Defaults["items"] ? {
+        type: import('vue').PropType<any[]>;
+        default: () => never[];
+    } : Omit<{
+        type: import('vue').PropType<any[]>;
+        default: () => never[];
+    }, "type" | "default"> & {
+        type: import('vue').PropType<unknown extends Defaults["items"] ? any[] : any[] | Defaults["items"]>;
+        default: unknown extends Defaults["items"] ? any[] : any[] | Defaults["items"];
+    };
+    itemKey: unknown extends Defaults["itemKey"] ? Omit<{
+        type: import('vue').PropType<string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import('vue').PropType<string>;
+        default: string;
+    } : Omit<Omit<{
+        type: import('vue').PropType<string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import('vue').PropType<string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import('vue').PropType<unknown extends Defaults["itemKey"] ? string : string | Defaults["itemKey"]>;
+        default: unknown extends Defaults["itemKey"] ? string : string | Defaults["itemKey"];
+    };
+    itemText: unknown extends Defaults["itemText"] ? {
+        type: import('vue').PropType<string>;
+        default: string;
+    } : Omit<{
+        type: import('vue').PropType<string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import('vue').PropType<unknown extends Defaults["itemText"] ? string : string | Defaults["itemText"]>;
+        default: unknown extends Defaults["itemText"] ? string : string | Defaults["itemText"];
+    };
+    itemChildren: unknown extends Defaults["itemChildren"] ? Omit<{
+        type: import('vue').PropType<boolean | string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import('vue').PropType<NonNullable<string | boolean>>;
+        default: NonNullable<string | boolean>;
+    } : Omit<Omit<{
+        type: import('vue').PropType<boolean | string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import('vue').PropType<NonNullable<string | boolean>>;
+        default: NonNullable<string | boolean>;
+    }, "type" | "default"> & {
+        type: import('vue').PropType<unknown extends Defaults["itemChildren"] ? NonNullable<string | boolean> : Defaults["itemChildren"] | NonNullable<NonNullable<string | boolean>>>;
+        default: unknown extends Defaults["itemChildren"] ? NonNullable<string | boolean> : Defaults["itemChildren"] | NonNullable<NonNullable<string | boolean>>;
+    };
+};
+export declare function refineListItems(props: Omit<ListItemProps, 'items'>, items: any[]): ListItem<any>[];
+export declare function refineListItem(props: Omit<ListItemProps, 'items'>, item: any): ListItem;
+export declare function useItems(props: ListItemProps): {
+    items: import('vue').ComputedRef<ListItem<any>[]>;
+    toEmitItems: (items: any[]) => any[];
+    toRefineItems: (values: any[]) => ListItem<any>[];
+};
+export {};

package/types/src/composables/progress.d.ts

@@ -0,0 +1,4 @@
+export declare function useProgress(props: any): {
+    numValue: import('vue').ComputedRef<number>;
+    delta: import('vue').ShallowRef<number, number>;
+};

package/types/src/composables/ref.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+
+export declare function useRefs<T extends {}>(): {
+    refs: Ref<(T | undefined)[], (T | undefined)[]>;
+    updateRef: (e: any, i: number) => void;
+};

package/types/src/composables/resize-observer.d.ts

@@ -0,0 +1,24 @@
+export declare function useResizeObserver(callback?: ResizeObserverCallback): {
+    resizeObservedRef: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    contentRect: Readonly<import('vue').Ref<{
+        readonly bottom: number;
+        readonly height: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        readonly width: number;
+        readonly x: number;
+        readonly y: number;
+        readonly toJSON: () => any;
+    } | undefined, {
+        readonly bottom: number;
+        readonly height: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        readonly width: number;
+        readonly x: number;
+        readonly y: number;
+        readonly toJSON: () => any;
+    } | undefined>>;
+};

package/types/src/composables/scope.d.ts

@@ -0,0 +1,3 @@
+import { WatchSource } from 'vue';
+
+export declare function useToggleScope(source: WatchSource<boolean>, fn: (reset: () => void) => void): void;

package/types/src/composables/style-color.d.ts

@@ -0,0 +1,14 @@
+import { ExtractPropTypes } from 'vue';
+
+export declare const styleColorPropsOptions: {
+    color: StringConstructor;
+    background: StringConstructor;
+    backgroundOpacity: {
+        type: NumberConstructor;
+    };
+};
+export declare function useStyleColor(props: ExtractPropTypes<typeof styleColorPropsOptions>, name: string): {
+    colorVars: import('vue').ComputedRef<{
+        [x: string]: string | undefined;
+    }>;
+};