@icc-grow/web-components 1.0.0

package/dist/types/components/i-select/index.d.ts

@@ -0,0 +1,184 @@
+import { default as Select } from './src/select.vue';
+export * from './src/types';
+export type ISelectInstance = InstanceType<typeof Select>;
+export declare const ISelect: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue?: import('.').SelectValue | import('.').SelectValue[];
+    } & import('.').SelectProps> & Readonly<{
+        onClear?: (() => any) | undefined;
+        onSearch?: ((keyword: string) => any) | undefined;
+        onChange?: ((value: import('.').SelectValue | import('.').SelectValue[] | undefined, option: import('.').SelectOptionItem | import('.').SelectOptionItem[] | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+        "onVisible-change"?: ((visible: boolean) => any) | undefined;
+    }>, {
+        show: () => void;
+        hide: () => void;
+        focus: () => void;
+        blur: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        clear: () => any;
+        search: (keyword: string) => any;
+        change: (value: import('.').SelectValue | import('.').SelectValue[] | undefined, option: import('.').SelectOptionItem | import('.').SelectOptionItem[] | undefined) => any;
+        "update:modelValue": (...args: unknown[]) => any;
+        "visible-change": (visible: boolean) => any;
+    }, import('vue').PublicProps, {
+        props: import('.').SelectFieldNames;
+        placeholder: string;
+        options: import('.').SelectOptionItem[];
+        multiple: boolean;
+        disabled: boolean;
+        validateEvent: boolean;
+        clearable: boolean;
+        tagLimit: number;
+        filterable: boolean;
+        remote: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        triggerRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly disabled?: boolean | undefined;
+                readonly readonly?: boolean | undefined;
+                readonly focused?: boolean | undefined;
+                readonly error?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                readonly block?: boolean | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                wrapperRef: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('..').FieldShellProps> & Readonly<{}>, {
+                wrapperRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                error: boolean;
+                block: boolean;
+                disabled: boolean;
+                readonly: boolean;
+                focused: boolean;
+                multiline: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            error: boolean;
+            block: boolean;
+            disabled: boolean;
+            readonly: boolean;
+            focused: boolean;
+            multiline: boolean;
+        }> & Omit<Readonly<import('..').FieldShellProps> & Readonly<{}>, "wrapperRef" | ("error" | "block" | "disabled" | "readonly" | "focused" | "multiline")> & import('vue').ShallowUnwrapRef<{
+            wrapperRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null;
+        inputRef: HTMLInputElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        modelValue?: import('.').SelectValue | import('.').SelectValue[];
+    } & import('.').SelectProps> & Readonly<{
+        onClear?: (() => any) | undefined;
+        onSearch?: ((keyword: string) => any) | undefined;
+        onChange?: ((value: import('.').SelectValue | import('.').SelectValue[] | undefined, option: import('.').SelectOptionItem | import('.').SelectOptionItem[] | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+        "onVisible-change"?: ((visible: boolean) => any) | undefined;
+    }>, {
+        show: () => void;
+        hide: () => void;
+        focus: () => void;
+        blur: () => void;
+    }, {}, {}, {}, {
+        props: import('.').SelectFieldNames;
+        placeholder: string;
+        options: import('.').SelectOptionItem[];
+        multiple: boolean;
+        disabled: boolean;
+        validateEvent: boolean;
+        clearable: boolean;
+        tagLimit: number;
+        filterable: boolean;
+        remote: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{
+    modelValue?: import('.').SelectValue | import('.').SelectValue[];
+} & import('.').SelectProps> & Readonly<{
+    onClear?: (() => any) | undefined;
+    onSearch?: ((keyword: string) => any) | undefined;
+    onChange?: ((value: import('.').SelectValue | import('.').SelectValue[] | undefined, option: import('.').SelectOptionItem | import('.').SelectOptionItem[] | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+    "onVisible-change"?: ((visible: boolean) => any) | undefined;
+}>, {
+    show: () => void;
+    hide: () => void;
+    focus: () => void;
+    blur: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => any;
+    search: (keyword: string) => any;
+    change: (value: import('.').SelectValue | import('.').SelectValue[] | undefined, option: import('.').SelectOptionItem | import('.').SelectOptionItem[] | undefined) => any;
+    "update:modelValue": (...args: unknown[]) => any;
+    "visible-change": (visible: boolean) => any;
+}, string, {
+    props: import('.').SelectFieldNames;
+    placeholder: string;
+    options: import('.').SelectOptionItem[];
+    multiple: boolean;
+    disabled: boolean;
+    validateEvent: boolean;
+    clearable: boolean;
+    tagLimit: number;
+    filterable: boolean;
+    remote: boolean;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+        dropdown?(_: {}): any;
+        option?(_: {
+            item: import('.').SelectOptionItem;
+            index: number;
+            isSelected: boolean;
+        }): any;
+        footer?(_: {}): any;
+    };
+}) & import('vue').Plugin;
+export default ISelect;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/components/i-select/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/i-select/index.ts"],"names":[],"mappings":"AACA,OAAO,MAAM,MAAM,kBAAkB,CAAC;AAEtC,cAAc,aAAa,CAAC;AAC5B,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,OAAO,MAAM,CAAC,CAAC;AAE1D,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAE0yzB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAF14zB,CAAC;AAC3C,eAAe,OAAO,CAAC"}

package/dist/types/components/i-select/src/select.vue.d.ts

@@ -0,0 +1,200 @@
+import { SelectProps, SelectOptionItem, SelectValue } from './types';
+import { nextTick } from 'vue';
+type __VLS_Props = SelectProps;
+type __VLS_PublicProps = {
+    modelValue?: SelectValue | SelectValue[];
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        prefix?(_: {}): any;
+        suffix?(_: {}): any;
+        dropdown?(_: {}): any;
+        option?(_: {
+            item: SelectOptionItem;
+            index: number;
+            isSelected: boolean;
+        }): any;
+        footer?(_: {}): any;
+    };
+    refs: {
+        triggerRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly disabled?: boolean | undefined;
+                readonly readonly?: boolean | undefined;
+                readonly focused?: boolean | undefined;
+                readonly error?: boolean | undefined;
+                readonly multiline?: boolean | undefined;
+                readonly block?: boolean | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                wrapperRef: HTMLDivElement;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: (event: string, ...args: any[]) => void;
+            $el: HTMLDivElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('../..').FieldShellProps> & Readonly<{}>, {
+                wrapperRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                error: boolean;
+                block: boolean;
+                disabled: boolean;
+                readonly: boolean;
+                focused: boolean;
+                multiline: boolean;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            error: boolean;
+            block: boolean;
+            disabled: boolean;
+            readonly: boolean;
+            focused: boolean;
+            multiline: boolean;
+        }> & Omit<Readonly<import('../..').FieldShellProps> & Readonly<{}>, "wrapperRef" | ("error" | "block" | "disabled" | "readonly" | "focused" | "multiline")> & import('vue').ShallowUnwrapRef<{
+            wrapperRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | null;
+        inputRef: HTMLInputElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    show: () => void;
+    hide: () => void;
+    focus: () => void;
+    blur: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => any;
+    search: (keyword: string) => any;
+    change: (value: SelectValue | SelectValue[] | undefined, option: SelectOptionItem | SelectOptionItem[] | undefined) => any;
+    "update:modelValue": (...args: unknown[]) => any;
+    "visible-change": (visible: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClear?: (() => any) | undefined;
+    onSearch?: ((keyword: string) => any) | undefined;
+    onChange?: ((value: SelectValue | SelectValue[] | undefined, option: SelectOptionItem | SelectOptionItem[] | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+    "onVisible-change"?: ((visible: boolean) => any) | undefined;
+}>, {
+    props: import('./types').SelectFieldNames;
+    placeholder: string;
+    options: SelectOptionItem[];
+    multiple: boolean;
+    disabled: boolean;
+    validateEvent: boolean;
+    clearable: boolean;
+    tagLimit: number;
+    filterable: boolean;
+    remote: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    triggerRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly disabled?: boolean | undefined;
+            readonly readonly?: boolean | undefined;
+            readonly focused?: boolean | undefined;
+            readonly error?: boolean | undefined;
+            readonly multiline?: boolean | undefined;
+            readonly block?: boolean | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            wrapperRef: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('../..').FieldShellProps> & Readonly<{}>, {
+            wrapperRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            error: boolean;
+            block: boolean;
+            disabled: boolean;
+            readonly: boolean;
+            focused: boolean;
+            multiline: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        error: boolean;
+        block: boolean;
+        disabled: boolean;
+        readonly: boolean;
+        focused: boolean;
+        multiline: boolean;
+    }> & Omit<Readonly<import('../..').FieldShellProps> & Readonly<{}>, "wrapperRef" | ("error" | "block" | "disabled" | "readonly" | "focused" | "multiline")> & import('vue').ShallowUnwrapRef<{
+        wrapperRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) | null;
+    inputRef: HTMLInputElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=select.vue.d.ts.map

package/dist/types/components/i-select/src/select.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/i-select/src/select.vue"],"names":[],"mappings":"AA+IA;AAweA,OAAO,KAAK,EAAE,WAAW,EAA6B,gBAAgB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACrG,OAAO,EAAiB,QAAQ,EAAE,MAAM,KAAK,CAAC;AAa9C,KAAK,WAAW,GAAG,WAAW,CAAC;AAoT/B,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,WAAW,GAAG,WAAW,EAAE,CAAC;CACxC,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAoUT,OAAO,IAA6B;;wBAhBrB,GAAG;wBACH,GAAG;0BACD,GAAG;;;;;YACL,GAAG;wBACH,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCA3PoB,GAAG,8CAClB,GAAG,yBAE/B,GAAG,6DACO,GAClB;;;;;;;;;;;;;;;;;;EAuQA;AAgDD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA7T+B,GAAG,8CAClB,GAAG,yBAE/B,GAAG,6DACO,GAClB;;;;;;;;;;;;;;;;OAmUC,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/types/components/i-select/src/types.d.ts

@@ -0,0 +1,61 @@
+/** 选项值类型 */
+export type SelectValue = string | number;
+/** 字段映射配置 */
+export interface SelectFieldNames {
+    /** 显示文本字段名 */
+    label?: string;
+    /** 值字段名 */
+    value?: string;
+    /** 禁用字段名 */
+    disabled?: string;
+}
+/** 选项数据（允许任意结构，通过 props 字段映射） */
+export type SelectOptionItem = Record<string, unknown>;
+/** Select 组件 Props */
+export interface SelectProps {
+    /** 选项数据 */
+    options?: SelectOptionItem[];
+    /** 字段映射配置 */
+    props?: SelectFieldNames;
+    /** 是否多选 */
+    multiple?: boolean;
+    /** 是否禁用 */
+    disabled?: boolean;
+    /** 是否可清空 */
+    clearable?: boolean;
+    /** 占位文本 */
+    placeholder?: string;
+    /** 是否可搜索（本地过滤） */
+    filterable?: boolean;
+    /** 是否远程搜索 */
+    remote?: boolean;
+    /** 多选 Tag 最多展示数量 */
+    tagLimit?: number;
+    /** 是否触发表单校验 */
+    validateEvent?: boolean;
+}
+/** Select 组件 Emits */
+export interface SelectEmits {
+    /** v-model 更新 */
+    'update:modelValue': [value: SelectValue | SelectValue[] | undefined];
+    /** 值变化，返回值和选项对象 */
+    change: [value: SelectValue | SelectValue[] | undefined, option: SelectOptionItem | SelectOptionItem[] | undefined];
+    /** 搜索词变化（远程搜索模式） */
+    search: [keyword: string];
+    /** 清空 */
+    clear: [];
+    /** 面板显隐变化 */
+    'visible-change': [visible: boolean];
+}
+/** Select 组件暴露方法 */
+export interface SelectExpose {
+    /** 手动打开下拉面板 */
+    show: () => void;
+    /** 手动关闭下拉面板 */
+    hide: () => void;
+    /** 聚焦触发器 */
+    focus: () => void;
+    /** 失焦触发器 */
+    blur: () => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/components/i-select/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/components/i-select/src/types.ts"],"names":[],"mappings":"AAAA,YAAY;AACZ,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AAE1C,aAAa;AACb,MAAM,WAAW,gBAAgB;IAC/B,cAAc;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,iCAAiC;AACjC,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEvD,sBAAsB;AACtB,MAAM,WAAW,WAAW;IAC1B,WAAW;IACX,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC7B,aAAa;IACb,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,WAAW;IACX,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW;IACX,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY;IACZ,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,WAAW;IACX,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa;IACb,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,oBAAoB;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,sBAAsB;AACtB,MAAM,WAAW,WAAW;IAC1B,iBAAiB;IACjB,mBAAmB,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,EAAE,GAAG,SAAS,CAAC,CAAC;IACtE,mBAAmB;IACnB,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,EAAE,GAAG,SAAS,EAAE,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,EAAE,GAAG,SAAS,CAAC,CAAC;IACpH,oBAAoB;IACpB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC1B,SAAS;IACT,KAAK,EAAE,EAAE,CAAC;IACV,aAAa;IACb,gBAAgB,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,oBAAoB;AACpB,MAAM,WAAW,YAAY;IAC3B,eAAe;IACf,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,eAAe;IACf,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,YAAY;IACZ,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,YAAY;IACZ,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB"}

package/dist/types/components/i-sortable/index.d.ts

@@ -0,0 +1,107 @@
+import { default as Sortable } from './src/sortable.vue';
+export * from './src/types';
+export type ISortableInstance = InstanceType<typeof Sortable>;
+export declare const ISortable: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('.').SortableProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: unknown[]) => any) | undefined;
+        "onSort-start"?: ((event: {
+            item: unknown;
+            index: number;
+        }) => any) | undefined;
+        "onSort-end"?: ((event: {
+            item: unknown;
+            oldIndex: number;
+            newIndex: number;
+        }) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:modelValue": (value: unknown[]) => any;
+        "sort-start": (event: {
+            item: unknown;
+            index: number;
+        }) => any;
+        "sort-end": (event: {
+            item: unknown;
+            oldIndex: number;
+            newIndex: number;
+        }) => any;
+    }, import('vue').PublicProps, {
+        animationDuration: number;
+        direction: import('.').SortDirection;
+        disabled: boolean;
+        tag: string;
+        threshold: number;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        containerRef: unknown;
+        dragPreviewRef: HTMLDivElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('.').SortableProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: unknown[]) => any) | undefined;
+        "onSort-start"?: ((event: {
+            item: unknown;
+            index: number;
+        }) => any) | undefined;
+        "onSort-end"?: ((event: {
+            item: unknown;
+            oldIndex: number;
+            newIndex: number;
+        }) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        animationDuration: number;
+        direction: import('.').SortDirection;
+        disabled: boolean;
+        tag: string;
+        threshold: number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('.').SortableProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: unknown[]) => any) | undefined;
+    "onSort-start"?: ((event: {
+        item: unknown;
+        index: number;
+    }) => any) | undefined;
+    "onSort-end"?: ((event: {
+        item: unknown;
+        oldIndex: number;
+        newIndex: number;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: unknown[]) => any;
+    "sort-start": (event: {
+        item: unknown;
+        index: number;
+    }) => any;
+    "sort-end": (event: {
+        item: unknown;
+        oldIndex: number;
+        newIndex: number;
+    }) => any;
+}, string, {
+    animationDuration: number;
+    direction: import('.').SortDirection;
+    disabled: boolean;
+    tag: string;
+    threshold: number;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {
+            item: unknown;
+            index: number;
+            isDragging: boolean;
+        }): any;
+        default?(_: {
+            item: {} | undefined;
+            index: number;
+            isDragging: boolean;
+        }): any;
+    };
+}) & import('vue').Plugin;
+export default ISortable;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/components/i-sortable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/i-sortable/index.ts"],"names":[],"mappings":"AACA,OAAO,QAAQ,MAAM,oBAAoB,CAAC;AAE1C,cAAc,aAAa,CAAC;AAC5B,MAAM,MAAM,iBAAiB,GAAG,YAAY,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE9D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAwB,CAAC;AAC/C,eAAe,SAAS,CAAC"}

package/dist/types/components/i-sortable/src/sortable.vue.d.ts

@@ -0,0 +1,62 @@
+import { SortableProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            item: unknown;
+            index: number;
+            isDragging: boolean;
+        }): any;
+        default?(_: {
+            item: {} | undefined;
+            index: number;
+            isDragging: boolean;
+        }): any;
+    };
+    refs: {
+        containerRef: unknown;
+        dragPreviewRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SortableProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: unknown[]) => any;
+    "sort-start": (event: {
+        item: unknown;
+        index: number;
+    }) => any;
+    "sort-end": (event: {
+        item: unknown;
+        oldIndex: number;
+        newIndex: number;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<SortableProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: unknown[]) => any) | undefined;
+    "onSort-start"?: ((event: {
+        item: unknown;
+        index: number;
+    }) => any) | undefined;
+    "onSort-end"?: ((event: {
+        item: unknown;
+        oldIndex: number;
+        newIndex: number;
+    }) => any) | undefined;
+}>, {
+    animationDuration: number;
+    direction: import('./types').SortDirection;
+    disabled: boolean;
+    tag: string;
+    threshold: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    containerRef: unknown;
+    dragPreviewRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=sortable.vue.d.ts.map

package/dist/types/components/i-sortable/src/sortable.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortable.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/i-sortable/src/sortable.vue"],"names":[],"mappings":"AA+BA;AAolBA,OAAO,KAAK,EAAiB,aAAa,EAAE,MAAM,SAAS,CAAC;AAshB5D,iBAAS,cAAc;WAwFT,OAAO,IAA6B;;;;;;YAbrB,GAAG;;;;;YACH,GAAG;;;;;;;EAiB/B;AAqBD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAUnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}