@epie/bi-crud 2.0.1

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

@@ -0,0 +1,58 @@
+/// <reference types="../index" />
+import type { PropType } from "vue";
+declare const _default: import("vue").DefineComponent<{
+    items: {
+        type: PropType<ClForm.Item[]>;
+        default: () => never[];
+    };
+    props: PropType<ElementPlus.FormProps | undefined>;
+    sync: BooleanConstructor;
+    op: PropType<{
+        hidden?: boolean | undefined;
+        saveButtonText?: string | undefined;
+        closeButtonText?: string | undefined;
+        buttons?: ("close" | "save" | Render.OpButton)[] | undefined;
+    } | undefined>;
+    dialog: PropType<{
+        [key: string]: any;
+        title?: string | undefined;
+        width?: string | undefined;
+        hideHeader?: boolean | undefined;
+        controls?: ("close" | "fullscreen")[] | undefined;
+    } | undefined>;
+    onOpen: FunctionConstructor;
+    onClose: FunctionConstructor;
+    onInfo: FunctionConstructor;
+    onSubmit: FunctionConstructor;
+}, any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("opened" | "closed")[], "opened" | "closed", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    items: {
+        type: PropType<ClForm.Item[]>;
+        default: () => never[];
+    };
+    props: PropType<ElementPlus.FormProps | undefined>;
+    sync: BooleanConstructor;
+    op: PropType<{
+        hidden?: boolean | undefined;
+        saveButtonText?: string | undefined;
+        closeButtonText?: string | undefined;
+        buttons?: ("close" | "save" | Render.OpButton)[] | undefined;
+    } | undefined>;
+    dialog: PropType<{
+        [key: string]: any;
+        title?: string | undefined;
+        width?: string | undefined;
+        hideHeader?: boolean | undefined;
+        controls?: ("close" | "fullscreen")[] | undefined;
+    } | undefined>;
+    onOpen: FunctionConstructor;
+    onClose: FunctionConstructor;
+    onInfo: FunctionConstructor;
+    onSubmit: FunctionConstructor;
+}>> & {
+    onClosed?: ((...args: any[]) => any) | undefined;
+    onOpened?: ((...args: any[]) => any) | undefined;
+}, {
+    items: ClForm.Item[];
+    sync: boolean;
+}>;
+export default _default;

package/types/emitter.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="../index" />
+export declare const crudList: ClCrud.Ref[];
+export declare const emitter: Emitter;

package/types/hooks/browser.d.ts

@@ -0,0 +1,4 @@
+export declare function useBrowser(app?: any): {
+    screen: string;
+    isMini: boolean;
+};

package/types/hooks/core.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="../index" />
+export declare function useRefs(): {
+    refs: any;
+    setRefs: (index: number) => (el: HTMLElement) => void;
+};
+export declare function useTools(): {
+    browser: any;
+    style: any;
+};
+export declare function useCore(): {
+    crud: ClCrud.Provide;
+    mitt: Emitter;
+};

package/types/hooks/crud.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="../index" />
+import { Ref } from "vue";
+export declare function useCrud(options?: ClCrud.Props, cb?: (app: ClCrud.Ref) => void): Ref<ClCrud.Ref | undefined>;
+export declare function useUpsert(options?: ClUpsert.Props): Ref<ClUpsert.Ref | undefined>;
+export declare function useTable(options?: ClTable.Props): Ref<ClTable.Ref | undefined>;
+export declare function useAdvSearch(options: ClAdvSearch.Props): Ref<ClAdvSearch.Ref | undefined>;
+export declare function useForm(cb?: (app: ClForm.Ref) => void): Ref<ClForm.Ref | undefined>;
+export declare function useDialog(options?: {
+    onFullscreen(visible: boolean): void;
+}): {
+    fullscreen: Ref<boolean>;
+    visible: Ref<boolean>;
+} | undefined;

package/types/hooks/form.d.ts

@@ -0,0 +1,6 @@
+export declare const format: any;
+declare const _default: {
+    bind(data: any): any;
+    submit(data: any): any;
+};
+export default _default;

