morghulis 3.0.16 → 3.0.17

package/dist/types/MApp.vue.d.ts

@@ -1,8 +1,14 @@
-declare var __VLS_1: {};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
 type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
+} & {
+    connecting?: (props: typeof __VLS_3) => any;
+} & {
+    connect?: (props: typeof __VLS_5) => 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, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<{}, {
+    open: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/types/components/table-data/DTable.vue.d.ts

@@ -0,0 +1,3 @@
+import { DTableProps } from "./types";
+declare const _default: import("vue").DefineComponent<DTableProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DTableProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/types/components/table-data/types.d.ts

@@ -0,0 +1,17 @@
+import { MetaDatabase } from "../../hooks/use-mata/types";
+import { QueryConfig } from "../../hooks/use-query/types";
+import { MTableButton, MTableColumn } from "../table-morghulis/types";
+export type DTableProps = {
+    db: MetaDatabase;
+    entity: string;
+    code?: string;
+    auth?: boolean;
+    buttons?: MTableButton[];
+    columns?: MTableColumn[];
+} & QueryConfig;
+export type DTableInfo = {
+    current: number;
+    total: number;
+    page: number;
+    size: number;
+};

package/dist/types/components/table-morghulis/MTable.vue.d.ts

@@ -0,0 +1,42 @@
+import { type MTableProps } from "./types";
+declare function getSelection(): any;
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_40: {
+    field: import("../../hooks/use-mata/types").MetaField;
+    row: any;
+    prop: string | number;
+}, __VLS_42: {}, __VLS_44: {};
+type __VLS_Slots = {} & {
+    header?: (props: typeof __VLS_1) => any;
+} & {
+    'header-tool'?: (props: typeof __VLS_3) => any;
+} & {
+    cell?: (props: typeof __VLS_40) => any;
+} & {
+    footer?: (props: typeof __VLS_42) => any;
+} & {
+    'footer-tool'?: (props: typeof __VLS_44) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<MTableProps, {
+    getSelection: typeof getSelection;
+    setSelection: (keys: any[]) => void;
+    closePopover: () => boolean;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MTableProps> & Readonly<{}>, {
+    border: boolean;
+    fit: boolean;
+    showHeader: boolean;
+    highlightCurrentRow: boolean;
+    headerCellClassName: ((data: {
+        row: any;
+        column: any;
+        rowIndex: number;
+        columnIndex: number;
+    }) => string) | string;
+    showOverflowTooltip: boolean;
+}, {}, {}, {}, 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-morghulis/types.d.ts

@@ -0,0 +1,174 @@
+import type { Component } from "vue";
+import { type CSSProperties, type VNode } from "vue";
+import { type ElTooltipProps, type Sort, type TreeNode } from "element-plus";
+import { MetaView } from "../../hooks/use-mata/types";
+/**
+ * style function
+ */
+type RowClassNameFn = (data: {
+    row: any;
+    rowIndex: number;
+}) => string;
+type RowStyleFn = (data: {
+    row: any;
+    rowIndex: number;
+}) => CSSProperties;
+type CellClassNameFn = (data: {
+    row: any;
+    column: any;
+    rowIndex: number;
+    columnIndex: number;
+}) => string;
+type CellStyleFn = (data: {
+    row: any;
+    column: any;
+    rowIndex: number;
+    columnIndex: number;
+}) => CSSProperties;
+type HeaderRowClassNameFn = (data: {
+    row: any;
+    rowIndex: number;
+}) => string;
+type HeaderRowStyleFn = (data: {
+    row: any;
+    rowIndex: number;
+}) => CSSProperties;
+type HeaderCellClassNameFn = (data: {
+    row: any;
+    column: any;
+    rowIndex: number;
+    columnIndex: number;
+}) => string;
+type HeaderCellStyleFn = (data: {
+    row: any;
+    column: any;
+    rowIndex: number;
+    columnIndex: number;
+}) => CSSProperties;
+/**
+ * control function
+ */
+type RowKeyFn = (row: any) => string;
+type SpanMethodFn = (data: {
+    row: any;
+    column: any;
+    rowIndex: number;
+    columnIndex: number;
+}) => number[] | {
+    rowspan: number;
+    colspan: number;
+} | void;
+type TooltipFormatterFn = (data: {
+    row: any;
+    column: any;
+    cellValue: any;
+}) => VNode | string;
+type SummaryMethodFn = (data: {
+    columns: any[];
+    data: any[];
+}) => (VNode | string)[];
+type LoadFn = (row: any, treeNode: TreeNode, resolve: (data: any[]) => void) => void;
+export interface TableProps {
+    data: any[];
+    height?: number | string;
+    maxHeight?: number | string;
+    stripe?: boolean;
+    border?: boolean;
+    size?: '' | 'large' | 'default' | 'small';
+    fit?: boolean;
+    showHeader?: boolean;
+    highlightCurrentRow?: boolean;
+    currentRowKey?: string | number;
+    rowClassName?: RowClassNameFn | string;
+    rowStyle?: RowStyleFn | CSSProperties;
+    cellClassName?: CellClassNameFn | string;
+    cellStyle?: CellStyleFn | CSSProperties;
+    headerRowClassName?: HeaderRowClassNameFn | string;
+    headerRowStyle?: HeaderRowStyleFn | CSSProperties;
+    headerCellClassName?: HeaderCellClassNameFn | string;
+    headerCellStyle?: HeaderCellStyleFn | CSSProperties;
+    rowKey?: RowKeyFn | string;
+    emptyText?: string;
+    defaultExpandAll?: boolean;
+    expandRowKeys?: string[];
+    defaultSort?: Sort;
+    tooltipEffect?: 'dark' | 'light';
+    tooltipOptions?: Pick<ElTooltipProps, 'effect' | 'enterable' | 'hideAfter' | 'offset' | 'placement' | 'popperClass' | 'popperOptions' | 'showAfter' | 'showArrow'>;
+    appendFilterPanelTo?: string;
+    showSummary?: boolean;
+    sumText?: string;
+    summaryMethod?: SummaryMethodFn;
+    spanMethod?: SpanMethodFn;
+    selectOnIndeterminate?: boolean;
+    indent?: number;
+    lazy?: boolean;
+    load?: LoadFn;
+    treeProps?: {
+        hasChildren?: string;
+        children?: string;
+        checkStrictly?: boolean;
+    };
+    tableLayout?: 'fixed' | 'auto';
+    scrollbarAlwaysOn?: boolean;
+    showOverflowTooltip?: boolean;
+    flexible?: boolean;
+    scrollbarTabindex?: string | number;
+    allowDragLastColumn?: boolean;
+    tooltipFormatter?: TooltipFormatterFn;
+    preserveExpandedContent?: boolean;
+}
+export type MTableProps = TableProps & {
+    loading?: boolean;
+    view: MetaView;
+    buttons?: MTableButton[];
+    columns?: MTableColumn[];
+    sortableCallback?: MTableSortableFn;
+};
+export type MTablePopper = {
+    ref?: any;
+    visible?: boolean;
+    type?: string | null | undefined;
+    data?: any;
+    placement?: 'left' | 'right' | 'top' | 'bottom' | null | string;
+};
+export type MTableSortableFn = (newIndex: number, oldIndex: number) => void;
+export type MTableButton = {
+    size?: 'default' | 'small' | 'large' | "";
+    handler?: (row: any, event?: Event) => void;
+    title?: string | Function;
+    type?: "success" | "info" | "warning" | "danger" | 'primary' | Function;
+    link?: boolean | Function;
+    plain?: boolean | Function;
+    text?: boolean | Function;
+    round?: boolean | Function;
+    circle?: boolean | Function;
+    disabled?: boolean | Function;
+    dark?: boolean | Function;
+    color?: string | Function;
+    tag?: string | Function;
+};
+export type MTableColumn = {
+    label: string;
+    component: Component;
+    width?: string | number;
+};
+export declare const mTablePropsDefaults: {
+    border: boolean;
+    fit: boolean;
+    showHeader: boolean;
+    highlightCurrentRow: boolean;
+    headerCellClassName: string;
+    showOverflowTooltip: boolean;
+};
+export declare const mTableTooltipOptions: {
+    placement: string;
+    popperClass: string;
+    enterable: boolean;
+    effect: string;
+    hideAfter: number;
+    offset: number;
+    popperOptions: {};
+    showAfter: number;
+    showArrow: boolean;
+};
+export {};

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

@@ -1,5 +1,5 @@
-import type { MorghulisChannel, MorghulisChannelConfig } from "./types";
+import { MorghulisChannelConfig, MorghulisChannelSimple } from "./types";
 export declare function useMChannel(auth?: boolean): {
-    register: (handler: string, channel?: MorghulisChannelConfig, socketURL?: string) => void;
-    getChannel: (handler: string) => MorghulisChannel | undefined;
+    register: (handler: string, channel?: MorghulisChannelConfig, socketURL?: string) => MorghulisChannelSimple;
+    getChannel: (handler: string) => MorghulisChannelSimple;
 };

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

@@ -4,6 +4,10 @@ export type MorghulisChannelConfig = {
     onStop?: () => void;
     onProceed?: (payload: any) => void;
 };
+export type MorghulisChannelSimple = {
+    loading: Ref<boolean>;
+    activate: (body: any) => void;
+};
 export type MorghulisChannel = {
     payload: Ref<any>;
     loading: Ref<boolean>;
@@ -11,7 +15,7 @@ export type MorghulisChannel = {
     $url: string;
     $start: () => void;
     $stop: () => void;
-    $proceed?: (payload: any) => void;
+    $proceed: (payload: any) => void;
 };
 export type MorghulisChannels = {
     [key: string]: MorghulisChannel;

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

@@ -1,9 +1,25 @@
 import { type Ref } from "vue";
-import { type Meta } from "../use-mata/types";
+import { type Meta, MetaView } from "../use-mata/types";
 import { MorghulisChannelConfig } from "../use-channel/types";
+import { DataItem, Query } from "../use-query/types";
 /**
  * http和socket的loading冲突问题
  */
-export declare function useMDao(meta: Ref<Meta>, channel?: MorghulisChannelConfig, auth?: boolean): {
-    handler: import("vue").ComputedRef<string>;
+export declare function useMDao(meta: Ref<Meta>, channelConfig?: MorghulisChannelConfig, auth?: boolean): {
+    loading: import("vue").ComputedRef<boolean>;
+    find_many: (query: Query) => 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) => Promise<boolean>;
+    update_many: (query: Query, template: DataItem) => Promise<boolean>;
+    load_view: () => Promise<MetaView>;
+    save_many: (array: DataItem[]) => void;
 };

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

@@ -1,2 +1,3 @@
-import { QueryTemplate } from "./types";
-export declare function useMQuery(template?: QueryTemplate): void;
+import { Query, QueryConfig } from "./types";
+import { ComputedRef, Ref } from "vue";
+export declare function useMQuery(config?: Ref<QueryConfig>): ComputedRef<Query>;

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

@@ -1,20 +1,28 @@
 export type DataItem = {
-    id?: DataItem;
+    id?: DataItemId;
     [key: string]: any;
 };
-export type DataItemId = string | number;
-export type Orders = {
+type DataItemId = string | number;
+type Orders = {
     [key: string]: 1 | -1;
 };
-export type Condition = {
+type Condition = {
     includes: DataItem;
     excludes: DataItem;
 };
-export type QueryTemplate = {
+export type QueryConfig = {
     includes?: DataItem;
     excludes?: DataItem;
     orders?: Orders;
     page?: number;
     size?: number;
 };
-export type Query = {};
+export type Query = {
+    condition?: Condition;
+    orders?: Orders;
+    page?: number;
+    size?: number;
+    template?: DataItem;
+    search?: Condition[];
+};
+export {};

package/dist/types/hooks/use-table-data/index.d.ts

@@ -0,0 +1,76 @@
+import { ComputedRef, Ref } from "vue";
+import { DTableInfo, DTableProps } from "../../components/table-data/types";
+import { Meta, MetaView } from "../use-mata/types";
+import { DataItem, Query } from "../use-query/types";
+export declare function useDTable(table: Ref, props: DTableProps): {
+    meta: ComputedRef<Meta>;
+    query: ComputedRef<Query>;
+    view: Ref<{
+        fields?: {
+            [key: string]: import("../use-mata/types").MetaField;
+        } | undefined;
+        path?: 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;
+    }, MetaView | {
+        fields?: {
+            [key: string]: import("../use-mata/types").MetaField;
+        } | undefined;
+        path?: 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;
+    }>;
+    info: Ref<{
+        current: number;
+        total: number;
+        page: number;
+        size: number;
+    }, DTableInfo | {
+        current: number;
+        total: number;
+        page: number;
+        size: number;
+    }>;
+    results: Ref<{
+        [x: string]: any;
+        id?: (string | number) | undefined;
+    }[], DataItem[] | {
+        [x: string]: any;
+        id?: (string | number) | undefined;
+    }[]>;
+    selection: ComputedRef<any[]>;
+    loading: ComputedRef<boolean>;
+    load: () => void;
+};

package/dist/types/hooks/use-table-morghulis/index.d.ts

@@ -0,0 +1,25 @@
+import { type Ref } from "vue";
+import { MTableProps } from "../../components/table-morghulis/types";
+export declare function useMTable(table: Ref, props: MTableProps): {
+    popover: {
+        ref?: any;
+        visible?: boolean | undefined;
+        type?: string | null | undefined | undefined;
+        data?: any;
+        placement?: "left" | "right" | "top" | "bottom" | null | string | undefined;
+    };
+    selection: import("vue").ComputedRef<any>;
+    tableCellClassName: (data: any) => "m-table-cell" | "m-table-index" | "m-table-custom";
+    tableRowClassName: (payload: any) => "" | "m-table-current" | "m-table-highlight";
+    handleCellClick: (row: object, column: any, cell: any, event: any) => void;
+    handleCellContextMenu: (row: any, column: any, cell: any, event: any) => void;
+    showPopover: (event: {
+        clientX: number;
+        clientY: number;
+    }, type: string, data?: any, placement?: string) => void;
+    closePopover: () => boolean;
+    setSelection: (keys: any[]) => void;
+    hasSearchSlot: import("vue").ComputedRef<boolean>;
+    hasFieldSlot: import("vue").ComputedRef<boolean>;
+    hasMetaViewSlot: import("vue").ComputedRef<boolean>;
+};

package/dist/types/index.d.ts

@@ -5,15 +5,19 @@ import { useMChannel } from "./hooks/use-channel";
 import { useMSockets } from "./hooks/use-socket";
 import { MorghulisOptions } from "./hooks/use-morghulis/types";
 import type { MorghulisChannelConfig } from "./hooks/use-channel/types";
-import MApp from "./MApp.vue";
 import MDialog from "./components/dialog/MDialog.vue";
+import MApp from "./MApp.vue";
+import MTable from "./components/table-morghulis/MTable.vue";
+import DTable from "./components/table-data/DTable.vue";
 declare module "vue" {
     interface GlobalComponents {
         MApp: typeof MApp;
         MDialog: typeof MDialog;
+        MTable: typeof MTable;
+        DTable: typeof DTable;
     }
 }
 declare const createMorghulis: (options?: MorghulisOptions) => {
     install(Vue: App): void;
 };
-export { MApp, MDialog, createMorghulis, useMRequest, useMChannel, useMSockets, MorghulisChannelConfig };
+export { MApp, MDialog, MTable, DTable, createMorghulis, useMRequest, useMChannel, useMSockets, MorghulisChannelConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "morghulis",
-  "version": "3.0.16",
+  "version": "3.0.17",
   "type": "module",
   "files": [
     "dist"