halo-pc 1.0.50 → 1.0.51

package/esm/comp/driver/Picker.vue.d.ts

@@ -0,0 +1,108 @@
+import { type DriverPickerProps } from "halo-fe";
+type __VLS_Props = DriverPickerProps;
+type __VLS_PublicProps = {
+    modelValue?: any[];
+} & __VLS_Props;
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {
+    loadAsync(app: string, env: string): Promise<any[]>;
+    updateForm(): void;
+    refresh(): Promise<void>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: any[]) => any;
+} & {
+    loaded: (ret: any) => any;
+    change: (value: number, option: any) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onLoaded?: (ret: any) => any;
+    onChange?: (value: number, option: any) => any;
+    "onUpdate:modelValue"?: (value: any[]) => any;
+}>, {
+    label: boolean;
+    editable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+    dropdownRef: {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly modelValue?: any[];
+            readonly kind: string;
+            readonly form: import("halo-fe/esm/comp/business/drivers/@types/KindFormProps.js").KindFormProps;
+            readonly label?: boolean;
+            readonly editable?: boolean;
+            readonly to?: string | HTMLElement;
+            readonly onLoaded?: (ret: any) => any;
+            readonly onChange?: (value: number, option: any) => any;
+            readonly "onUpdate:modelValue"?: (value: any[]) => any;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        $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: "loaded", ret: any) => void) & ((event: "change", value: number, option: any) => void) & ((event: "update:modelValue", value: any[]) => void);
+        $el: HTMLDivElement;
+        $options: import("vue").ComponentOptionsBase<Readonly<{
+            modelValue?: any[];
+        } & DriverPickerProps> & Readonly<{
+            onLoaded?: (ret: any) => any;
+            onChange?: (value: number, option: any) => any;
+            "onUpdate:modelValue"?: (value: any[]) => any;
+        }>, {
+            loadAsync(app: string, env: string): Promise<any[]>;
+            updateForm(): void;
+            refresh(): Promise<void>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (value: any[]) => any;
+        } & {
+            loaded: (ret: any) => any;
+            change: (value: number, option: any) => any;
+        }, string, {
+            label: boolean;
+            editable: 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<{
+        label: boolean;
+        editable: boolean;
+    }> & Omit<Readonly<{
+        modelValue?: any[];
+    } & DriverPickerProps> & Readonly<{
+        onLoaded?: (ret: any) => any;
+        onChange?: (value: number, option: any) => any;
+        "onUpdate:modelValue"?: (value: any[]) => any;
+    }>, "refresh" | "label" | "editable" | "loadAsync" | "updateForm"> & import("vue").ShallowUnwrapRef<{
+        loadAsync(app: string, env: string): Promise<any[]>;
+        updateForm(): void;
+        refresh(): Promise<void>;
+    }> & {} & import("vue").ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    };
+}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,4 @@
+import HaDriver from "./Index.vue";
+import HaCrud from "./Crud.vue";
+import HaDriverPicker from "./Picker.vue";
+export { HaDriver, HaCrud, HaDriverPicker, };

package/esm/{coms/commons/Debug.vue.d.ts → comp/global/HeaderTab.vue.d.ts}

@@ -4,10 +4,10 @@ declare function __VLS_template(): {
         default?(_: {}): any;
     };
     refs: {};
-    rootEl: any;
+    rootEl: HTMLAnchorElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, HTMLAnchorElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

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

@@ -0,0 +1,336 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    menus: {
+        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;
+        };
+        required: true;
+    };
+    direction: {
+        type: StringConstructor;
+        default: string;
+    };
+    expandActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    options: {
+        type: ObjectConstructor;
+    };
+    modelValue: {
+        type: StringConstructor;
+    };
+}>, {
+    resize: (event: ResizeObserverEntry) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    menus: {
+        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;
+        };
+        required: true;
+    };
+    direction: {
+        type: StringConstructor;
+        default: string;
+    };
+    expandActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    options: {
+        type: ObjectConstructor;
+    };
+    modelValue: {
+        type: StringConstructor;
+    };
+}>> & Readonly<{
+    onClick?: (...args: any[]) => any;
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+}>, {
+    direction: string;
+    expandActive: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {
+    menusRef: import("vue").CreateComponentPublicInstanceWithMixins<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;
+    }>, {
+        resize: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (...args: any[]) => void;
+    }, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
+        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 import("../../main.js").I18ns;
+                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>;
+                menuRef: import("vue").Ref<any, any>;
+                menusRef: import("vue").Ref<any, any>;
+                scrollerRef: import("vue").Ref<any, any>;
+                contentStyle: import("vue").Ref<any, any>;
+                hovered: import("vue").Ref<boolean, boolean>;
+                click: (menu: any) => void;
+                childClick: (menu: any) => void;
+                mouseOver: (event: MouseEvent) => void;
+                mouseOut: (event: MouseEvent) => void;
+                position: import("vue").ComputedRef<string>;
+                active: import("vue").ComputedRef<boolean>;
+                anchor: import("vue").ComputedRef<{
+                    href: any;
+                    target: any;
+                }>;
+            }, {}, {}, {}, 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 import("../../main.js").I18ns;
+            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>;
+            menuRef: import("vue").Ref<any, any>;
+            menusRef: import("vue").Ref<any, any>;
+            scrollerRef: import("vue").Ref<any, any>;
+            contentStyle: import("vue").Ref<any, any>;
+            hovered: import("vue").Ref<boolean, boolean>;
+            click: (menu: any) => void;
+            childClick: (menu: any) => void;
+            mouseOver: (event: MouseEvent) => void;
+            mouseOut: (event: MouseEvent) => void;
+            position: import("vue").ComputedRef<string>;
+            active: import("vue").ComputedRef<boolean>;
+            anchor: import("vue").ComputedRef<{
+                href: any;
+                target: any;
+            }>;
+        }> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {};
+        })[];
+    }, HTMLDivElement, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, 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;
+    }>, {
+        resize: () => void;
+    }, {}, {}, {}, {}>[];
+}, any>;
+export default _default;