package/types/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./crud";
+export * from "./core";
+export * from "./browser";
+export * from "./proxy";

package/types/hooks/proxy.d.ts

@@ -0,0 +1 @@
+export declare function useProxy(ret: any): void;

package/types/index.d.ts

@@ -0,0 +1,10 @@
+import "./static/index.scss";
+declare const Crud: {
+    install(app: any, options: any): {
+        name: string;
+    };
+};
+export default Crud;
+export * from "./emitter";
+export * from "./hooks";
+export { ContextMenu } from "./components/context-menu";

package/types/types/adv-search.d.ts

@@ -0,0 +1,16 @@
+declare namespace ClAdvSearch {
+  interface Props {
+    items: ClForm.Item[];
+    title?: string;
+    size?: string | number;
+    op?: Array<"clear" | "reset" | "close" | "save">;
+    onSearch?(
+      data: any,
+      event: {
+        next(params: any): void;
+        close(): void;
+      }
+    ): void;
+  }
+  interface Ref extends ClForm.Ref {}
+}

package/types/types/browser.d.ts

@@ -0,0 +1,4 @@
+declare type Browser = {
+  screen: string;
+  isMini: boolean;
+};

package/types/types/context-menu.d.ts

@@ -0,0 +1,26 @@
+declare namespace ClContextMenu {
+  interface Item {
+    label: string;
+    icon?: string;
+    prefixIcon?: string;
+    suffixIcon?: string;
+    ellipsis?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+    children?: Item[];
+    showChildren?: boolean;
+    callback?(done: fun): void;
+  }
+  interface Event {
+    pageX: number;
+    pageY: number;
+    [key: string]: any;
+  }
+  interface Options {
+    list: Item[];
+  }
+  interface Ref {
+    open(event: Event, options: Options): Ref;
+    close(): void;
+  }
+}

package/types/types/crud.d.ts

@@ -0,0 +1,137 @@
+declare namespace ClCrud {
+  interface Dict {
+    api?: {
+      list?: string;
+      add?: string;
+      update?: string;
+      delete?: string;
+      info?: string;
+      page?: string;
+    };
+    pagination?: {
+      page?: string;
+      size?: string;
+    };
+    search?: {
+      keyWord?: string;
+      query?: string;
+    };
+    sort?: {
+      order?: string;
+      prop?: string;
+    };
+    label?: {
+      add?: string;
+      delete?: string;
+      multiDelete?: string;
+      update?: string;
+      refresh?: string;
+      advSearch?: string;
+    };
+  }
+  interface Permission {
+    page?: boolean;
+    list?: boolean;
+    add?: boolean;
+    delete?: boolean;
+    update?: boolean;
+    info?: boolean;
+    [key: string]: any;
+  }
+  interface Service {
+    page: {
+      params: {
+        page?: number;
+        size?: number;
+        keyWord?: string;
+        [key: string]: any;
+      };
+      result: {
+        list: any[];
+        pagination?: {
+          total?: number;
+          page?: number;
+          size?: number;
+        };
+        [key: string]: any;
+      };
+      request(
+        params?: Service["page"]["params"]
+      ): Promise<Service["page"]["result"]>;
+    };
+    delete: {
+      params: {
+        ids?: Array<string | number>;
+        [key: string]: any;
+      };
+      request(params: Service["delete"]["params"]): Promise<any>;
+    };
+    info: {
+      params: {
+        id?: string | number;
+        [key: string]: any;
+      };
+      request(params: Service["info"]["params"]): Promise<any>;
+    };
+    upsert: {
+      request(params: any): Promise<any>;
+    };
+    list: {
+      request(params: any): Promise<any[]>;
+    };
+    api: {
+      page?(params?: any): Promise<any>;
+      list?(params?: any): Promise<any>;
+      add?(params?: any): Promise<any>;
+      update?(params?: any): Promise<any>;
+      info?(params?: any): Promise<any>;
+      delete?(params?: any): Promise<any>;
+      [key: string]: any;
+    };
+  }
+  interface Props {
+    service: Service["api"];
+    permission?: Permission;
+    dict?: Dict;
+    onRefresh?(
+      params: Service["page"]["params"],
+      event: {
+        done: fun;
+        next: Service["page"]["request"];
+        render: (
+          list: any[],
+          pagination?: Service["page"]["result"]["pagination"]
+        ) => void;
+      }
+    ): any;
+    onDelete?(
+      selection: any[],
+      event: {
+        next: Service["delete"]["request"];
+      }
+    ): any;
+  }
+  interface Ref {
+    name: string;
+    routePath: string;
+    permission: Permission;
+    dict: Dict;
+    service: Service["api"];
+    loading: boolean;
+    params: any;
+    selection: any[];
+    set(key: "dict" | "style" | "service" | "permission", value: any): void;
+    done(): void;
+    getParams(): any;
+    getPermission(key?: string): boolean;
+    rowAdd(): any;
+    rowEdit(data: any): any;
+    rowAppend(data?: any): any;
+    rowClose(): any;
+    rowDelete(...selection: any[]): void;
+    refresh: Service["page"]["request"];
+  }
+  interface Provide extends Ref {
+    [key: string]: any;
+  }
+}

