aio-entity 1.0.1 → 1.0.3

package/index.d.ts

@@ -9,91 +9,75 @@ type I_sort<T> = {
     columnId?: string;
     order?: number;
 };
-type I_flatRow<T> = T & {
-    _parent?: T;
+type I_detail = {
+    _parentIds?: (string | number)[];
     _childsLength?: number;
+    _isLeaf: boolean;
 };
-export type I_useEntity<T, F> = {
-    sync: I_useSync<T>;
+export type I_useEntity<T> = {
     getId: (row: T) => string | number;
-    popup?: any;
-    getChilds?: (row: T) => (T[] | void);
-    setChilds?: (row: T, childs: T[] | undefined) => T;
-    setId: (row: T) => T;
-    filter?: {
-        getFilteredRows: (rows: T[], filter: F) => {
-            rows: T[];
-            data: any;
-        };
-        getDefaultFilter: () => F;
+    fetchData: () => Promise<T[] | false>;
+    saveData: (data: T[]) => Promise<boolean>;
+    initData?: T[];
+    childs?: {
+        get: (row: T) => (T[] | void);
+        set: (row: T, childs: T[] | undefined) => T;
     };
-    fa?: boolean;
+    setId: (row: T) => T;
 };
-export declare const useEntity: <T, F>(p: I_useEntity<T, F>) => {
+export declare const useEntity: <T>(p: I_useEntity<T>) => {
     data: T[];
-    changeData: (data: T[]) => Promise<void>;
+    changeData: (data: T[]) => Promise<boolean>;
     getId: (row: T) => string | number;
-    render: () => import("react/jsx-runtime").JSX.Element;
-    add: (row: T, parentId?: string | number) => Promise<void>;
-    edit: (row: T) => Promise<void>;
-    remove: (rowId: string | number) => Promise<void>;
-    moveTo: (fromId: string | number, toId: string | number) => Promise<void>;
-    editChilds: (rows: T[], callback: (row: T) => T) => Promise<void>;
-    duplicate: (row: T) => Promise<void>;
-    sort: (sorts: I_sort<T>[], parentRow?: T) => Promise<void>;
-    filter: F;
-    filteredData: {
-        rows: T[];
-        data: any;
-    };
-    hasFilter: boolean;
+    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>;
+    duplicate: (row: T) => Promise<string | number | false>;
+    getLeafs: (rows?: T[]) => T[];
+    sort: (sorts: I_sort<T>[], parentRow?: T) => Promise<boolean>;
     getNodes: <R>(p: {
         row?: T;
-        filter?: (row: T) => boolean;
-        map?: (row: I_flatRow<T>) => false | R;
+        getValue: (row: T, detail: I_detail) => R | false | undefined;
     }) => R[];
     getRowAndParentsById: (p: {
         rowId: string | number;
     }) => {
-        row?: T;
+        row?: T | undefined;
         parents: T[];
     };
-    importData: (callback: (data: T[]) => void) => Promise<void>;
-    exportData: (data: T[]) => void;
-    getLeafs: (p: {
-        row?: T;
-        rows: T[];
-    }) => T[];
     getChilds: (row: T) => void | T[];
-    changeFilter: (p: Partial<F>) => void;
-    getReport: <NODE, RES>(nodes: NODE[], getValue: (node: NODE) => RES, getGroup?: (node: NODE) => string) => {
-        dic: RES;
-        total: RES;
-    };
-    getReports: (nodes: any[], getValue: (node: any) => any, getGroup?: (node: any) => string[]) => any;
+    getReport: (p: {
+        rows?: T[];
+        getValue: (row: T, detail: I_detail) => {
+            [key: string]: any[] | number;
+        } | false | undefined;
+        getGroup?: (row: T) => string[];
+    }) => any;
     getParentByRowId: (p: {
         rowId: any;
         rows: T[];
     }) => T;
 };
-type I_useSync<T> = {
-    cordova?: any;
-    key: string;
-    fetchData?: () => Promise<T[] | false>;
-    saveData?: (data: T[]) => Promise<boolean>;
-    apis?: {
-        save: (data: T[]) => Promise<boolean>;
-        load: (def: T[]) => Promise<false | T[]>;
+type I_useFilter<T, F> = {
+    getFilteredRows: (rows: T[], filter: F) => {
+        rows: T[];
+        data: any;
     };
-    initData: T[];
+    getDefaultFilter: () => F;
+    getRows: () => T[];
 };
-export declare const useSync: <T>(p: I_useSync<T>) => {
-    saveData: (data: T[]) => Promise<boolean>;
-    loadData: () => Promise<false | T[]>;
-    forceFetchData: () => Promise<false | T[]>;
-    openLogs: () => any;
-    importData: (callback: (data: T[]) => void) => Promise<void>;
-    exportData: (data: T[]) => void;
-    popup: any;
+export declare const useFilter: <T, F>(p: I_useFilter<T, F>) => {
+    filter: F;
+    changeFilter: (p: Partial<F>) => void;
+    filteredData: {
+        rows: T[];
+        data: any;
+    };
+    updateFilteredRows: (rows: T[], pFilter?: F) => void;
 };
 export {};

package/index.js

@@ -7,76 +7,68 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from "react";
-import usePopup from "aio-popup";
-import { Cards } from "aio-input";
-import { Debounce, SortArray } from 'aio-utils';
-import { useEntity } from 'aio-entity';
+import { Debounce, SortArray } from './../aio-utils';
 export const useEntity = (p) => {
-    const { getFilteredRows = () => ({ rows: [], data: {} }), getDefaultFilter = () => { return {}; } } = p.filter || {};
     const entity = new EntityClass({
-        getId: p.getId, setId: p.setId, getChilds: p.getChilds, setChilds: p.setChilds
+        getId: p.getId, setId: p.setId, childs: p.childs
     });
-    const sync = useSync(p.sync);
-    const [data, setData] = useState(p.sync.initData || []), dataRef = useRef(data);
+    const [data, setData] = useState(p.initData || []), dataRef = useRef(data);
     dataRef.current = data;
-    const filterHook = useFilter({ getFilteredRows, getDefaultFilter, getRows: () => data });
     const fetchData = () => __awaiter(void 0, void 0, void 0, function* () {
-        const res = yield sync.loadData();
+        const res = yield p.fetchData();
         if (res !== false) {
             setData(res);
         }
     });
     useEffect(() => { fetchData(); }, []);
     const changeData = (data) => __awaiter(void 0, void 0, void 0, function* () {
-        const res = yield sync.saveData(data);
+        const res = yield p.saveData(data);
         if (res !== false) {
             dataRef.current = data;
             setData(data);
         }
+        return res;
     });
-    useEffect(() => { filterHook.updateFilteredRows(data); }, [data]);
-    const render = () => (_jsx(_Fragment, { children: sync.popup.render() }));
     return {
-        data, changeData, getId: p.getId, render,
-        add: (row, parentId) => __awaiter(void 0, void 0, void 0, function* () { yield changeData(entity.add({ row, parentId, rows: dataRef.current })); }),
+        data, changeData, getId: p.getId,
+        add: (row, parentId) => __awaiter(void 0, void 0, void 0, function* () {
+            const { rows, addedId } = entity.add({ row, parentId, rows: dataRef.current });
+            if (addedId === undefined) {
+                return false;
+            }
+            const res = yield changeData(rows);
+            if (!res) {
+                return false;
+            }
+            return addedId;
+        }),
         edit: (row) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.edit({ row, rows: dataRef.current })); }),
         remove: (rowId) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.remove({ rowId, rows: dataRef.current })); }),
-        moveTo: (fromId, toId) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.moveTo({ fromId, toId, rows: dataRef.current })); }),
+        removeByIds: (rowIds) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.removeByIds({ rowIds, rows: dataRef.current })); }),
+        mergeToExistRow: (rowIds, parentId) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.mergeToExistRow({ rowIds, rows: dataRef.current, parentId })); }),
+        mergeToNewRow: (rowIds, newRow, newRowParentId) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.mergeToNewRow({ rowIds, rows: dataRef.current, newRow, newRowParentId })); }),
+        moveTo: (fromIds, toId) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.moveTo({ fromIds, toId, rows: dataRef.current })); }),
         editChilds: (rows, callback) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.editChilds({ rows, callback })); }),
