@ngutil/data 0.0.10

package/esm2022/query/grouper.mjs

@@ -0,0 +1,67 @@
+export function groupBy(grouper) {
+    return grouperCompile(grouper);
+}
+function grouperCompile(grouper) {
+    return _ => undefined;
+}
+export function grouperMerge(...groupers) {
+    return undefined;
+}
+// import { Primitive } from "utility-types"
+// import { Eval, Flatten } from "@ngutil/common"
+// import { type Model } from "./query"
+// import { SorterFn } from "./sorter"
+// export interface Grouped<T extends Model> {
+//     items: T[]
+//     groups: Group<T>
+// }
+// export type GrouperFn<T extends Model> = (items: T[]) => any
+// export type GroupKey<T extends Model> = (item: T, index: number) => Primitive[]
+// export type GroupItemIsMatch<T extends Model> = (item: T, index: number) => boolean
+// export interface GrouperX<T extends Model> {
+//     name: string
+//     title?: string
+//     isMatch?: GroupKey<T>
+//     [key: string]: any
+// }
+// export interface GrouperXNormalized<T extends Model> extends GrouperX<T> {
+//     key: GroupKey<T>
+// }
+// type _Groupers<T extends Model, F> = keyof F | Grouper<T>
+// export type Grouper<T extends Model, F = Flatten<T>> = Eval<Array<_Groupers<T, F>>>
+// export type GrouperNormalized<T extends Model> = { [key: string]: GrouperXNormalized<T> }
+// export interface Group<T extends Model, G extends Grouper<T> = Grouper<T>> {
+//     grouper: G
+//     begin: number
+//     end: number
+// }
+// /**
+//  * @example
+//  * ```ts
+//  * const grouped = groupBy(["status"])(items)
+//  * // expexted: {[status]: [...items]}
+//  *
+//  * const grouped = groupBy(["name", "age"])(items)
+//  * // expected {[status]: {[age]: [...items]}}
+//  *
+//  * const STATUS_LABELS = {active: "Active", inactive: "Inactive"}
+//  * const grouped = groupBy([(item) => (STATUS_LABELS[item.status] || "Undefined")])(items)
+//  * // expected {["Active" | "Inactive" | "Undefined"]: [...items]}
+//  *
+//  * const grouped = groupBy([(item) => (STATUS_LABELS[item.status] || "Undefined"), "age"])(items)
+//  * // expected {["Active" | "Inactive" | "Undefined"]: {[age]: [...items]}}
+//  * ```
+//  */
+// export function groupBy<T extends Model>(groupers: Grouper<T>): SorterFn<T> {
+//     return (_a, _b) => 0
+// }
+// export function grouperNormalize() {}
+// export function grouperCompile<T extends Model>(groupers: Grouper<T>): GrouperFn<T> {
+//     return _ => undefined
+// }
+// export function grouperMerge<T extends Model, F = Flatten<T>>(
+//     ...groupers: Array<Grouper<T, F> | undefined | null>
+// ): Grouper<T, F> | undefined {
+//     return undefined
+// }
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/query/index.mjs