package/types/types/element-plus.d.ts

@@ -0,0 +1,15 @@
+declare namespace ElementPlus {
+  type Size = "large" | "default" | "small";
+  interface FormProps {
+    inline?: boolean;
+    labelPosition?: "left" | "right" | "top";
+    labelWidth?: string | number;
+    labelSuffix?: string;
+    hideRequiredAsterisk?: boolean;
+    showMessage?: boolean;
+    inlineMessage?: boolean;
+    statusIcon?: boolean;
+    validateOnRuleChange?: boolean;
+    size?: Size;
+  }
+}

package/types/types/emitter.d.ts

@@ -0,0 +1,16 @@
+declare interface EmitterItem {
+  name: string;
+  callback(
+    data: any,
+    events: {
+      refresh(params: any): void;
+      crudList: ClCrud.Ref[];
+    }
+  ): void;
+}
+declare interface Emitter {
+  list: EmitterItem[];
+  init(events: any): void;
+  emit(name: string, data?: any): void;
+  on(name: string, callback: any): void;
+}

package/types/types/form.d.ts

@@ -0,0 +1,112 @@
+declare namespace ClForm {
+	interface Item {
+		type?: "tabs";
+		prop?: string;
+		props?: {
+			labels?: Array<{
+				label: string;
+				value: string;
+				name?: string;
+			}>;
+			justify?: "left" | "center" | "right";
+			color?: string;
+			mergeProp?: boolean;
+			labelWidth?: string;
+			error?: string;
+			showMessage?: boolean;
+			inlineMessage?: boolean;
+			size?: "medium" | "default" | "small";
+			[key: string]: any;
+		};
+		hook?: Hook.Form;
+		group?: string;
+		collapse?: boolean;
+		value?: any;
+		label?:
+			| string
+			| {
+					text?: string;
+					icon?: string;
+					tip?: string;
+			  };
+		span?: number;
+		flex?: boolean;
+		hidden?:
+			| boolean
+			| ((data: { scope: any; isEdit: boolean }) => boolean)
+			| ":isEdit"
+			| `@${string}`;
+		prepend?: Render.Options;
+		component?: Render.Options;
+		append?: Render.Options;
+		rules?: any;
+		required?: boolean;
+	}
+	interface Options {
+		title?: string;
+		width?: string;
+		props?: ElementPlus.FormProps;
+		items: Item[];
+		form?: any;
+		on?: {
+			open?(form: any): void;
+			close?(done: fun): void;
+			submit?(
+				data: any,
+				event: {
+					close: fun;
+					done: fun;
+				}
+			): void;
+		};
+		op?: {
+			hidden?: boolean;
+			saveButtonText?: string;
+			closeButtonText?: string;
+			buttons?: Array<"close" | "save" | Render.OpButton>;
+		};
+		dialog?: {
+			title?: string;
+			width?: string;
+			hideHeader?: boolean;
+			controls?: Array<"fullscreen" | "close">;
+			[key: string]: any;
+		};
+		[key: string]: any;
+	}
+	interface Ref {
+		form: any;
+		open(options: Options): void;
+		close(): void;
+		done(): void;
+		clear(): void;
+		reset(): void;
+		showLoading(): void;
+		hideLoading(): void;
+		bindForm(data: any): void;
+		setData(prop: string, value: any): void;
+		setOptions(
+			prop: string,
+			list: Array<{
+				label: string;
+				value?: any;
+			}>
+		): void;
+		setProps(prop: string, value: any): void;
+		getForm(prop?: string): any;
+		setForm(prop: string, value: any): void;
+		showItem(props: string[]): void;
+		hideItem(props: string[]): void;
+		toggleItem(prop: string, flag?: boolean): void;
+		resetFields(): void;
+		clearValidate(props?: string[] | string): void;
+		validateField(
+			props: string[] | string,
+			callback: (isValid: boolean, invalidFields: any[]) => void
+		): Promise<void>;
+		validate(callback: (isValid: boolean, invalidFields: any[]) => void): Promise<void>;
+		changeTab(value: any, valid?: boolean): Promise<any>;
+		setTitle(value: string): void;
+		submit(callback?: (data: any) => void): void;
+	}
+}

