halo-pc 1.0.50 → 1.0.51

package/esm/comp/global/MenuItem.vue.d.ts

@@ -0,0 +1,259 @@
+import { I18ns } from "../../factory";
+declare let menu: import("vue").Ref<Record<string, any>, Record<string, any>>, level: import("vue").Ref<number, number>, direction: import("vue").Ref<string, string>, opts: import("vue").Ref<Record<string, any>, Record<string, any>>, activeIds: import("vue").Ref<any[], any[]>, modelValue: import("vue").Ref<string, string>;
+declare let menuRef: import("vue").Ref<any, any>, menusRef: import("vue").Ref<any, any>, scrollerRef: import("vue").Ref<any, any>;
+declare let contentStyle: import("vue").Ref<any, any>, hovered: import("vue").Ref<boolean, boolean>;
+declare let click: (menu: any) => void;
+declare let childClick: (menu: any) => void;
+declare let mouseOver: (event: MouseEvent) => void;
+declare let mouseOut: (event: MouseEvent) => void;
+/**
+ * 当前菜单相对于父菜单的位置
+ */
+declare let position: import("vue").ComputedRef<string>;
+declare let active: import("vue").ComputedRef<boolean>;
+declare let anchor: import("vue").ComputedRef<{
+    href: any;
+    target: any;
+}>;
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    menu: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    level: {
+        type: NumberConstructor;
+        required: true;
+    };
+    direction: {
+        type: StringConstructor;
+    };
+    opts: {
+        type: ObjectConstructor;
+    };
+    activeIds: {
+        type: {
+            (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[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+    };
+    modelValue: {
+        type: StringConstructor;
+    };
+}>, {
+    resize: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    menu: {
+        type: ObjectConstructor;
+        required: true;
+    };
+    level: {
+        type: NumberConstructor;
+        required: true;
+    };
+    direction: {
+        type: StringConstructor;
+    };
+    opts: {
+        type: ObjectConstructor;
+    };
+    activeIds: {
+        type: {
+            (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[];
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+    };
+    modelValue: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{
+    onClick?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
+    menuRef: HTMLDivElement;
+    scrollerRef: unknown;
+    menusRef: ({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<{
+            readonly menu: Record<string, any>;
+            readonly level: number;
+            readonly modelValue?: string;
+            readonly direction?: string;
+            readonly opts?: Record<string, any>;
+            readonly activeIds?: any[];
+            readonly onClick?: (...args: any[]) => any;
+        } & 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<any>;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "click", ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            menu: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            level: {
+                type: NumberConstructor;
+                required: true;
+            };
+            direction: {
+                type: StringConstructor;
+            };
+            opts: {
+                type: ObjectConstructor;
+            };
+            activeIds: {
+                type: {
+                    (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[];
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+            };
+            modelValue: {
+                type: StringConstructor;
+            };
+        }>> & Readonly<{
+            onClick?: (...args: any[]) => any;
+        }>, {
+            I18ns: typeof I18ns;
+            menu: typeof menu;
+            level: typeof level;
+            direction: typeof direction;
+            opts: typeof opts;
+            activeIds: typeof activeIds;
+            modelValue: typeof modelValue;
+            menuRef: typeof menuRef;
+            menusRef: typeof menusRef;
+            scrollerRef: typeof scrollerRef;
+            contentStyle: typeof contentStyle;
+            hovered: typeof hovered;
+            click: typeof click;
+            childClick: typeof childClick;
+            mouseOver: typeof mouseOver;
+            mouseOut: typeof mouseOut;
+            position: typeof position;
+            active: typeof active;
+            anchor: typeof anchor;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            click: (...args: any[]) => void;
+        }, string, {}, {}, 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<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{
+        menu: {
+            type: ObjectConstructor;
+            required: true;
+        };
+        level: {
+            type: NumberConstructor;
+            required: true;
+        };
+        direction: {
+            type: StringConstructor;
+        };
+        opts: {
+            type: ObjectConstructor;
+        };
+        activeIds: {
+            type: {
+                (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[];
+                readonly [Symbol.species]: ArrayConstructor;
+            };
+        };
+        modelValue: {
+            type: StringConstructor;
+        };
+    }>> & Readonly<{
+        onClick?: (...args: any[]) => any;
+    }>, "anchor" | "position" | "click" | "menu" | "I18ns" | "modelValue" | "direction" | "level" | "opts" | "activeIds" | "menuRef" | "menusRef" | "scrollerRef" | "contentStyle" | "hovered" | "childClick" | "mouseOver" | "mouseOut" | "active"> & import("vue").ShallowUnwrapRef<{
+        I18ns: typeof I18ns;
+        menu: typeof menu;
+        level: typeof level;
+        direction: typeof direction;
+        opts: typeof opts;
+        activeIds: typeof activeIds;
+        modelValue: typeof modelValue;
+        menuRef: typeof menuRef;
+        menusRef: typeof menusRef;
+        scrollerRef: typeof scrollerRef;
+        contentStyle: typeof contentStyle;
+        hovered: typeof hovered;
+        click: typeof click;
+        childClick: typeof childClick;
+        mouseOver: typeof mouseOver;
+        mouseOut: typeof mouseOut;
+        position: typeof position;
+        active: typeof active;
+        anchor: typeof anchor;
+    }> & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {};
+    })[];
+}, HTMLDivElement>;
+export default _default;

package/esm/comp/global/Window.vue.d.ts

@@ -0,0 +1,32 @@
+import { WindowProps } from "./@types";
+declare const _default: import("vue").DefineComponent<WindowProps, {
+    affixTo: (position: string) => void;
+    toggleShow: () => void;
+    options: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+        index?: number;
+        side?: number;
+        focus?: boolean;
+        state?: string;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    close: (evt: MouseEvent) => any;
+    blur: () => any;
+    focus: (evt: MouseEvent) => any;
+    max: () => any;
+    min: () => any;
+}, string, import("vue").PublicProps, Readonly<WindowProps> & Readonly<{
+    onClose?: (evt: MouseEvent) => any;
+    onBlur?: () => any;
+    onFocus?: (evt: MouseEvent) => any;
+    onMax?: () => any;
+    onMin?: () => any;
+}>, {
+    bottom: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    windowRef: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/esm/comp/global/index.d.ts

@@ -0,0 +1,7 @@
+import HaHeaderTab from "./HeaderTab.vue";
+import HaMissComponent from "./MissComponent.vue";
+import HaMenu from "./Menu.vue";
+import HaSideTab from "./SideTab.vue";
+import HaPcWindow from "./Window.vue";
+export * from "./@types";
+export { HaHeaderTab, HaMissComponent, HaMenu, HaSideTab, HaPcWindow, };

package/esm/{coms/headers → comp/header}/@types/ChangeProps.d.ts

@@ -1,4 +1,4 @@
-import { WindowOptions } from "../../globals";
+import { WindowOptions } from "../../global";
 /**
  * 功能变化属性
  */

package/esm/{comps/headers → comp/header}/@types/HeaderProps.d.ts

@@ -1,3 +1,2 @@
 export interface HeaderProps {
-    bottom?: number;
 }

package/esm/{comps/headers → comp/header}/@types/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./ChangeProps";
 export * from "./HeaderProps";
-export * from "./TipsProps";

package/esm/comp/header/HeaderRight.vue.d.ts

@@ -0,0 +1,28 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "show-tips": (...args: any[]) => void;
+    "show-changes": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    "onShow-tips"?: (...args: any[]) => any;
+    "onShow-changes"?: (...args: any[]) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
+    marqueeRef: HTMLDivElement;
+    settingRef: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{
+        onClose?: (...args: any[]) => any;
+    }>, {
+        show: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        close: (...args: any[]) => void;
+    }, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{
+        onClose?: (...args: any[]) => any;
+    }>, {
+        show: () => void;
+    }, {}, {}, {}, {}>;
+}, any>;
+export default _default;

package/esm/comp/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./business";
+export * from "./common";
+export * from "./control";
+export * from "./driver";
+export * from "./page";
+export * from "./paging";
+export * from "./panel";
+export * from "./partial";
+export * from "./search";
+export * from "./single";
+export * from "./layout";
+export * from "./global";

package/esm/comp/layout/@types/DesktopDialog.d.ts

@@ -0,0 +1,48 @@
+import { type DialogExpose } from "halo-fe";
+/**
+ * 桌面对话框属性
+ */
+export interface DesktopDialog {
+    /**
+     * 当前激活菜单
+     */
+    menu: any;
+    /**
+     * 标题
+     */
+    title: string;
+    /**
+     * 页面对应环境
+     */
+    env?: string;
+    /**
+     * 侧边菜单，目的：减少菜单变更导致的赋值过程
+     */
+    sideMenu: any;
+    /**
+     * 顶部菜单，1：减少循环侧边菜单导致头部页面数据冗余；2：减少赋值过程
+     */
+    headerMenu: any;
+    /**
+     * 防止前面元素被删除（如关闭先打开的窗口），导致所有窗口被重建而额外触发关闭事件
+     */
+    id: string;
+    sideMenuId: string;
+    headerMenuId: string;
+    /**
+     * 新窗口默认聚焦
+     */
+    focused?: boolean;
+    /**
+     * 显示内容的url
+     */
+    bodyUrl: string;
+    /**
+     * 对话框引用
+     */
+    dialogRef?: DialogExpose;
+    /**
+     * 页面引用
+     */
+    pageRef?: any;
+}

package/esm/comp/layout/@types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./DesktopDialog";
+export * from "./ITaskBar";

package/esm/comp/layout/Desktop.vue.d.ts

@@ -0,0 +1,111 @@
+import { Ref } from "vue";
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
+    appRef: HTMLDivElement;
+    feedbackRef: import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {
+        show: (name: string, url: string) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
+        feedbackRef: {
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{}> & Omit<{
+                readonly side?: number;
+                readonly top?: number;
+                readonly kind?: string;
+                readonly type?: string;
+                readonly name?: string;
+                readonly title?: string;
+                readonly index?: number;
+                readonly focused?: boolean;
+                readonly class?: string;
+                readonly options?: import("halo-fe").DialogOptions;
+                readonly minOptions?: import("halo-fe").DialogOptions;
+                readonly maxOptions?: import("halo-fe").DialogOptions;
+                readonly onChange?: (options: import("halo-fe").DialogOptions) => any;
+                readonly onClose?: (event: MouseEvent) => any;
+                readonly onFocus?: (value: boolean) => any;
+                readonly onResize?: (options: import("halo-fe").DialogOptions) => any;
+                readonly onMax?: (options: import("halo-fe").DialogOptions) => any;
+                readonly onMin?: (options: import("halo-fe").DialogOptions) => any;
+                readonly onVisible?: (value: boolean) => any;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: any;
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any>;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "close", event: MouseEvent) => void) & ((event: "change", options: import("halo-fe").DialogOptions) => void) & ((event: "focus", value: boolean) => void) & ((event: "resize", options: import("halo-fe").DialogOptions) => void) & ((event: "max", options: import("halo-fe").DialogOptions) => void) & ((event: "visible", value: boolean) => void) & ((event: "min", options: import("halo-fe").DialogOptions) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("halo-fe/esm/comp/window/@types").WindowProps> & Readonly<{
+                onChange?: (options: import("halo-fe").DialogOptions) => any;
+                onClose?: (event: MouseEvent) => any;
+                onFocus?: (value: boolean) => any;
+                onResize?: (options: import("halo-fe").DialogOptions) => any;
+                onMax?: (options: import("halo-fe").DialogOptions) => any;
+                onMin?: (options: import("halo-fe").DialogOptions) => any;
+                onVisible?: (value: boolean) => any;
+            }>, {
+                toggle: (value?: boolean) => void;
+                update: () => void;
+                state: import("vue").Ref<import("halo-fe").DialogState, import("halo-fe").DialogState>;
+                visible: import("vue").Ref<boolean, boolean>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                change: (options: import("halo-fe").DialogOptions) => any;
+                close: (event: MouseEvent) => any;
+                focus: (value: boolean) => any;
+                resize: (options: import("halo-fe").DialogOptions) => any;
+                max: (options: import("halo-fe").DialogOptions) => any;
+                min: (options: import("halo-fe").DialogOptions) => any;
+                visible: (value: boolean) => any;
+            }, string, {}, {}, 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<{}> & Omit<Readonly<import("halo-fe/esm/comp/window/@types").WindowProps> & Readonly<{
+            onChange?: (options: import("halo-fe").DialogOptions) => any;
+            onClose?: (event: MouseEvent) => any;
+            onFocus?: (value: boolean) => any;
+            onResize?: (options: import("halo-fe").DialogOptions) => any;
+            onMax?: (options: import("halo-fe").DialogOptions) => any;
+            onMin?: (options: import("halo-fe").DialogOptions) => any;
+            onVisible?: (value: boolean) => any;
+        }>, "toggle" | "update" | "visible" | "state"> & import("vue").ShallowUnwrapRef<{
+            toggle: (value?: boolean) => void;
+            update: () => void;
+            state: import("vue").Ref<import("halo-fe").DialogState, import("halo-fe").DialogState>;
+            visible: import("vue").Ref<boolean, boolean>;
+        }> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: any;
+        };
+    }, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {
+        show: (name: string, url: string) => void;
+    }, {}, {}, {}, {}>;
+}, HTMLDivElement>;
+export default _default;