New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

onu-ui

Package Overview
Dependencies
Maintainers
2
Versions
46
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

onu-ui - npm Package Compare versions

Comparing version 1.0.12 to 1.0.13-alpha

./dist/onu-ui.umd.cjs
dist/types/utils/locale/lang/pt.d.ts

55

dist/types/components/_components/ClientOnly.vue.d.ts

@@ -1,48 +0,9 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
default: (_: {}) => any;
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>, {
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

8

dist/types/components/alert/index.d.ts

@@ -8,5 +8,5 @@ export declare const OAlert: import("../../utils/types").SFCWithInstall<{

type: "error" | "info" | "primary" | "secondary" | "success" | "warning";
description: string;
light: boolean;
icon: string;
description: string;
closeText: string;

@@ -50,3 +50,3 @@ closable: boolean;

onClose?: ((evt: MouseEvent) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "title" | "type" | "description" | "light" | "icon" | "closeText" | "closable" | "center">;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "title" | "type" | "light" | "icon" | "description" | "closeText" | "closable" | "center">;
$attrs: {

@@ -105,5 +105,5 @@ [x: string]: unknown;

type: "error" | "info" | "primary" | "secondary" | "success" | "warning";
description: string;
light: boolean;
icon: string;
description: string;
closeText: string;

@@ -211,5 +211,5 @@ closable: boolean;

type: "error" | "info" | "primary" | "secondary" | "success" | "warning";
description: string;
light: boolean;
icon: string;
description: string;
closeText: string;

@@ -216,0 +216,0 @@ closable: boolean;

229

dist/types/components/alert/src/index.vue.d.ts

@@ -1,169 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
title: string;
type: "error" | "info" | "primary" | "secondary" | "success" | "warning";
description: string;
light: boolean;
icon: string;
closeText: string;
closable: boolean;
center: boolean;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
type: {
type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
default: string;
};
title: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
closeText: {
type: StringConstructor;
default: string;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
light: {
type: BooleanConstructor;
default: boolean;
};
center: {
type: BooleanConstructor;
default: boolean;
};
}>> & {
onClose?: ((evt: MouseEvent) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "title" | "type" | "description" | "light" | "icon" | "closeText" | "closable" | "center">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: "close", evt: MouseEvent) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
type: {
type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
default: string;
};
title: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
closeText: {
type: StringConstructor;
default: string;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
light: {
type: BooleanConstructor;
default: boolean;
};
center: {
type: BooleanConstructor;
default: boolean;
};
}>> & {
onClose?: ((evt: MouseEvent) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
close: (evt: MouseEvent) => boolean;
}, string, {
title: string;
type: "error" | "info" | "primary" | "secondary" | "success" | "warning";
description: string;
light: boolean;
icon: string;
closeText: string;
closable: boolean;
center: boolean;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
type: {
type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
default: string;
};
title: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
closeText: {
type: StringConstructor;
default: string;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
light: {
type: BooleanConstructor;
default: boolean;
};
center: {
type: BooleanConstructor;
default: boolean;
};
}>> & {
onClose?: ((evt: MouseEvent) => any) | undefined;
} & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
type: {

@@ -201,23 +34,59 @@ type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;

};
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
close: (evt: MouseEvent) => boolean;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
type: {
type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
default: string;
};
title: {
type: StringConstructor;
default: string;
};
description: {
type: StringConstructor;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
closeText: {
type: StringConstructor;
default: string;
};
closable: {
type: BooleanConstructor;
default: boolean;
};
light: {
type: BooleanConstructor;
default: boolean;
};
center: {
type: BooleanConstructor;
default: boolean;
};
}>> & {
onClose?: ((evt: MouseEvent) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
close: (evt: MouseEvent) => boolean;
}, string, {
}, {
title: string;
type: "error" | "info" | "primary" | "secondary" | "success" | "warning";
description: string;
light: boolean;
icon: string;
description: string;
closeText: string;
closable: boolean;
center: boolean;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
icon: (_: {}) => any;
title: (_: {}) => any;
close: (_: {}) => any;
default: (_: {}) => any;
}>, {
icon: (_: {}) => any;
title: (_: {}) => any;
close: (_: {}) => any;
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

2

dist/types/components/alert/src/props.d.ts

@@ -47,2 +47,2 @@ import type { ExtractPropTypes, PropType } from 'vue';

};
export declare type OAlertProps = ExtractPropTypes<typeof alertProps>;
export type OAlertProps = ExtractPropTypes<typeof alertProps>;

4

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

@@ -19,3 +19,3 @@ import type { ExtractPropTypes, PropType } from 'vue';

};
export declare type OAvatarProps = ExtractPropTypes<typeof avatarProps>;
export declare type OAvatarGroupProps = ExtractPropTypes<typeof avatarGroupProps>;
export type OAvatarProps = ExtractPropTypes<typeof avatarProps>;
export type OAvatarGroupProps = ExtractPropTypes<typeof avatarGroupProps>;

83

dist/types/components/avatar/src/group.vue.d.ts

@@ -1,63 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
size: "xs" | "sm" | "md" | "lg";
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "size">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
size: "xs" | "sm" | "md" | "lg";
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
}>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
size: {

@@ -67,9 +6,17 @@ type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;

};
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
}>>, {
size: "xs" | "sm" | "md" | "lg";
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
default: (_: {}) => any;
}>, {
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

105

dist/types/components/avatar/src/index.vue.d.ts

@@ -1,80 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
mode: "img" | "bg";
size: "xs" | "sm" | "md" | "lg";
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
src: StringConstructor;
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
mode: {
type: import("vue").PropType<"img" | "bg">;
default: string;
};
}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "mode" | "size">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
src: StringConstructor;
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
mode: {
type: import("vue").PropType<"img" | "bg">;
default: string;
};
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
mode: "img" | "bg";
size: "xs" | "sm" | "md" | "lg";
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
src: StringConstructor;
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
mode: {
type: import("vue").PropType<"img" | "bg">;
default: string;
};
}>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
src: StringConstructor;

@@ -89,10 +11,23 @@ size: {

};
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
src: StringConstructor;
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
mode: {
type: import("vue").PropType<"img" | "bg">;
default: string;
};
}>>, {
mode: "img" | "bg";
size: "xs" | "sm" | "md" | "lg";
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
default: (_: {}) => any;
}>, {
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

2

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

@@ -20,2 +20,2 @@ import type { ExtractPropTypes, PropType } from 'vue';

};
export declare type OBadgeProps = ExtractPropTypes<typeof badgeProps>;
export type OBadgeProps = ExtractPropTypes<typeof badgeProps>;

137

dist/types/components/badge/src/index.vue.d.ts

@@ -1,105 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
value: string | number;
max: number;
showZero: boolean;
dot: boolean;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
max: {
type: NumberConstructor;
default: number;
};
value: {
type: import("vue").PropType<string | number>;
default: string;
};
showZero: {
type: BooleanConstructor;
default: boolean;
};
dot: {
type: BooleanConstructor;
default: boolean;
};
}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "value" | "max" | "showZero" | "dot">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
max: {
type: NumberConstructor;
default: number;
};
value: {
type: import("vue").PropType<string | number>;
default: string;
};
showZero: {
type: BooleanConstructor;
default: boolean;
};
dot: {
type: BooleanConstructor;
default: boolean;
};
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
value: string | number;
max: number;
showZero: boolean;
dot: boolean;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
max: {
type: NumberConstructor;
default: number;
};
value: {
type: import("vue").PropType<string | number>;
default: string;
};
showZero: {
type: BooleanConstructor;
default: boolean;
};
dot: {
type: BooleanConstructor;
default: boolean;
};
}>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
max: {

@@ -121,3 +18,20 @@ type: NumberConstructor;

};
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
max: {
type: NumberConstructor;
default: number;
};
value: {
type: import("vue").PropType<string | number>;
default: string;
};
showZero: {
type: BooleanConstructor;
default: boolean;
};
dot: {
type: BooleanConstructor;
default: boolean;
};
}>>, {
value: string | number;

@@ -127,7 +41,10 @@ max: number;

dot: boolean;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
default: (_: {}) => any;
}>, {
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

143

dist/types/components/button/src/index.vue.d.ts

@@ -1,110 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
text: boolean;
size: "xs" | "sm" | "md" | "lg";
type: "error" | "info" | "default" | "primary" | "secondary" | "success" | "warning";
shadow: boolean;
light: boolean;
dashed: boolean;
disabled: boolean;
loading: boolean;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
type: {
type: import("vue").PropType<"error" | "info" | "default" | "primary" | "secondary" | "success" | "warning">;
default: string;
};
to: StringConstructor;
shadow: BooleanConstructor;
light: BooleanConstructor;
dashed: BooleanConstructor;
text: BooleanConstructor;
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
disabled: BooleanConstructor;
loading: BooleanConstructor;
}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "text" | "size" | "type" | "shadow" | "light" | "dashed" | "disabled" | "loading">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
type: {
type: import("vue").PropType<"error" | "info" | "default" | "primary" | "secondary" | "success" | "warning">;
default: string;
};
to: StringConstructor;
shadow: BooleanConstructor;
light: BooleanConstructor;
dashed: BooleanConstructor;
text: BooleanConstructor;
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
disabled: BooleanConstructor;
loading: BooleanConstructor;
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
text: boolean;
size: "xs" | "sm" | "md" | "lg";
type: "error" | "info" | "default" | "primary" | "secondary" | "success" | "warning";
shadow: boolean;
light: boolean;
dashed: boolean;
disabled: boolean;
loading: boolean;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
type: {
type: import("vue").PropType<"error" | "info" | "default" | "primary" | "secondary" | "success" | "warning">;
default: string;
};
to: StringConstructor;
shadow: BooleanConstructor;
light: BooleanConstructor;
dashed: BooleanConstructor;
text: BooleanConstructor;
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
disabled: BooleanConstructor;
loading: BooleanConstructor;
}>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
type: {

@@ -125,3 +17,19 @@ type: import("vue").PropType<"error" | "info" | "default" | "primary" | "secondary" | "success" | "warning">;

loading: BooleanConstructor;
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
type: {
type: import("vue").PropType<"error" | "info" | "default" | "primary" | "secondary" | "success" | "warning">;
default: string;
};
to: StringConstructor;
shadow: BooleanConstructor;
light: BooleanConstructor;
dashed: BooleanConstructor;
text: BooleanConstructor;
size: {
type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
default: string;
};
disabled: BooleanConstructor;
loading: BooleanConstructor;
}>>, {
text: boolean;

@@ -135,8 +43,11 @@ size: "xs" | "sm" | "md" | "lg";

loading: boolean;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
icon: (_: {}) => any;
default: (_: {}) => any;
}>, {
icon: (_: {}) => any;
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

2

dist/types/components/button/src/props.d.ts

@@ -19,2 +19,2 @@ import type { ExtractPropTypes, PropType } from 'vue';

};
export declare type OButtonProps = ExtractPropTypes<typeof buttonProps>;
export type OButtonProps = ExtractPropTypes<typeof buttonProps>;

