@hlw-vue/crud 1.0.0

package/types/components/form-tabs/index.d.ts

@@ -0,0 +1,38 @@
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: (NumberConstructor | StringConstructor)[];
+    labels: {
+        type: ArrayConstructor;
+        default: () => any[];
+    };
+    justify: {
+        type: PropType<"start" | "end" | "left" | "right" | "center" | "justify" | "match-parent">;
+        default: string;
+    };
+    type: {
+        type: PropType<"card" | "default">;
+        default: string;
+    };
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: (NumberConstructor | StringConstructor)[];
+    labels: {
+        type: ArrayConstructor;
+        default: () => any[];
+    };
+    justify: {
+        type: PropType<"start" | "end" | "left" | "right" | "center" | "justify" | "match-parent">;
+        default: string;
+    };
+    type: {
+        type: PropType<"card" | "default">;
+        default: string;
+    };
+}>> & Readonly<{
+    onChange?: (...args: any[]) => any;
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+}>, {
+    type: "default" | "card";
+    labels: unknown[];
+    justify: "left" | "center" | "right" | "justify" | "start" | "end" | "match-parent";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/index.d.ts

@@ -0,0 +1,5 @@
+import { App } from 'vue';
+export declare const components: {
+    [key: string]: any;
+};
+export declare function useComponent(app: App): void;

package/types/components/multi-delete-btn/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/pagination/index.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/refresh-btn/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/row/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/search/helper/plugins.d.ts

@@ -0,0 +1,3 @@
+export declare function usePlugins(): {
+    create: (plugins?: HlwSearch.Plugin[]) => void;
+};

package/types/components/search/index.d.ts

@@ -0,0 +1,66 @@
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    props: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    data: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    items: {
+        type: PropType<HlwForm.Item[]>;
+        default: () => any[];
+    };
+    resetBtn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    collapse: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onLoad: FunctionConstructor;
+    onSearch: FunctionConstructor;
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "reset"[], "reset", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    props: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    data: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    items: {
+        type: PropType<HlwForm.Item[]>;
+        default: () => any[];
+    };
+    resetBtn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    collapse: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    onLoad: FunctionConstructor;
+    onSearch: FunctionConstructor;
+}>> & Readonly<{
+    onReset?: (...args: any[]) => any;
+}>, {
+    data: Record<string, any>;
+    props: Record<string, any>;
+    items: HlwForm.Item<any>[];
+    inline: boolean;
+    resetBtn: boolean;
+    collapse: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/search-key/index.d.ts

@@ -0,0 +1,55 @@
+import { PropType } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    modelValue: StringConstructor;
+    field: {
+        type: StringConstructor;
+        default: string;
+    };
+    fieldList: {
+        type: PropType<Array<{
+            label: string;
+            value: string;
+        }>>;
+        default: () => any[];
+    };
+    onSearch: FunctionConstructor;
+    placeholder: StringConstructor;
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    refreshOnInput: BooleanConstructor;
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("change" | "update:modelValue" | "field-change")[], "change" | "update:modelValue" | "field-change", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: StringConstructor;
+    field: {
+        type: StringConstructor;
+        default: string;
+    };
+    fieldList: {
+        type: PropType<Array<{
+            label: string;
+            value: string;
+        }>>;
+        default: () => any[];
+    };
+    onSearch: FunctionConstructor;
+    placeholder: StringConstructor;
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    refreshOnInput: BooleanConstructor;
+}>> & Readonly<{
+    onChange?: (...args: any[]) => any;
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+    "onField-change"?: (...args: any[]) => any;
+}>, {
+    width: string | number;
+    refreshOnInput: boolean;
+    field: string;
+    fieldList: {
+        label: string;
+        value: string;
+    }[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/table/helper/data.d.ts

@@ -0,0 +1,7 @@
+export declare function useData({ config, Table }: {
+    config: HlwTable.Config;
+    Table: Vue.Ref<any>;
+}): {
+    data: import('vue').Ref<obj[], obj[]>;
+    setData: (list: obj[]) => void;
+};

package/types/components/table/helper/header.d.ts

@@ -0,0 +1 @@
+export declare function renderHeader(item: HlwTable.Column, { scope, slots }: any): any;

package/types/components/table/helper/height.d.ts

@@ -0,0 +1,7 @@
+export declare function useHeight({ config, Table }: {
+    Table: Vue.Ref<any>;
+    config: HlwTable.Config;
+}): {
+    maxHeight: import('vue').Ref<number, number>;
+    calcMaxHeight: import('lodash-es').DebouncedFunc<() => Promise<void>>;
+};

package/types/components/table/helper/index.d.ts

@@ -0,0 +1,191 @@
+import { TableInstance } from 'element-plus';
+export declare function useTable(props: any): {
+    Table: import('vue').Ref<TableInstance, TableInstance>;
+    config: {
+        columns: {
+            [x: string]: any;
+            type: HlwTable.ColumnType;
+            hidden: boolean | {
+                value: boolean;
+            };
+            component: {
+                [x: string]: any;
+                name?: string;
+                options?: {
+                    [x: string]: any;
+                    label?: string;
+                    value?: any;
+                    color?: string;
+                    type?: string;
+                }[] | {
+                    value: {
+                        [x: string]: any;
+                        label?: string;
+                        value?: any;
+                        color?: string;
+                        type?: string;
+                    }[];
+                };
+                props?: {
+                    [x: string]: any;
+                    onChange?: (value: any) => void;
+                } | {
+                    value: {
+                        [x: string]: any;
+                        onChange?: (value: any) => void;
+                    };
+                };
+                style?: obj;
+                slots?: {
+                    [key: string]: (data?: any) => any;
+                };
+                vm?: any;
+            };
+            search: {
+                isInput: boolean;
+                value: any;
+                icon: () => any;
+                refreshOnChange: boolean;
+                component: {
+                    [x: string]: any;
+                    name?: string;
+                    options?: {
+                        [x: string]: any;
+                        label?: string;
+                        value?: any;
+                        color?: string;
+                        type?: string;
+                    }[] | {
+                        value: {
+                            [x: string]: any;
+                            label?: string;
+                            value?: any;
+                            color?: string;
+                            type?: string;
+                        }[];
+                    };
+                    props?: {
+                        [x: string]: any;
+                        onChange?: (value: any) => void;
+                    } | {
+                        value: {
+                            [x: string]: any;
+                            onChange?: (value: any) => void;
+                        };
+                    };
+                    style?: obj;
+                    slots?: {
+                        [key: string]: (data?: any) => any;
+                    };
+                    vm?: any;
+                };
+            };
+            dict: {
+                [x: string]: any;
+                label?: string;
+                value?: any;
+                color?: string;
+                type?: string;
+            }[] | {
+                value: {
+                    [x: string]: any;
+                    label?: string;
+                    value?: any;
+                    color?: string;
+                    type?: string;
+                }[];
+            };
+            dictFormatter: (values: DictOptions) => string;
+            dictColor: boolean;
+            dictSeparator: string;
+            dictAllLevels: boolean;
+            buttons: ((options: {
+                scope: any;
+            }) => HlwTable.OpButton) | ("info" | "delete" | "edit" | AnyString | `slot-${string}` | {
+                [x: string]: any;
+                label: string;
+                type?: string;
+                hidden?: boolean;
+                onClick: (options: {
+                    scope: obj;
+                }) => void;
+            })[];
+            align: ElementPlus.Align;
+            label: any;
+            renderLabel: (options: {
+                column: any;
+                $index: number;
+            }) => any;
+            className: string;
+            prop: string & {};
+            orderNum: number;
+            width: string | number | {
+                value: string | number;
+            };
+            minWidth: string | number | {
+                value: string | number;
+            };
+            renderHeader: (options: {
+                column: any;
+                $index: number;
+            }) => any;
+            sortable: boolean | "desc" | "descending" | "ascending" | "asc" | "custom";
+            sortMethod: fn;
+            sortBy: string | any[] | ((row: any, index: number) => any);
+            resizable: boolean;
+            columnKey: string;
+            headerAlign: ElementPlus.Align;
+            showOverflowTooltip: boolean;
+            fixed: boolean | string;
+            render: (row: any, column: any, value: any, index: number) => any;
+            formatter: (row: any, column: any, value: any, index: number) => any;
+            selectable: (row: any, index: number) => boolean;
+            reserveSelection: boolean;
+            filterMethod: fn;
+            filteredValue: unknown[];
+            filters: unknown[];
+            filterPlacement: string;
+            filterMultiple: boolean;
+            index: ((index: number) => number) | number;
+            sortOrders: unknown[];
+            children: any[];
+        }[];
+        autoHeight: boolean;
+        height: any;
+        contextMenu: ("info" | "update" | "delete" | "edit" | "refresh" | {
+            [x: string]: any;
+            label: string;
+            prefixIcon?: any;
+            suffixIcon?: any;
+            ellipsis?: boolean;
+            disabled?: boolean;
+            hidden?: boolean;
+            children?: any[];
+            showChildren?: boolean;
+            callback?: (done: fn) => void;
+        } | ((row: obj, column: obj, event: PointerEvent) => ClContextMenu.Item) | "check" | "order-desc" | "order-asc")[];
+        defaultSort: {
+            prop: string;
+            order: "descending" | "ascending";
+        };
+        sortRefresh: boolean;
+        emptyText: string;
+        rowKey: string;
+        on?: {
+            [key: string]: (...args: any[]) => void;
+        };
+        props?: {
+            [key: string]: any;
+        };
+        plugins?: HlwTable.Plugin[];
+        onRowContextmenu?: (row: any, column: any, event: any) => void;
+    };
+};
+export * from './data';
+export * from './height';
+export * from './op';
+export * from './render';
+export * from './row';
+export * from './selection';
+export * from './sort';
+export * from './header';

package/types/components/table/helper/op.d.ts

@@ -0,0 +1,9 @@
+export declare function useOp({ config }: {
+    config: HlwTable.Config;
+}): {
+    visible: import('vue').Ref<boolean, boolean>;
+    reBuild: (cb?: fn) => Promise<void>;
+    showColumn: (prop: string | string[], status?: boolean) => void;
+    hideColumn: (prop: string | string[]) => void;
+    setColumns: (list: HlwTable.Column[]) => void;
+};

package/types/components/table/helper/plugins.d.ts

@@ -0,0 +1,3 @@
+export declare function usePlugins(): {
+    create: (plugins?: HlwTable.Plugin[]) => void;
+};

package/types/components/table/helper/render.d.ts

@@ -0,0 +1,7 @@
+export declare function useRender(): {
+    renderColumn: (columns: HlwTable.Column[]) => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>[];
+    renderEmpty: (emptyText: string) => any;
+    renderAppend: () => any;
+};

package/types/components/table/helper/row.d.ts

@@ -0,0 +1,13 @@
+export declare function useRow({ Table, config, Sort }: {
+    Table: Vue.Ref<any>;
+    config: HlwTable.Config;
+    Sort: {
+        defaultSort: {
+            prop?: string;
+            order?: string;
+        };
+        changeSort(prop: string, order: string): void;
+    };
+}): {
+    onRowContextMenu: (row: obj, column: obj, event: PointerEvent) => void;
+};

package/types/components/table/helper/selection.d.ts

@@ -0,0 +1,6 @@
+export declare function useSelection({ emit }: {
+    emit: Vue.Emit;
+}): {
+    selection: obj[];
+    onSelectionChange: (selection: any[]) => void;
+};

package/types/components/table/helper/sort.d.ts

@@ -0,0 +1,18 @@
+export declare function useSort({ config, Table, emit }: {
+    config: HlwTable.Config;
+    Table: Vue.Ref<any>;
+    emit: Vue.Emit;
+}): {
+    defaultSort: {
+        prop: string;
+        order: "descending" | "ascending";
+    } | {
+        prop?: undefined;
+        order?: undefined;
+    };
+    onSortChange: ({ prop, order }: {
+        prop: string | undefined;
+        order: string;
+    }) => void;
+    changeSort: (prop: string, order: string) => void;
+};

package/types/components/table/index.d.ts

@@ -0,0 +1,62 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    columns: {
+        type: ArrayConstructor;
+        default: () => any[];
+    };
+    autoHeight: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    height: any;
+    contextMenu: {
+        type: (ArrayConstructor | BooleanConstructor)[];
+        default: any;
+    };
+    defaultSort: ObjectConstructor;
+    sortRefresh: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyText: StringConstructor;
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("selection-change" | "sort-change")[], "selection-change" | "sort-change", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    columns: {
+        type: ArrayConstructor;
+        default: () => any[];
+    };
+    autoHeight: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    height: any;
+    contextMenu: {
+        type: (ArrayConstructor | BooleanConstructor)[];
+        default: any;
+    };
+    defaultSort: ObjectConstructor;
+    sortRefresh: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyText: StringConstructor;
+    rowKey: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onSelection-change"?: (...args: any[]) => any;
+    "onSort-change"?: (...args: any[]) => any;
+}>, {
+    columns: unknown[];
+    autoHeight: boolean;
+    height: any;
+    contextMenu: boolean | unknown[];
+    sortRefresh: boolean;
+    rowKey: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/components/upsert/index.d.ts

@@ -0,0 +1,38 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    items: {
+        type: ArrayConstructor;
+        default: () => any[];
+    };
+    props: ObjectConstructor;
+    sync: BooleanConstructor;
+    op: ObjectConstructor;
+    dialog: ObjectConstructor;
+    onOpen: FunctionConstructor;
+    onOpened: FunctionConstructor;
+    onClose: FunctionConstructor;
+    onClosed: FunctionConstructor;
+    onInfo: FunctionConstructor;
+    onSubmit: FunctionConstructor;
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("opened" | "closed")[], "opened" | "closed", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    items: {
+        type: ArrayConstructor;
+        default: () => any[];
+    };
+    props: ObjectConstructor;
+    sync: BooleanConstructor;
+    op: ObjectConstructor;
+    dialog: ObjectConstructor;
+    onOpen: FunctionConstructor;
+    onOpened: FunctionConstructor;
+    onClose: FunctionConstructor;
+    onClosed: FunctionConstructor;
+    onInfo: FunctionConstructor;
+    onSubmit: FunctionConstructor;
+}>> & Readonly<{
+    onOpened?: (...args: any[]) => any;
+    onClosed?: (...args: any[]) => any;
+}>, {
+    sync: boolean;
+    items: unknown[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/emitter.d.ts

@@ -0,0 +1,2 @@
+export declare const crudList: HlwCrud.Ref[];
+export declare const emitter: Emitter;

package/types/entry.d.ts

@@ -0,0 +1,13 @@
+import { App } from 'vue';
+declare const Crud: {
+    install(app: App, options?: any): {
+        name: string;
+    };
+};
+export { Crud };
+export * from './emitter';
+export * from './hooks';
+export * from './locale';
+export { registerFormHook } from './utils/form-hook';
+export { renderNode } from './utils/vnode';
+export { ContextMenu } from './components/context-menu';

package/types/hooks/crud.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+export declare function useCrud(options?: HlwCrud.Options, cb?: (app: HlwCrud.Ref) => void): Ref<HlwCrud.Ref, HlwCrud.Ref>;
+export declare function useUpsert<T = any>(options?: HlwUpsert.Options<T>): Ref<HlwUpsert.Ref<any>, HlwUpsert.Ref<any>>;
+export declare function useTable<T = any>(options?: HlwTable.Options<T>, cb?: (table: HlwTable.Ref) => void): Ref<HlwTable.Ref<T>, HlwTable.Ref<T>>;
+export declare function useForm<T = any>(cb?: (app: HlwForm.Ref<T>) => void): Ref<HlwForm.Ref<T>, HlwForm.Ref<T>>;
+export declare function useAdvSearch<T = any>(options?: HlwAdvSearch.Options<T>): Ref<HlwAdvSearch.Ref<T>, HlwAdvSearch.Ref<T>>;
+export declare function useSearch<T = any>(options?: HlwSearch.Options<T>): Ref<HlwSearch.Ref<T>, HlwSearch.Ref<T>>;
+export declare function useDialog(options?: {
+    onFullscreen(visible: boolean): void;
+}): HlwDialog.Provide;

package/types/hooks/index.d.ts

@@ -0,0 +1,16 @@
+import { Mitt } from '../utils/mitt';
+export declare function useCore(): {
+    crud: HlwCrud.Ref;
+    mitt: Mitt;
+};
+export declare function useConfig(): Config;
+export declare function useBrowser(): Browser;
+export declare function useRefs(): {
+    refs: {
+        [key: string]: obj;
+    };
+    setRefs: (name: string) => (el: any) => void;
+};
+export declare function useProxy(ctx: any): any;
+export declare function useElApi(keys: string[], el: any): obj;
+export * from './crud';

package/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./entry";

package/types/locale/en.d.ts

@@ -0,0 +1,33 @@
+declare const _default: {
+    op: string;
+    add: string;
+    delete: string;
+    multiDelete: string;
+    update: string;
+    refresh: string;
+    info: string;
+    search: string;
+    reset: string;
+    clear: string;
+    save: string;
+    close: string;
+    confirm: string;
+    advSearch: string;
+    searchKey: string;
+    placeholder: string;
+    tips: string;
+    saveSuccess: string;
+    deleteSuccess: string;
+    deleteConfirm: string;
+    empty: string;
+    desc: string;
+    asc: string;
+    select: string;
+    deselect: string;
+    seeMore: string;
+    hideContent: string;
+    nonEmpty: string;
+    collapse: string;
+    expand: string;
+};
+export default _default;