-        duplicate: (row) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.duplicate({ rows: dataRef.current, row })); }),
+        duplicate: (row) => __awaiter(void 0, void 0, void 0, function* () {
+            const { rows, addedId } = entity.duplicate({ rows: dataRef.current, row });
+            if (addedId === undefined) {
+                return false;
+            }
+            const res = yield changeData(rows);
+            if (!res) {
+                return false;
+            }
+            return addedId;
+        }),
+        getLeafs: (rows) => entity.getLeafs(dataRef.current, rows),
         sort: (sorts, parentRow) => __awaiter(void 0, void 0, void 0, function* () { return yield changeData(entity.sort({ rows: dataRef.current, parentRow, sorts })); }),
-        filter: filterHook.filter, filteredData: filterHook.filteredData, hasFilter: !!p.filter,
-        getNodes: (p) => entity.getNodes(Object.assign(Object.assign({}, p), { rows: dataRef.current })),
+        getNodes: (p) => entity.getNodes(Object.assign(Object.assign({}, p), { data: dataRef.current })),
         getRowAndParentsById: (p) => entity.getRowAndParentsById(Object.assign(Object.assign({}, p), { rows: dataRef.current })),
-        importData: sync.importData,
-        exportData: sync.exportData,
-        getLeafs: entity.getLeafs,
         getChilds: entity.getChilds,