package/types/types/hook.d.ts

@@ -0,0 +1,18 @@
+declare namespace Hook {
+  type FormPipe =
+    | "number"
+    | "string"
+    | "split"
+    | "join"
+    | "boolean"
+    | "booleanNumber"
+    | "datetimerange"
+    | FormPipe[]
+    | fun;
+  type Form =
+    | string
+    | {
+        bind?: FormPipe;
+        submit?: FormPipe;
+      };
+}

package/types/types/index.d.ts

@@ -0,0 +1 @@
+declare type fun = () => void;

package/types/types/render.d.ts

@@ -0,0 +1,17 @@
+declare namespace Render {
+    type OpButton = `slot-${string}` | {
+        label: string;
+        onClick({ scope }: any): void;
+    };
+    interface Options {
+        name?: string;
+        options?: Array<{
+            label: string;
+            value?: any;
+            [key: string]: any;
+        }> | fun;
+        props?: any;
+        vm?: any;
+        [key: string]: any;
+    }
+}

package/types/types/table.d.ts

@@ -0,0 +1,91 @@
+declare namespace ClTable {
+  interface Column {
+    type?: "index" | "selection" | "expand" | "op";
+    hidden?: boolean;
+    component?: Render.Options;
+    dict?: Array<{
+      label: string;
+      value?: any;
+      type?: "success" | "warning" | "info" | "danger";
+      size?: "medium" | "default" | "small";
+      effect?: "dark" | "light" | "plain";
+      color?: string;
+    }>;
+    buttons?: Array<"edit" | "delete" | Render.OpButton>;
+    align?: "left" | "center" | "right";
+    label?: string;
+    className?: string;
+    prop?: string;
+    width?: number;
+    minWidth?: number | string;
+    renderHeader?: fun;
+    sortable?:
+      | boolean
+      | "desc"
+      | "descending"
+      | "ascending"
+      | "asc"
+      | "custom"
+      | string;
+    sortMethod?: fun;
+    sortBy?: string | fun | unknown[];
+    resizable?: {
+      type: boolean;
+      default: true;
+    };
+    columnKey?: string;
+    headerAlign?: string;
+    showOverflowTooltip?: boolean;
+    fixed?: boolean | string;
+    formatter?: fun;
+    selectable?: fun;
+    reserveSelection?: boolean;
+    filterMethod?: fun;
+    filteredValue?: unknown[];
+    filters?: unknown[];
+    filterPlacement?: string;
+    filterMultiple?: {
+      type: boolean;
+      default: true;
+    };
+    index?: number | fun;
+    sortOrders?: unknown[];
+  }
+  interface Props {
+    columns: Column[];
+    contextMenu?:
+      | boolean
+      | Array<
+          | ClContextMenu.Item
+          | ((row: any) => ClContextMenu.Item)
+          | "refresh"
+          | "check"
+          | "update"
+          | "edit"
+          | "delete"
+          | "order-desc"
+          | "order-asc"
+        >;
+  }
+  interface Ref {
+    selection: any[];
+    data: any[];
+    columns: Column[];
+    showColumn(prop: string | string[], status?: boolean): void;
+    hideColumn(prop: string | string[]): void;
+    changeSort(prop: string, order: string): void;
+    clearSelection(): void;
+    getSelectionRows(): any[];
+    toggleRowSelection(row: any, selected: any[]): void;
+    toggleAllSelection(): void;
+    toggleRowExpansion(row: any, expanded: any[]): void;
+    setCurrentRow(row: any): void;
+    clearSort(): void;
+    clearFilter(columnKeys: string[]): void;
+    doLayout(): void;
+    sort(prop: string, order: string): void;
+    scrollTo(position: { top?: number; left?: number }): void;
+    setScrollTop(top: number): void;
+    setScrollLeft(left: number): void;
+  }
+}