@@ -0,0 +1,8 @@
+export { filterBy, filterMerge } from "./filter";
+export { groupBy, grouperMerge } from "./grouper";
+export { sortBy, sorterMerge } from "./sorter";
+export { slimBy, slimerMerge } from "./slimer";
+export { sliceMerge, sliceApply, sliceInsert, sliceToPages, sliceClamp, sliceEq } from "./slice";
+export { pathGetterCompile } from "./path";
+export { queryExecutor } from "./executor";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYXRhL3NyYy9xdWVyeS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQVUsUUFBUSxFQUFFLFdBQVcsRUFBWSxNQUFNLFVBQVUsQ0FBQTtBQUNsRSxPQUFPLEVBQVcsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUMxRCxPQUFPLEVBQVUsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLFVBQVUsQ0FBQTtBQUN0RCxPQUFPLEVBQVUsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLFVBQVUsQ0FBQTtBQUN0RCxPQUFPLEVBQVMsVUFBVSxFQUFFLFVBQVUsRUFBRSxXQUFXLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxPQUFPLEVBQUUsTUFBTSxTQUFTLENBQUE7QUFDdkcsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sUUFBUSxDQUFBO0FBRTFDLE9BQU8sRUFBRSxhQUFhLEVBQWlCLE1BQU0sWUFBWSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgRmlsdGVyLCBmaWx0ZXJCeSwgZmlsdGVyTWVyZ2UsIEZpbHRlck9wIH0gZnJvbSBcIi4vZmlsdGVyXCJcbmV4cG9ydCB7IEdyb3VwZXIsIGdyb3VwQnksIGdyb3VwZXJNZXJnZSB9IGZyb20gXCIuL2dyb3VwZXJcIlxuZXhwb3J0IHsgU29ydGVyLCBzb3J0QnksIHNvcnRlck1lcmdlIH0gZnJvbSBcIi4vc29ydGVyXCJcbmV4cG9ydCB7IFNsaW1lciwgc2xpbUJ5LCBzbGltZXJNZXJnZSB9IGZyb20gXCIuL3NsaW1lclwiXG5leHBvcnQgeyBTbGljZSwgc2xpY2VNZXJnZSwgc2xpY2VBcHBseSwgc2xpY2VJbnNlcnQsIHNsaWNlVG9QYWdlcywgc2xpY2VDbGFtcCwgc2xpY2VFcSB9IGZyb20gXCIuL3NsaWNlXCJcbmV4cG9ydCB7IHBhdGhHZXR0ZXJDb21waWxlIH0gZnJvbSBcIi4vcGF0aFwiXG5leHBvcnQgeyBRdWVyeSwgUXVlcnlSZXN1bHQgfSBmcm9tIFwiLi9xdWVyeVwiXG5leHBvcnQgeyBxdWVyeUV4ZWN1dG9yLCBRdWVyeUV4ZWN1dG9yIH0gZnJvbSBcIi4vZXhlY3V0b3JcIlxuIl19

package/esm2022/query/path.mjs

