aio-entity 1.0.0

package/index.d.ts

@@ -0,0 +1,99 @@
+import { type ReactNode } from "react";
+type I_sort<T> = {
+    active?: boolean;
+    dir?: 'dec' | 'inc';
+    title?: ReactNode;
+    sortId?: string;
+    getValue?: (row: T, dir: 'inc' | 'dec') => any;
+    isDate?: boolean;
+    columnId?: string;
+    order?: number;
+};
+type I_flatRow<T> = T & {
+    _parent?: T;
+    _childsLength?: number;
+};
+export type I_useEntity<T, F> = {
+    sync: I_useSync<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;
+    };
+    fa?: boolean;
+};
+export declare const useEntity: <T, F>(p: I_useEntity<T, F>) => {
+    data: T[];
+    changeData: (data: T[]) => Promise<void>;
+    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;
+    getNodes: <R>(p: {
+        row?: T;
+        filter?: (row: T) => boolean;
+        map?: (row: I_flatRow<T>) => false | R;
+    }) => R[];
+    getRowAndParentsById: (p: {
+        rowId: string | number;
+    }) => {
+        row?: T;
+        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;
+    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[]>;
+    };
+    initData: 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 {};

package/index.js

@@ -0,0 +1,491 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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';
+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
+    });
+    const sync = useSync(p.sync);
+    const [data, setData] = useState(p.sync.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();
+        if (res !== false) {
+            setData(res);
+        }
+    });
+    useEffect(() => { fetchData(); }, []);
+    const changeData = (data) => __awaiter(void 0, void 0, void 0, function* () {
+        const res = yield sync.saveData(data);
+        if (res !== false) {
+            dataRef.current = data;
+            setData(data);
+        }
+    });
+    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 })); }),
+        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 })); }),
+        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 })); }),
+        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 })),
+        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);
+    };
+    useEffect(() => { updateFilteredRows(p.getRows()); }, [filter]);
+    return { filter, changeFilter, filteredData, updateFilteredRows };
+};
+class EntityClass {
+    constructor(p) {
+        this.getRowAndParentsById_req = (rows, id, parents, result) => {
+            if (result.row) {
+                return;
+            }
+            for (let i = 0; i < rows.length; i++) {
+                const row = rows[i];
+                if (this.params.getId(row) === id) {
+                    result.row = row;
+                    result.parents = parents;
+                    return;
+                }
+                const childs = !!this.params.getChilds ? (this.params.getChilds(row) || []) : undefined;
+                if (childs && childs.length) {
+                    this.getRowAndParentsById_req(childs, id, [...parents, row], result);
+                }
+            }
+        };
+        this.addToParent = (p) => {
+            const { getChilds, setChilds } = this.params;
+            const { parentRow, row } = p;
+            if (!getChilds || !setChilds) {
+                return row;
+            }
+            const childs = getChilds ? (getChilds(parentRow) || []) : undefined;
+            if (!childs) {
+                return row;
+            }
+            return setChilds(parentRow, [...childs, row]) || row;
+        };
+        this.editByParent = (p) => {
+            const { parentRow, row } = p;
+            const { getChilds, setChilds, getId } = this.params;
+            if (!getChilds || !setChilds) {
+                return parentRow;
+            }
+            const rowId = getId(row);
+            const childs = getChilds(parentRow);
+            if (!childs) {
+                return parentRow;
+            }
+            const newChilds = childs.map((o) => getId(o) === rowId ? row : o);
+            return setChilds(parentRow, newChilds) || parentRow;
+        };
+        this.removeChild = (p) => {
+            const { parentRow, rowId, rows } = p;
+            const { getChilds, setChilds, getId } = this.params;
+            if (!getChilds || !setChilds) {
+                return rows;
+            }
+            let parentChilds = getChilds(parentRow);
+            if (!parentChilds || !parentChilds.length) {
+                return rows;
+            }
+            parentChilds = parentChilds.filter((o) => getId(o) !== rowId);
+            const res = setChilds(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.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.walk = (p) => {
+            var _a;
+            const { getChilds } = this.params;
+            if (!p.childs) {
+                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))
+                    continue;
+                const mapped = p.map ? p.map(flat) : flat;
+                if (mapped !== false) {
+                    p.result.push(mapped);
+                }
+                const subchilds = getChilds === null || getChilds === void 0 ? void 0 : getChilds(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.sort_req = (p) => {
+            const { getChilds, setChilds } = this.params;
+            const { rows, sorts, result, parentRow } = p;
+            let sortedChilds = [];
+            if (!parentRow) {
+                sortedChilds = SortArray(rows, sorts);
+                result.rows = sortedChilds;
+            }
+            else {
+                if (!getChilds || !setChilds) {
+                    return;
+                }
+                const childs = this.getChilds(parentRow);
+                if (childs && childs.length) {
+                    sortedChilds = SortArray(childs, p.sorts);
+                    const fixedParent = setChilds(parentRow, sortedChilds);
+                    p.result.rows = this.edit({ row: fixedParent, rows: p.result.rows });
+                }
+            }
+            for (let i = 0; i < sortedChilds.length; i++) {
+                this.sort_req({ parentRow: sortedChilds[i], sorts, result, rows });
+            }
+        };
+        this.editChilds_req = (rows, callback, result) => {
+            const { getChilds } = this.params;
+            if (!getChilds) {
+                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);
+                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;
+                    }
+                }
+            }
+            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]];
+                }
+                for (let i = 1; i < groupKeys.length; i++) {
+                    const groupKey = groupKeys[i];
+                    temp[groupKey] = temp[groupKey] || {};
+                    temp = temp[groupKey];
+                }
+                for (const field in values) {
+                    const value = values[field];
+                    if (Array.isArray(value)) {
+                        temp[field] = temp[field] || [];
+                        temp[field] = temp[field].concat(value);
+                    }
+                    else if (typeof value === 'number') {
+                        temp[field] = (temp[field] || 0) + value;
+                    }
+                }
+            }
+            return getGroup ? res : res['_all'];
+        };
+        this.add = (p) => {
+            const { rows, row, parentId } = p;
+            const newRow = this.params.setId(row);
+            if (parentId !== undefined) {
+                const res = this.getRowAndParentsById({ rowId: parentId, rows });
+                if (!res.row) {
+                    return rows;
+                }
+                const res1 = this.addToParent({ parentRow: res.row, row: newRow });
+                return this.edit({ row: res1, rows });
+            }
+            else {
+                return [...rows, newRow];
+            }
+        };
+        this.editRoot = (rows, row) => {
+            const { getId } = this.params;
+            return rows.map((o) => getId(o) === getId(row) ? row : o);
+        };
+        this.edit = (p) => {
+            const { getChilds, setChilds } = this.params;
+            const { row, rows } = p;
+            const rowId = this.params.getId(row);
+            if (!!getChilds && !!setChilds) {
+                let parentRow = this.getParentByRowId({ rowId, rows });
+                if (parentRow) {
+                    parentRow = this.editByParent({ parentRow, row });
+                    return this.edit({ row: parentRow, rows: p.rows });
+                }
+                else {
+                    const res = this.editRoot(rows, row);
+                    console.log(res);
+                    return res;
+                }
+            }
+            else {
+                return this.editRoot(rows, row);
+            }
+        };
+        this.remove = (p) => {
+            const { getId } = this.params;
+            const { rowId, rows } = p;
+            const parentResult = this.getParentByRowId({ rowId, rows });
+            if (parentResult) {
+                return this.removeChild({ parentRow: parentResult, rowId, rows });
+            }
+            else {
+                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.getNodes = (params) => {
+            const result = [];
+            this.walk({ childs: params.row ? [params.row] : params.rows, filter: params.filter, map: params.map, result, parentIds: [] });
+            return result;
+        };
+        this.getChilds = (row) => !this.params.getChilds ? undefined : this.params.getChilds(row);
+        this.getRowAndParentsById = (p) => {
+            let result = { parents: [] };
+            this.getRowAndParentsById_req(p.rows, p.rowId, [], result);
+            return result;
+        };
+        this.getParentByRowId = (p) => {
+            const res = this.getRowAndParentsById(p);
+            if (!res.row) {
+                return;
+            }
+            const { parents } = res;
+            if (!parents.length) {
+                return;
+            }
+            return parents[parents.length - 1];
+        };
+        this.moveTo = (p) => {
+            const { fromId, toId, rows } = p;
+            const parentResult = this.getRowAndParentsById({ rowId: toId, rows });
+            if (!parentResult.row) {
+                return p.rows;
+            }
+            const childResult = this.getRowAndParentsById({ rowId: fromId, rows });
+            if (!childResult.row) {
+                return p.rows;
+            }
+            const editedRows = this.remove({ rowId: fromId, rows });
+            return this.edit({ row: this.addToParent({ parentRow: parentResult.row, row: childResult.row }), rows: editedRows });
+        };
+        this.editChilds = (p) => {
+            const { rows, callback } = p;
+            const result = { rows };
+            this.editChilds_req(rows ? [...rows] : rows, callback, result);
+            return result.rows;
+        };
+        this.duplicate = (p) => {
+            const { getId, setId } = this.params;
+            const { rows, row } = p;
+            const rowId = getId(row);
+            const parent = this.getParentByRowId({ rowId, rows });
+            const parentId = parent ? getId(parent) : undefined;
+            const newRow = setId(row);
+            return this.add({ row: newRow, parentId, rows });
+        };
+        this.sort = (p) => {
+            const fixedSorts = p.sorts.map((sort) => ({ getValue: (row) => row[sort.columnId], dir: sort.dir }));
+            const result = { rows: p.rows };
+            const { rows, parentRow } = p;
+            this.sort_req({ sorts: fixedSorts, parentRow, result, rows });
+            return result.rows;
+        };
+        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);
+        }
+    };
+    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" })] }));
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "aio-entity",
+    "version": "1.0.0",
+    "description": "kit",
+    "main": "index.js",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/mohammadFeiz/aio-entity.git"
+    },
+    "dependencies": {
+        "aio-table": "latest",
+        "aio-cordova": "latest",
+        "aio-entity": "latest",
+        "aio-input": "latest",
+        "aio-utils": "latest",
+        "aio-date": "latest"
+    },
+    "keywords": [
+        "login",
+        "otp",
+        "jwt"
+    ],
+    "author": "mohammad sharif feiz feiz.ms@gmail.com",
+    "license": "ISC",
+    "bugs": {
+        "url": "https://github.com/mohammadFeiz/aio-entity/issues"
+    },
+    "homepage": "https://github.com/mohammadFeiz/aio-entity#readme"
+}