-        changeFilter: filterHook.changeFilter,
-        getReport: entity.getReport,
-        getReports: entity.getReports,
-        getParentByRowId: entity.getParentByRowId,
-    };
-};
-const useFilter = (p) => {
-    const [filter, setFilter] = useState(p.getDefaultFilter);
-    const filterRef = useRef(filter);
-    filterRef.current = filter;
-    const [filteredData, setFilteredData] = useState({ rows: [], data: {} });
-    const filteredDataRef = useRef(filteredData);
-    filteredDataRef.current = filteredData;
-    const changeFilter = (p) => setFilter(Object.assign(Object.assign({}, filter), p));
-    const updateFilteredRows = (rows, pFilter) => {
-        Debounce(() => {
-            const filter = pFilter || filterRef.current;
-            const filteredData = p.getFilteredRows(rows, filter);
-            setFilteredData(filteredData);
-        }, 50);
+        getReport: (p) => entity.getReport({ data: dataRef.current, rows: p.rows, getValue: p.getValue, getGroup: p.getGroup }),
+        getParentByRowId: entity.getParentByRowId
     };
-    useEffect(() => { updateFilteredRows(p.getRows()); }, [filter]);
-    return { filter, changeFilter, filteredData, updateFilteredRows };
 };
 class EntityClass {
     constructor(p) {
@@ -91,106 +83,95 @@ class EntityClass {
                     result.parents = parents;
                     return;
                 }
-                const childs = !!this.params.getChilds ? (this.params.getChilds(row) || []) : undefined;
+                const childs = !!this.params.childs ? (this.params.childs.get(row) || []) : undefined;
                 if (childs && childs.length) {
                     this.getRowAndParentsById_req(childs, id, [...parents, row], result);
                 }
             }
         };
         this.addToParent = (p) => {
-            const { getChilds, setChilds } = this.params;
+            const { childs: c } = this.params;
             const { parentRow, row } = p;
-            if (!getChilds || !setChilds) {
+            if (!c) {
                 return row;
             }
-            const childs = getChilds ? (getChilds(parentRow) || []) : undefined;
+            const childs = c.get(parentRow) || [];
             if (!childs) {
                 return row;
             }
-            return setChilds(parentRow, [...childs, row]) || row;
+            return c.set(parentRow, [...childs, row]) || row;
         };
         this.editByParent = (p) => {
             const { parentRow, row } = p;
-            const { getChilds, setChilds, getId } = this.params;
-            if (!getChilds || !setChilds) {
+            const { childs: c, getId } = this.params;
+            if (!c) {
                 return parentRow;
             }
             const rowId = getId(row);
-            const childs = getChilds(parentRow);
+            const childs = c.get(parentRow);
             if (!childs) {
                 return parentRow;
             }
             const newChilds = childs.map((o) => getId(o) === rowId ? row : o);
-            return setChilds(parentRow, newChilds) || parentRow;
+            return c.set(parentRow, newChilds) || parentRow;
         };
         this.removeChild = (p) => {
             const { parentRow, rowId, rows } = p;
-            const { getChilds, setChilds, getId } = this.params;
-            if (!getChilds || !setChilds) {
+            const { childs: c, getId } = this.params;
+            if (!c) {
                 return rows;
             }
-            let parentChilds = getChilds(parentRow);
+            let parentChilds = c.get(parentRow);
             if (!parentChilds || !parentChilds.length) {
                 return rows;
             }
             parentChilds = parentChilds.filter((o) => getId(o) !== rowId);
-            const res = setChilds(parentRow, parentChilds);
+            const res = c.set(parentRow, parentChilds);
             if (!res) {
                 return rows;
             }
             return this.edit({ row: res, rows });
         };
-        this.getLeafs_req = (rows, result) => {
-            const { getChilds } = this.params;
-            for (let i = 0; i < rows.length; i++) {
-                const row = rows[i];
-                const childs = !!getChilds ? getChilds(row) : undefined;
-                if (childs) {
-                    this.getLeafs_req(childs, result);
-                }
-                else {
-                    result.push(row);
-                }
-            }
+        this.getLeafs = (data, rows) => {
+            const res = this.getReport({
+                rows, data,
+                getValue: (o, detail) => detail._isLeaf ? { rows: [o] } : undefined,
+            });
+            return res.rows;
         };
-        this.getFlatRow = (row, _parentIds, childsLength) => {
-            const { getChilds, setChilds } = this.params;
-            if (!setChilds || !getChilds) {
-                return Object.assign(Object.assign({}, row), { _childsLength: undefined, _parentIds: [] });
-            }
-            let _childsLength = childsLength;
-            if (childsLength === undefined) {
-                const res = getChilds(row);
-                if (res) {
-                    _childsLength = res.length;
-                }
-            }
-            return Object.assign(Object.assign({}, setChilds(Object.assign({}, row), undefined)), { _parentIds, _childsLength });
+        this.getDetail = (row) => {
+            const { childs: c } = this.params;
+            if (!c) {
+                return { _parentIds: [], _childsLength: undefined, _isLeaf: false };
+            }
+            const childs = c.get(row);
+            const childsLength = childs ? childs.length : undefined;
+            return { _parentIds: [], _childsLength: childsLength, _isLeaf: childsLength === undefined };
         };
         this.walk = (p) => {
-            var _a;
-            const { getChilds } = this.params;
-            if (!p.childs) {
+            const { childs: c } = this.params;
+            if (!p.childs || !c) {
                 return;
             }
             for (let i = 0; i < p.childs.length; i++) {
                 const row = p.childs[i];
                 const rowId = this.params.getId(row);
-                const flat = this.getFlatRow(row, p.parentIds);
-                if ((_a = p.filter) === null || _a === void 0 ? void 0 : _a.call(p, flat))
+                const detail = this.getDetail(row);
+                const mapped = p.getValue(row, detail);
+                if (mapped === false) {
                     continue;
-                const mapped = p.map ? p.map(flat) : flat;
-                if (mapped !== false) {
+                }
+                if (mapped !== undefined) {
                     p.result.push(mapped);
                 }
-                const subchilds = getChilds === null || getChilds === void 0 ? void 0 : getChilds(row);
+                const subchilds = c.get(row);
                 if (subchilds === null || subchilds === void 0 ? void 0 : subchilds.length) {
-                    this.walk({ childs: subchilds, filter: p.filter, map: p.map, result: p.result, parentIds: [...p.parentIds, rowId] });
+                    this.walk({ childs: subchilds, getValue: p.getValue, result: p.result, parentIds: [...p.parentIds, rowId] });
                 }
             }
         };
         this.sort_req = (p) => {
-            const { getChilds, setChilds } = this.params;
+            const { childs: c } = this.params;
             const { rows, sorts, result, parentRow } = p;
             let sortedChilds = [];
             if (!parentRow) {
@@ -198,13 +179,13 @@ class EntityClass {
                 result.rows = sortedChilds;
             }
             else {
-                if (!getChilds || !setChilds) {
+                if (!c) {
                     return;
                 }
                 const childs = this.getChilds(parentRow);
                 if (childs && childs.length) {
                     sortedChilds = SortArray(childs, p.sorts);
-                    const fixedParent = setChilds(parentRow, sortedChilds);
+                    const fixedParent = c.set(parentRow, sortedChilds);
                     p.result.rows = this.edit({ row: fixedParent, rows: p.result.rows });
                 }
             }
@@ -213,89 +194,93 @@ class EntityClass {
             }
         };
         this.editChilds_req = (rows, callback, result) => {
-            const { getChilds } = this.params;
-            if (!getChilds) {
+            const { childs: c } = this.params;
+            if (!c) {
                 return [];
             }
             for (let i = 0; i < rows.length; i++) {
                 const row = rows[i];
                 result.rows = this.edit({ row: callback(row), rows: result.rows });
-                const childs = getChilds(row);
+                const childs = c.get(row);
                 if (!childs || !childs.length) {
                     continue;
                 }
                 this.editChilds_req(childs, callback, result);
             }
         };
-        this.getReport = (nodes, getValue, getGroup) => {
-            const total = {};
-            const res = {};
-            for (const node of nodes) {
-                const groupKey = getGroup ? getGroup(node) : '_all';
-                const values = getValue(node);
-                if (!values)
-                    continue;
-                res[groupKey] = res[groupKey] || {};
-                for (const field in values) {
-                    const value = values[field];
-                    if (Array.isArray(value)) {
-                        res[groupKey][field] = res[groupKey][field] || [];
-                        res[groupKey][field] = res[groupKey][field].concat(value);
-                        total[groupKey] = total[groupKey] || [];
-                        total[groupKey] = total[groupKey].concat(value);
-                    }
-                    else if (typeof value === 'number') {
-                        res[groupKey][field] = (res[groupKey][field] || 0) + value;
-                        total[groupKey] = total[groupKey] || 0;
-                        total[groupKey] += value;
-                    }
+        this.filterRows = (rows, getResult) => {
+            const { childs: c } = this.params;
+            const res = rows.filter((o) => getResult(o));
+            return res.map((row) => {
+                const childs = c ? c.get(row) : undefined;
+                if (childs && c) {
+                    const newChilds = this.filterRows(childs, getResult);
+                    return c.set(row, newChilds);
                 }
-            }
-            return getGroup ? { dic: res, total } : { dic: res['_all'], total };
-        };
-        this.getReports = (nodes, getValue, getGroup) => {
-            const res = {};
-            for (const node of nodes) {
-                const groupKeys = getGroup ? getGroup(node) : ['_all'];
-                const values = getValue(node);
-                if (!values)
-                    continue;
-                let temp = res[groupKeys[0]];
-                if (!temp) {
-                    res[groupKeys[0]] = res[groupKeys[0]] || {};
-                    temp = res[groupKeys[0]];
+                else {
+                    return row;
                 }
-                for (let i = 1; i < groupKeys.length; i++) {
-                    const groupKey = groupKeys[i];
-                    temp[groupKey] = temp[groupKey] || {};
-                    temp = temp[groupKey];
+            });
+        };
+        this.updateReport = (values, groups, dic) => {
+            let tempGroups = dic;
+            if (groups.length) {
+                for (let i = 0; i < groups.length; i++) {
+                    const group = groups[i];
+                    tempGroups[group] = tempGroups[group] || {};
+                    tempGroups = tempGroups[group];
                 }
-                for (const field in values) {
-                    const value = values[field];
-                    if (Array.isArray(value)) {
-                        temp[field] = temp[field] || [];
-                        temp[field] = temp[field].concat(value);
+            }
+            for (const field in values) {
+                const value = values[field];
+                if (Array.isArray(value)) {
+                    if (!Array.isArray(tempGroups[field])) {
+                        tempGroups[field] = [];
                     }
-                    else if (typeof value === 'number') {
-                        temp[field] = (temp[field] || 0) + value;
+                    tempGroups[field] = tempGroups[field].concat(value);
+                }
+                else if (typeof value === 'number') {
+                    if (typeof tempGroups[field] !== 'number') {
+                        tempGroups[field] = 0;
                     }
+                    tempGroups[field] = (tempGroups[field] || 0) + value;
                 }
             }
-            return getGroup ? res : res['_all'];
+        };
+        this.getReport = (p) => {
+            const dic = {};
+            const rows = p.rows || p.data;
+            for (let i = 0; i < rows.length; i++) {
+                this.getNodes({
+                    data: p.data, row: rows[i], getValue: (o) => {
+                        const detail = this.getDetail(o);
+                        const values = p.getValue(o, detail);
+                        if (values === false || values === undefined) {
+                            return values;
+                        }
+                        const groups = p.getGroup ? p.getGroup(o) : [];
+                        this.updateReport(values, groups, dic);
+                    }
+                });
+            }
+            return dic;
         };
         this.add = (p) => {
             const { rows, row, parentId } = p;
             const newRow = this.params.setId(row);
+            const addedId = this.params.getId(newRow);
             if (parentId !== undefined) {
                 const res = this.getRowAndParentsById({ rowId: parentId, rows });
                 if (!res.row) {
-                    return rows;
+                    return { rows };
                 }
                 const res1 = this.addToParent({ parentRow: res.row, row: newRow });
-                return this.edit({ row: res1, rows });
+                const newRows = this.edit({ row: res1, rows });
+                return { rows: newRows, addedId };
             }
             else {
-                return [...rows, newRow];
+                const newRows = [...rows, newRow];
+                return { rows: newRows, addedId };
             }
         };
         this.editRoot = (rows, row) => {
@@ -303,10 +288,10 @@ class EntityClass {
             return rows.map((o) => getId(o) === getId(row) ? row : o);
         };
         this.edit = (p) => {
-            const { getChilds, setChilds } = this.params;
+            const { childs: c } = this.params;
             const { row, rows } = p;
             const rowId = this.params.getId(row);
-            if (!!getChilds && !!setChilds) {
+            if (!!c) {
                 let parentRow = this.getParentByRowId({ rowId, rows });
                 if (parentRow) {
                     parentRow = this.editByParent({ parentRow, row });
@@ -333,18 +318,70 @@ class EntityClass {
                 return rows.filter((o) => getId(o) !== rowId);
             }
         };
-        this.getLeafs = (p) => { const result = []; this.getLeafs_req(p.row ? [p.row] : p.rows, result); return result; };
+        this.removeByIds = (p) => {
+            const { rowIds, rows } = p;
+            let tempRows = rows;
+            for (let i = 0; i < rowIds.length; i++) {
+                const rowId = rowIds[i];
+                tempRows = this.remove({ rowId, rows: tempRows });
+            }
+            return tempRows;
+        };
+        this.mergeToExistRow = (p) => {
+            let rows = p.rows;
+            if (!this.params.childs) {
+                return rows;
+            }
+            const { row: parentRow } = this.getRowAndParentsById({ rows: p.rows, rowId: p.parentId });
+            if (!parentRow) {
+                return rows;
+            }
+            const newChilds = this.getRowsByIds({ rows: p.rows, rowIds: p.rowIds });
+            if (!newChilds.length) {
+                return rows;
+            }
+            const parentChilds = this.params.childs.get(parentRow);
+            if (!parentChilds) {
+                return rows;
+            }
+            rows = this.removeByIds({ rows, rowIds: p.rowIds });
+            const newParentChilds = [...parentChilds, ...newChilds];
+            const newParentRow = this.params.childs.set(parentRow, newParentChilds);
+            return this.edit({ rows, row: newParentRow });
+        };
+        this.mergeToNewRow = (p) => {
+            const { rows, addedId } = this.add({ rows: p.rows, row: p.newRow, parentId: p.newRowParentId });
+            if (addedId === undefined) {
+                return rows;
+            }
+            return this.mergeToExistRow({ rows, rowIds: p.rowIds, parentId: addedId });
+        };
         this.getNodes = (params) => {
             const result = [];
-            this.walk({ childs: params.row ? [params.row] : params.rows, filter: params.filter, map: params.map, result, parentIds: [] });
+            this.walk({ childs: params.row ? [params.row] : params.data, getValue: params.getValue, result, parentIds: [] });
             return result;
         };
-        this.getChilds = (row) => !this.params.getChilds ? undefined : this.params.getChilds(row);
+        this.getChilds = (row) => !this.params.childs ? undefined : this.params.childs.get(row);
         this.getRowAndParentsById = (p) => {
             let result = { parents: [] };
             this.getRowAndParentsById_req(p.rows, p.rowId, [], result);
             return result;
         };
+        this.getRowsByIds = (p) => {
+            const res = [];
+            const usedIds = [];
+            for (let i = 0; i < p.rowIds.length; i++) {
+                const id = p.rowIds[i];
+                if (usedIds.indexOf(id) !== -1) {
+                    continue;
+                }
+                const { row } = this.getRowAndParentsById({ rowId: id, rows: p.rows });
+                if (row) {
+                    res.push(row);
+                }
+            }
+            return res;
+        };
         this.getParentByRowId = (p) => {
             const res = this.getRowAndParentsById(p);
             if (!res.row) {
@@ -356,18 +393,34 @@ class EntityClass {
             }
             return parents[parents.length - 1];
         };
-        this.moveTo = (p) => {
+        this.moveToUnit = (p) => {
             const { fromId, toId, rows } = p;
-            const parentResult = this.getRowAndParentsById({ rowId: toId, rows });
-            if (!parentResult.row) {
+            let { row: toRow } = this.getRowAndParentsById({ rowId: toId, rows });
+            if (!toRow) {
+                return p.rows;
+            }
+            let { row: fromRow } = this.getRowAndParentsById({ rowId: fromId, rows });
+            if (!fromRow) {
                 return p.rows;
             }
-            const childResult = this.getRowAndParentsById({ rowId: fromId, rows });
-            if (!childResult.row) {
+            const rowsAfterRemove = this.remove({ rowId: fromId, rows });
+            //اگر بروز نشه مشکل بوجود میاد
+            toRow = this.getRowAndParentsById({ rowId: toId, rows: rowsAfterRemove }).row;
+            if (!toRow) {
                 return p.rows;
             }
-            const editedRows = this.remove({ rowId: fromId, rows });
-            return this.edit({ row: this.addToParent({ parentRow: parentResult.row, row: childResult.row }), rows: editedRows });
+            const newToRow = this.addToParent({ parentRow: toRow, row: fromRow });
+            const res = this.edit({ row: newToRow, rows: rowsAfterRemove });
+            return res;
+        };
+        this.moveTo = (p) => {
+            const { fromIds, toId } = p;
+            let rows = p.rows;
+            for (let i = 0; i < p.fromIds.length; i++) {
+                const fromId = fromIds[i];
+                rows = this.moveToUnit({ fromId, toId, rows });
+            }
+            return rows;
         };
         this.editChilds = (p) => {
             const { rows, callback } = p;
@@ -394,99 +447,21 @@ class EntityClass {
         this.params = p;
     }
 }
-export const useSync = (p) => {
-    const [logs, setLogs] = useState([]);
-    const popup = usePopup();
-    const logsRef = useRef(logs);
-    logsRef.current = logs;
-    const addLog = (log) => setLogs((prev) => [...prev, log]);
-    const openLogs = () => popup.addModal({ header: { title: 'Logs' }, body: (_jsx(Cards, { list: { items: logsRef.current, option: { text: (o) => o } } })) });
-    const hasUnSync = () => __awaiter(void 0, void 0, void 0, function* () { return !p.cordova ? false : yield p.cordova.storageLoad(p.key + '_unSync', false); });
-    const setUnSync = (v) => __awaiter(void 0, void 0, void 0, function* () { if (p.cordova) {
-        yield p.cordova.storageSave(p.key + '_unSync', !p.apis ? false : v);
-    } });
-    const syncCordova = (data) => __awaiter(void 0, void 0, void 0, function* () {
-        const unsync = yield hasUnSync();
-        if (!unsync) {
-            return;
-        }
-        const res = yield postData(data);
-        if (res) {
-            yield setUnSync(!res);
-        }
-    });
-    const loadData = () => __awaiter(void 0, void 0, void 0, function* () {
-        if (p.cordova) {
-            const data = yield p.cordova.storageLoad(p.key, p.initData || []);
-            if (p.apis) {
-                yield syncCordova(data);
-            }
-            return data;
-        }
-        else if (p.apis) {
-            return yield fetchData();
-        }
-        else if (p.fetchData) {
-            return yield p.fetchData();
-        }
-        else {
-            addLog('dont fetch and not cordova available.return init data');
-            return p.initData;
-        }
-    });
-    const fetchData = () => __awaiter(void 0, void 0, void 0, function* () { return p.apis ? yield p.apis.load(p.initData) : p.initData; });
-    const postData = (data) => __awaiter(void 0, void 0, void 0, function* () { return p.apis ? yield p.apis.save(data) : false; });
-    const saveCordova = (data) => __awaiter(void 0, void 0, void 0, function* () { return yield p.cordova.storageSave(p.key, data); });
-    const saveData = (data) => __awaiter(void 0, void 0, void 0, function* () {
-        if (p.apis) {
-            setUnSync(true);
-            const res = yield postData(data);
-            setUnSync(res);
-            if (!res && !p.cordova) {
-                return false;
-            }
-        }
-        else if (p.saveData) {
-            setUnSync(true);
-            const res = yield p.saveData(data);
-            if (res) {
-                setUnSync(res);
-            }
-        }
-        if (p.cordova) {
-            saveCordova(data);
-        }
-        return true;
-    });
-    const forceFetchData = () => __awaiter(void 0, void 0, void 0, function* () {
-        const res = yield loadData();
-        if (res) {
-            saveData(res);
-        }
-        else {
-            alert('failed to force fetch data');
-            return false;
-        }
-        return res;
-    });
-    const importData = (callback) => __awaiter(void 0, void 0, void 0, function* () {
-        popup.addModal({ header: { title: 'ورود دیتا' }, body: _jsx(ImportDb, { onSubmit: (data) => { callback(data); popup.removeModal(); } }) });
-    });
-    const exportData = (data) => {
-        const isCordova = typeof window !== "undefined" && !!window.cordova;
-        if (!isCordova) {
-            popup.addModal({
-                header: { title: 'فایل دیتابیس' },
-                body: (_jsx("div", { className: "h-full", children: _jsx("textarea", { className: 'h-full w-full !text-white', value: JSON.stringify(data) }) }))
-            });
-        }
-        else if (p.cordova) {
-            p.cordova.share(data);
-        }
+export const useFilter = (p) => {
+    const [filter, setFilter] = useState(p.getDefaultFilter);
+    const filterRef = useRef(filter);
+    filterRef.current = filter;
+    const [filteredData, setFilteredData] = useState({ rows: [], data: {} });
+    const filteredDataRef = useRef(filteredData);
+    filteredDataRef.current = filteredData;
+    const changeFilter = (p) => setFilter(Object.assign(Object.assign({}, filter), p));
+    const updateFilteredRows = (rows, pFilter) => {
+        Debounce(() => {
+            const filter = pFilter || filterRef.current;
+            const filteredData = p.getFilteredRows(rows, filter);
+            setFilteredData(filteredData);
+        }, 50);
     };
-    return { saveData, loadData, forceFetchData, openLogs, importData, exportData, popup };
-};
-const ImportDb = ({ onSubmit }) => {
-    const [str, setStr] = useState('');
-    return (_jsxs("div", { className: "flex flex-col gap-2 h-full p-2", style: { direction: 'ltr', color: '#333' }, children: [_jsx("textarea", { value: str, onChange: (e) => setStr(e.target.value), className: 'flex-1 w-full text-white p-1' }), _jsx("button", { className: "d1-active-button", onClick: () => onSubmit(JSON.parse(str)), children: "\u062A\u0627\u06CC\u06CC\u062F" })] }));
+    useEffect(() => { updateFilteredRows(p.getRows()); }, [filter]);
+    return { filter, changeFilter, filteredData, updateFilteredRows };
 };

package/package.json

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