@@ -0,0 +1,18 @@
+import { flattenDepth } from "lodash";
+export function pathGetterCompile(path) {
+    if (!path || path.length === 0) {
+        throw new Error("Empty path");
+    }
+    return path.split(".").reduce((parent, part) => makeGetter(part, parent), (obj) => (obj == null ? [] : [obj]));
+}
+const IsNumber = /^\d+$/;
+function makeGetter(part, parent) {
+    if (part === "*") {
+        return obj => flattenDepth(parent(obj), 1);
+    }
+    else {
+        const key = IsNumber.test(part) ? Number(part) : part;
+        return obj => parent(obj).map(v => (v != null ? v[key] : undefined));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/query/query.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYXRhL3NyYy9xdWVyeS9xdWVyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdHlwZSBEZWVwUmVhZG9ubHkgfSBmcm9tIFwiQG5ndXRpbC9jb21tb25cIlxuXG5pbXBvcnQgeyB0eXBlIE1vZGVsIH0gZnJvbSBcIi4uL21vZGVsXCJcbmltcG9ydCB7IHR5cGUgRmlsdGVyIH0gZnJvbSBcIi4vZmlsdGVyXCJcbmltcG9ydCB7IHR5cGUgR3JvdXBlciB9IGZyb20gXCIuL2dyb3VwZXJcIlxuaW1wb3J0IHsgdHlwZSBTbGljZSB9IGZyb20gXCIuL3NsaWNlXCJcbmltcG9ydCB7IHR5cGUgU2xpbWVyIH0gZnJvbSBcIi4vc2xpbWVyXCJcbmltcG9ydCB7IHR5cGUgU29ydGVyIH0gZnJvbSBcIi4vc29ydGVyXCJcblxuZXhwb3J0IGludGVyZmFjZSBRdWVyeTxUIGV4dGVuZHMgTW9kZWw+IHtcbiAgICBmaWx0ZXI/OiBEZWVwUmVhZG9ubHk8RmlsdGVyPFQ+PlxuICAgIHNvcnRlcj86IERlZXBSZWFkb25seTxTb3J0ZXI8VD4+XG4gICAgc2xpbWVyPzogRGVlcFJlYWRvbmx5PFNsaW1lcjxUPj5cbiAgICBncm91cGVyPzogRGVlcFJlYWRvbmx5PEdyb3VwZXI8VD4+XG4gICAgc2xpY2U/OiBEZWVwUmVhZG9ubHk8U2xpY2U+XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUXVlcnlSZXN1bHQ8VCBleHRlbmRzIE1vZGVsPiB7XG4gICAgaXRlbXM6IHJlYWRvbmx5IFRbXVxuICAgIHRvdGFsPzogbnVtYmVyXG4gICAgZ3JvdXBzPzogYW55W11cbn1cbiJdfQ==

package/esm2022/query/slice.mjs

@@ -0,0 +1,61 @@
+import { deepClone } from "@ngutil/common";
+export function sliceMerge(...slices) {
+    let result = undefined;
+    for (const slice of slices) {
+        if (slice == null) {
+            continue;
+        }
+        if (result == null) {
+            result = deepClone(slice);
+        }
+        else {
+            result = { ...result, ...slice };
+        }
+    }
+    return result;
+}
+/**
+ * Apply slice to array, and force the result length to equal with Slice length,
+ * so fill array with undefined if not enought elements
+ */
+export function sliceApply(slice, array) {
+    const result = array.slice(slice.start, slice.end);
+    result.length = slice.end - slice.start;
+    return result;
+}
+/**
+ * @returns Page numbers, eg.: `[10, 11, 12, 13, ...]`
+ */
+export function sliceToPages(slice) {
+    if (slice.pageSize == null) {
+        throw new Error("Missing `step` from slice");
+    }
+    const start = Math.floor(slice.start / slice.pageSize);
+    const end = Math.ceil(slice.end / slice.pageSize);
+    return Array.from({ length: end - start }, (_, i) => start + i);
+}
+export function sliceInsert(slice, array, newItems) {
+    if (slice.start === slice.end) {
+        return array;
+    }
+    let result = array.slice(0, slice.start);
+    result.length = slice.start;
+    result = result.concat(newItems);
+    result.length = slice.end;
+    return result.concat(array.slice(slice.end));
+}
+export function sliceClamp(slice, constraint) {
+    return {
+        start: Math.max(slice.start, constraint.start),
+        end: Math.min(slice.end, constraint.end),
+        pageSize: slice.pageSize
+    };
+}
+export function sliceEq(a, b) {
+    return a.start === b.start && a.end === b.end && a.pageSize === b.pageSize;
+}
+// TODO: sliceOverlap(other: Slice): Slice
+// TODO: sliceIncludes(other: Slice): boolean
+// TODO: sliceConcat(...slices: Slice[]): Slice[]
+// TODO: sliceDiff(slice: Slice): Slice[]
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/query/slimer.mjs

@@ -0,0 +1,7 @@
+export function slimBy(slimer) { }
+export function slimerNormalize(slimer) { }
+function slimerCompile(slimer) {
+    return item => item;
+}
+export function slimerMerge(...slimers) { }
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpbWVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGF0YS9zcmMvcXVlcnkvc2xpbWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWlCQSxNQUFNLFVBQVUsTUFBTSxDQUFrQixNQUFpQixJQUFTLENBQUM7QUFFbkUsTUFBTSxVQUFVLGVBQWUsQ0FBa0IsTUFBaUIsSUFBUyxDQUFDO0FBRTVFLFNBQVMsYUFBYSxDQUFrQixNQUFpQjtJQUNyRCxPQUFPLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFBO0FBQ3ZCLENBQUM7QUFFRCxNQUFNLFVBQVUsV0FBVyxDQUFrQixHQUFHLE9BQWtCLElBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1vZGVsIH0gZnJvbSBcIi4uL21vZGVsXCJcblxuLyoqXG4gKiBAZXhtYXBsZVxuICogYGBgdHNcbiAqIFtcbiAqICBcImZpZWxkX25hbWVcIixcbiAqICB7XCJjaGlsZF9uYW1lXCI6IFtcImNoaWxkX2ZpZWxkX25hbWVcIl19LFxuICogIHtcImNoaWxkcmVuXCI6IFtcImNoaWxkcmVuX2ZpZWxkX25hbWVcIiwge1wiJHR5cGVcIjogQXJ0aWNsZSwgc2xpbWVyOiBbXCJpZFwiLCBcInRpdGxlXCJdfV19LFxuICogIHtcIiR0eXBlXCI6IEVtcGxveWVlLCBzbGltZXI6IFtcIm5hbWVcIl19LlxuICogIHtcIiRmaWx0ZXJcIjogRmlsdGVyPFQsIEY+fVxuICogXVxuICogYGBgXG4gKi9cbmV4cG9ydCB0eXBlIFNsaW1lcjxUIGV4dGVuZHMgTW9kZWw+ID0gYW55XG5leHBvcnQgdHlwZSBTbGltZXJGbjxUPiA9IChpdGVtOiBUKSA9PiBUXG5cbmV4cG9ydCBmdW5jdGlvbiBzbGltQnk8VCBleHRlbmRzIE1vZGVsPihzbGltZXI6IFNsaW1lcjxUPik6IHZvaWQge31cblxuZXhwb3J0IGZ1bmN0aW9uIHNsaW1lck5vcm1hbGl6ZTxUIGV4dGVuZHMgTW9kZWw+KHNsaW1lcjogU2xpbWVyPFQ+KTogdm9pZCB7fVxuXG5mdW5jdGlvbiBzbGltZXJDb21waWxlPFQgZXh0ZW5kcyBNb2RlbD4oc2xpbWVyOiBTbGltZXI8VD4pOiBTbGltZXJGbjxUPiB7XG4gICAgcmV0dXJuIGl0ZW0gPT4gaXRlbVxufVxuXG5leHBvcnQgZnVuY3Rpb24gc2xpbWVyTWVyZ2U8VCBleHRlbmRzIE1vZGVsPiguLi5zbGltZXJzOiBTbGltZXI8VD4pOiB2b2lkIHt9XG4iXX0=

package/esm2022/query/sorter.mjs

@@ -0,0 +1,166 @@
+import { flattenDeep, isEqual } from "lodash";
+import { deepClone, isPlainObject } from "@ngutil/common";
+import { pathGetterCompile } from "./path";
+/**
+ * @example
+ *```ts
+ * items.toSorted(sortBy([{"author.name": "asc"}]))
+ * ```
+ */
+export function sortBy(sorters) {
+    if (sorters.length === 0) {
+        throw new Error("Empty sorter");
+    }
+    return _sorterCompile(sorters);
+}
+/**
+ * Normalize sorter definition
+ *
+ * @example
+ * ```ts
+ * normalizeSorter([{id: "asc"}]) -> [{path: "id", isAsc: true, emptyFirst: true}]
+ * normalizeSorter([{id: {dir: "desc", emptyFirst: false}}]) -> [{path: "id", isAsc: false, emptyFirst: false}]
+ * ```
+ */
+export function sorterNormalize(sorters) {
+    return flattenDeep(sorters.map((s) => Object.entries(s).map(([k, v]) => {
+        if (typeof v === "string") {
+            const isAsc = v.toLowerCase() === "asc";
+            return { path: k, isAsc, emptyFirst: isAsc ? false : true };
+        }
+        else if (isPlainObject(v)) {
+            return {
+                path: k,
+                isAsc: (v.dir || "asc").toLowerCase() === "asc",
+                emptyFirst: v.emptyFirst == null ? true : !!v.emptyFirst
+            };
+        }
+        else {
+            throw new Error(`Invalid sorter: ${v}`);
+        }
+    })));
+}
+function _sorterCompile(sorters) {
+    if (sorters.length === 0) {
+        return (_a, _b) => 0;
+    }
+    const norm = sorterNormalize(sorters).map(createComparator);
+    if (norm.length === 1) {
+        return norm[0];
+    }
+    const initial = norm.pop();
+    return norm.reduceRight((next, curr) => (a, b) => {
+        const r = curr(a, b);
+        return r === 0 ? next(a, b) : r;
+    }, initial);
+}
+function createComparator({ path, isAsc, emptyFirst }) {
+    const getter = pathGetterCompile(path);
+    if (isAsc) {
+        return (a, b) => compare(getter(a), getter(b), emptyFirst);
+    }
+    else {
+        return (a, b) => compare(getter(a), getter(b), !emptyFirst) * -1;
+    }
+}
+export function compare(a, b, emptyFirst) {
+    // console.log("COMPARE", a, b)
+    if (a == null && b != null) {
+        return emptyFirst === true ? -1 : 1;
+    }
+    else if (a != null && b == null) {
+        return emptyFirst === true ? 1 : -1;
+    }
+    else if (a == null && b == null) {
+        return 0;
+    }
+    else if (isEqual(a, b)) {
+        return 0;
+    }
+    else if (typeof a === "number" && typeof b === "number") {
+        return a - b;
+    }
+    else if (typeof a === "string" && typeof b === "string") {
+        const al = a.length;
+        const bl = b.length;
+        // if both lengths is 0 the code execution not reach that point, because a === b
+        if (emptyFirst === true) {
+            if (al === 0) {
+                return -1;
+            }
+            else if (bl === 0) {
+                return 1;
+            }
+        }
+        else {
+            if (al === 0) {
+                return 1;
+            }
+            else if (bl === 0) {
+                return -1;
+            }
+        }
+        return a.localeCompare(b);
+    }
+    else if (Array.isArray(a) && Array.isArray(b)) {
+        const al = a.length;
+        const bl = b.length;
+        const l = Math.min(al, bl);
+        for (let i = 0; i < l; i++) {
+            const res = compare(a[i], b[i], emptyFirst);
+            if (res !== 0) {
+                return res;
+            }
+        }
+        if (al === bl) {
+            return 0;
+        }
+        if (emptyFirst === true) {
+            if (al === 0) {
+                return -1;
+            }
+            else if (bl === 0) {
+                return 1;
+            }
+        }
+        else {
+            if (al === 0) {
+                return 1;
+            }
+            else if (bl === 0) {
+                return -1;
+            }
+        }
+        return al - bl;
+    }
+    else if (isPlainObject(a) && isPlainObject(b)) {
+        return JSON.stringify(a).localeCompare(JSON.stringify(b));
+    }
+    return a > b ? -1 : 1;
+}
+export function sorterMerge(...sorters) {
+    let result;
+    for (const sorter of sorters) {
+        if (sorter == null) {
+            continue;
+        }
+        if (result == null) {
+            result = deepClone(sorter);
+            continue;
+        }
+        for (const sentry of sorter) {
+            for (const [k, v] of Object.entries(sentry)) {
+                const existing = result.find((value) => value[k] != null);
+                if (existing) {
+                    ;
+                    existing[k] = deepClone(v);
+                }
+                else {
+                    result.push({ [k]: deepClone(v) });
+                }
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sorter.js","sourceRoot":"","sources":["../../../../../packages/data/src/query/sorter.ts"],"names":[],"mappings":"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","sourcesContent":["import { flattenDeep, isEqual } from \"lodash\"\n\nimport { deepClone, isPlainObject } from \"@ngutil/common\"\n\nimport { Model } from \"../model\"\nimport { pathGetterCompile } from \"./path\"\n\nexport type SorterFn<T = any> = (a: T, b: T) => number\n\nexport const enum SortDirection {\n    Asc = \"asc\",\n    Desc = \"desc\"\n}\n\ntype Direction = SortDirection.Asc | SortDirection.Desc | \"asc\" | \"desc\"\ntype DirectionExtra = { dir: Direction; emptyFirst: boolean }\n\ntype _Sorter<F> = { [K in keyof F]: { [key in K]: Direction | DirectionExtra } }[keyof F]\n// TODO: fix recursion\n// export type Sorter<T extends Model> = Array<_Sorter<Flatten<T>>>\nexport type Sorter<T extends Model> = Array<{ [key: string]: Direction | DirectionExtra }>\n\ntype NormalizedEntry = { path: string; isAsc: boolean; emptyFirst: boolean }\nexport type SorterNormalized = Array<NormalizedEntry>\n\n/**\n * @example\n *```ts\n * items.toSorted(sortBy([{\"author.name\": \"asc\"}]))\n * ```\n */\nexport function sortBy<T extends Model>(sorters: Sorter<T>): SorterFn<T> {\n    if (sorters.length === 0) {\n        throw new Error(\"Empty sorter\")\n    }\n    return _sorterCompile<T>(sorters) as any\n}\n\n/**\n * Normalize sorter definition\n *\n * @example\n * ```ts\n * normalizeSorter([{id: \"asc\"}]) -> [{path: \"id\", isAsc: true, emptyFirst: true}]\n * normalizeSorter([{id: {dir: \"desc\", emptyFirst: false}}]) -> [{path: \"id\", isAsc: false, emptyFirst: false}]\n * ```\n */\nexport function sorterNormalize<T extends Model>(sorters: Sorter<T>): SorterNormalized {\n    return flattenDeep(\n        (sorters as any).map((s: any) =>\n            Object.entries(s).map(([k, v]) => {\n                if (typeof v === \"string\") {\n                    const isAsc = v.toLowerCase() === \"asc\"\n                    return { path: k, isAsc, emptyFirst: isAsc ? false : true }\n                } else if (isPlainObject(v)) {\n                    return {\n                        path: k,\n                        isAsc: ((v as DirectionExtra).dir || \"asc\").toLowerCase() === \"asc\",\n                        emptyFirst: (v as DirectionExtra).emptyFirst == null ? true : !!(v as DirectionExtra).emptyFirst\n                    }\n                } else {\n                    throw new Error(`Invalid sorter: ${v}`)\n                }\n            })\n        )\n    )\n}\n\nfunction _sorterCompile<T extends Model>(sorters: Sorter<T>): SorterFn<T> {\n    if (sorters.length === 0) {\n        return (_a, _b) => 0\n    }\n\n    const norm = sorterNormalize<T>(sorters).map(createComparator)\n    if (norm.length === 1) {\n        return norm[0]\n    }\n\n    const initial = norm.pop()!\n    return norm.reduceRight<SorterFn<T>>(\n        (next, curr) => (a, b) => {\n            const r = curr(a, b)\n            return r === 0 ? next(a, b) : r\n        },\n        initial\n    )\n}\n\nfunction createComparator({ path, isAsc, emptyFirst }: NormalizedEntry): SorterFn {\n    const getter = pathGetterCompile(path)\n    if (isAsc) {\n        return (a, b) => compare(getter(a), getter(b), emptyFirst)\n    } else {\n        return (a, b) => compare(getter(a), getter(b), !emptyFirst) * -1\n    }\n}\n\nexport function compare(a: any, b: any, emptyFirst: boolean): number {\n    // console.log(\"COMPARE\", a, b)\n    if (a == null && b != null) {\n        return emptyFirst === true ? -1 : 1\n    } else if (a != null && b == null) {\n        return emptyFirst === true ? 1 : -1\n    } else if (a == null && b == null) {\n        return 0\n    } else if (isEqual(a, b)) {\n        return 0\n    } else if (typeof a === \"number\" && typeof b === \"number\") {\n        return a - b\n    } else if (typeof a === \"string\" && typeof b === \"string\") {\n        const al = a.length\n        const bl = b.length\n        // if both lengths is 0 the code execution not reach that point, because a === b\n        if (emptyFirst === true) {\n            if (al === 0) {\n                return -1\n            } else if (bl === 0) {\n                return 1\n            }\n        } else {\n            if (al === 0) {\n                return 1\n            } else if (bl === 0) {\n                return -1\n            }\n        }\n        return a.localeCompare(b)\n    } else if (Array.isArray(a) && Array.isArray(b)) {\n        const al = a.length\n        const bl = b.length\n        const l = Math.min(al, bl)\n\n        for (let i = 0; i < l; i++) {\n            const res = compare(a[i], b[i], emptyFirst)\n            if (res !== 0) {\n                return res\n            }\n        }\n\n        if (al === bl) {\n            return 0\n        }\n\n        if (emptyFirst === true) {\n            if (al === 0) {\n                return -1\n            } else if (bl === 0) {\n                return 1\n            }\n        } else {\n            if (al === 0) {\n                return 1\n            } else if (bl === 0) {\n                return -1\n            }\n        }\n\n        return al - bl\n    } else if (isPlainObject(a) && isPlainObject(b)) {\n        return JSON.stringify(a).localeCompare(JSON.stringify(b))\n    }\n\n    return a > b ? -1 : 1\n}\n\nexport function sorterMerge<T extends Model>(...sorters: Array<Sorter<T> | undefined | null>): Sorter<T> | undefined {\n    let result: Sorter<T> | undefined\n\n    for (const sorter of sorters) {\n        if (sorter == null) {\n            continue\n        }\n        if (result == null) {\n            result = deepClone(sorter)\n            continue\n        }\n\n        for (const sentry of sorter) {\n            for (const [k, v] of Object.entries(sentry)) {\n                const existing = (result as any).find((value: any) => value[k] != null)\n                if (existing) {\n                    ;(existing as any)[k] = deepClone(v)\n                } else {\n                    result.push({ [k]: deepClone(v) } as any)\n                }\n            }\n        }\n    }\n\n    return result\n}\n"]}