207

dist/types/components/card/src/index.vue.d.ts

@@ -1,153 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
readonly embed: boolean;
readonly size: "sm" | "md";
readonly shadow: "hover" | "always" | "never";
readonly divider: boolean;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
readonly title: {
readonly type: StringConstructor;
};
readonly description: {
readonly type: StringConstructor;
};
readonly content: {
readonly type: import("vue").PropType<string | ((h: typeof import("vue").h) => import("../../types").SlotReturnValue)>;
};
readonly cover: {
readonly type: StringConstructor;
};
readonly size: {
readonly type: import("vue").PropType<"sm" | "md">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly shadow: {
readonly type: import("vue").PropType<"hover" | "always" | "never">;
readonly default: "always";
};
readonly divider: BooleanConstructor;
readonly header: {
readonly type: import("vue").PropType<(h: typeof import("vue").h) => import("../../types").SlotReturnValue>;
};
readonly extra: {
readonly type: import("vue").PropType<string | ((h: typeof import("vue").h) => import("../../types").SlotReturnValue)>;
};
readonly actions: {
readonly type: import("vue").PropType<(h: typeof import("vue").h) => import("../../types").SlotReturnValue>;
};
readonly embed: BooleanConstructor;
}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "embed" | "size" | "shadow" | "divider">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
readonly title: {
readonly type: StringConstructor;
};
readonly description: {
readonly type: StringConstructor;
};
readonly content: {
readonly type: import("vue").PropType<string | ((h: typeof import("vue").h) => import("../../types").SlotReturnValue)>;
};
readonly cover: {
readonly type: StringConstructor;
};
readonly size: {
readonly type: import("vue").PropType<"sm" | "md">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly shadow: {
readonly type: import("vue").PropType<"hover" | "always" | "never">;
readonly default: "always";
};
readonly divider: BooleanConstructor;
readonly header: {
readonly type: import("vue").PropType<(h: typeof import("vue").h) => import("../../types").SlotReturnValue>;
};
readonly extra: {
readonly type: import("vue").PropType<string | ((h: typeof import("vue").h) => import("../../types").SlotReturnValue)>;
};
readonly actions: {
readonly type: import("vue").PropType<(h: typeof import("vue").h) => import("../../types").SlotReturnValue>;
};
readonly embed: BooleanConstructor;
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
readonly embed: boolean;
readonly size: "sm" | "md";
readonly shadow: "hover" | "always" | "never";
readonly divider: boolean;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
readonly title: {
readonly type: StringConstructor;
};
readonly description: {
readonly type: StringConstructor;
};
readonly content: {
readonly type: import("vue").PropType<string | ((h: typeof import("vue").h) => import("../../types").SlotReturnValue)>;
};
readonly cover: {
readonly type: StringConstructor;
};
readonly size: {
readonly type: import("vue").PropType<"sm" | "md">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly shadow: {
readonly type: import("vue").PropType<"hover" | "always" | "never">;
readonly default: "always";
};
readonly divider: BooleanConstructor;
readonly header: {
readonly type: import("vue").PropType<(h: typeof import("vue").h) => import("../../types").SlotReturnValue>;
};
readonly extra: {
readonly type: import("vue").PropType<string | ((h: typeof import("vue").h) => import("../../types").SlotReturnValue)>;
};
readonly actions: {
readonly type: import("vue").PropType<(h: typeof import("vue").h) => import("../../types").SlotReturnValue>;
};
readonly embed: BooleanConstructor;
}>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
readonly title: {

@@ -185,3 +34,36 @@ readonly type: StringConstructor;

readonly embed: BooleanConstructor;
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly title: {
readonly type: StringConstructor;
};
readonly description: {
readonly type: StringConstructor;
};
readonly content: {
readonly type: import("vue").PropType<string | ((h: typeof import("vue").h) => import("../../types").SlotReturnValue)>;
};
readonly cover: {
readonly type: StringConstructor;
};
readonly size: {
readonly type: import("vue").PropType<"sm" | "md">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly shadow: {
readonly type: import("vue").PropType<"hover" | "always" | "never">;
readonly default: "always";
};
readonly divider: BooleanConstructor;
readonly header: {
readonly type: import("vue").PropType<(h: typeof import("vue").h) => import("../../types").SlotReturnValue>;
};
readonly extra: {
readonly type: import("vue").PropType<string | ((h: typeof import("vue").h) => import("../../types").SlotReturnValue)>;
};
readonly actions: {
readonly type: import("vue").PropType<(h: typeof import("vue").h) => import("../../types").SlotReturnValue>;
};
readonly embed: BooleanConstructor;
}>>, {
readonly embed: boolean;

@@ -191,10 +73,13 @@ readonly size: "sm" | "md";

readonly divider: boolean;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
header: (_: {}) => any;
extra: (_: {}) => any;
default: (_: {}) => any;
actions: (_: {}) => any;
}>, {
header: (_: {}) => any;
extra: (_: {}) => any;
default: (_: {}) => any;
actions: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

2

dist/types/components/card/src/props.d.ts

@@ -47,2 +47,2 @@ import type { ExtractPropTypes, PropType } from 'vue';

};
export declare type OCardProps = ExtractPropTypes<typeof cardProps>;
export type OCardProps = ExtractPropTypes<typeof cardProps>;

2

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

@@ -15,2 +15,2 @@ import type { ExtractPropTypes, PropType } from 'vue';

};
export declare type OCheckBoxProps = ExtractPropTypes<typeof checkBoxProps>;
export type OCheckBoxProps = ExtractPropTypes<typeof checkBoxProps>;

126

dist/types/components/checkbox/src/index.vue.d.ts

@@ -1,99 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
size: "md" | "lg";
disabled: boolean;
icon: string;
modelValue: boolean;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
modelValue: BooleanConstructor;
disabled: BooleanConstructor;
label: StringConstructor;
icon: {
type: StringConstructor;
default: string;
};
size: {
type: import("vue").PropType<"md" | "lg">;
default: string;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "size" | "disabled" | "icon" | "modelValue">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
modelValue: BooleanConstructor;
disabled: BooleanConstructor;
label: StringConstructor;
icon: {
type: StringConstructor;
default: string;
};
size: {
type: import("vue").PropType<"md" | "lg">;
default: string;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], string, {
size: "md" | "lg";
disabled: boolean;
icon: string;
modelValue: boolean;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
modelValue: BooleanConstructor;
disabled: BooleanConstructor;
label: StringConstructor;
icon: {
type: StringConstructor;
default: string;
};
size: {
type: import("vue").PropType<"md" | "lg">;
default: string;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
} & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
modelValue: BooleanConstructor;

@@ -110,6 +13,18 @@ disabled: BooleanConstructor;

};
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
modelValue: BooleanConstructor;
disabled: BooleanConstructor;
label: StringConstructor;
icon: {
type: StringConstructor;
default: string;
};
size: {
type: import("vue").PropType<"md" | "lg">;
default: string;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", {
}, {
size: "md" | "lg";

@@ -119,7 +34,10 @@ disabled: boolean;

modelValue: boolean;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
default: (_: {}) => any;
}>, {
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

127

dist/types/components/collapse/src/collapse.vue.d.ts

@@ -1,96 +0,3 @@

import { CollapseActiveName } from './props';
declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
accordion: boolean;
expandedNames: CollapseActiveName;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
accordion: {
type: BooleanConstructor;
default: boolean;
};
expandedNames: {
type: import("vue").PropType<CollapseActiveName>;
default: () => readonly [];
};
}>> & {
onChange?: ((value: CollapseActiveName) => any) | undefined;
"onUpdate:expanded-names"?: ((value: CollapseActiveName) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "accordion" | "expandedNames">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: ((event: "change", value: CollapseActiveName) => void) & ((event: "update:expanded-names", value: CollapseActiveName) => void);
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
accordion: {
type: BooleanConstructor;
default: boolean;
};
expandedNames: {
type: import("vue").PropType<CollapseActiveName>;
default: () => readonly [];
};
}>> & {
onChange?: ((value: CollapseActiveName) => any) | undefined;
"onUpdate:expanded-names"?: ((value: CollapseActiveName) => any) | undefined;
}, {
activeNames: import("vue").Ref<(string | number)[]>;
setActiveNames: (_activeNames: CollapseActiveName) => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
'update:expanded-names': (value: CollapseActiveName) => "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
change: (value: CollapseActiveName) => "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
}, string, {
accordion: boolean;
expandedNames: CollapseActiveName;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
accordion: {
type: BooleanConstructor;
default: boolean;
};
expandedNames: {
type: import("vue").PropType<CollapseActiveName>;
default: () => readonly [];
};
}>> & {
onChange?: ((value: CollapseActiveName) => any) | undefined;
"onUpdate:expanded-names"?: ((value: CollapseActiveName) => any) | undefined;
} & import("vue").ShallowUnwrapRef<{
activeNames: import("vue").Ref<(string | number)[]>;
setActiveNames: (_activeNames: CollapseActiveName) => void;
}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
import type { CollapseActiveName } from './props';
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
accordion: {

@@ -104,5 +11,2 @@ type: BooleanConstructor;

};
}>> & {
onChange?: ((value: CollapseActiveName) => any) | undefined;
"onUpdate:expanded-names"?: ((value: CollapseActiveName) => any) | undefined;
}, {

@@ -114,10 +18,25 @@ activeNames: import("vue").Ref<(string | number)[]>;

change: (value: CollapseActiveName) => "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
}, string, {
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
accordion: {
type: BooleanConstructor;
default: boolean;
};
expandedNames: {
type: import("vue").PropType<CollapseActiveName>;
default: () => readonly [];
};
}>> & {
onChange?: ((value: CollapseActiveName) => any) | undefined;
"onUpdate:expanded-names"?: ((value: CollapseActiveName) => any) | undefined;
}, {
accordion: boolean;
expandedNames: CollapseActiveName;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
default: (_: {}) => any;
}>, {
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

165

dist/types/components/collapse/src/collapseItem.vue.d.ts

@@ -1,123 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
name: string | number;
title: string;
disabled: boolean;
icon: string;
arrowPlacement: "right" | "left";
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
disabled: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: StringConstructor;
default: undefined;
};
name: {
type: import("vue").PropType<string | number>;
default: () => number;
};
arrowPlacement: {
type: import("vue").PropType<"right" | "left">;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "name" | "title" | "disabled" | "icon" | "arrowPlacement">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
disabled: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: StringConstructor;
default: undefined;
};
name: {
type: import("vue").PropType<string | number>;
default: () => number;
};
arrowPlacement: {
type: import("vue").PropType<"right" | "left">;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
}>>, {
isActive: import("vue").ComputedRef<boolean | undefined>;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
name: string | number;
title: string;
disabled: boolean;
icon: string;
arrowPlacement: "right" | "left";
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
disabled: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: StringConstructor;
default: undefined;
};
name: {
type: import("vue").PropType<string | number>;
default: () => number;
};
arrowPlacement: {
type: import("vue").PropType<"right" | "left">;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
}>> & import("vue").ShallowUnwrapRef<{
isActive: import("vue").ComputedRef<boolean | undefined>;
}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
disabled: {

@@ -143,5 +22,26 @@ type: BooleanConstructor;

};
}, {
isActive: import("vue").ComputedRef<boolean | undefined>;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
disabled: {
type: BooleanConstructor;
default: boolean;
};
title: {
type: StringConstructor;
default: undefined;
};
name: {
type: import("vue").PropType<string | number>;
default: () => number;
};
arrowPlacement: {
type: import("vue").PropType<"right" | "left">;
default: string;
};
icon: {
type: StringConstructor;
default: string;
};
}>>, {
isActive: import("vue").ComputedRef<boolean | undefined>;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
name: string | number;

@@ -152,9 +52,12 @@ title: string;

arrowPlacement: "right" | "left";
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
icon: (_: {}) => any;
title: (_: {}) => any;
default: (_: {}) => any;
}>, {
icon: (_: {}) => any;
title: (_: {}) => any;
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

12

dist/types/components/collapse/src/props.d.ts

@@ -0,5 +1,5 @@

import type { ExtractPropTypes, InjectionKey, PropType, Ref } from 'vue';
import type OCollapseItem from './collapseItem.vue';
import type { ExtractPropTypes, InjectionKey, PropType, Ref } from 'vue';
export declare type CollapseActiveName = (string | number)[];
export declare type RendererElement = Record<string, any>;
export type CollapseActiveName = (string | number)[];
export type RendererElement = Record<string, any>;
export declare const collapseProps: {

@@ -48,5 +48,5 @@ /** 手风琴 是否只允许展开一个面板 */

};
export declare type OCollapseProps = ExtractPropTypes<typeof collapseProps>;
export declare type OCollapseItemProps = ExtractPropTypes<typeof collapseItemProps>;
export declare type OCollapseItemInstance = InstanceType<typeof OCollapseItem>;
export type OCollapseProps = ExtractPropTypes<typeof collapseProps>;
export type OCollapseItemProps = ExtractPropTypes<typeof collapseItemProps>;
export type OCollapseItemInstance = InstanceType<typeof OCollapseItem>;
export interface CollapseContext {

@@ -53,0 +53,0 @@ activeNames: Ref<CollapseActiveName>;

109

dist/types/components/empty/src/index.vue.d.ts

@@ -1,80 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
image: string;
description: string;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
image: {
type: StringConstructor;
default: string;
};
imgSize: NumberConstructor;
description: {
type: StringConstructor;
default: string;
};
}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "image" | "description">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
image: {
type: StringConstructor;
default: string;
};
imgSize: NumberConstructor;
description: {
type: StringConstructor;
default: string;
};
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
image: string;
description: string;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
image: {
type: StringConstructor;
default: string;
};
imgSize: NumberConstructor;
description: {
type: StringConstructor;
default: string;
};
}>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
image: {

@@ -89,12 +11,25 @@ type: StringConstructor;

};
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
image: {
type: StringConstructor;
default: string;
};
imgSize: NumberConstructor;
description: {
type: StringConstructor;
default: string;
};
}>>, {
image: string;
description: string;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
image: (_: {}) => any;
description: (_: {}) => any;
default: (_: {}) => any;
}>, {
image: (_: {}) => any;
description: (_: {}) => any;
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

2

dist/types/components/empty/src/props.d.ts

@@ -13,2 +13,2 @@ import type { ExtractPropTypes } from 'vue';

};
export declare type OEmptyProps = ExtractPropTypes<typeof emptyProps>;
export type OEmptyProps = ExtractPropTypes<typeof emptyProps>;