package/types/types/test.d.ts

@@ -0,0 +1,3 @@
+declare interface A {
+  name: string;
+}

package/types/types/upsert.d.ts

@@ -0,0 +1,29 @@
+declare namespace ClUpsert {
+  interface Props {
+    items: ClForm.Item[];
+    props?: ClForm.Options["props"];
+    sync?: boolean;
+    op?: ClForm.Options["op"];
+    dialog?: ClForm.Options["dialog"];
+    onOpen?(isEdit: boolean, data: any): void;
+    onClose?(done: fun): void;
+    onInfo?(
+      data: ClCrud.Service["info"]["params"],
+      event: {
+        close: fun;
+        done(data: any): void;
+        next: ClCrud.Service["info"]["request"];
+      }
+    ): void;
+    onSubmit?(
+      isEdit: boolean,
+      data: any,
+      event: {
+        close: fun;
+        done: fun;
+        next: ClCrud.Service["upsert"]["request"];
+      }
+    ): void;
+  }
+  interface Ref extends ClForm.Ref {}
+}

package/types/utils/index.d.ts

@@ -0,0 +1,18 @@
+import cloneDeep from "clone-deep";
+import flat from "array.prototype.flat";
+import merge from "merge";
+export declare function isArray(value: any): boolean;
+export declare function isObject(value: any): boolean;
+export declare function isNumber(value: any): boolean;
+export declare function isFunction(value: any): boolean;
+export declare function isString(value: any): boolean;
+export declare function isNull(value: any): boolean;
+export declare function isBoolean(value: any): boolean;
+export declare function isEmpty(value: any): boolean;
+export declare function clone(obj: any): any;
+export declare function dataset(obj: any, key: string, value: any): any;
+export declare function contains(parent: any, node: any): any;
+export declare function deepMerge(a: any, b: any): any;
+export declare function addClass(el: Element, name: string): void;
+export declare function removeClass(el: Element, name: string): void;
+export { cloneDeep, flat, merge };

package/types/utils/mitt.d.ts

@@ -0,0 +1,9 @@
+declare class Emitter {
+    id: number;
+    constructor(id?: number);
+    send(type: string, name: string, ...args: any[]): void;
+    on(name: string, ...args: any[]): void;
+    emit(name: string, ...args: any[]): void;
+    off(name: string, ...args: any[]): void;
+}
+export default Emitter;

package/types/utils/parse.d.ts

@@ -0,0 +1,8 @@
+/**
+ * parse hidden
+ * 1 Boolean
+ * 2 Function({ scope })
+ * 3 :[prop] is bind form[prop] value
+ * @param {*} value
+ */
+export default function (method: string, { value, scope, data }: any): any;