@lingshugroup/web-plus 1.3.0 → 1.3.2

package/lib/types/components/map/types.d.ts

@@ -0,0 +1,61 @@
+import { EpPropFinalized } from '../_utils/types';
+export type MarkerAnchorType = 'top-left' | 'top-center' | 'top-right' | 'middle-left' | 'center' | 'middle-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+export declare const lsMapProps: {
+    securityCode: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    mapKey: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    width: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    height: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    searchWord: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    center: EpPropFinalized<(ArrayConstructor | null)[], unknown, unknown, () => null, boolean>;
+    zoom: EpPropFinalized<NumberConstructor, unknown, unknown, number, boolean>;
+    zooms: EpPropFinalized<{
+        (arrayLength: number): number[];
+        (...items: number[]): number[];
+        new (arrayLength: number): number[];
+        new (...items: number[]): number[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, number[], boolean>;
+    areaColor: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    showMarker: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    markerList: EpPropFinalized<{
+        (arrayLength: number): any[];
+        (...items: any[]): any[];
+        new (arrayLength: number): any[];
+        new (...items: any[]): any[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    markerIcon: EpPropFinalized<ObjectConstructor, unknown, unknown, null, boolean>;
+    markerIconSize: EpPropFinalized<ArrayConstructor, unknown, unknown, () => number[], boolean>;
+    showMarkerDialog: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    markerDialogContent: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    markerDialogAnchor: EpPropFinalized<(new (...args: any[]) => "top-left" | "top-center" | "top-right" | "middle-left" | "center" | "middle-right" | "bottom-left" | "bottom-center" | "bottom-right") | (() => MarkerAnchorType) | (((new (...args: any[]) => "top-left" | "top-center" | "top-right" | "middle-left" | "center" | "middle-right" | "bottom-left" | "bottom-center" | "bottom-right") | (() => MarkerAnchorType)) | null)[], unknown, unknown, string, boolean>;
+    markerDialogOffset: EpPropFinalized<ArrayConstructor, unknown, unknown, () => number[], boolean>;
+};

package/lib/types/components/menu/Index.vue.d.ts

@@ -0,0 +1,193 @@
+import { MenuBaseType } from './types';
+import { CreateComponentPublicInstanceWithMixins, ComputedOptions, MethodOptions, RendererNode, RendererElement, ComponentOptionsMixin, VNodeProps, AllowedComponentProps, ComponentCustomProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, DefineComponent, PublicProps } from 'vue';
+import { EpPropFinalized, EpPropMergeType } from 'element-plus/es/utils';
+import { MenuItemClicked } from 'element-plus';
+import { NavigationFailure } from 'vue-router';
+import { EpPropFinalized, EpPropMergeType } from '../_utils/types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: {}) => any>>;
+    refs: {
+        lsComMenu: CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+            readonly mode: EpPropFinalized<StringConstructor, "horizontal" | "vertical", unknown, "vertical", boolean>;
+            readonly defaultActive: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly defaultOpeneds: EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
+            readonly uniqueOpened: BooleanConstructor;
+            readonly router: BooleanConstructor;
+            readonly menuTrigger: EpPropFinalized<StringConstructor, "click" | "hover", unknown, "hover", boolean>;
+            readonly collapse: BooleanConstructor;
+            readonly backgroundColor: StringConstructor;
+            readonly textColor: StringConstructor;
+            readonly activeTextColor: StringConstructor;
+            readonly closeOnClickOutside: BooleanConstructor;
+            readonly collapseTransition: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly ellipsis: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly popperOffset: EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+            readonly ellipsisIcon: EpPropFinalized<(new (...args: any[]) => (string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown, () => any, boolean>;
+            readonly popperEffect: EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "dark", boolean>;
+            readonly popperClass: StringConstructor;
+            readonly showTimeout: EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
+            readonly hideTimeout: EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
+        }>> & {
+            onSelect?: ((index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure> | undefined) => any) | undefined;
+            onClose?: ((index: string, indexPath: string[]) => any) | undefined;
+            onOpen?: ((index: string, indexPath: string[]) => any) | undefined;
+        }, () => globalThis.VNode< RendererNode, RendererElement, {
+            [key: string]: any;
+        }>, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+            close: (index: string, indexPath: string[]) => boolean;
+            open: (index: string, indexPath: string[]) => boolean;
+            select: (index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure> | undefined) => boolean;
+        }, VNodeProps & AllowedComponentProps & ComponentCustomProps, {
+            readonly ellipsis: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly collapse: boolean;
+            readonly mode: EpPropMergeType<StringConstructor, "horizontal" | "vertical", unknown>;
+            readonly defaultActive: string;
+            readonly defaultOpeneds: string[];
+            readonly menuTrigger: EpPropMergeType<StringConstructor, "click" | "hover", unknown>;
+            readonly collapseTransition: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly popperOffset: number;
+            readonly ellipsisIcon: EpPropMergeType<(new (...args: any[]) => (string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>;
+            readonly popperEffect: string;
+            readonly showTimeout: number;
+            readonly hideTimeout: number;
+            readonly uniqueOpened: boolean;
+            readonly router: boolean;
+            readonly closeOnClickOutside: boolean;
+        }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<globalThis.ExtractPropTypes<{
+            readonly mode: EpPropFinalized<StringConstructor, "horizontal" | "vertical", unknown, "vertical", boolean>;
+            readonly defaultActive: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly defaultOpeneds: EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | ((new (...args: any[]) => string[]) | (() => string[]))[], unknown, unknown, () => [], boolean>;
+            readonly uniqueOpened: BooleanConstructor;
+            readonly router: BooleanConstructor;
+            readonly menuTrigger: EpPropFinalized<StringConstructor, "click" | "hover", unknown, "hover", boolean>;
+            readonly collapse: BooleanConstructor;
+            readonly backgroundColor: StringConstructor;
+            readonly textColor: StringConstructor;
+            readonly activeTextColor: StringConstructor;
+            readonly closeOnClickOutside: BooleanConstructor;
+            readonly collapseTransition: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly ellipsis: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly popperOffset: EpPropFinalized<NumberConstructor, unknown, unknown, 6, boolean>;
+            readonly ellipsisIcon: EpPropFinalized<(new (...args: any[]) => (string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown, () => any, boolean>;
+            readonly popperEffect: EpPropFinalized<(new (...args: any[]) => string & {}) | (() => string) | ((new (...args: any[]) => string & {}) | (() => string))[], unknown, unknown, "dark", boolean>;
+            readonly popperClass: StringConstructor;
+            readonly showTimeout: EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
+            readonly hideTimeout: EpPropFinalized<NumberConstructor, unknown, unknown, 300, boolean>;
+        }>> & {
+            onSelect?: ((index: string, indexPath: string[], item: MenuItemClicked, routerResult?: Promise<void | NavigationFailure> | undefined) => any) | undefined;
+            onClose?: ((index: string, indexPath: string[]) => any) | undefined;
+            onOpen?: ((index: string, indexPath: string[]) => any) | undefined;
+        }, () => globalThis.VNode< RendererNode, RendererElement, {
+            [key: string]: any;
+        }>, {}, {}, {}, {
+            readonly ellipsis: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly collapse: boolean;
+            readonly mode: EpPropMergeType<StringConstructor, "horizontal" | "vertical", unknown>;
+            readonly defaultActive: string;
+            readonly defaultOpeneds: string[];
+            readonly menuTrigger: EpPropMergeType<StringConstructor, "click" | "hover", unknown>;
+            readonly collapseTransition: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly popperOffset: number;
+            readonly ellipsisIcon: EpPropMergeType<(new (...args: any[]) => (string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) | ((new (...args: any[]) => (string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>) & {}) | (() => string | globalThis.Component<any, any, any, ComputedOptions, MethodOptions>))[], unknown, unknown>;
+            readonly popperEffect: string;
+            readonly showTimeout: number;
+            readonly hideTimeout: number;
+            readonly uniqueOpened: boolean;
+            readonly router: boolean;
+            readonly closeOnClickOutside: boolean;
+        }> | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<globalThis.ExtractPropTypes<{
+    menuConfigList: EpPropFinalized<{
+        (arrayLength: number): MenuBaseType[];
+        (...items: MenuBaseType[]): MenuBaseType[];
+        new (arrayLength: number): MenuBaseType[];
+        new (...items: MenuBaseType[]): MenuBaseType[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    needPermission: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    permissionList: EpPropFinalized<{
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    hoverColor: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    menuConfigList: EpPropFinalized<{
+        (arrayLength: number): MenuBaseType[];
+        (...items: MenuBaseType[]): MenuBaseType[];
+        new (arrayLength: number): MenuBaseType[];
+        new (...items: MenuBaseType[]): MenuBaseType[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    needPermission: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    permissionList: EpPropFinalized<{
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    hoverColor: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+}>> & Readonly<{}>, {
+    menuConfigList: MenuBaseType[];
+    needPermission: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    permissionList: (string | number)[];
+    hoverColor: string;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/types/components/menu/MenuItem.vue.d.ts

@@ -0,0 +1,59 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { EpPropFinalized, EpPropMergeType } from '../_utils/types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<any, (_: {}) => any>> & Partial<Record<any, (_: {}) => any>>;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<globalThis.ExtractPropTypes<{
+    needPermission: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    permissionList: EpPropFinalized<{
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    item: EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    needPermission: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    permissionList: EpPropFinalized<{
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    item: EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+}>> & Readonly<{}>, {
+    item: Record<string, any>;
+    needPermission: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    permissionList: (string | number)[];
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/types/components/menu/index.d.ts

@@ -0,0 +1,141 @@
+import { App, CreateComponentPublicInstanceWithMixins, ComponentOptionsMixin, PublicProps, GlobalComponents, GlobalDirectives, ComponentProvideOptions, ComponentOptionsBase, VNodeProps, AllowedComponentProps, ComponentCustomProps } from 'vue';
+import { LSOptions, EpPropFinalized, EpPropMergeType } from '../_utils/types';
+import { MenuBaseType } from './types';
+declare const LSMenu: {
+    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+        menuConfigList: EpPropFinalized<{
+            (arrayLength: number): MenuBaseType[];
+            (...items: MenuBaseType[]): MenuBaseType[];
+            new (arrayLength: number): MenuBaseType[];
+            new (...items: MenuBaseType[]): MenuBaseType[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, () => never[], boolean>;
+        needPermission: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        permissionList: EpPropFinalized<{
+            (arrayLength: number): (string | number)[];
+            (...items: (string | number)[]): (string | number)[];
+            new (arrayLength: number): (string | number)[];
+            new (...items: (string | number)[]): (string | number)[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, () => never[], boolean>;
+        hoverColor: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    }>> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
+        menuConfigList: MenuBaseType[];
+        needPermission: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        permissionList: (string | number)[];
+        hoverColor: string;
+    }, true, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<globalThis.ExtractPropTypes<{
+        menuConfigList: EpPropFinalized<{
+            (arrayLength: number): MenuBaseType[];
+            (...items: MenuBaseType[]): MenuBaseType[];
+            new (arrayLength: number): MenuBaseType[];
+            new (...items: MenuBaseType[]): MenuBaseType[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, () => never[], boolean>;
+        needPermission: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+        permissionList: EpPropFinalized<{
+            (arrayLength: number): (string | number)[];
+            (...items: (string | number)[]): (string | number)[];
+            new (arrayLength: number): (string | number)[];
+            new (...items: (string | number)[]): (string | number)[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        }, unknown, unknown, () => never[], boolean>;
+        hoverColor: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+    }>> & Readonly<{}>, {}, {}, {}, {}, {
+        menuConfigList: MenuBaseType[];
+        needPermission: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        permissionList: (string | number)[];
+        hoverColor: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly<globalThis.ExtractPropTypes<{
+    menuConfigList: EpPropFinalized<{
+        (arrayLength: number): MenuBaseType[];
+        (...items: MenuBaseType[]): MenuBaseType[];
+        new (arrayLength: number): MenuBaseType[];
+        new (...items: MenuBaseType[]): MenuBaseType[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    needPermission: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    permissionList: EpPropFinalized<{
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    hoverColor: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+}>> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    menuConfigList: MenuBaseType[];
+    needPermission: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    permissionList: (string | number)[];
+    hoverColor: string;
+}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: Partial<Record<string, (_: {}) => any>>;
+}) & {
+    install: (app: App, options?: LSOptions) => void;
+};
+export default LSMenu;

package/lib/types/components/menu/types.d.ts

@@ -0,0 +1,100 @@
+import { IconConfigType } from '../_types';
+import { LocationQueryRaw } from 'vue-router';
+import { EpPropFinalized } from '../_utils/types';
+export type MenuBaseType = {
+    title: string;
+    name: string;
+    path?: string;
+    key?: string;
+    cpoPath?: string;
+    iconConfig?: IconConfigType;
+    leaf?: boolean;
+    hideMenu?: boolean;
+    redirect?: string;
+    pCode?: string | number;
+    iconSlot?: string;
+    defJump?: boolean;
+    link?: string;
+    children?: Array<MenuBaseType>;
+};
+export type BCListItemType = {
+    title: string;
+    name?: string;
+};
+export type MenuBCListType = {
+    bcList?: Array<BCListItemType>;
+};
+export interface ConfigItemType extends MenuBaseType, MenuBCListType {
+}
+export interface MenuItemType extends ConfigItemType {
+    children?: Array<MenuBaseType>;
+}
+export type JumpParamsType = {
+    name?: string | symbol;
+    title?: string;
+    path?: string;
+    query?: LocationQueryRaw;
+    link?: string;
+};
+export type GroupOptionType = {
+    id: number;
+    groupId: number;
+    groupName: string;
+};
+export declare const lsEmitNames: string[];
+export declare const lsMenuProps: {
+    menuConfigList: EpPropFinalized<{
+        (arrayLength: number): MenuBaseType[];
+        (...items: MenuBaseType[]): MenuBaseType[];
+        new (arrayLength: number): MenuBaseType[];
+        new (...items: MenuBaseType[]): MenuBaseType[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    needPermission: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    permissionList: EpPropFinalized<{
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    hoverColor: EpPropFinalized<StringConstructor, unknown, unknown, string, boolean>;
+};
+export declare const lsMenuItemProps: {
+    needPermission: EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    permissionList: EpPropFinalized<{
+        (arrayLength: number): (string | number)[];
+        (...items: (string | number)[]): (string | number)[];
+        new (arrayLength: number): (string | number)[];
+        new (...items: (string | number)[]): (string | number)[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    item: EpPropFinalized<ObjectConstructor, unknown, unknown, () => {}, boolean>;
+};

package/lib/types/components/preview/Index.vue.d.ts

@@ -0,0 +1,67 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<globalThis.ExtractPropTypes<{
+    type: {
+        type: globalThis.PropType<"docx" | "pdf" | "xlsx" | "image">;
+        require: boolean;
+        default: string;
+    };
+    source: {};
+    zoomSize: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    needLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingOption: {
+        type: ObjectConstructor;
+        default: () => {
+            text: string;
+            background: string;
+        };
+    };
+    modelValue: {
+        type: globalThis.PropType<boolean>;
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean | undefined) => any;
+} & {
+    loadComplete: () => any;
+    loadError: () => any;
+}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    type: {
+        type: globalThis.PropType<"docx" | "pdf" | "xlsx" | "image">;
+        require: boolean;
+        default: string;
+    };
+    source: {};
+    zoomSize: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    needLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingOption: {
+        type: ObjectConstructor;
+        default: () => {
+            text: string;
+            background: string;
+        };
+    };
+    modelValue: {
+        type: globalThis.PropType<boolean>;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean | undefined) => any) | undefined;
+    onLoadComplete?: (() => any) | undefined;
+    onLoadError?: (() => any) | undefined;
+}>, {
+    type: "docx" | "pdf" | "xlsx" | "image";
+    zoomSize: string | number;
+    needLoading: boolean;
+    loadingOption: Record<string, any>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/lib/types/components/preview/components/Docx.vue.d.ts

@@ -0,0 +1,12 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { EpPropFinalized, EpPropMergeType } from '../../_utils/types';
+declare const _default: DefineComponent<globalThis.ExtractPropTypes<{
+    source: EpPropFinalized<(ArrayBufferConstructor | StringConstructor)[], unknown, unknown, null, boolean>;
+    onClose: FunctionConstructor;
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    source: EpPropFinalized<(ArrayBufferConstructor | StringConstructor)[], unknown, unknown, null, boolean>;
+    onClose: FunctionConstructor;
+}>> & Readonly<{}>, {
+    source: EpPropMergeType<(ArrayBufferConstructor | StringConstructor)[], unknown, unknown>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;