aio-entity 2.0.0 → 2.0.2

package/index.d.ts

@@ -39,6 +39,7 @@ export declare const useEntity: <T>(p: I_useEntity<T>) => {
     mergeToNewRow: (rowIds: (string | number)[], newRow: T, newRowParentId?: string | number) => Promise<boolean>;
     moveTo: (fromIds: (string | number)[], toId: string | number) => Promise<boolean>;
     editChilds: (rows: T[], callback: (row: T) => T) => Promise<boolean>;
+    changeOrderByDir: (row: T, dir: 1 | -1) => Promise<boolean>;
     duplicate: (row: T) => Promise<string | number | false>;
     filterRows: (rows: T[], getResult: (row: T, detail: I_detail) => boolean, parentIds?: (string | number)[]) => T[];
     search: (rows: T[], getResult: (row: T, detail: I_detail) => boolean) => T[];
@@ -60,9 +61,9 @@ export declare const useEntity: <T>(p: I_useEntity<T>) => {
         get: () => any;
         set: () => any;
     };
-    getReport: (rows: T[], getValue: (row: T, detail: I_detail) => {
-        [key: string]: any[] | number;
-    } | false | undefined, getGroup?: (row: T) => string[]) => any;
+    getReport: (rows: T[], getValue: (row: T, detail: I_detail) => false | {
+        [key: string]: number | any[];
+    }, getGroup?: (row: T) => string[]) => any;
     getParentByRowId: (data: T[], rowId: string | number) => T;
 };
 type I_EntityClass<T> = {
@@ -84,11 +85,12 @@ declare class EntityClass<T> {
     private removeChild;
     private walk;
     private editChilds_req;
+    private replace;
     filterRows: (rows: T[], getResult: (row: T, detail: I_detail) => boolean, parentIds?: (string | number)[]) => T[];
     updateReport: (values: any, groups: string[], dic: any) => void;
-    getReport: (rows: T[], getValue: (row: T, detail: I_detail) => {
-        [key: string]: any[] | number;
-    } | false | undefined, getGroup?: (row: T) => string[]) => any;
+    getReport: (rows: T[], getValue: (row: T, detail: I_detail) => false | {
+        [key: string]: number | any[];
+    }, getGroup?: (row: T) => string[]) => any;
     add: (data: T[], row: T, parentId?: string | number) => {
         data: T[];
         addedId?: string | number;
@@ -99,7 +101,7 @@ declare class EntityClass<T> {
     removeByIds: (data: T[], rowIds: (string | number)[]) => T[];
     mergeToExistRow: (data: T[], rowIds: (string | number)[], parentId: string | number) => T[];
     mergeToNewRow: (data: T[], rowIds: (string | number)[], newRow: T, newRowParentId?: string | number) => T[];
-    getNodes: <R = any>(data: T[], getValue: (row: T, detail: I_detail) => R | false | undefined) => R[];
+    getNodes: <R = any>(data: T[], getValue: (row: T, detail: I_detail) => false | R) => R[];
     getChilds: (row: T) => void | T[];
     getRowAndParentsById: (data: T[], rowId: string | number) => {
         row?: T;
@@ -111,6 +113,10 @@ declare class EntityClass<T> {
     moveTo: (data: T[], fromIds: (string | number)[], toId: string | number) => T[];
     editChilds: (rows: T[], callback: (row: T) => T) => T[];
     search: (rows: T[], getResult: (row: T, detail: I_detail) => boolean) => T[];
+    getParentById: (rows: T[], rowId: string | number) => false | T;
+    replaceById: (rows: T[], fromId: string | number, toId: string | number) => T[];
+    changeOrderByDir: (rows: T[], row: T, dir: 1 | -1) => T[];
+    changeOrderByIndex: (rows: T[], parent: T, fromIndex: number, toIndex: number) => T[];
     duplicate: (data: T[], row: T) => {
         data: T[];
         addedId?: string | number;
@@ -132,11 +138,53 @@ export declare const useFilter: <T, F>(p: {
     report: any;
 };
 export declare const useEntityFilter: <T, F>(p: {
-    entity: ReturnType<typeof useEntity<T>>;
+    entity: {
+        methods: EntityClass<T>;
+        data: T[];
+        changeData: (data: T[]) => Promise<boolean>;
+        id: {
+            get: (row: T) => string | number;
+            set: (row: T) => T;
+        };
+        add: (row: T, parentId?: string | number) => Promise<number | string | false>;
+        edit: (row: T) => Promise<boolean>;
+        remove: (rowId: string | number) => Promise<boolean>;
+        removeByIds: (rowIds: (string | number)[]) => Promise<boolean>;
+        mergeToExistRow: (rowIds: (string | number)[], parentId: string | number) => Promise<boolean>;
+        mergeToNewRow: (rowIds: (string | number)[], newRow: T, newRowParentId?: string | number) => Promise<boolean>;
+        moveTo: (fromIds: (string | number)[], toId: string | number) => Promise<boolean>;
+        editChilds: (rows: T[], callback: (row: T) => T) => Promise<boolean>;
+        changeOrderByDir: (row: T, dir: 1 | -1) => Promise<boolean>;
+        duplicate: (row: T) => Promise<string | number | false>;
+        filterRows: (rows: T[], getResult: (row: T, detail: I_detail) => boolean, parentIds?: (string | number)[]) => T[];
+        search: (rows: T[], getResult: (row: T, detail: I_detail) => boolean) => T[];
+        getLeafs: (rows: T[]) => T[];
+        getSortedData: (rows: T[], sorts: I_sort<T>[]) => T[];
+        sort: (params: {
+            sorts: I_sort<T>[];
+            row?: T;
+        }) => Promise<false | T[]>;
+        getNodes: <R = any>(data: T[], getValue: (row: T, detail: I_detail) => false | R) => R[];
+        getRowAndParentsById: (rowId: string | number) => {
+            row?: T;
+            parents: T[];
+        };
+        childs: {
+            get: (row: T) => void | T[];
+            set: (row: T, childs: T[]) => T;
+        } | {
+            get: () => any;
+            set: () => any;
+        };
+        getReport: (rows: T[], getValue: (row: T, detail: I_detail) => false | {
+            [key: string]: number | any[];
+        }, getGroup?: (row: T) => string[]) => any;
+        getParentByRowId: (data: T[], rowId: string | number) => T;
+    };
     defaultFilter: F;
     getResult: (row: T, detail: I_detail, filter: F) => boolean;
-    getReport?: (row: T, detail: I_detail, filter: F) => false | undefined | {
-        [key: string]: any[] | number;
+    getReport?: (row: T, detail: I_detail, filter: F) => false | void | {
+        [key: string]: number | any[];
     };
     defaultReport?: any;
 }) => {

package/index.js

@@ -53,6 +53,7 @@ export const useEntity = (p) => {
         mergeToNewRow: (rowIds, newRow, newRowParentId) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.mergeToNewRow(dataRef.current, rowIds, newRow, newRowParentId)); }),
         moveTo: (fromIds, toId) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.moveTo(dataRef.current, fromIds, toId)); }),
         editChilds: (rows, callback) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.editChilds(rows, callback)); }),
+        changeOrderByDir: (row, dir) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.changeOrderByDir(dataRef.current, row, dir)); }),
         duplicate: (row) => __awaiter(void 0, void 0, void 0, function* () {
             const { data, addedId } = entity.duplicate(dataRef.current, row);
             if (addedId === undefined) {
@@ -193,6 +194,59 @@ class EntityClass {
                 this.editChilds_req(childs, callback, result);
             }
         };
+        this.replace = (rows, fromId, toId, helper) => {
+            const { childs: c, id } = this.params;
+            if (fromId === toId) {
+                return rows;
+            }
+            if (c) {
+                let parentChilds = [];
+                let parent = helper && helper.parent ? helper.parent : this.getParentById(rows, fromId);
+                if (!parent) {
+                    return rows;
+                }
+                if (helper && helper.parentChilds) {
+                    parentChilds = helper.parentChilds;
+                }
+                else {
+                    const res = c.get(parent);
+                    if (!res) {
+                        return rows;
+                    }
+                    parentChilds = res;
+                }
+                const { fromIndex = parentChilds.findIndex((o) => id.get(o) === fromId), toIndex = parentChilds.findIndex((o) => id.get(o) === toId) } = helper || {};
+                if (fromIndex === -1 || toIndex === -1) {
+                    return rows;
+                }
+                const newParentChilds = parentChilds.map((o, i) => {
+                    if (i === fromIndex) {
+                        return parentChilds[toIndex];
+                    }
+                    if (i === toIndex) {
+                        return parentChilds[fromIndex];
+                    }
+                    return o;
+                });
+                const newParent = c.set(parent, newParentChilds);
+                return this.edit(rows, newParent);
+            }
+            else {
+                const { fromIndex = rows.findIndex((o) => id.get(o) === fromId), toIndex = rows.findIndex((o) => id.get(o) === toId) } = helper || {};
+                if (fromIndex === -1 || toIndex === -1) {
+                    return rows;
+                }
+                return rows.map((o, i) => {
+                    if (i === fromIndex) {
+                        return rows[toIndex];
+                    }
+                    if (i === toIndex) {
+                        return rows[fromIndex];
+                    }
+                    return o;
+                });
+            }
+        };
         this.filterRows = (rows, getResult, parentIds) => {
             const { childs: c, id } = this.params;
             if (!c) {
@@ -406,6 +460,60 @@ class EntityClass {
             });
             return this.filterRows(rows, (row) => !!dic['a' + id.get(row)]);
         };
+        this.getParentById = (rows, rowId) => {
+            const { parents } = this.getRowAndParentsById(rows, rowId);
+            if (!parents.length) {
+                return false;
+            }
+            return parents[parents.length - 1];
+        };
+        this.replaceById = (rows, fromId, toId) => this.replace(rows, fromId, toId);
+        this.changeOrderByDir = (rows, row, dir) => {
+            const { childs: c, id } = this.params;
+            const rowId = id.get(row);
+            let list = [];
+            let parentRow;
+            if (c) {
+                const res = this.getParentById(rows, rowId);
+                if (!res) {
+                    return rows;
+                }
+                parentRow = res;
+                const parentChilds = c.get(parentRow);
+                if (!parentChilds) {
+                    return rows;
+                }
+                list = parentChilds;
+            }
+            else {
+                list = rows;
+            }
+            const fromIndex = list.findIndex((o) => id.get(o) === rowId);
+            if (dir === 1 && fromIndex === list.length - 1) {
+                return rows;
+            }
+            if (dir === -1 && fromIndex === 0) {
+                return rows;
+            }
+            const toIndex = fromIndex + dir;
+            const from = list[fromIndex], to = list[toIndex];
+            if (!from || !to) {
+                return rows;
+            }
+            const fromId = id.get(from), toId = id.get(to);
+            return this.replace(rows, fromId, toId, { parent: parentRow, parentChilds: list, fromIndex, toIndex });
+        };
+        this.changeOrderByIndex = (rows, parent, fromIndex, toIndex) => {
+            const { childs: c, id } = this.params;
+            let parentChilds = c ? c.get(parent) : rows;
+            if (!parentChilds) {
+                return rows;
+            }
+            const from = parentChilds[fromIndex];
+            const to = parentChilds[toIndex];
+            const fromId = id.get(from), toId = id.get(to);
+            return this.replace(rows, fromId, toId, { parent, parentChilds, fromIndex, toIndex });
+        };
         this.duplicate = (data, row) => {
             const { id } = this.params;
             const rowId = id.get(row);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "aio-entity",
-    "version": "2.0.0",
+    "version": "2.0.2",
     "description": "kit",
     "main": "index.js",
     "scripts": {