lew-ui 2.7.20 → 2.7.22

package/dist/components/navigation/menu-tree/src/LewMenuTree.vue.d.ts

@@ -0,0 +1,63 @@
+import { LewMenuTreeOption } from '../../../../types';
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    options: {
+        type: PropType<LewMenuTreeOption[]>;
+        required: boolean;
+        typePopKeys: string[];
+        validator: (value: any[] | undefined) => boolean;
+    };
+    width: {
+        type: PropType<import("csstype").Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    modelValue: {
+        type: globalThis.PropType<string>;
+    };
+    expandKeys: {
+        type: globalThis.PropType<string[]>;
+    };
+    collapsed: {
+        type: globalThis.PropType<boolean>;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (value: string, item: LewMenuTreeOption) => void;
+    change: (item: LewMenuTreeOption) => void;
+    collapse: (expandKeys: string[]) => void;
+    expand: (expandKeys: string[]) => void;
+    "update:modelValue": (value: string) => void;
+    "update:expandKeys": (value: string[]) => void;
+    "update:collapsed": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    options: {
+        type: PropType<LewMenuTreeOption[]>;
+        required: boolean;
+        typePopKeys: string[];
+        validator: (value: any[] | undefined) => boolean;
+    };
+    width: {
+        type: PropType<import("csstype").Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    modelValue: {
+        type: globalThis.PropType<string>;
+    };
+    expandKeys: {
+        type: globalThis.PropType<string[]>;
+    };
+    collapsed: {
+        type: globalThis.PropType<boolean>;
+    };
+}>> & Readonly<{
+    onSelect?: ((value: string, item: LewMenuTreeOption) => any) | undefined;
+    onChange?: ((item: LewMenuTreeOption) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onCollapse?: ((expandKeys: string[]) => any) | undefined;
+    onExpand?: ((expandKeys: string[]) => any) | undefined;
+    "onUpdate:expandKeys"?: ((value: string[]) => any) | undefined;
+    "onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
+}>, {
+    width: import("csstype").Property.Width<0 | (string & {})>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/components/navigation/menu-tree/src/LewMenuTreeItem.vue.d.ts

@@ -0,0 +1,83 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    label: {
+        type: null;
+    };
+    icon: {
+        type: null;
+    };
+    value: {
+        type: StringConstructor;
+        required: boolean;
+        validator: (value: any) => boolean;
+    };
+    tagProps: {
+        type: PropType<import('../../../..').LewTagProps>;
+        validator: (value: unknown) => boolean;
+    };
+    level: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: number | undefined) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        validator: (value: any) => boolean;
+    };
+    isLeaf: {
+        type: BooleanConstructor;
+        validator: (value: any) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: () => void;
+}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    label: {
+        type: null;
+    };
+    icon: {
+        type: null;
+    };
+    value: {
+        type: StringConstructor;
+        required: boolean;
+        validator: (value: any) => boolean;
+    };
+    tagProps: {
+        type: PropType<import('../../../..').LewTagProps>;
+        validator: (value: unknown) => boolean;
+    };
+    level: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: number | undefined) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        validator: (value: any) => boolean;
+    };
+    isLeaf: {
+        type: BooleanConstructor;
+        validator: (value: any) => boolean;
+    };
+}>> & Readonly<{
+    onChange?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    level: number;
+    isLeaf: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/navigation/menu-tree/src/emits.d.ts

@@ -0,0 +1,10 @@
+import { LewMenuTreeOption } from '../../../..';
+export declare const menuTreeEmits: {
+    readonly change: (item: LewMenuTreeOption) => LewMenuTreeOption;
+    readonly select: (value: string, item: LewMenuTreeOption) => {
+        value: string;
+        item: LewMenuTreeOption;
+    };
+    readonly expand: (expandKeys: string[]) => string[];
+    readonly collapse: (expandKeys: string[]) => string[];
+};

package/dist/components/navigation/menu-tree/src/menuTreeItemEmits.d.ts

@@ -0,0 +1,4 @@
+export declare const menuTreeItemEmits: {
+    readonly change: () => boolean;
+};
+export type LewMenuTreeItemEmits = typeof menuTreeItemEmits;

package/dist/components/navigation/menu-tree/src/props.d.ts

@@ -0,0 +1,62 @@
+import { Property } from 'csstype';
+import { LewTagProps } from '../../../..';
+import { LewMenuTreeOption } from '../../../../types';
+import { ExtractPublicPropTypes, PropType } from 'vue';
+export declare const menuTreeModel: {
+    modelValue: {
+        type: StringConstructor;
+    };
+    expandKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    collapsed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare const menuTreeProps: {
+    options: {
+        type: PropType<LewMenuTreeOption[]>;
+        required: boolean;
+        typePopKeys: string[];
+        validator: (value: any[] | undefined) => boolean;
+    };
+    width: {
+        type: PropType<Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+};
+export declare const menuTreeItemProps: {
+    label: {
+        type: null;
+    };
+    icon: {
+        type: null;
+    };
+    value: {
+        type: StringConstructor;
+        required: boolean;
+        validator: (value: any) => boolean;
+    };
+    tagProps: {
+        type: PropType<LewTagProps>;
+        validator: (value: unknown) => boolean;
+    };
+    level: {
+        type: NumberConstructor;
+        default: number;
+        validator: (value: number | undefined) => boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        validator: (value: any) => boolean;
+    };
+    isLeaf: {
+        type: BooleanConstructor;
+        validator: (value: any) => boolean;
+    };
+};
+export type LewMenuTreeProps = ExtractPublicPropTypes<typeof menuTreeProps>;
+export type LewMenuTreeItemProps = ExtractPublicPropTypes<typeof menuTreeItemProps>;

package/dist/components/navigation/steps/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/emits';
+export { default as LewSteps } from './src/LewSteps.vue';
+export * from './src/props';

package/dist/components/navigation/steps/src/LewSteps.vue.d.ts

@@ -0,0 +1,51 @@
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    options: {
+        type: PropType<import('../../../..').LewStepsOption[]>;
+        typePopKeys: string[];
+        required: boolean;
+        validator: (value: any[] | undefined) => boolean;
+    };
+    status: {
+        type: PropType<import('../../../..').LewStepsStatus>;
+        default: string;
+        typeValues: import('../../../..').LewStepsStatus[];
+        validator: (value: any) => boolean;
+    };
+    minWidth: {
+        type: PropType<import("csstype").Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    modelValue: {
+        type: globalThis.PropType<any>;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: any) => any;
+}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    options: {
+        type: PropType<import('../../../..').LewStepsOption[]>;
+        typePopKeys: string[];
+        required: boolean;
+        validator: (value: any[] | undefined) => boolean;
+    };
+    status: {
+        type: PropType<import('../../../..').LewStepsStatus>;
+        default: string;
+        typeValues: import('../../../..').LewStepsStatus[];
+        validator: (value: any) => boolean;
+    };
+    minWidth: {
+        type: PropType<import("csstype").Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    modelValue: {
+        type: globalThis.PropType<any>;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+}>, {
+    minWidth: import("csstype").Property.Width<0 | (string & {})>;
+    status: import('../../../..').LewStepsStatus;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/components/navigation/steps/src/emits.d.ts

@@ -0,0 +1,3 @@
+export declare const stepsEmits: {
+    readonly change: (value: number) => number;
+};

package/dist/components/navigation/steps/src/props.d.ts

@@ -0,0 +1,28 @@
+import { Property } from 'csstype';
+import { LewStepsOption, LewStepsStatus } from '../../../../types';
+import { ExtractPublicPropTypes } from 'vue';
+export declare const stepsModel: {
+    modelValue: {
+        type: NumberConstructor;
+    };
+};
+export declare const stepsProps: {
+    options: {
+        type: PropType<LewStepsOption[]>;
+        typePopKeys: string[];
+        required: boolean;
+        validator: (value: any[] | undefined) => boolean;
+    };
+    status: {
+        type: PropType<LewStepsStatus>;
+        default: string;
+        typeValues: LewStepsStatus[];
+        validator: (value: any) => boolean;
+    };
+    minWidth: {
+        type: PropType<Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+};
+export type LewStepsProps = ExtractPublicPropTypes<typeof stepsProps>;

package/dist/directives/backtop/index.d.ts

@@ -0,0 +1,4 @@
+import { App } from 'vue';
+export declare const LewVBackTop: {
+    install(app: App): void;
+};

package/dist/directives/context-menu/index.d.ts

@@ -0,0 +1,22 @@
+import { LewContextMenusOption } from '../../types';
+import { App } from 'vue';
+export { default as LewContextMenu } from './src/LewContextMenu.vue';
+export { contextMenuProps } from './src/props';
+interface LewContextMenuConfig {
+    menu: Record<string, {
+        options: LewContextMenusOption[];
+        disabled: boolean;
+    }>;
+    contextMenu: ((e: MouseEvent) => void) | null;
+    instance: any;
+    menuInstance: Record<string, any>;
+}
+declare global {
+    interface Window {
+        LewContextMenu: LewContextMenuConfig;
+    }
+}
+export declare function initLewContextMenu(): void;
+export declare const LewVContextMenu: {
+    install(app: App): void;
+};

package/dist/directives/context-menu/src/LewContextMenu.vue.d.ts

@@ -0,0 +1,47 @@
+import { LewContextMenusOption } from '../../../types';
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    options: {
+        type: PropType<LewContextMenusOption[]>;
+        required: boolean;
+        typePopKeys: string[];
+        validator: (value: any[] | undefined) => boolean;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    dropdownInstance: {
+        type: null;
+        hidden: boolean;
+        default: null;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (item: any) => void;
+}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    options: {
+        type: PropType<LewContextMenusOption[]>;
+        required: boolean;
+        typePopKeys: string[];
+        validator: (value: any[] | undefined) => boolean;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    dropdownInstance: {
+        type: null;
+        hidden: boolean;
+        default: null;
+    };
+}>> & Readonly<{
+    onChange?: ((item: any) => any) | undefined;
+}>, {
+    disabled: boolean;
+    options: LewContextMenusOption[];
+    dropdownInstance: any;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/directives/context-menu/src/emits.d.ts

@@ -0,0 +1,3 @@
+export declare const contextMenuEmits: {
+    readonly change: (item: any) => any;
+};

package/dist/directives/context-menu/src/props.d.ts

@@ -0,0 +1,21 @@
+import { LewContextMenusOption } from '../../../types';
+import { PropType } from 'vue';
+export declare const contextMenuProps: {
+    options: {
+        type: PropType<LewContextMenusOption[]>;
+        required: boolean;
+        typePopKeys: string[];
+        validator: (value: any[] | undefined) => boolean;
+        default: () => never[];
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+    dropdownInstance: {
+        type: null;
+        hidden: boolean;
+        default: null;
+    };
+};

package/dist/directives/hover-menu/index.d.ts

@@ -0,0 +1,56 @@
+import { App, PropType } from 'vue';
+interface LewHoverMenuConfig {
+    menu: Record<string, any>;
+    disabledIds: string[];
+    hoverMenu: ((e: MouseEvent) => void) | null;
+    prevId: string;
+    instance: any;
+    menuInstance: Record<string, any>;
+}
+declare global {
+    interface Window {
+        LewHoverMenu: LewHoverMenuConfig;
+    }
+}
+/**
+ * 初始化悬浮菜单
+ * 创建全局悬浮菜单实例和相关配置
+ */
+export declare function initLewHoverMenu(): void;
+/**
+ * 悬浮菜单指令
+ * 提供悬浮菜单功能的Vue指令
+ */
+export declare const LewVHoverMenu: {
+    install(app: App): void;
+};
+/**
+ * 悬浮菜单项目接口定义
+ */
+export interface HoverMenus {
+    label?: string;
+    value?: string;
+    type?: string;
+    icon?: string;
+    children?: HoverMenus[];
+    disabled?: boolean;
+    level?: number;
+    isDividerLine?: false;
+    [key: string]: any;
+}
+/**
+ * 悬浮菜单组件属性定义
+ */
+export declare const hoverMenuProps: {
+    options: {
+        type: PropType<HoverMenus[]>;
+        default: () => never[];
+        description: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+        description: string;
+    };
+};
+export {};

package/dist/directives/index.d.ts

@@ -0,0 +1,5 @@
+export * from './backtop';
+export * from './context-menu';
+export * from './hover-menu';
+export * from './loading';
+export * from './tooltip';

package/dist/directives/loading/index.d.ts

@@ -0,0 +1,4 @@
+import { App as Application } from 'vue';
+export declare const LewLoading: {
+    install(app: Application): void;
+};

package/dist/directives/tooltip/index.d.ts

@@ -0,0 +1,4 @@
+import { App as Application } from 'vue';
+export declare const LewTooltip: {
+    install(app: Application): void;
+};

package/dist/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export declare function useEventListener(target: EventTarget, event: string, callback: EventListenerOrEventListenerObject): void;
+export declare function useDOMCreate(nodeId: string): void;