66

dist/types/components/icon/index.d.ts

@@ -1,59 +0,2 @@

export declare const OIcon: import("../../utils/types").SFCWithInstall<{
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{
name: {
type: import("vue").PropType<String>;
required: true;
};
}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
name: {
type: import("vue").PropType<String>;
required: true;
};
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
name: {
type: import("vue").PropType<String>;
required: true;
};
}>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
export declare const OIcon: import("../../utils/types").SFCWithInstall<import("vue").DefineComponent<{
name: {

@@ -63,3 +6,8 @@ type: import("vue").PropType<String>;

};
}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps> & Record<string, any>;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
name: {
type: import("vue").PropType<String>;
required: true;
};
}>>, {}>> & Record<string, any>;
export default OIcon;

58

dist/types/components/icon/src/index.vue.d.ts

@@ -1,55 +0,9 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
name: String;
}>>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
name: String;
}>>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
name: String;
}>>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
declare const _default: import("vue").DefineComponent<__VLS_TypePropsToRuntimeProps<{
name: String;
}>>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
name: String;
}>>>, {}>;
export default _default;
declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
declare type __VLS_TypePropsToRuntimeProps<T> = {
type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
type __VLS_TypePropsToRuntimeProps<T> = {
[K in keyof T]-?: {} extends Pick<T, K> ? {

@@ -56,0 +10,0 @@ type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;

293

dist/types/components/message/src/index.vue.d.ts

@@ -1,227 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
zIndex: number;
type: "error" | "info" | "primary" | "secondary" | "success" | "warning";
icon: string;
content: string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}> | (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>);
closable: boolean;
id: string;
duration: number;
parseHtml: boolean;
offset: number;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
id: {
type: StringConstructor;
default: "";
};
type: {
type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
default: "primary";
};
content: {
type: import("vue").PropType<string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}> | (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>)>;
default: "";
};
closable: {
type: BooleanConstructor;
default: false;
};
duration: {
type: NumberConstructor;
default: 3000;
};
onClose: {
type: import("vue").PropType<() => void>;
required: undefined;
};
icon: {
type: StringConstructor;
default: null;
};
zIndex: {
type: NumberConstructor;
default: 0;
};
parseHtml: {
type: BooleanConstructor;
default: false;
};
offset: {
type: NumberConstructor;
default: 16;
};
}>> & {
onClose?: ((evt: MouseEvent) => any) | undefined;
onDestroy?: (() => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "zIndex" | "type" | "icon" | "content" | "closable" | "id" | "duration" | "parseHtml" | "offset">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: ((event: "close", evt: MouseEvent) => void) & ((event: "destroy") => void);
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
id: {
type: StringConstructor;
default: "";
};
type: {
type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
default: "primary";
};
content: {
type: import("vue").PropType<string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}> | (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>)>;
default: "";
};
closable: {
type: BooleanConstructor;
default: false;
};
duration: {
type: NumberConstructor;
default: 3000;
};
onClose: {
type: import("vue").PropType<() => void>;
required: undefined;
};
icon: {
type: StringConstructor;
default: null;
};
zIndex: {
type: NumberConstructor;
default: 0;
};
parseHtml: {
type: BooleanConstructor;
default: false;
};
offset: {
type: NumberConstructor;
default: 16;
};
}>> & {
onClose?: ((evt: MouseEvent) => any) | undefined;
onDestroy?: (() => any) | undefined;
}, {
visible: import("vue").Ref<boolean>;
close: () => void;
bottom: import("vue").ComputedRef<number>;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
destroy: () => boolean;
close: (evt: MouseEvent) => boolean;
}, string, {
zIndex: number;
type: "error" | "info" | "primary" | "secondary" | "success" | "warning";
icon: string;
content: string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}> | (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>);
closable: boolean;
id: string;
duration: number;
parseHtml: boolean;
offset: number;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
id: {
type: StringConstructor;
default: "";
};
type: {
type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
default: "primary";
};
content: {
type: import("vue").PropType<string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}> | (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>)>;
default: "";
};
closable: {
type: BooleanConstructor;
default: false;
};
duration: {
type: NumberConstructor;
default: 3000;
};
onClose: {
type: import("vue").PropType<() => void>;
required: undefined;
};
icon: {
type: StringConstructor;
default: null;
};
zIndex: {
type: NumberConstructor;
default: 0;
};
parseHtml: {
type: BooleanConstructor;
default: false;
};
offset: {
type: NumberConstructor;
default: 16;
};
}>> & {
onClose?: ((evt: MouseEvent) => any) | undefined;
onDestroy?: (() => any) | undefined;
} & import("vue").ShallowUnwrapRef<{
visible: import("vue").Ref<boolean>;
close: () => void;
bottom: import("vue").ComputedRef<number>;
}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
id: {

@@ -271,5 +46,2 @@ type: StringConstructor;

};
}>> & {
onClose?: ((evt: MouseEvent) => any) | undefined;
onDestroy?: (() => any) | undefined;
}, {

@@ -282,3 +54,51 @@ visible: import("vue").Ref<boolean>;

close: (evt: MouseEvent) => boolean;
}, string, {
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
id: {
type: StringConstructor;
default: "";
};
type: {
type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
default: "primary";
};
content: {
type: import("vue").PropType<string | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}> | (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
[key: string]: any;
}>)>;
default: "";
};
closable: {
type: BooleanConstructor;
default: false;
};
duration: {
type: NumberConstructor;
default: 3000;
};
onClose: {
type: import("vue").PropType<() => void>;
required: undefined;
};
icon: {
type: StringConstructor;
default: null;
};
zIndex: {
type: NumberConstructor;
default: 0;
};
parseHtml: {
type: BooleanConstructor;
default: false;
};
offset: {
type: NumberConstructor;
default: 16;
};
}>> & {
onClose?: ((evt: MouseEvent) => any) | undefined;
onDestroy?: (() => any) | undefined;
}, {
zIndex: number;

@@ -297,7 +117,10 @@ type: "error" | "info" | "primary" | "secondary" | "success" | "warning";

offset: number;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
default: (_: {}) => any;
}>, {
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

18

dist/types/components/message/src/type.d.ts

@@ -0,3 +1,3 @@

import type { AppContext, ComponentInternalInstance, ExtractPropTypes, PropType, VNode } from 'vue';
import type { Mutable } from './../../types';
import type { AppContext, ComponentInternalInstance, ExtractPropTypes, PropType, VNode } from 'vue';
export declare const messageDefaults: {

@@ -64,3 +64,3 @@ readonly id: "";

};
export declare type OMessageProps = ExtractPropTypes<typeof messageProps>;
export type OMessageProps = ExtractPropTypes<typeof messageProps>;
export declare const messageEmits: {

@@ -70,16 +70,16 @@ destroy: () => boolean;

};
export declare type MessageEmits = typeof messageEmits;
export declare type MessageOptions = Partial<Mutable<Omit<OMessageProps, 'id'> & {
export type MessageEmits = typeof messageEmits;
export type MessageOptions = Partial<Mutable<Omit<OMessageProps, 'id'> & {
appendTo?: HTMLElement | string;
}>>;
export declare type CreateMessageType = Omit<OMessageProps, 'id'> & {
export type CreateMessageType = Omit<OMessageProps, 'id'> & {
appendTo: HTMLElement;
};
export declare type MessageParams = MessageOptions | MessageOptions['content'];
export declare type MessageOptionsWithType = Omit<MessageOptions, 'type'>;
export declare type MessageParamsWithType = MessageOptionsWithType | MessageOptions['content'];
export type MessageParams = MessageOptions | MessageOptions['content'];
export type MessageOptionsWithType = Omit<MessageOptions, 'type'>;
export type MessageParamsWithType = MessageOptionsWithType | MessageOptions['content'];
export interface MessageHandler {
close: () => void;
}
export declare type MessageTypedFn = (options?: MessageParamsWithType, appContext?: null | AppContext) => MessageHandler;
export type MessageTypedFn = (options?: MessageParamsWithType, appContext?: null | AppContext) => MessageHandler;
export interface MessageFn {

@@ -86,0 +86,0 @@ (options?: MessageParams, appContext?: null | AppContext): MessageHandler;

26

dist/types/components/popup/index.d.ts

@@ -45,4 +45,4 @@ export declare const OPopup: import("../../utils/types").SFCWithInstall<{

}>> & {
"onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
"onUpdate:popupVisible"?: ((_visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((_visible: boolean) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "popupVisible" | "defaultPopupVisible" | "trigger" | "position">;

@@ -60,3 +60,3 @@ $attrs: {

$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: ((event: "update:popupVisible", visible: boolean) => void) & ((event: "popupVisibleChange", visible: boolean) => void);
$emit: ((event: "update:popupVisible", _visible: boolean) => void) & ((event: "popupVisibleChange", _visible: boolean) => void);
$el: any;

@@ -98,7 +98,7 @@ $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{

}>> & {
"onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
"onUpdate:popupVisible"?: ((_visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((_visible: boolean) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
'update:popupVisible': (visible: boolean) => boolean;
popupVisibleChange: (visible: boolean) => boolean;
'update:popupVisible': (_visible: boolean) => boolean;
popupVisibleChange: (_visible: boolean) => boolean;
}, string, {

@@ -164,4 +164,4 @@ popupVisible: boolean;

}>> & {
"onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
"onUpdate:popupVisible"?: ((_visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((_visible: boolean) => any) | undefined;
} & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};

@@ -206,7 +206,7 @@ __isFragment?: undefined;

}>> & {
"onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
"onUpdate:popupVisible"?: ((_visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((_visible: boolean) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
'update:popupVisible': (visible: boolean) => boolean;
popupVisibleChange: (visible: boolean) => boolean;
'update:popupVisible': (_visible: boolean) => boolean;
popupVisibleChange: (_visible: boolean) => boolean;
}, string, {

@@ -213,0 +213,0 @@ popupVisible: boolean;

231

dist/types/components/popup/src/index.vue.d.ts

@@ -1,168 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
popupVisible: boolean;
defaultPopupVisible: boolean;
trigger: "click" | "focus" | "hover" | "context-menu" | ("click" | "focus" | "hover" | "context-menu")[];
position: "top" | "right" | "bottom" | "left" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "left-top" | "left-bottom" | "right-top" | "right-bottom";
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
popupVisible: {
type: BooleanConstructor;
default: undefined;
};
defaultPopupVisible: {
type: BooleanConstructor;
default: boolean;
};
title: StringConstructor;
content: StringConstructor;
trigger: {
type: import("vue").PropType<"click" | "focus" | "hover" | "context-menu" | ("click" | "focus" | "hover" | "context-menu")[]>;
default: string;
};
position: {
type: import("vue").PropType<"top" | "right" | "bottom" | "left" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "left-top" | "left-bottom" | "right-top" | "right-bottom">;
default: string;
};
contentClass: {
type: StringConstructor;
};
contentStyle: {
type: import("vue").PropType<import("vue").CSSProperties>;
};
arrowClass: {
type: StringConstructor;
};
arrowStyle: {
type: import("vue").PropType<import("vue").CSSProperties>;
};
popupContainer: {
type: import("vue").PropType<string | HTMLElement | undefined>;
};
}>> & {
"onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "popupVisible" | "defaultPopupVisible" | "trigger" | "position">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: ((event: "update:popupVisible", visible: boolean) => void) & ((event: "popupVisibleChange", visible: boolean) => void);
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
popupVisible: {
type: BooleanConstructor;
default: undefined;
};
defaultPopupVisible: {
type: BooleanConstructor;
default: boolean;
};
title: StringConstructor;
content: StringConstructor;
trigger: {
type: import("vue").PropType<"click" | "focus" | "hover" | "context-menu" | ("click" | "focus" | "hover" | "context-menu")[]>;
default: string;
};
position: {
type: import("vue").PropType<"top" | "right" | "bottom" | "left" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "left-top" | "left-bottom" | "right-top" | "right-bottom">;
default: string;
};
contentClass: {
type: StringConstructor;
};
contentStyle: {
type: import("vue").PropType<import("vue").CSSProperties>;
};
arrowClass: {
type: StringConstructor;
};
arrowStyle: {
type: import("vue").PropType<import("vue").CSSProperties>;
};
popupContainer: {
type: import("vue").PropType<string | HTMLElement | undefined>;
};
}>> & {
"onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
'update:popupVisible': (visible: boolean) => boolean;
popupVisibleChange: (visible: boolean) => boolean;
}, string, {
popupVisible: boolean;
defaultPopupVisible: boolean;
trigger: "click" | "focus" | "hover" | "context-menu" | ("click" | "focus" | "hover" | "context-menu")[];
position: "top" | "right" | "bottom" | "left" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "left-top" | "left-bottom" | "right-top" | "right-bottom";
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
popupVisible: {
type: BooleanConstructor;
default: undefined;
};
defaultPopupVisible: {
type: BooleanConstructor;
default: boolean;
};
title: StringConstructor;
content: StringConstructor;
trigger: {
type: import("vue").PropType<"click" | "focus" | "hover" | "context-menu" | ("click" | "focus" | "hover" | "context-menu")[]>;
default: string;
};
position: {
type: import("vue").PropType<"top" | "right" | "bottom" | "left" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "left-top" | "left-bottom" | "right-top" | "right-bottom">;
default: string;
};
contentClass: {
type: StringConstructor;
};
contentStyle: {
type: import("vue").PropType<import("vue").CSSProperties>;
};
arrowClass: {
type: StringConstructor;
};
arrowStyle: {
type: import("vue").PropType<import("vue").CSSProperties>;
};
popupContainer: {
type: import("vue").PropType<string | HTMLElement | undefined>;
};
}>> & {
"onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
} & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
popupVisible: {

@@ -201,9 +35,43 @@ type: BooleanConstructor;

};
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
'update:popupVisible': (_visible: boolean) => boolean;
popupVisibleChange: (_visible: boolean) => boolean;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
popupVisible: {
type: BooleanConstructor;
default: undefined;
};
defaultPopupVisible: {
type: BooleanConstructor;
default: boolean;
};
title: StringConstructor;
content: StringConstructor;
trigger: {
type: import("vue").PropType<"click" | "focus" | "hover" | "context-menu" | ("click" | "focus" | "hover" | "context-menu")[]>;
default: string;
};
position: {
type: import("vue").PropType<"top" | "right" | "bottom" | "left" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "left-top" | "left-bottom" | "right-top" | "right-bottom">;
default: string;
};
contentClass: {
type: StringConstructor;
};
contentStyle: {
type: import("vue").PropType<import("vue").CSSProperties>;
};
arrowClass: {
type: StringConstructor;
};
arrowStyle: {
type: import("vue").PropType<import("vue").CSSProperties>;
};
popupContainer: {
type: import("vue").PropType<string | HTMLElement | undefined>;
};
}>> & {
"onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
'update:popupVisible': (visible: boolean) => boolean;
popupVisibleChange: (visible: boolean) => boolean;
}, string, {
"onUpdate:popupVisible"?: ((_visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((_visible: boolean) => any) | undefined;
}, {
popupVisible: boolean;

@@ -213,9 +81,12 @@ defaultPopupVisible: boolean;

position: "top" | "right" | "bottom" | "left" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "left-top" | "left-bottom" | "right-top" | "right-bottom";
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
default: (_: {}) => any;
title: (_: {}) => any;
content: (_: {}) => any;
}>, {
default: (_: {}) => any;
title: (_: {}) => any;
content: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

8

dist/types/components/popup/src/props.d.ts

@@ -72,6 +72,6 @@ import type { CSSProperties, ExtractPropTypes, PropType } from 'vue';

export declare const popupEmits: {
'update:popupVisible': (visible: boolean) => boolean;
popupVisibleChange: (visible: boolean) => boolean;
'update:popupVisible': (_visible: boolean) => boolean;
popupVisibleChange: (_visible: boolean) => boolean;
};
export declare type PopupEmits = typeof popupEmits;
export declare type OPopupEmits = ExtractPropTypes<typeof popupProps>;
export type PopupEmits = typeof popupEmits;
export type OPopupEmits = ExtractPropTypes<typeof popupProps>;

189

dist/types/components/rate/index.d.ts

@@ -1,153 +0,2 @@

export declare const ORate: import("../../utils/types").SFCWithInstall<{
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
readonly text: string;
readonly readonly: boolean;
readonly modelValue: number;
readonly max: number;
readonly color: string;
readonly voidColor: string;
readonly allowHalf: boolean;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: NumberConstructor;
readonly default: 0;
};
readonly max: {
readonly type: NumberConstructor;
readonly default: 5;
};
readonly readonly: BooleanConstructor;
readonly text: {
readonly type: StringConstructor;
readonly default: "";
};
readonly color: {
readonly type: StringConstructor;
readonly default: "warning";
};
readonly voidColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly allowHalf: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "text" | "readonly" | "modelValue" | "max" | "color" | "voidColor" | "allowHalf">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: NumberConstructor;
readonly default: 0;
};
readonly max: {
readonly type: NumberConstructor;
readonly default: 5;
};
readonly readonly: BooleanConstructor;
readonly text: {
readonly type: StringConstructor;
readonly default: "";
};
readonly color: {
readonly type: StringConstructor;
readonly default: "warning";
};
readonly voidColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly allowHalf: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {
setCurValue: (item: number, e: MouseEvent) => void;
resetCurValue: () => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], string, {
readonly text: string;
readonly readonly: boolean;
readonly modelValue: number;
readonly max: number;
readonly color: string;
readonly voidColor: string;
readonly allowHalf: boolean;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: NumberConstructor;
readonly default: 0;
};
readonly max: {
readonly type: NumberConstructor;
readonly default: 5;
};
readonly readonly: BooleanConstructor;
readonly text: {
readonly type: StringConstructor;
readonly default: "";
};
readonly color: {
readonly type: StringConstructor;
readonly default: "warning";
};
readonly voidColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly allowHalf: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
} & import("vue").ShallowUnwrapRef<{
setCurValue: (item: number, e: MouseEvent) => void;
resetCurValue: () => void;
}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
export declare const ORate: import("../../utils/types").SFCWithInstall<import("vue").DefineComponent<{
readonly modelValue: {

@@ -178,2 +27,31 @@ readonly type: NumberConstructor;

};
}, {
setCurValue: (item: number, e: MouseEvent) => void;
resetCurValue: () => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: NumberConstructor;
readonly default: 0;
};
readonly max: {
readonly type: NumberConstructor;
readonly default: 5;
};
readonly readonly: BooleanConstructor;
readonly text: {
readonly type: StringConstructor;
readonly default: "";
};
readonly color: {
readonly type: StringConstructor;
readonly default: "warning";
};
readonly voidColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly allowHalf: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {

@@ -183,13 +61,10 @@ onChange?: ((...args: any[]) => any) | undefined;

}, {
setCurValue: (item: number, e: MouseEvent) => void;
resetCurValue: () => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", {
readonly text: string;
readonly readonly: boolean;
readonly modelValue: number;
readonly max: number;
readonly color: string;
readonly readonly: boolean;
readonly voidColor: string;
readonly allowHalf: boolean;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps> & Record<string, any>;
}>> & Record<string, any>;
export default ORate;

195

dist/types/components/rate/src/index.vue.d.ts

@@ -1,157 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
readonly text: string;
readonly readonly: boolean;
readonly modelValue: number;
readonly max: number;
readonly color: string;
readonly voidColor: string;
readonly allowHalf: boolean;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: NumberConstructor;
readonly default: 0;
};
readonly max: {
readonly type: NumberConstructor;
readonly default: 5;
};
readonly readonly: BooleanConstructor;
readonly text: {
readonly type: StringConstructor;
readonly default: "";
};
readonly color: {
readonly type: StringConstructor;
readonly default: "warning";
};
readonly voidColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly allowHalf: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "text" | "readonly" | "modelValue" | "max" | "color" | "voidColor" | "allowHalf">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: NumberConstructor;
readonly default: 0;
};
readonly max: {
readonly type: NumberConstructor;
readonly default: 5;
};
readonly readonly: BooleanConstructor;
readonly text: {
readonly type: StringConstructor;
readonly default: "";
};
readonly color: {
readonly type: StringConstructor;
readonly default: "warning";
};
readonly voidColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly allowHalf: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {
/** @description set current value */
setCurValue: (item: number, e: MouseEvent) => void;
/** @description reset current value */
resetCurValue: () => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], string, {
readonly text: string;
readonly readonly: boolean;
readonly modelValue: number;
readonly max: number;
readonly color: string;
readonly voidColor: string;
readonly allowHalf: boolean;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: NumberConstructor;
readonly default: 0;
};
readonly max: {
readonly type: NumberConstructor;
readonly default: 5;
};
readonly readonly: BooleanConstructor;
readonly text: {
readonly type: StringConstructor;
readonly default: "";
};
readonly color: {
readonly type: StringConstructor;
readonly default: "warning";
};
readonly voidColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly allowHalf: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
} & import("vue").ShallowUnwrapRef<{
/** @description set current value */
setCurValue: (item: number, e: MouseEvent) => void;
/** @description reset current value */
resetCurValue: () => void;
}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: import("vue").DefineComponent<{
readonly modelValue: {

@@ -182,5 +27,2 @@ readonly type: NumberConstructor;

};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {

@@ -191,11 +33,40 @@ /** @description set current value */

resetCurValue: () => void;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", {
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: NumberConstructor;
readonly default: 0;
};
readonly max: {
readonly type: NumberConstructor;
readonly default: 5;
};
readonly readonly: BooleanConstructor;
readonly text: {
readonly type: StringConstructor;
readonly default: "";
};
readonly color: {
readonly type: StringConstructor;
readonly default: "warning";
};
readonly voidColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly allowHalf: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {
readonly text: string;
readonly readonly: boolean;
readonly modelValue: number;
readonly max: number;
readonly color: string;
readonly readonly: boolean;
readonly voidColor: string;
readonly allowHalf: boolean;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
}>;
export default _default;

2

dist/types/components/rate/src/props.d.ts

@@ -29,2 +29,2 @@ import type { ExtractPropTypes } from 'vue';

};
export declare type ORateProps = ExtractPropTypes<typeof rateProps>;
export type ORateProps = ExtractPropTypes<typeof rateProps>;

145

dist/types/components/switch/index.d.ts

@@ -1,122 +0,2 @@

export declare const OSwitch: import("../../utils/types").SFCWithInstall<{
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
readonly size: "sm" | "md" | "lg";
readonly light: boolean;
readonly disabled: boolean;
readonly modelValue: boolean;
readonly backgroundColor: string;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: BooleanConstructor;
readonly size: {
readonly type: import("vue").PropType<"sm" | "md" | "lg">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly backgroundColor: {
readonly type: StringConstructor;
readonly default: "#dbdbdb";
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "size" | "light" | "disabled" | "modelValue" | "backgroundColor">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: BooleanConstructor;
readonly size: {
readonly type: import("vue").PropType<"sm" | "md" | "lg">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly backgroundColor: {
readonly type: StringConstructor;
readonly default: "#dbdbdb";
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], string, {
readonly size: "sm" | "md" | "lg";
readonly light: boolean;
readonly disabled: boolean;
readonly modelValue: boolean;
readonly backgroundColor: string;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: BooleanConstructor;
readonly size: {
readonly type: import("vue").PropType<"sm" | "md" | "lg">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly backgroundColor: {
readonly type: StringConstructor;
readonly default: "#dbdbdb";
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
} & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
export declare const OSwitch: import("../../utils/types").SFCWithInstall<import("vue").DefineComponent<{
readonly modelValue: {

@@ -140,6 +20,25 @@ readonly type: BooleanConstructor;

};
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: BooleanConstructor;
readonly size: {
readonly type: import("vue").PropType<"sm" | "md" | "lg">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly backgroundColor: {
readonly type: StringConstructor;
readonly default: "#dbdbdb";
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", {
}, {
readonly size: "sm" | "md" | "lg";

@@ -150,3 +49,3 @@ readonly light: boolean;

readonly backgroundColor: string;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps> & Record<string, any>;
}>> & Record<string, any>;
export default OSwitch;

145

dist/types/components/switch/src/index.vue.d.ts

@@ -1,122 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
readonly size: "sm" | "md" | "lg";
readonly light: boolean;
readonly disabled: boolean;
readonly modelValue: boolean;
readonly backgroundColor: string;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: BooleanConstructor;
readonly size: {
readonly type: import("vue").PropType<"sm" | "md" | "lg">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly backgroundColor: {
readonly type: StringConstructor;
readonly default: "#dbdbdb";
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "size" | "light" | "disabled" | "modelValue" | "backgroundColor">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: (event: "change" | "update:modelValue", ...args: any[]) => void;
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: BooleanConstructor;
readonly size: {
readonly type: import("vue").PropType<"sm" | "md" | "lg">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly backgroundColor: {
readonly type: StringConstructor;
readonly default: "#dbdbdb";
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], string, {
readonly size: "sm" | "md" | "lg";
readonly light: boolean;
readonly disabled: boolean;
readonly modelValue: boolean;
readonly backgroundColor: string;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: BooleanConstructor;
readonly size: {
readonly type: import("vue").PropType<"sm" | "md" | "lg">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly backgroundColor: {
readonly type: StringConstructor;
readonly default: "#dbdbdb";
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
} & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: import("vue").DefineComponent<{
readonly modelValue: {

@@ -140,6 +20,25 @@ readonly type: BooleanConstructor;

};
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly modelValue: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: BooleanConstructor;
readonly size: {
readonly type: import("vue").PropType<"sm" | "md" | "lg">;
readonly default: "md";
readonly validator: (val: string) => boolean;
};
readonly backgroundColor: {
readonly type: StringConstructor;
readonly default: "#dbdbdb";
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onChange?: ((...args: any[]) => any) | undefined;
"onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", {
}, {
readonly size: "sm" | "md" | "lg";

@@ -150,3 +49,3 @@ readonly light: boolean;

readonly backgroundColor: string;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
}>;
export default _default;

2

dist/types/components/switch/src/props.d.ts

@@ -22,2 +22,2 @@ import type { ExtractPropTypes, PropType } from 'vue';

};
export declare type OSwitchProps = ExtractPropTypes<typeof switchProps>;
export type OSwitchProps = ExtractPropTypes<typeof switchProps>;

213

dist/types/components/tag/src/index.vue.d.ts

@@ -1,162 +0,2 @@

declare const _default: {
new (...args: any[]): {
$: import("vue").ComponentInternalInstance;
$data: {};
$props: Partial<{
readonly size: "xs" | "sm" | "md" | "lg";
readonly type: "error" | "info" | "primary" | "secondary" | "success" | "warning";
readonly light: boolean;
readonly disabled: boolean;
readonly closable: boolean;
readonly bgColor: string;
readonly rounded: boolean;
}> & Omit<Readonly<import("vue").ExtractPropTypes<{
readonly type: {
readonly type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
readonly default: "primary";
};
readonly size: {
readonly type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
readonly default: "sm";
readonly validator: (val: string) => boolean;
};
readonly closable: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly bgColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly rounded: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onClick?: ((evt: MouseEvent) => any) | undefined;
onClose?: ((evt: MouseEvent) => any) | undefined;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "size" | "type" | "light" | "disabled" | "closable" | "bgColor" | "rounded">;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: import("vue").Slot | undefined;
}>;
$root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null;
$emit: ((event: "click", evt: MouseEvent) => void) & ((event: "close", evt: MouseEvent) => void);
$el: any;
$options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
readonly type: {
readonly type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
readonly default: "primary";
};
readonly size: {
readonly type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
readonly default: "sm";
readonly validator: (val: string) => boolean;
};
readonly closable: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly bgColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly rounded: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onClick?: ((evt: MouseEvent) => any) | undefined;
onClose?: ((evt: MouseEvent) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
close: (evt: MouseEvent) => boolean;
click: (evt: MouseEvent) => boolean;
}, string, {
readonly size: "xs" | "sm" | "md" | "lg";
readonly type: "error" | "info" | "primary" | "secondary" | "success" | "warning";
readonly light: boolean;
readonly disabled: boolean;
readonly closable: boolean;
readonly bgColor: string;
readonly rounded: boolean;
}, {}, string> & {
beforeCreate?: ((() => void) | (() => void)[]) | undefined;
created?: ((() => void) | (() => void)[]) | undefined;
beforeMount?: ((() => void) | (() => void)[]) | undefined;
mounted?: ((() => void) | (() => void)[]) | undefined;
beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
updated?: ((() => void) | (() => void)[]) | undefined;
activated?: ((() => void) | (() => void)[]) | undefined;
deactivated?: ((() => void) | (() => void)[]) | undefined;
beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
destroyed?: ((() => void) | (() => void)[]) | undefined;
unmounted?: ((() => void) | (() => void)[]) | undefined;
renderTracked?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
renderTriggered?: (((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[]) | undefined;
errorCaptured?: (((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}> | null, info: string) => boolean | void)[]) | undefined;
};
$forceUpdate: () => void;
$nextTick: typeof import("vue").nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean> | undefined): import("vue").WatchStopHandle;
} & Readonly<import("vue").ExtractPropTypes<{
readonly type: {
readonly type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
readonly default: "primary";
};
readonly size: {
readonly type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
readonly default: "sm";
readonly validator: (val: string) => boolean;
};
readonly closable: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly bgColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly rounded: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onClick?: ((evt: MouseEvent) => any) | undefined;
onClose?: ((evt: MouseEvent) => any) | undefined;
} & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
__isFragment?: undefined;
__isTeleport?: undefined;
__isSuspense?: undefined;
} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
readonly type: {

@@ -191,9 +31,39 @@ readonly type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;

};
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
close: (evt: MouseEvent) => boolean;
click: (evt: MouseEvent) => boolean;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
readonly type: {
readonly type: import("vue").PropType<"error" | "info" | "primary" | "secondary" | "success" | "warning">;
readonly default: "primary";
};
readonly size: {
readonly type: import("vue").PropType<"xs" | "sm" | "md" | "lg">;
readonly default: "sm";
readonly validator: (val: string) => boolean;
};
readonly closable: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly light: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly bgColor: {
readonly type: StringConstructor;
readonly default: "";
};
readonly rounded: {
readonly type: BooleanConstructor;
readonly default: false;
};
readonly disabled: {
readonly type: BooleanConstructor;
readonly default: false;
};
}>> & {
onClick?: ((evt: MouseEvent) => any) | undefined;
onClose?: ((evt: MouseEvent) => any) | undefined;
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
close: (evt: MouseEvent) => boolean;
click: (evt: MouseEvent) => boolean;
}, string, {
}, {
readonly size: "xs" | "sm" | "md" | "lg";

@@ -206,7 +76,10 @@ readonly type: "error" | "info" | "primary" | "secondary" | "success" | "warning";

readonly rounded: boolean;
}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
$slots: {
default: (_: {}) => any;
}>, {
default: (_: {}) => any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
new (): {
$slots: S;
};
});
export default _default;
};

4

dist/types/components/tag/src/props.d.ts

@@ -40,3 +40,3 @@ import type { ExtractPropTypes, PropType } from 'vue';

};
export declare type OTagProps = ExtractPropTypes<typeof tagProps>;
export type OTagProps = ExtractPropTypes<typeof tagProps>;
export declare const tagEmits: {

@@ -46,2 +46,2 @@ close: (evt: MouseEvent) => boolean;

};
export declare type TagEmits = typeof tagEmits;
export type TagEmits = typeof tagEmits;

8

dist/types/components/trigger/index.d.ts

@@ -107,4 +107,4 @@ export declare const OTrigger: import("../../utils/types").SFCWithInstall<import("vue").DefineComponent<{

}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
'update:popupVisible': (visible: boolean) => boolean;
popupVisibleChange: (visible: boolean) => boolean;
'update:popupVisible': (_visible: boolean) => boolean;
popupVisibleChange: (_visible: boolean) => boolean;
show: () => boolean;

@@ -222,4 +222,4 @@ hide: () => boolean;

onShow?: (() => any) | undefined;
"onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
"onUpdate:popupVisible"?: ((_visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((_visible: boolean) => any) | undefined;
}, {

@@ -226,0 +226,0 @@ disabled: boolean;

8

dist/types/components/trigger/src/index.d.ts

@@ -109,4 +109,4 @@ import type { CSSProperties } from 'vue';

}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
'update:popupVisible': (visible: boolean) => boolean;
popupVisibleChange: (visible: boolean) => boolean;
'update:popupVisible': (_visible: boolean) => boolean;
popupVisibleChange: (_visible: boolean) => boolean;
show: () => boolean;

@@ -224,4 +224,4 @@ hide: () => boolean;

onShow?: (() => any) | undefined;
"onUpdate:popupVisible"?: ((visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((visible: boolean) => any) | undefined;
"onUpdate:popupVisible"?: ((_visible: boolean) => any) | undefined;
onPopupVisibleChange?: ((_visible: boolean) => any) | undefined;
}, {

@@ -228,0 +228,0 @@ disabled: boolean;

8

dist/types/components/trigger/src/props.d.ts

@@ -178,4 +178,4 @@ import type { CSSProperties, ExtractPropTypes, PropType } from 'vue';

export declare const triggerEmits: {
'update:popupVisible': (visible: boolean) => boolean;
popupVisibleChange: (visible: boolean) => boolean;
'update:popupVisible': (_visible: boolean) => boolean;
popupVisibleChange: (_visible: boolean) => boolean;
show: () => boolean;

@@ -185,3 +185,3 @@ hide: () => boolean;

};
export declare type TriggerEmits = typeof triggerEmits;
export declare type OTriggerEmits = ExtractPropTypes<typeof TriggerProps>;
export type TriggerEmits = typeof triggerEmits;
export type OTriggerEmits = ExtractPropTypes<typeof TriggerProps>;

2

dist/types/components/trigger/src/utils.d.ts

@@ -11,3 +11,3 @@ import type { CSSProperties } from 'vue';

}
export declare type TriggerPopupTranslate = [number, number] | {
export type TriggerPopupTranslate = [number, number] | {
[key in Placement]?: [number, number];

@@ -14,0 +14,0 @@ };

28

dist/types/components/types.d.ts

@@ -1,9 +0,9 @@

declare type VNode = import('vue').VNode;
export declare type SlotReturnValue = VNode | string | boolean | null | undefined | SlotReturnArray;
export declare type SlotReturnArray = Array<SlotReturnValue>;
export declare type INodeReturnType = SlotReturnValue;
export declare type INode<T = undefined> = T extends undefined ? (h: typeof import('vue').h) => INodeReturnType : (h: typeof import('vue').h, props: T) => INodeReturnType;
export declare type AttachNodeReturnValue = HTMLElement | Element | Document;
export declare type AttachNode = string | ((triggerNode?: HTMLElement) => AttachNodeReturnValue);
export declare type Mutable<T> = {
type VNode = import('vue').VNode;
export type SlotReturnValue = VNode | string | boolean | null | undefined | SlotReturnArray;
export type SlotReturnArray = Array<SlotReturnValue>;
export type INodeReturnType = SlotReturnValue;
export type INode<T = undefined> = T extends undefined ? (h: typeof import('vue').h) => INodeReturnType : (h: typeof import('vue').h, props: T) => INodeReturnType;
export type AttachNodeReturnValue = HTMLElement | Element | Document;
export type AttachNode = string | ((triggerNode?: HTMLElement) => AttachNodeReturnValue);
export type Mutable<T> = {
-readonly [P in keyof T]: T[P];

@@ -17,8 +17,8 @@ };

export declare const commonShadowTrigger: readonly ["hover", "always", "never"];
export declare type SizeType = typeof commonSize[number];
export declare type PositionType = typeof commonPosition[number];
export declare type ThemeType = typeof commonTheme[number];
export declare type Placement = typeof commonPlacement[number];
export declare type TriggerType = typeof commonTrigger[number];
export declare type ShadowType = typeof commonShadowTrigger[number];
export type SizeType = typeof commonSize[number];
export type PositionType = typeof commonPosition[number];
export type ThemeType = typeof commonTheme[number];
export type Placement = typeof commonPlacement[number];
export type TriggerType = typeof commonTrigger[number];
export type ShadowType = typeof commonShadowTrigger[number];
export {};

2

dist/types/onu-ui/src/components.d.ts
import type { Plugin } from 'vue';
declare const _default: Plugin[];
declare const _default: Plugin<any[]>[];
export default _default;

2

dist/types/onu-ui/src/plugin.d.ts

@@ -0,3 +1,3 @@

import type { App, Plugin } from 'vue';
import type { InstallOptions } from '../../utils';
import type { App, Plugin } from 'vue';
export declare const createInstaller: (components?: Plugin[]) => {

@@ -4,0 +4,0 @@ version: string;

5

dist/types/preset/src/shortcuts/collapse.d.ts
export declare const collapseShortcuts: {
'o-collapse-base': string;
'o-collapse-item-wrap': string;
'o-collapse-item-wrap-active': string;
'o-collapse-item-title': string;
'o-collapse-item-title-active': string;
'o-collapse-item-title-arrow-right': string;
'o-collapse-item-title-left': string;
'o-collapse-item-title-arrow-base': string;
'o-collapse-item-wrap': string;
'o-collapse-item-content-wrap': string;
'o-collapse-item-content': string;
};

4

dist/types/preset/src/type.d.ts

@@ -1,2 +0,2 @@

export declare type SizeType = 'xs' | 'sm' | 'md' | 'lg';
export declare type ThemeType = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
export type SizeType = 'xs' | 'sm' | 'md' | 'lg';
export type ThemeType = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';

2

dist/types/utils/hooks/useGlobalConfig.d.ts

@@ -0,3 +1,3 @@

import type { App, Ref } from 'vue';
import type { InstallOptions } from '../tokens';
import type { App, Ref } from 'vue';
import type { MaybeRef } from '../types';

@@ -4,0 +4,0 @@ /**

6

dist/types/utils/hooks/useLocale.d.ts

@@ -0,6 +1,6 @@

import type { Ref } from 'vue';
import type { language } from '../locale';
import type { Ref } from 'vue';
import type { MaybeRef } from '../types';
export declare type OnuTranslatorOption = Record<string, string | number>;
export declare type OnuTranslator = (path: string, option?: OnuTranslatorOption) => string;
export type OnuTranslatorOption = Record<string, string | number>;
export type OnuTranslator = (path: string, option?: OnuTranslatorOption) => string;
export interface OnuLocaleContext {

@@ -7,0 +7,0 @@ locale: Ref<language>;

1

dist/types/utils/locale/index.d.ts
export { default as en } from './lang/en';
export { default as pt } from './lang/pt';
export { default as zhCn } from './lang/zh-cn';

@@ -3,0 +4,0 @@ export interface TranslatePair {

6

dist/types/utils/types.d.ts
import type { AppContext, Plugin, Ref } from 'vue';
export declare type SFCWithInstall<T> = T & Plugin;
export declare type SFCInstallWithContext<T> = SFCWithInstall<T> & {
export type SFCWithInstall<T> = T & Plugin;
export type SFCInstallWithContext<T> = SFCWithInstall<T> & {
_context: AppContext | null;
};
export declare type MaybeRef<T> = T | Ref<T>;
export type MaybeRef<T> = T | Ref<T>;

38

package.json
{
"name": "onu-ui",
"type": "module",
"version": "1.0.13-alpha",
"description": "Onu-UI for web glassmorphism components generate by UnoCSS.",
"type": "module",
"version": "1.0.12",
"keywords": [
"onu-ui",
"unocss",
"vueuse"
],
"author": "chris-zhu <https://github.com/chris-zhu>",
"license": "MIT",
"author": "chris-zhu <https://github.com/chris-zhu>",
"homepage": "https://github.com/onu-ui/onu-ui#readme",
"repository": {

@@ -18,13 +14,22 @@ "type": "git",

},
"main": "./dist/onu-ui.umd.cjs",
"module": "./dist/onu-ui.js",
"types": "./dist/types/onu-ui/src/index.d.ts",
"bugs": {
"url": "https://github.com/onu-ui/onu-ui/issues"
},
"keywords": [
"onu-ui",
"unocss",
"vueuse"
],
"sideEffects": false,
"exports": {
".": {
"import": "./dist/onu-ui.js",
"types": "./dist/types/onu-ui/src/index.d.ts",
"require": "./dist/onu-ui.umd.cjs",
"types": "./dist/types/onu-ui/src/index.d.ts"
"import": "./dist/onu-ui.js"
},
"./dist/style.css": "./dist/style.css"
},
"main": "./dist/onu-ui.umd.cjs",
"module": "./dist/onu-ui.js",
"types": "./dist/types/onu-ui/src/index.d.ts",
"files": [

@@ -34,9 +39,4 @@ "dist",

],
"sideEffects": false,
"bugs": {
"url": "https://github.com/onu-ui/onu-ui/issues"
},
"homepage": "https://github.com/onu-ui/onu-ui#readme",
"dependencies": {
"@onu-ui/components": "1.0.12"
"@onu-ui/components": "1.0.13-alpha"
},

@@ -43,0 +43,0 @@ "publishConfig": {

42

README.md

@@ -15,8 +15,8 @@ <p align="center">

- 🌈 Components Design - Onu provides neat & beautiful crafted UI components.
- 🔥 Introduce on demand - Provide resolver to automatically import only used components.
- 🎉 TS Supported - Support TypeScript & type checked & type inference.
- 💡 Cli Build - Easy to create repo with Onu Cli.
- 🍬 CSS Preset - Has UnoCSS preset package to use, rendered UI easily.
- ⚙️ Theme Config - Use attribute mode like unocss to design. Support theme config to customize theme.
- 🌈 **Components Design** - Onu provides neat & beautiful crafted UI components.
- 🔥 **On demand Import** - Provide resolver to automatically import only used components.
- 🎉 **Typescript Supported** - Support TypeScript & type checked & type inference.
- 💎 **[Iconify Icons](https://icones.js.org/)** - Use any icon from the library you love.
- 🍬 **[CSS Preset](https://github.com/onu-ui/onu-ui/tree/main/packages/preset)** - Has UnoCSS preset package to use, rendered UI easily.
- ⚙️ **Theme Config** - Use attribute mode like unocss to design. Support theme config to customize theme.

@@ -91,28 +91,40 @@ ## Usage

## Playground
## Online Playground
You can try OnuUI out with the components built-in playground.
### Try it with our built-in playground(WIP)
### Try it with our built-in playground
### Try it with stackblitz
[Playground](https://onu.zyob.top/play/)
[![Edit Onu UI](https://img.shields.io/badge/Edit%20on%20Stackblitz-1877F2?style=for-the-badge&logo=stackblitz&logoColor=white)](https://stackblitz.com/edit/onu-starter)
### Try it with stackblitz or codesandbox
<a target="_blank" href="https://codesandbox.io/p/github/yzh990918/onu-starter/main">
<img src="https://img.shields.io/badge/Try%20On-CodeSandbox-hsl(265%2C97%25%2C66%25)?style=for-the-badge&logo=codesandbox" height="35" />
</a><br/>
<a target="_blank" href="https://stackblitz.com/edit/onu-starter">
<img src="https://img.shields.io/badge/Try%20on%20Stackblitz-1877F2?style=for-the-badge&logo=stackblitz&logoColor=white" height="35" />
</a>
## Contributing
Developers interested in contributing should read the [Code of Conduct](https://github.com/onu-ui/onu-ui/blob/main/CODE_OF_CONDUCT.md) and the [Contributing Guide](https://github.com/onu-ui/onu-ui/blob/main/CONTRIBUTING.md).
Developers interested in contributing should read the [Code of Conduct](./CODE_OF_CONDUCT.md) and the [Contributing Guide](./CONTRIBUTING.md).
Thank you to all the people who already contributed to OnuUI!
Thanks to everyone who has already contributed to OnuUI!
<a href="https://github.com/onu-ui/onu-ui/graphs/contributors"><img src="https://contrib.rocks/image?repo=onu-ui/onu-ui" /></a>
## Discussions
Since `OnuUI` is under intensive development, we need your valuable comments and feature requirements of the component
Welcome to contact us at [Discussions](https://github.com/onu-ui/onu-ui/discussions) or [Issues](https://github.com/onu-ui/onu-ui/issues/new/choose), we will be more than happy to reply to your message.
## Credits
[UnoCSS](https://github.com/unocss/unocss)
- [UnoCSS](https://github.com/unocss/unocss)
- [@nuxt/ui](https://github.com/nuxt/ui)
[@nuxt/ui](https://github.com/nuxt/ui)
## License
[MIT](https://github.com/onu-ui/onu-ui/blob/main/LICENSE) License © 2022 [chris-zhu](https://github.com/chris-zhu)
dist/onu-ui.js

Sorry, the diff of this file is too big to display

dist/onu-ui.umd.cjs

Sorry, the diff of this file is not supported yet

dist/style.css

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc