morghulis 3.1.1 → 3.1.3

package/dist/types/components/tree/simple/MTree.vue.d.ts

@@ -0,0 +1,76 @@
+import { MTreeProps } from "./types";
+import { DataItemId } from "../../../hooks/use-query/types";
+declare function getSelection(): any[];
+declare function getCurrent(): {
+    [x: string]: any;
+    pid: number | string;
+    isLeaf: boolean;
+    icon?: import("../../common/types.js").IconNames | undefined;
+    children: /*elided*/ any[];
+    id?: DataItemId | undefined;
+} | null;
+declare function setExpended(expended: DataItemId[]): void;
+declare var __VLS_6: {}, __VLS_8: {}, __VLS_34: {}, __VLS_36: {}, __VLS_38: {
+    type: import("../../wrapper/types.js").MWrapperPopperType;
+    data: any;
+}, __VLS_59: {
+    data: any;
+    node: any;
+}, __VLS_61: {
+    data: any;
+    node: any;
+}, __VLS_63: {
+    data: any;
+    node: any;
+}, __VLS_69: {
+    data: any;
+    node: any;
+}, __VLS_71: {
+    data: any;
+    node: any;
+}, __VLS_73: {
+    data: any;
+    node: any;
+};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_6) => any;
+} & {
+    'header-tool'?: (props: typeof __VLS_8) => any;
+} & {
+    footer?: (props: typeof __VLS_34) => any;
+} & {
+    'footer-tool'?: (props: typeof __VLS_36) => any;
+} & {
+    pop?: (props: typeof __VLS_38) => any;
+} & {
+    left?: (props: typeof __VLS_59) => any;
+} & {
+    'left-leaf'?: (props: typeof __VLS_61) => any;
+} & {
+    'left-branch'?: (props: typeof __VLS_63) => any;
+} & {
+    right?: (props: typeof __VLS_69) => any;
+} & {
+    'right-leaf'?: (props: typeof __VLS_71) => any;
+} & {
+    'right-branch'?: (props: typeof __VLS_73) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<MTreeProps, {
+    setSelection: (nodes: any[]) => void;
+    getSelection: typeof getSelection;
+    closePopover: () => void;
+    getCurrent: typeof getCurrent;
+    setCurrent: (node: import("../../../hooks/use-query/types").TreeItem | null) => void;
+    getExpended: () => (DataItemId | undefined)[];
+    setExpended: typeof setExpended;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MTreeProps> & Readonly<{}>, {
+    labelKey: string;
+    nodeKey: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/tree/simple/hook.d.ts

@@ -0,0 +1,40 @@
+import { Ref } from "vue";
+import { MTreeProps } from "./types";
+import { DataItemId, TreeItem } from "../../../hooks/use-query/types";
+import { TreeNode } from "../types";
+export declare function useMTree(tree: Ref, wrapper: Ref, props: MTreeProps): {
+    current: Ref<{
+        [x: string]: any;
+        pid: number | string;
+        isLeaf: boolean;
+        icon?: import("../../common/types").IconNames | undefined;
+        children: /*elided*/ any[];
+        id?: DataItemId | undefined;
+    } | null, TreeItem | {
+        [x: string]: any;
+        pid: number | string;
+        isLeaf: boolean;
+        icon?: import("../../common/types").IconNames | undefined;
+        children: /*elided*/ any[];
+        id?: DataItemId | undefined;
+    } | null>;
+    text: Ref<string, string>;
+    selection: Ref<any[], any[]>;
+    toggleExpandAll: (expanded: boolean) => void;
+    handleClick: (data: TreeItem, node: TreeNode, _: any, event: Event) => void;
+    setSelection: (nodes: any[]) => void;
+    setCurrent: (node: TreeItem | null) => void;
+    handleSelect: (data: TreeItem, info: {
+        checkedNodes: TreeItem[];
+    }) => void;
+    handleExpand: (data: TreeItem, node: TreeNode) => void;
+    handleCollapse: (data: TreeItem, node: TreeNode) => void;
+    allow_drag: (node: TreeNode) => boolean | undefined;
+    allow_drop: (draggingNode: TreeNode, dropNode: TreeNode, type: "prev" | "inner" | "next") => boolean;
+    handleNodeDrop: (draggingNode: TreeNode, dropNode: TreeNode, dropType: "before" | "after" | "inner", event: Event) => void;
+    handleContextmenu: (event: PointerEvent, data: TreeItem) => void;
+    handleFilter: (value: string, data: any, node: any) => boolean;
+    toggleAllSelection: (flag: boolean) => void;
+    closePopover: () => void;
+    getExpended: () => (DataItemId | undefined)[];
+};

package/dist/types/components/tree/simple/tool.d.ts

@@ -0,0 +1,4 @@
+export declare const mTreePropsDefaults: {
+    nodeKey: string;
+    labelKey: string;
+};

package/dist/types/components/tree/simple/types.d.ts

@@ -0,0 +1,18 @@
+import { MTableButton } from "../../table/simple/types";
+import { TreeItem, TreeMapping } from "../../../hooks/use-query/types";
+import { MetaView } from "../../../hooks/use-mata/types";
+export type MTreeProps = {
+    data: TreeItem[];
+    root: string | number;
+    view: MetaView;
+    mapping: TreeMapping;
+    buttons?: MTableButton[];
+    nodeKey?: string;
+    labelKey?: string;
+    admin?: boolean;
+    loading?: boolean;
+    sortCallback?: Function;
+    treeSize?: '' | 'large' | 'default' | 'small';
+    accordion?: boolean;
+    expandAll?: boolean;
+};

package/dist/types/components/tree/simple/widgets/MTreeExpand.vue.d.ts

@@ -0,0 +1,12 @@
+type __VLS_Props = {
+    admin?: boolean;
+    selection: any[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    meta: (...args: any[]) => void;
+    expand: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onMeta?: ((...args: any[]) => any) | undefined;
+    onExpand?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/components/tree/simple/widgets/MTreeNode.vue.d.ts

@@ -0,0 +1,21 @@
+import { TreeItem } from "../../../../hooks/use-query/types";
+import { TreeNode } from "../../types";
+type __VLS_Props = {
+    data: TreeItem;
+    node: TreeNode;
+    selection: any[];
+    labelKey: string;
+    text: string;
+};
+declare var __VLS_14: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_14) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/tree/tool.d.ts

@@ -0,0 +1,7 @@
+import { DataItemId, TreeItem, TreeMapping } from "../../hooks/use-query/types";
+export declare function listToTree(nodes: TreeItem[], root_id?: DataItemId): {
+    options: TreeItem[];
+    mapping: TreeMapping;
+    root_name: any;
+    root: TreeItem;
+};

package/dist/types/components/tree/types.d.ts

@@ -0,0 +1,20 @@
+import { DataItemId, TreeItem, TreeMapping } from "../../hooks/use-query/types";
+export type TreeNode = {
+    expanded: boolean;
+    data: TreeItem;
+    childNodes: TreeNode[];
+    checked: boolean;
+    isLeaf: boolean;
+    id: string | number;
+    indeterminate: boolean;
+    canFocus: boolean;
+};
+export declare class TreeModel {
+    nodes: TreeItem[];
+    root_id: number | string;
+    root: TreeItem;
+    options: TreeItem[];
+    root_name: string;
+    mapping: TreeMapping;
+    constructor(nodes: TreeItem[], root_id?: DataItemId);
+}

package/dist/types/components/wrapper/MWrapper.vue.d.ts

@@ -0,0 +1,37 @@
+import { MWrapperPopperType } from "./types";
+type __VLS_Props = {
+    loading?: boolean;
+};
+declare function showPopover(event: PointerEvent, type: MWrapperPopperType, data?: any, placement?: string): void;
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {}, __VLS_7: {}, __VLS_9: {}, __VLS_15: {
+    type: MWrapperPopperType;
+    data: any;
+};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_1) => any;
+} & {
+    'header-tool'?: (props: typeof __VLS_3) => any;
+} & {
+    default?: (props: typeof __VLS_5) => any;
+} & {
+    footer?: (props: typeof __VLS_7) => any;
+} & {
+    'footer-tool'?: (props: typeof __VLS_9) => any;
+} & {
+    pop?: (props: typeof __VLS_15) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    showPopover: typeof showPopover;
+    closePopover: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/{table/data/widgets/DPopoverWrapper.vue.d.ts → wrapper/MWrapperPopContent.vue.d.ts}

@@ -1,12 +1,13 @@
-import { MTablePopperType } from "../../simple/types";
-import { MetaDatabase, MetaView } from "../../../../hooks/use-mata/types";
-import { Query } from "../../../../hooks/use-query/types";
+import { MetaDatabase, MetaView } from "../../hooks/use-mata/types";
+import { MWrapperPopperMapping, MWrapperPopperType } from "./types";
+import { Query } from "../../hooks/use-query/types";
 type __VLS_Props = {
-    type: MTablePopperType;
     db: MetaDatabase;
-    query: Query;
+    type: MWrapperPopperType;
+    query?: Query;
     view: MetaView;
     data: any;
+    mapping: MWrapperPopperMapping;
 };
 declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     search: (...args: any[]) => void;

package/dist/types/components/wrapper/types.d.ts

@@ -0,0 +1,22 @@
+import { MetaView } from "../../hooks/use-mata/types";
+import { Component } from "vue";
+import { TreeItem } from "../../hooks/use-query/types";
+export type MWrapperPopperType = 'meta' | 'search' | 'field' | 'cell' | 'index';
+type MPBStringFn = (node: any | TreeItem) => string;
+type MPBooleanFn = (node: TreeItem) => boolean;
+type MPBTypeFn = (node: TreeItem) => 'primary' | 'info' | 'success' | 'warning' | 'danger';
+export type MWrapperPopperButton = {
+    icon: string | MPBStringFn;
+    type: 'primary' | 'info' | 'success' | 'warning' | 'danger' | MPBTypeFn;
+    disabled?: boolean | MPBooleanFn;
+    handler: (item: any, data: any) => void;
+};
+export type MWrapperPopperMapping = {
+    [prop: string]: {
+        width: string | MPBStringFn;
+        component: Component;
+        title: (data: any, view: MetaView) => string;
+        buttons: MWrapperPopperButton[];
+    };
+};
+export {};

package/dist/types/hooks/use-admin/index.d.ts

@@ -0,0 +1,4 @@
+export declare function useAdmin(): {
+    isAdmin: import("vue").Ref<boolean, boolean>;
+    admin: import("vue").Ref<boolean, boolean>;
+};

package/dist/types/hooks/use-channel/index.d.ts

@@ -1,5 +1,10 @@
-import { MorghulisChannelConfig, MorghulisChannelSimple } from "./types";
-export declare function useMChannel(auth?: boolean): {
-    register: (handler: string, channel?: MorghulisChannelConfig, socketURL?: string) => MorghulisChannelSimple;
-    getChannel: (handler: string) => MorghulisChannelSimple;
+import { Ref } from "vue";
+import { ChannelParam } from "./types";
+export declare function useMChannel(param: Ref<ChannelParam>, auth?: boolean): {
+    activate: (data: any) => void;
+    channels: import("./types").ChannelContainer;
+    status: {
+        loading: boolean;
+        payload: any;
+    };
 };

package/dist/types/hooks/use-channel/types.d.ts

@@ -1,22 +1,41 @@
-import { Ref } from "vue";
-export type MorghulisChannelConfig = {
+import { Reactive } from "vue";
+import { AxiosInstance } from "axios";
+export type ChannelConfig = {
+    url?: string;
     onStart?: () => void;
     onStop?: () => void;
     onProceed?: (payload: any) => void;
 };
-export type MorghulisChannelSimple = {
-    loading: Ref<boolean>;
-    payload: Ref<any>;
-    activate: (body: any) => void;
+export type ChannelParam = {
+    handlerKey: string;
+    channelKey: string;
+    config: ChannelConfig;
 };
-export type MorghulisChannel = {
-    payload: Ref<any>;
-    loading: Ref<boolean>;
-    activate: (body: any) => void;
-    $start: () => void;
-    $stop: () => void;
-    $proceed: (payload: any) => void;
-};
-export type MorghulisChannels = {
-    [key: string]: MorghulisChannel;
+export type ChannelStatus = {
+    loading: boolean;
+    payload: any;
 };
+/**
+ * handler is just the entity
+ */
+export declare class ChannelContainer {
+    container: {
+        [handlerKey: string]: {
+            [channelKey: string]: Channel;
+        };
+    };
+    constructor();
+    getChannel(handlerKey: string, channelKey: string): Channel;
+    destroy(handlerKey: string, channelKey: string): void;
+    register(handlerKey: string, channelKey: string | undefined, config: ChannelConfig, status: Reactive<ChannelStatus>): void;
+    execute(request: AxiosInstance, handlerKey: string, channelKey: string, data: any): void;
+}
+export declare class Channel {
+    config: ChannelConfig;
+    private status;
+    constructor(config: ChannelConfig, status: Reactive<ChannelStatus>);
+    ready(loading?: boolean, payload?: any): void;
+    start(): void;
+    stop(): void;
+    proceed(data: any): void;
+}

package/dist/types/hooks/use-dao/index.d.ts

@@ -1,20 +1,181 @@
 import { type Ref } from "vue";
 import { type Meta, MetaView } from "../use-mata/types";
-import { MorghulisChannelConfig } from "../use-channel/types";
-import { DataItem, IQuery, Query } from "../use-query/types";
-export declare function useDao(meta: Meta, auth?: boolean): {
+import { ChannelConfig } from "../use-channel/types";
+import { DataItem, IQuery, Query, QueryConfig, QueryInfo, TreeItem, TreeMapping } from "../use-query/types";
+import { TreeModel } from "../../components/tree/types";
+export type QueryDaoParams = {
+    isTree?: boolean;
+    beforeLoad?: () => any;
+    afterLoad: (param: any) => void;
+};
+export declare function useQueryDao(props: QueryConfig & Meta, selection: Ref<any[]>, params: QueryDaoParams): {
+    isAdmin: Ref<boolean, boolean>;
+    admin: Ref<boolean, boolean>;
+    config: Ref<{
+        includes?: {
+            [x: string]: any;
+            id?: import("../use-query/types").DataItemId | undefined;
+        } | undefined;
+        excludes?: {
+            [x: string]: any;
+            id?: import("../use-query/types").DataItemId | undefined;
+        } | undefined;
+        orders?: import("../use-query/types").Orders | undefined;
+        page?: number | undefined;
+        size?: number | undefined;
+        root?: import("../use-query/types").DataItemId | undefined;
+        finder?: import("../use-query/types").Finder | undefined;
+    }, QueryConfig | {
+        includes?: {
+            [x: string]: any;
+            id?: import("../use-query/types").DataItemId | undefined;
+        } | undefined;
+        excludes?: {
+            [x: string]: any;
+            id?: import("../use-query/types").DataItemId | undefined;
+        } | undefined;
+        orders?: import("../use-query/types").Orders | undefined;
+        page?: number | undefined;
+        size?: number | undefined;
+        root?: import("../use-query/types").DataItemId | undefined;
+        finder?: import("../use-query/types").Finder | undefined;
+    }>;
+    query: import("vue").ComputedRef<Query>;
+    meta: import("vue").ComputedRef<Meta>;
+    switchAdmin: () => void;
+    load: () => void;
+    reload: () => void;
+    status: {
+        loading: boolean;
+        payload: any;
+    };
+    find_many: (query: Query | IQuery, code?: string) => Promise<{
+        results: DataItem[];
+        total?: number;
+    }>;
+    save_one: (item: DataItem) => Promise<{
+        item: DataItem;
+    }>;
+    delete_one: (id: string | number) => Promise<boolean>;
+    find_one: (id: string | number) => Promise<{
+        item: DataItem;
+    }>;
+    delete_many: (query: Query | IQuery) => Promise<boolean>;
+    update_many: (query: Query | IQuery, template: DataItem) => Promise<boolean>;
+    load_view: (code?: string) => Promise<MetaView>;
+    save_many: (array: DataItem[]) => void;
+    find_tree: (query: Query | IQuery) => Promise<TreeModel>;
+    view: Ref<{
+        isTree?: boolean | undefined;
+        id?: number | undefined;
+        fields?: {
+            [key: string]: import("../use-mata/types").MetaField;
+        } | undefined;
+        entity?: string | undefined;
+        code?: string | undefined;
+        meta_name?: string | undefined;
+        view_name?: string | undefined;
+        form_width?: number | undefined;
+        form_height?: number | undefined;
+        table_width?: number | undefined;
+        table_height?: number | undefined;
+        enable?: boolean | undefined;
+        show_header?: boolean | undefined;
+        allow_batch?: boolean | undefined;
+        allow_search?: boolean | undefined;
+        allow_sort?: boolean | undefined;
+        allow_pop?: boolean | undefined;
+        allow_insert?: boolean | undefined;
+        allow_edit?: boolean | undefined;
+        allow_remove?: boolean | undefined;
+        allow_download?: boolean | undefined;
+        allow_upload?: boolean | undefined;
+        meta?: {
+            entity: string;
+            name: string;
+        } | undefined;
+    }, MetaView | {
+        isTree?: boolean | undefined;
+        id?: number | undefined;
+        fields?: {
+            [key: string]: import("../use-mata/types").MetaField;
+        } | undefined;
+        entity?: string | undefined;
+        code?: string | undefined;
+        meta_name?: string | undefined;
+        view_name?: string | undefined;
+        form_width?: number | undefined;
+        form_height?: number | undefined;
+        table_width?: number | undefined;
+        table_height?: number | undefined;
+        enable?: boolean | undefined;
+        show_header?: boolean | undefined;
+        allow_batch?: boolean | undefined;
+        allow_search?: boolean | undefined;
+        allow_sort?: boolean | undefined;
+        allow_pop?: boolean | undefined;
+        allow_insert?: boolean | undefined;
+        allow_edit?: boolean | undefined;
+        allow_remove?: boolean | undefined;
+        allow_download?: boolean | undefined;
+        allow_upload?: boolean | undefined;
+        meta?: {
+            entity: string;
+            name: string;
+        } | undefined;
+    }>;
+    results: Ref<{
+        [x: string]: any;
+        id?: import("../use-query/types").DataItemId | undefined;
+    }[], DataItem[] | {
+        [x: string]: any;
+        id?: import("../use-query/types").DataItemId | undefined;
+    }[]>;
+    info: Ref<{
+        current: number;
+        total: number;
+    }, QueryInfo | {
+        current: number;
+        total: number;
+    }>;
+    options: Ref<{
+        [x: string]: any;
+        pid: number | string;
+        isLeaf: boolean;
+        icon?: import("../../components/common/types").IconNames | undefined;
+        children: /*elided*/ any[];
+        id?: import("../use-query/types").DataItemId | undefined;
+    }[], TreeItem[] | {
+        [x: string]: any;
+        pid: number | string;
+        isLeaf: boolean;
+        icon?: import("../../components/common/types").IconNames | undefined;
+        children: /*elided*/ any[];
+        id?: import("../use-query/types").DataItemId | undefined;
+    }[]>;
+    mapping: Ref<TreeMapping, TreeMapping>;
+    remove: () => void;
+    clip: () => void;
+    clone: () => void;
+};
+export declare function useDao(meta: Meta, channelConfig?: ChannelConfig): {
+    channels: import("../use-channel/types").ChannelContainer;
     meta: Ref<{
         db: import("../use-mata/types").MetaDatabase;
         entity: string;
         code?: string | undefined;
+        lock?: boolean | undefined;
     }, Meta | {
         db: import("../use-mata/types").MetaDatabase;
         entity: string;
         code?: string | undefined;
+        lock?: boolean | undefined;
     }>;
-    loading: import("vue").ComputedRef<boolean>;
-    payload: Ref<any, any>;
-    find_many: (query: Query | IQuery) => Promise<{
+    status: {
+        loading: boolean;
+        payload: any;
+    };
+    find_many: (query: Query | IQuery, code?: string) => Promise<{
         results: DataItem[];
         total?: number;
     }>;
@@ -27,16 +188,21 @@ export declare function useDao(meta: Meta, auth?: boolean): {
     }>;
     delete_many: (query: Query | IQuery) => Promise<boolean>;
     update_many: (query: Query | IQuery, template: DataItem) => Promise<boolean>;
-    load_view: () => Promise<MetaView>;
+    load_view: (code?: string) => Promise<MetaView>;
     save_many: (array: DataItem[]) => void;
+    find_tree: (query: Query | IQuery) => Promise<TreeModel>;
 };
 /**
  * http和socket的loading冲突问题
  */
-export declare function useMDao(meta: Ref<Meta>, channelConfig?: MorghulisChannelConfig, auth?: boolean): {
-    loading: import("vue").ComputedRef<boolean>;
-    payload: Ref<any, any>;
-    find_many: (query: Query | IQuery) => Promise<{
+export declare function useMDao(meta: Ref<Meta>, channelConfig?: ChannelConfig, auth?: boolean): {
+    find_tree: (query: Query | IQuery) => Promise<TreeModel>;
+    channels: import("../use-channel/types").ChannelContainer;
+    status: {
+        loading: boolean;
+        payload: any;
+    };
+    find_many: (query: Query | IQuery, code?: string) => Promise<{
         results: DataItem[];
         total?: number;
     }>;
@@ -49,6 +215,6 @@ export declare function useMDao(meta: Ref<Meta>, channelConfig?: MorghulisChanne
     }>;
     delete_many: (query: Query | IQuery) => Promise<boolean>;
     update_many: (query: Query | IQuery, template: DataItem) => Promise<boolean>;
-    load_view: () => Promise<MetaView>;
+    load_view: (code?: string) => Promise<MetaView>;
     save_many: (array: DataItem[]) => void;
 };

package/dist/types/hooks/use-dao/types.d.ts

@@ -1,10 +1,10 @@
 import { DataItem, Query } from "../use-query/types";
 import { MetaView } from "../use-mata/types";
 import { ComputedRef } from "vue";
-import { MorghulisChannelConfig } from "../use-channel/types";
+import { ChannelConfig } from "../use-channel/types";
 export type DaoConfig = {
     auth?: boolean;
-    channel: MorghulisChannelConfig;
+    channel: ChannelConfig;
 };
 export type DaoPayload = {
     results: DataItem[];

package/dist/types/hooks/use-mata/types.d.ts

@@ -3,8 +3,10 @@ export type Meta = {
     db: MetaDatabase;
     entity: string;
     code?: string;
+    lock?: boolean;
 };
 export type MetaView = {
+    isTree?: boolean;
     id?: number;
     fields?: {
         [key: string]: MetaField;
@@ -28,6 +30,10 @@ export type MetaView = {
     allow_remove?: boolean;
     allow_download?: boolean;
     allow_upload?: boolean;
+    meta?: {
+        entity: string;
+        name: string;
+    };
 };
 export type ManyField = 'ManyToManyField' | 'ManyToManyRel' | 'ManyToOneRef';
 export type RefField = 'OneOnOneField' | 'OneOnOneRel' | 'ForeignKey';
@@ -38,6 +44,7 @@ export type SpecialField = 'JSONField' | 'FileField';
 export type ReadonlyField = 'UUIDField' | 'BigAutoField' | 'Custom';
 export type MetaFieldDomain = SimpleField | ManyField | RefField | SpecialField | ReadonlyField | NumberField | DateField;
 export type MetaField = {
+    id?: string | number;
     prop?: string;
     label?: string;
     name?: string;
@@ -66,6 +73,7 @@ export type MetaField = {
     hide_on_form_insert?: boolean;
     hide_on_form_branch?: boolean;
     hide_on_form_leaf?: boolean;
+    entity?: string;
 };
 export type MetaRefer = {
     entity?: string;
@@ -78,17 +86,22 @@ export type MetaRefer = {
     includes?: object;
     excludes?: object;
     root?: number;
+    isTree?: boolean;
 };
 export type MetaFormat = {
     maxlength?: number;
-    type?: 'date' | 'datetime';
+    type?: 'text' | 'textarea';
     min?: number | null;
     max?: number | null;
     step?: number | null;
     precision?: number | null;
     step_strictly?: boolean;
-    accept?: string;
-    width?: number | string;
-    height?: number | string;
-    locket?: boolean;
+    frequency?: 'year' | 'month' | 'week' | 'date' | 'datetime' | 'yearrange' | 'monthrange' | 'daterange' | 'datetimerange' | 'years' | 'months' | 'dates' | null;
+    maximum?: number;
+    accept?: string[];
+    width?: number | null;
+    height?: number | null;
+    file_name_field?: string | null;
+    locked?: boolean;
+    set?: any[][];
 };