@morghulis/core 0.0.6 → 0.0.7

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

@@ -9,7 +9,7 @@ export default class Channel {
     channelKey: string;
     url: string;
     request: AxiosInstance;
-    constructor(config: ChannelConfig);
+    constructor(config: ChannelConfig, request: AxiosInstance);
     execute(data?: any): void;
     ready(): void;
     start(): void;

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

@@ -1,10 +1,12 @@
 import { ChannelContainer } from "./types";
 import Channel from "./Channel";
+import { AxiosInstance } from "axios";
 import { ChannelConfig } from "./config";
 export default class ChannelHub {
     container: ChannelContainer;
-    constructor();
+    getHttpRequest: (auth?: boolean) => AxiosInstance;
+    constructor(getHttpRequest: (auth?: boolean) => AxiosInstance);
     loadChannel(handlerKey: string, channelKey: string): Promise<Channel>;
     destroy(handlerKey: string, channelKey: string): void;
-    register(config: ChannelConfig): Channel;
+    register(config: ChannelConfig, auth?: boolean): Channel;
 }

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

@@ -10,7 +10,7 @@ export type IChannelConfig = {
 export type ChannelConfig = {
     handlerKey: string;
     channelKey: string;
-    url: string;
+    url?: string;
     auth?: boolean;
     onStart(): void;
     onStop(): void;

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

@@ -1,9 +1,24 @@
-import { IChannelConfig } from "./config";
-import { Ref } from "vue";
+import { ChannelConfig, IChannelConfig } from "./config";
 import Channel from "./Channel";
-export declare function createChannel(config: IChannelConfig): Channel;
-export declare function useChannel(config: Ref<IChannelConfig>): {
-    channel: Ref<{
+export declare function useChannel($config: IChannelConfig): {
+    config: import("vue").Ref<{
+        handlerKey: string;
+        channelKey: string;
+        url?: string | undefined;
+        auth?: boolean | undefined;
+        onStart: () => void;
+        onStop: () => void;
+        onProceed?: ((payload: any) => void) | undefined;
+    }, ChannelConfig | {
+        handlerKey: string;
+        channelKey: string;
+        url?: string | undefined;
+        auth?: boolean | undefined;
+        onStart: () => void;
+        onStop: () => void;
+        onProceed?: ((payload: any) => void) | undefined;
+    }>;
+    channel: import("vue").Ref<{
         status: {
             loading: boolean;
             payload: any;

package/dist/types/{types.d.ts → hooks/core/use-core/types.d.ts}

@@ -1,5 +1,5 @@
 import { Ref } from "vue";
-import ChannelHub from "./hooks/core/use-channel/ChannelHub";
+import ChannelHub from "../use-channel/ChannelHub";
 export type IOptions = {
     baseURL?: string;
     minioURL?: string;

package/dist/types/hooks/core/use-request/index.d.ts

@@ -1,5 +1,6 @@
 import { AxiosInstance } from 'axios';
-export declare function useRequest(): {
+import { Options } from "../use-core/types";
+export declare function useRequest(options?: Options): {
     getHttpRequest: (auth?: boolean) => AxiosInstance;
     download: (path: string) => void;
     all: (mapping: {

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

@@ -1,8 +1,17 @@
-import { Meta } from "../use-meta/types";
+import { IMeta, Meta } from "../use-meta/types";
+import { Ref } from "vue";
 import { Dao } from "./types";
-export declare function createDao(meta: Meta, token?: string, auth?: boolean): {
+export declare function useDao($meta: IMeta, auth?: boolean): {
+    meta: Ref<{
+        db: import("./types").Database;
+        entity: string;
+        code: string;
+    }, Meta | {
+        db: import("./types").Database;
+        entity: string;
+        code: string;
+    }>;
     dao: Dao;
     loading: import("vue").ComputedRef<boolean>;
     payload: import("vue").ComputedRef<any>;
-    destroy: () => void;
 };

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

@@ -1,20 +1,9 @@
-import { DataItem, DataItemId, TreeItem } from "../types";
-import { Condition, Search } from "../use-query/types/search";
-import TableModel from "./TableModel";
-import TreeModel from "./TreeModel";
 import MetaView from "../use-meta/MetaView";
-export type QueryInfo = {
-    current: number;
-    total: number;
-};
-export type TreeMapping = {
-    [id: string | number]: TreeItem;
-};
-export type TableResults = {
-    results: DataItem[];
-    total: number;
-};
-export type TreeResults = TreeItem[];
+import { DataItem, DataItemId } from "../use-model/DataModel";
+import TableModel from "../use-model/TableModel";
+import TreeModel from "../use-model/TreeModel";
+import { Condition, Search } from "../use-query/types";
+export type Database = 'orm' | 'mon';
 export type Dao = {
     save_many: (array: DataItem[]) => void;
     delete_many: (...conditions: Condition[]) => void;
@@ -25,5 +14,5 @@ export type Dao = {
     find: (...conditions: Condition[]) => Promise<DataItem[]>;
     table: (search: Search) => Promise<TableModel>;
     tree: (search: Search) => Promise<TreeModel>;
-    meta_view: (code: string) => Promise<MetaView>;
+    meta_view: () => Promise<MetaView>;
 };

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

@@ -0,0 +1,118 @@
+import { Search } from "../use-query/types";
+import { ComputedRef } from "vue";
+import MetaView from "../use-meta/MetaView";
+import { Dao } from "../use-dao/types";
+import TableModel from "../use-model/TableModel";
+import TreeModel from "../use-model/TreeModel";
+import { DataType, IDataConfig } from "./types";
+export declare function useData($config: IDataConfig, type?: DataType, auth?: boolean): {
+    meta: import("vue").Ref<{
+        db: import("../use-dao/types").Database;
+        entity: string;
+        code: string;
+    }, import("../use-meta/types").Meta | {
+        db: import("../use-dao/types").Database;
+        entity: string;
+        code: string;
+    }>;
+    config: import("vue").Ref<{
+        includes: {
+            [x: string]: any;
+            id?: import("../use-model/DataModel").DataItemId | undefined;
+        };
+        excludes: {
+            [x: string]: any;
+            id?: import("../use-model/DataModel").DataItemId | undefined;
+        };
+        orders: import("../use-query/types").Orders;
+        page: number;
+        size: number;
+        root: import("../use-model/DataModel").DataItemId;
+    }, import("../use-query/types").QueryConfig | {
+        includes: {
+            [x: string]: any;
+            id?: import("../use-model/DataModel").DataItemId | undefined;
+        };
+        excludes: {
+            [x: string]: any;
+            id?: import("../use-model/DataModel").DataItemId | undefined;
+        };
+        orders: import("../use-query/types").Orders;
+        page: number;
+        size: number;
+        root: import("../use-model/DataModel").DataItemId;
+    }>;
+    finders: import("vue").Ref<{
+        includes: {
+            prop: string;
+            value: any;
+            isnull: boolean;
+            decorate: boolean;
+            lookup: import("../use-query/Lookup").LookupType;
+            load: (param: import("../use-query/Lookup").ILookup) => void;
+            equals: (that: import("../use-query/Lookup").default) => boolean;
+            fromKV: (key: string, value: any) => import("../use-query/Lookup").default;
+            toDataItem: () => {
+                [k: string]: any;
+            };
+        }[];
+        excludes: {
+            prop: string;
+            value: any;
+            isnull: boolean;
+            decorate: boolean;
+            lookup: import("../use-query/Lookup").LookupType;
+            load: (param: import("../use-query/Lookup").ILookup) => void;
+            equals: (that: import("../use-query/Lookup").default) => boolean;
+            fromKV: (key: string, value: any) => import("../use-query/Lookup").default;
+            toDataItem: () => {
+                [k: string]: any;
+            };
+        }[];
+        add: (type: import("../use-query/types").ConditionType, lookup: import("../use-query/Lookup").default) => void;
+        toCondition: () => {
+            includes: {};
+            excludes: {};
+        };
+    }[], import("../use-query/Finder").default[] | {
+        includes: {
+            prop: string;
+            value: any;
+            isnull: boolean;
+            decorate: boolean;
+            lookup: import("../use-query/Lookup").LookupType;
+            load: (param: import("../use-query/Lookup").ILookup) => void;
+            equals: (that: import("../use-query/Lookup").default) => boolean;
+            fromKV: (key: string, value: any) => import("../use-query/Lookup").default;
+            toDataItem: () => {
+                [k: string]: any;
+            };
+        }[];
+        excludes: {
+            prop: string;
+            value: any;
+            isnull: boolean;
+            decorate: boolean;
+            lookup: import("../use-query/Lookup").LookupType;
+            load: (param: import("../use-query/Lookup").ILookup) => void;
+            equals: (that: import("../use-query/Lookup").default) => boolean;
+            fromKV: (key: string, value: any) => import("../use-query/Lookup").default;
+            toDataItem: () => {
+                [k: string]: any;
+            };
+        }[];
+        add: (type: import("../use-query/types").ConditionType, lookup: import("../use-query/Lookup").default) => void;
+        toCondition: () => {
+            includes: {};
+            excludes: {};
+        };
+    }[]>;
+    dao: Dao;
+    loading: ComputedRef<boolean>;
+    payload: ComputedRef<any>;
+    template: ComputedRef<import("../use-model/DataModel").DataItem>;
+    search: ComputedRef<Search>;
+    view: import("vue").Ref<MetaView | undefined, MetaView | undefined>;
+    model: import("vue").Ref<TableModel | undefined, TableModel | undefined> | import("vue").Ref<TreeModel | undefined, TreeModel | undefined>;
+    load: (() => void) | (() => void);
+};

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

@@ -0,0 +1,4 @@
+import { IMeta } from "../use-meta/types";
+import { IQueryConfig } from "../use-query/types";
+export type DataType = 'table' | 'tree';
+export type IDataConfig = IMeta & IQueryConfig;

package/dist/types/hooks/data/use-meta/MetaField.d.ts

@@ -1,7 +1,7 @@
-import { Database } from "../types";
 import { MetaFieldDomain, MetaFieldTool } from "./frame";
 import MetaRefer, { IMetaRefer } from "./MetaRefer";
 import MetaFormat, { IMetaFormat } from "./MetaFormat";
+import { Database } from "../use-dao/types";
 export type IMetaField = {
     $db?: Database;
     $entity?: string;

package/dist/types/hooks/data/use-meta/MetaView.d.ts

@@ -1,5 +1,5 @@
-import { Database } from "../types";
 import MetaField, { IMetaField } from "./MetaField";
+import { Database } from "../use-dao/types";
 export type IMetaView = {
     $db?: Database;
     $entity?: string;

package/dist/types/hooks/data/use-meta/types.d.ts

@@ -1,6 +1,11 @@
-import { Database } from "../types";
+import { Database } from "../use-dao/types";
+export type IMeta = {
+    db?: Database;
+    entity: string;
+    code?: string;
+};
 export type Meta = {
     db: Database;
     entity: string;
-    code?: string;
+    code: string;
 };

package/dist/types/hooks/data/use-model/DataModel.d.ts

@@ -0,0 +1,13 @@
+export type DataItemId = string | number;
+export type DataItem = {
+    id?: DataItemId;
+    [prop: string]: any;
+};
+export default class DataModel {
+    length: number;
+    items: DataItem[];
+    props: string[];
+    constructor(data?: DataItem[]);
+    load(data?: DataItem[]): void;
+    getProps(): string[];
+}

package/dist/types/hooks/data/use-model/TableModel.d.ts

@@ -0,0 +1,17 @@
+import DataModel, { DataItem } from "./DataModel";
+export type TableResults = {
+    results: DataItem[];
+    total: number;
+};
+export type TableMapping = {
+    [id: string | number]: DataItem;
+};
+export default class TableModel {
+    length: number;
+    total: number;
+    results: DataItem[];
+    mapping: TableMapping;
+    constructor(res?: TableResults);
+    load(res?: TableResults): void;
+    getDataModel(): DataModel;
+}

package/dist/types/hooks/data/use-model/TreeModel.d.ts

@@ -0,0 +1,25 @@
+import { IconNames } from "../../utils/use-icon/types";
+import { DataItem } from "./DataModel";
+export type TreeItem = {
+    pid: number | string;
+    isLeaf: boolean;
+    icon?: IconNames;
+    children: TreeItem[];
+} & DataItem;
+export type TreeResults = {
+    results: TreeItem[];
+    root?: number;
+};
+export type TreeMapping = {
+    [id: string | number]: TreeItem;
+};
+export default class TreeModel {
+    nodes: TreeItem[];
+    root_id: number | string;
+    root: TreeItem | null;
+    options: TreeItem[];
+    mapping: TreeMapping;
+    constructor(res: TreeResults);
+    load(res: TreeResults): void;
+    private initMapping;
+}

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

@@ -0,0 +1,12 @@
+import Lookup from "./Lookup";
+import { Condition, ConditionType } from "./types";
+export default class Finder {
+    includes: Lookup[];
+    excludes: Lookup[];
+    add(type: ConditionType, lookup: Lookup): void;
+    toCondition(): {
+        includes: {};
+        excludes: {};
+    };
+    constructor(condition?: Condition);
+}

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

@@ -0,0 +1,26 @@
+export type LookupType = 'contains' | 'exact' | 'startswith' | 'endswith' | 'gt' | 'lt' | 'isnull';
+export declare const char_decorated_lookup: string[];
+export declare const number_decorated_lookup: string[];
+export declare const simple_lookup: LookupType[];
+export declare const lookups: string[];
+export type ILookup = {
+    prop: string;
+    value: any;
+    isnull: boolean;
+    decorate: boolean;
+    lookup: LookupType;
+};
+export default class Lookup {
+    prop: string;
+    value: any;
+    isnull: boolean;
+    decorate: boolean;
+    lookup: LookupType;
+    constructor(param?: ILookup);
+    load(param: ILookup): void;
+    equals(that: Lookup): boolean;
+    fromKV(key: string, value: any): this;
+    toDataItem(): {
+        [k: string]: any;
+    };
+}

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

@@ -1,9 +1,99 @@
-import { IQueryConfig } from "./types/config";
-import { Ref } from "vue";
-import Query from "./Query";
-import { Finder } from "./types/finder";
-import { QueryType } from "./types/search";
-export declare function useQuery(config: Ref<IQueryConfig>, finders: Ref<Finder[]>, type?: QueryType): {
-    search: import("vue").ComputedRef<import("./types/search").Search>;
-    query: import("vue").ComputedRef<Query>;
+import { DataItem } from "../use-model/DataModel";
+import Finder from "./Finder";
+import { IQueryConfig, QueryConfig, Search } from "./types";
+export declare function useQuery($config?: IQueryConfig): {
+    config: import("vue").Ref<{
+        includes: {
+            [x: string]: any;
+            id?: import("../use-model/DataModel").DataItemId | undefined;
+        };
+        excludes: {
+            [x: string]: any;
+            id?: import("../use-model/DataModel").DataItemId | undefined;
+        };
+        orders: import("./types").Orders;
+        page: number;
+        size: number;
+        root: import("../use-model/DataModel").DataItemId;
+    }, QueryConfig | {
+        includes: {
+            [x: string]: any;
+            id?: import("../use-model/DataModel").DataItemId | undefined;
+        };
+        excludes: {
+            [x: string]: any;
+            id?: import("../use-model/DataModel").DataItemId | undefined;
+        };
+        orders: import("./types").Orders;
+        page: number;
+        size: number;
+        root: import("../use-model/DataModel").DataItemId;
+    }>;
+    template: import("vue").ComputedRef<DataItem>;
+    finders: import("vue").Ref<{
+        includes: {
+            prop: string;
+            value: any;
+            isnull: boolean;
+            decorate: boolean;
+            lookup: import("./Lookup").LookupType;
+            load: (param: import("./Lookup").ILookup) => void;
+            equals: (that: import("./Lookup").default) => boolean;
+            fromKV: (key: string, value: any) => import("./Lookup").default;
+            toDataItem: () => {
+                [k: string]: any;
+            };
+        }[];
+        excludes: {
+            prop: string;
+            value: any;
+            isnull: boolean;
+            decorate: boolean;
+            lookup: import("./Lookup").LookupType;
+            load: (param: import("./Lookup").ILookup) => void;
+            equals: (that: import("./Lookup").default) => boolean;
+            fromKV: (key: string, value: any) => import("./Lookup").default;
+            toDataItem: () => {
+                [k: string]: any;
+            };
+        }[];
+        add: (type: import("./types").ConditionType, lookup: import("./Lookup").default) => void;
+        toCondition: () => {
+            includes: {};
+            excludes: {};
+        };
+    }[], Finder[] | {
+        includes: {
+            prop: string;
+            value: any;
+            isnull: boolean;
+            decorate: boolean;
+            lookup: import("./Lookup").LookupType;
+            load: (param: import("./Lookup").ILookup) => void;
+            equals: (that: import("./Lookup").default) => boolean;
+            fromKV: (key: string, value: any) => import("./Lookup").default;
+            toDataItem: () => {
+                [k: string]: any;
+            };
+        }[];
+        excludes: {
+            prop: string;
+            value: any;
+            isnull: boolean;
+            decorate: boolean;
+            lookup: import("./Lookup").LookupType;
+            load: (param: import("./Lookup").ILookup) => void;
+            equals: (that: import("./Lookup").default) => boolean;
+            fromKV: (key: string, value: any) => import("./Lookup").default;
+            toDataItem: () => {
+                [k: string]: any;
+            };
+        }[];
+        add: (type: import("./types").ConditionType, lookup: import("./Lookup").default) => void;
+        toCondition: () => {
+            includes: {};
+            excludes: {};
+        };
+    }[]>;
+    search: import("vue").ComputedRef<Search>;
 };

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

@@ -0,0 +1,32 @@
+import { DataItem, DataItemId } from "../use-model/DataModel";
+export type IQueryConfig = {
+    includes?: DataItem;
+    excludes?: DataItem;
+    orders?: Orders;
+    page?: number;
+    size?: number;
+    root?: DataItemId;
+};
+export type QueryConfig = {
+    includes: DataItem;
+    excludes: DataItem;
+    orders: Orders;
+    page: number;
+    size: number;
+    root: DataItemId;
+};
+export type ConditionType = 'includes' | 'excludes';
+export type Orders = {
+    [key: string]: 1 | -1;
+};
+export type Condition = {
+    includes: DataItem;
+    excludes: DataItem;
+};
+export type Search = {
+    conditions: Condition[];
+    orders: Orders;
+    page: number;
+    size: number;
+    root: DataItemId;
+};

package/dist/types/hooks/utils/use-aoa/index.d.ts

@@ -0,0 +1,5 @@
+import { Aoa, Separator } from "./types";
+export declare function useAoa(separator?: Separator): {
+    fromText: (text: string) => Aoa;
+    toText: (aoa: Aoa[]) => string;
+};

package/dist/types/hooks/utils/use-aoa/types.d.ts

@@ -0,0 +1,8 @@
+export type Separator = {
+    cell: string;
+    line: string;
+};
+export type Aoa = any[][];
+export type AoaMap = {
+    [name: string]: Aoa;
+};

package/dist/types/hooks/utils/use-xlsx/index.d.ts

@@ -1,5 +1,6 @@
-import { Aoa, AoaMap, Separator } from "./types";
-export declare function useXlsx(separator?: Separator): {
-    fromText: (text: string) => Aoa;
-    fromFile: (file: File) => Promise<AoaMap>;
+import { XlsSheet } from "./types";
+import { AoaMap } from "../use-aoa/types";
+export declare function useXlsx(): {
+    readXlsx: (file: File) => Promise<AoaMap>;
+    writeXlsx: (title: string, ...sheets: XlsSheet[]) => void;
 };

package/dist/types/hooks/utils/use-xlsx/types.d.ts

@@ -1,8 +1,17 @@
-export type Separator = {
-    cell: string;
-    line: string;
+import { Aoa } from "../use-aoa/types";
+type XlsCell = {
+    r: number;
+    c: number;
+    value?: any;
 };
-export type Aoa = any[][];
-export type AoaMap = {
-    [name: string]: Aoa;
+export type XlsSheetMerge = {
+    s: XlsCell;
+    e: XlsCell;
 };
+export type XlsSheet = {
+    name?: string;
+    data: Aoa;
+    headers?: string[];
+    merges?: XlsSheetMerge[];
+};
+export {};

package/dist/types/index.d.ts

@@ -1,7 +1,7 @@
 import { App } from "vue";
 import 'nprogress/nprogress.css';
-import { IOptions } from "./types";
-import { createChannel, useChannel } from "./hooks/core/use-channel";
+import type { IOptions, Options } from "./hooks/core/use-core/types";
+import { useChannel } from "./hooks/core/use-channel";
 import { useRequest } from "./hooks/core/use-request";
 import { useAuth } from "./hooks/utils/use-auth";
 import { useCookies } from "./hooks/utils/use-cookie";
@@ -9,8 +9,21 @@ import { usePaster } from "./hooks/utils/use-paster";
 import { useXlsx } from "./hooks/utils/use-xlsx";
 import { useSocket } from "./hooks/core/use-socket";
 import { useQuery } from "./hooks/data/use-query";
-import { createDao } from "./hooks/data/use-dao";
+import { useDao } from "./hooks/data/use-dao";
+import { useAoa } from "./hooks/utils/use-aoa";
+import type { XlsSheet, XlsSheetMerge } from "./hooks/utils/use-xlsx/types";
+import type { Aoa } from "./hooks/utils/use-aoa/types";
+import MetaField from "./hooks/data/use-meta/MetaField";
+import MetaView from "./hooks/data/use-meta/MetaView";
+import type { Meta } from "./hooks/data/use-meta/types";
+import DataModel, { type DataItem, type DataItemId } from "./hooks/data/use-model/DataModel";
+import TableModel from "./hooks/data/use-model/TableModel";
+import TreeModel, { type TreeItem } from "./hooks/data/use-model/TreeModel";
+import type { IQueryConfig } from "./hooks/data/use-query/types";
+import Lookup from "./hooks/data/use-query/Lookup";
+import { useData } from "./hooks/data/use-data";
+import type { IDataConfig } from "./hooks/data/use-data/types";
 declare const createMorghulisCore: (options?: IOptions) => {
     install(app: App): void;
 };
-export { createMorghulisCore, useRequest, createChannel, useChannel, useAuth, useCookies, useXlsx, usePaster, useSocket, useQuery, createDao };
+export { Options, createMorghulisCore, useRequest, useChannel, useAuth, useCookies, usePaster, useSocket, XlsSheet, XlsSheetMerge, useXlsx, Aoa, useAoa, useDao, Meta, MetaView, MetaField, DataItem, DataItemId, TreeItem, DataModel, TableModel, TreeModel, IQueryConfig, Lookup, useQuery, useData, IDataConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@morghulis/core",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/dist/types/hooks/data/types.d.ts

@@ -1,18 +0,0 @@
-import { IconNames } from "../utils/use-icon/types";
-export type Database = 'orm' | 'mon';
-export type DataItemId = string | number;
-export type DataItem = {
-    id?: DataItemId;
-    [key: string]: any;
-};
-export type TreeItem = {
-    pid: number | string;
-    isLeaf: boolean;
-    icon?: IconNames;
-    children: TreeItem[];
-} & DataItem;
-export type PropItem = {
-    label: string;
-    value: string;
-    display?: string;
-};

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

@@ -1,4 +0,0 @@
-import { TableResults } from "./types";
-export default class TableModel {
-    constructor(res: TableResults);
-}