@ngutil/data 0.0.10

package/README.md

@@ -0,0 +1,7 @@
+# list
+
+## Example
+
+```html
+<xyz-grid [nuList]="src" [nuListFilter]="filter" [nuListSorter]="sorter" [nuListTrackBy]="trackBy"> </xyz-grid>
+```

package/esm2022/index.mjs

@@ -0,0 +1,3 @@
+export { sortBy } from "./query/sorter";
+export { filterBy } from "./query/filter";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9kYXRhL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFZLE1BQU0sZ0JBQWdCLENBQUE7QUFDakQsT0FBTyxFQUFFLFFBQVEsRUFBWSxNQUFNLGdCQUFnQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgc29ydEJ5LCBTb3J0ZXJGbiB9IGZyb20gXCIuL3F1ZXJ5L3NvcnRlclwiXG5leHBvcnQgeyBmaWx0ZXJCeSwgRmlsdGVyRm4gfSBmcm9tIFwiLi9xdWVyeS9maWx0ZXJcIlxuIl19

package/esm2022/model/index.mjs

@@ -0,0 +1,2 @@
+export { ModelRefNorm, ModelMeta, ModelRefByIndex, ModelRefByKey, UnknownMeta } from "./meta";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYXRhL3NyYy9tb2RlbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBR0gsWUFBWSxFQUNaLFNBQVMsRUFJVCxlQUFlLEVBQ2YsYUFBYSxFQUNiLFdBQVcsRUFDZCxNQUFNLFFBQVEsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gICAgTW9kZWwsXG4gICAgTW9kZWxSZWYsXG4gICAgTW9kZWxSZWZOb3JtLFxuICAgIE1vZGVsTWV0YSxcbiAgICBNb2RlbE1ldGFQcm9wcyxcbiAgICBNb2RlbFJlZkZpbHRlcixcbiAgICBNb2RlbE1ldGFJbnB1dCxcbiAgICBNb2RlbFJlZkJ5SW5kZXgsXG4gICAgTW9kZWxSZWZCeUtleSxcbiAgICBVbmtub3duTWV0YVxufSBmcm9tIFwiLi9tZXRhXCJcbiJdfQ==

package/esm2022/model/meta.mjs

@@ -0,0 +1,125 @@
+import { isEqual } from "lodash";
+import { filterBy, pathGetterCompile } from "../query";
+export class ModelMeta {
+    static coerce(value) {
+        if (value instanceof ModelMeta) {
+            return value;
+        }
+        else {
+            return new ModelMeta(value);
+        }
+    }
+    #getKey;
+    constructor(props) {
+        this.keys = props.keys;
+        if (this.keys.length > 0) {
+            const getters = this.keys.map(pathGetterCompile);
+            if (props.trackBy == null) {
+                this.trackBy = (index, item) => getters.map(p => p(item)).join("∀");
+            }
+            else {
+                this.trackBy = props.trackBy;
+            }
+            this.#getKey = (item) => getters.map(p => p(item)).join("∀");
+        }
+        else {
+            if (props.trackBy == null) {
+                throw new Error("Can't compile track by function without `keys` declaration");
+            }
+            else {
+                this.trackBy = props.trackBy;
+            }
+        }
+    }
+    isEqual(a, b) {
+        return isEqual(a, b);
+    }
+    isEqualByTrack(a, b) {
+        if (a == null || b == null) {
+            return a == null && b == null;
+        }
+        if (a.index == null || b.index == null) {
+            return a.index == null && b.index == null;
+        }
+        if (a.model == null || b.model == null) {
+            return a.model == null && b.model == null;
+        }
+        return this.trackBy(a.index, a.model) === this.trackBy(b.index, b.model);
+    }
+    isEqualByKey(a, b) {
+        if (this.#getKey != null) {
+            if (a == null || b == null) {
+                return a == null && b == null;
+            }
+            return this.#getKey(a) === this.#getKey(b);
+        }
+        console.warn("Primary keys is not defined for", a, b);
+        return false;
+    }
+    normalizeRef(ref) {
+        if (ref instanceof ModelRefNorm) {
+            return ref;
+        }
+        if (ref.key != null && ref.index != null) {
+            throw new Error("Only provide `pk` or `index` value not both");
+        }
+        if (ref.key != null) {
+            const keyValue = (Array.isArray(ref.key) ? ref.key : [ref.key]);
+            if (keyValue.length > 0) {
+                if (this.keys.length === 0) {
+                    throw new Error("Can't normalize ref without `keys`");
+                }
+                if (keyValue.length !== this.keys.length) {
+                    throw new Error(`Wrong number of \`key\` values for this keys: [${this.keys.join(",")}]`);
+                }
+                return new ModelRefByKey(keyValue, this.keys);
+            }
+            else {
+                console.warn("Empty key in ModelRef", ref);
+            }
+        }
+        if (ref.index != null) {
+            return new ModelRefByIndex(ref.index);
+        }
+        throw new Error("Missing `key` or `index` value");
+    }
+}
+export class ModelRefNorm {
+    #filter;
+    toFilter() {
+        if (this.#filter == null) {
+            return (this.#filter = this._asFilter());
+        }
+        return this.#filter;
+    }
+}
+export class ModelRefByKey extends ModelRefNorm {
+    #keys;
+    constructor(key, keys) {
+        super();
+        this.key = key;
+        this.#keys = keys;
+    }
+    _asFilter() {
+        const filter = {};
+        for (let i = 0; i < this.#keys.length; i++) {
+            filter[this.#keys[i]] = this.key[i];
+        }
+        return filterBy(filter);
+    }
+}
+export class ModelRefByIndex extends ModelRefNorm {
+    constructor(index) {
+        super();
+        this.index = index;
+    }
+    _asFilter() {
+        return (item, index) => this.index === index;
+    }
+}
+export class UnknownMeta extends ModelMeta {
+    constructor() {
+        super({ keys: [], trackBy: (index) => index });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"meta.js","sourceRoot":"","sources":["../../../../../packages/data/src/model/meta.ts"],"names":[],"mappings":"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","sourcesContent":["import { TrackByFunction } from \"@angular/core\"\n\nimport { isEqual } from \"lodash\"\nimport { Primitive } from \"utility-types\"\n\nimport { filterBy, pathGetterCompile } from \"../query\"\n\nexport type Model = { [key: string]: any }\n\nexport type ModelRef = { key?: Primitive | Array<Primitive>; index?: number }\nexport type ModelRefFilter<T> = (item: T, index: number) => boolean\n\nexport interface ModelMetaProps<T extends Model> {\n    readonly keys: readonly string[]\n    readonly trackBy?: TrackByFunction<T>\n}\n\nexport type ModelMetaInput<T extends Model> = ModelMeta<T> | ModelMetaProps<T>\n\nexport type TrackedModel<T extends Model> = { index: number; model: T }\n\nexport class ModelMeta<T extends Model> implements ModelMetaProps<T> {\n    static coerce<M extends Model>(value: ModelMetaInput<M>): ModelMeta<M> {\n        if (value instanceof ModelMeta) {\n            return value\n        } else {\n            return new ModelMeta(value)\n        }\n    }\n\n    readonly keys: readonly string[]\n    readonly trackBy: TrackByFunction<T>\n    readonly #getKey?: (model: T) => string\n\n    constructor(props: ModelMetaProps<T>) {\n        this.keys = props.keys\n\n        if (this.keys.length > 0) {\n            const getters = this.keys.map(pathGetterCompile)\n            if (props.trackBy == null) {\n                this.trackBy = (index: number, item: T) => getters.map(p => p(item)).join(\"∀\")\n            } else {\n                this.trackBy = props.trackBy\n            }\n            this.#getKey = (item: T) => getters.map(p => p(item)).join(\"∀\")\n        } else {\n            if (props.trackBy == null) {\n                throw new Error(\"Can't compile track by function without `keys` declaration\")\n            } else {\n                this.trackBy = props.trackBy\n            }\n        }\n    }\n\n    isEqual(a: T, b: T): boolean {\n        return isEqual(a, b)\n    }\n\n    isEqualByTrack(a: TrackedModel<T>, b: TrackedModel<T>): boolean {\n        if (a == null || b == null) {\n            return a == null && b == null\n        }\n\n        if (a.index == null || b.index == null) {\n            return a.index == null && b.index == null\n        }\n\n        if (a.model == null || b.model == null) {\n            return a.model == null && b.model == null\n        }\n\n        return this.trackBy(a.index, a.model) === this.trackBy(b.index, b.model)\n    }\n\n    isEqualByKey(a: T, b: T): boolean {\n        if (this.#getKey != null) {\n            if (a == null || b == null) {\n                return a == null && b == null\n            }\n            return this.#getKey(a) === this.#getKey(b)\n        }\n        console.warn(\"Primary keys is not defined for\", a, b)\n        return false\n    }\n\n    normalizeRef(ref: ModelRef | ModelRefNorm): ModelRefNorm {\n        if (ref instanceof ModelRefNorm) {\n            return ref\n        }\n\n        if (ref.key != null && ref.index != null) {\n            throw new Error(\"Only provide `pk` or `index` value not both\")\n        }\n\n        if (ref.key != null) {\n            const keyValue = (Array.isArray(ref.key) ? ref.key : [ref.key]) as readonly Primitive[]\n\n            if (keyValue.length > 0) {\n                if (this.keys.length === 0) {\n                    throw new Error(\"Can't normalize ref without `keys`\")\n                }\n\n                if (keyValue.length !== this.keys.length) {\n                    throw new Error(`Wrong number of \\`key\\` values for this keys: [${this.keys.join(\",\")}]`)\n                }\n                return new ModelRefByKey(keyValue, this.keys)\n            } else {\n                console.warn(\"Empty key in ModelRef\", ref)\n            }\n        }\n\n        if (ref.index != null) {\n            return new ModelRefByIndex(ref.index)\n        }\n\n        throw new Error(\"Missing `key` or `index` value\")\n    }\n}\n\nexport abstract class ModelRefNorm {\n    readonly key?: readonly Primitive[]\n    readonly index?: number\n\n    #filter?: ModelRefFilter<any>\n    toFilter() {\n        if (this.#filter == null) {\n            return (this.#filter = this._asFilter())\n        }\n        return this.#filter\n    }\n\n    protected abstract _asFilter(): ModelRefFilter<any>\n}\n\nexport class ModelRefByKey extends ModelRefNorm {\n    override readonly key: readonly Primitive[]\n\n    #keys: readonly string[]\n    constructor(key: readonly Primitive[], keys: readonly string[]) {\n        super()\n        this.key = key\n        this.#keys = keys\n    }\n\n    protected _asFilter(): ModelRefFilter<any> {\n        const filter = {} as any\n        for (let i = 0; i < this.#keys.length; i++) {\n            filter[this.#keys[i]] = this.key[i]\n        }\n        return filterBy(filter)\n    }\n}\n\nexport class ModelRefByIndex extends ModelRefNorm {\n    override readonly index: number\n\n    constructor(index: number) {\n        super()\n        this.index = index\n    }\n\n    protected _asFilter(): ModelRefFilter<any> {\n        return (item: any, index: number) => this.index === index\n    }\n}\n\nexport class UnknownMeta<T extends Model> extends ModelMeta<T> {\n    constructor() {\n        super({ keys: [], trackBy: (index: number) => index })\n    }\n}\n"]}

package/esm2022/ngutil-data.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd1dGlsLWRhdGEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9kYXRhL3NyYy9uZ3V0aWwtZGF0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/query/executor.mjs

@@ -0,0 +1,76 @@
+import { groupBy, isEqual, sortBy } from "lodash";
+import { toSorted } from "@ngutil/common";
+import { filterBy } from "./filter";
+const INPUT = Symbol("INPUT");
+export function queryExecutor(query, previous) {
+    const executors = {
+        filterFn: filterExecutor(query.filter, previous?.filterFn),
+        sorterFn: sorterExecutor(query.sorter, previous?.sorterFn),
+        grouperFn: grouperExecutor(query.grouper, previous?.grouperFn),
+        slicerFn: sliceExecutor(query.slice, previous?.slicerFn)
+    };
+    const changed = previous == null || Object.entries(executors).some(([k, v]) => previous[k] !== v);
+    if (!changed) {
+        return previous;
+    }
+    const executor = (items) => {
+        if (items == null || items.length === 0) {
+            return { items: [], total: 0 };
+        }
+        let result = items;
+        if (executors.filterFn) {
+            result = result.filter(executors.filterFn);
+        }
+        if (executors.sorterFn) {
+            result = toSorted(result, executors.sorterFn);
+        }
+        const total = result.length;
+        // TODO: grouper
+        if (executors.slicerFn) {
+            result = executors.slicerFn(result);
+        }
+        return { items: result, total };
+    };
+    for (const [k, v] of Object.entries(executors)) {
+        Object.defineProperty(executor, k, {
+            value: v,
+            enumerable: true,
+            writable: false
+        });
+    }
+    return executor;
+}
+function filterExecutor(filter, prev) {
+    return compileExec(filter, prev, filterBy);
+}
+function sorterExecutor(sorter, prev) {
+    return compileExec(sorter, prev, sortBy);
+}
+function grouperExecutor(sorter, prev) {
+    return compileExec(sorter, prev, groupBy);
+}
+function sliceExecutor(slice, prev) {
+    return compileExec(slice, prev, sliceBy);
+}
+function sliceBy(slice) {
+    return (items) => items.slice(slice.start, slice.end);
+}
+function compileExec(input, prev, compiler) {
+    if (input == null) {
+        return undefined;
+    }
+    if (prev != null) {
+        // thorically input is readonly
+        if (prev[INPUT] === input || isEqual(prev[INPUT], input)) {
+            return prev;
+        }
+    }
+    const exec = compiler(input);
+    Object.defineProperty(exec, INPUT, {
+        value: input,
+        enumerable: true,
+        writable: false
+    });
+    return exec;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"executor.js","sourceRoot":"","sources":["../../../../../packages/data/src/query/executor.ts"],"names":[],"mappings":"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","sourcesContent":["import { groupBy, isEqual, sortBy } from \"lodash\"\nimport { Primitive } from \"utility-types\"\n\nimport { DeepReadonly, toSorted } from \"@ngutil/common\"\n\nimport { Model } from \"../model\"\nimport { Filter, filterBy } from \"./filter\"\nimport { Query, QueryResult } from \"./query\"\nimport { Slice } from \"./slice\"\nimport { Sorter } from \"./sorter\"\n\nconst INPUT = Symbol(\"INPUT\")\n\ninterface PartialExecutor {\n    [INPUT]: any\n}\n\nexport interface QueryExecutors<T extends Model> {\n    readonly filterFn?: FilterExecutor<T>\n    readonly sorterFn?: SorterExecutor<T>\n    readonly grouperFn?: GrouperExecutor<T>\n    readonly slicerFn?: SliceExecutor<T>\n}\n\nexport interface QueryExecutor<T extends Model> extends QueryExecutors<T> {\n    (items: readonly T[]): QueryResult<T>\n}\n\nexport function queryExecutor<T extends Model>(query: Query<T>, previous?: QueryExecutor<T>): QueryExecutor<T> {\n    const executors: QueryExecutors<T> = {\n        filterFn: filterExecutor(query.filter, previous?.filterFn),\n        sorterFn: sorterExecutor(query.sorter, previous?.sorterFn),\n        grouperFn: grouperExecutor(query.grouper, previous?.grouperFn),\n        slicerFn: sliceExecutor(query.slice, previous?.slicerFn)\n    }\n\n    const changed = previous == null || Object.entries(executors).some(([k, v]) => (previous as any)[k] !== v)\n    if (!changed) {\n        return previous\n    }\n\n    const executor = (items: readonly T[]): QueryResult<T> => {\n        if (items == null || items.length === 0) {\n            return { items: [], total: 0 }\n        }\n\n        let result: readonly T[] = items\n\n        if (executors.filterFn) {\n            result = result.filter(executors.filterFn)\n        }\n\n        if (executors.sorterFn) {\n            result = toSorted(result, executors.sorterFn)\n        }\n\n        const total = result.length\n\n        // TODO: grouper\n\n        if (executors.slicerFn) {\n            result = executors.slicerFn(result)\n        }\n\n        return { items: result, total }\n    }\n\n    for (const [k, v] of Object.entries(executors)) {\n        Object.defineProperty(executor, k, {\n            value: v,\n            enumerable: true,\n            writable: false\n        })\n    }\n\n    return executor\n}\n\ninterface FilterExecutor<T extends Model> extends PartialExecutor {\n    (item: T): boolean\n}\n\nfunction filterExecutor<T extends Model>(\n    filter?: DeepReadonly<Filter<T>>,\n    prev?: FilterExecutor<T>\n): FilterExecutor<T> | undefined {\n    return compileExec<T>(filter, prev, filterBy)\n}\n\ninterface SorterExecutor<T extends Model> extends PartialExecutor {\n    (a: T, b: T): number\n}\n\nfunction sorterExecutor<T extends Model>(\n    sorter?: DeepReadonly<Sorter<T>>,\n    prev?: SorterExecutor<T>\n): SorterExecutor<T> | undefined {\n    return compileExec<T>(sorter, prev, sortBy)\n}\n\ninterface GrouperExecutor<T extends Model> extends PartialExecutor {\n    (item: T): Primitive\n}\n\nfunction grouperExecutor<T extends Model>(\n    sorter?: DeepReadonly<Sorter<T>>,\n    prev?: GrouperExecutor<T>\n): GrouperExecutor<T> | undefined {\n    return compileExec<T>(sorter, prev, groupBy)\n}\n\ninterface SliceExecutor<T extends Model> extends PartialExecutor {\n    (items: readonly T[]): T[]\n}\n\nfunction sliceExecutor<T extends Model>(\n    slice?: DeepReadonly<Slice>,\n    prev?: SliceExecutor<T>\n): SliceExecutor<T> | undefined {\n    return compileExec<T>(slice, prev, sliceBy)\n}\n\nfunction sliceBy<T extends Model>(slice: Slice) {\n    return (items: T[]) => items.slice(slice.start, slice.end)\n}\n\nfunction compileExec<T extends Model>(input: any, prev: any, compiler: any): any {\n    if (input == null) {\n        return undefined\n    }\n\n    if (prev != null) {\n        // thorically input is readonly\n        if (prev[INPUT] === input || isEqual(prev[INPUT], input)) {\n            return prev\n        }\n    }\n\n    const exec = compiler(input) as any\n    Object.defineProperty(exec, INPUT, {\n        value: input,\n        enumerable: true,\n        writable: false\n    })\n    return exec\n}\n"]}

package/esm2022/query/filter.mjs

@@ -0,0 +1,288 @@
+import { flattenDeep, intersection } from "lodash";
+import { deepClone, isPlainObject } from "@ngutil/common";
+import { pathGetterCompile } from "./path";
+export const OPERATORS = [
+    "==" /* FilterOp.Eq */,
+    "===" /* FilterOp.EqStrict */,
+    "==*" /* FilterOp.EqInsesitive */,
+    "!=" /* FilterOp.Neq */,
+    "!==" /* FilterOp.NeqStrict */,
+    "!=*" /* FilterOp.NeqInsesitive */,
+    ">" /* FilterOp.Gt */,
+    ">*" /* FilterOp.GtInsesitive */,
+    ">=" /* FilterOp.Gte */,
+    ">=*" /* FilterOp.GteInsesitive */,
+    "<" /* FilterOp.Lt */,
+    "<*" /* FilterOp.LtInsesitive */,
+    "<=" /* FilterOp.Lte */,
+    "<=*" /* FilterOp.LteInsesitive */,
+    "%" /* FilterOp.Contains */,
+    "%*" /* FilterOp.ContainsInsesitive */,
+    "^" /* FilterOp.StartsWith */,
+    "^*" /* FilterOp.StartsWithInsesitive */,
+    "$" /* FilterOp.EndsWith */,
+    "$*" /* FilterOp.EndsWithInsesitive */,
+    "~" /* FilterOp.Regexp */,
+    "~*" /* FilterOp.RegexpInsesitive */,
+    "|" /* FilterOp.Or */,
+    "&" /* FilterOp.And */
+];
+export function asOperators(value) {
+    const ops = intersection(Object.keys(value), OPERATORS);
+    if (ops.length > 0) {
+        return ops.map(op => {
+            return { op, value: value[op] };
+        });
+    }
+    else {
+        return [{ op: "==" /* FilterOp.Eq */, value }];
+    }
+}
+/**
+ * @example
+ * ```ts
+ * items.filter(filterBy({id: 42}))
+ * ```
+ */
+export function filterBy(filters) {
+    return _filterCompile(filters);
+}
+// TODO: Normalize filter
+// type _Filter = { path: string; op: FilterOp; value: any }
+// type _Or = { "|": Array<_Filter> }
+// type _And = { "&": Array<_Filter> }
+// export type NormalizedFilter = _Or | _And
+// /**
+//  * @example
+//  * ```ts
+//  * normalizeFilter({id: 2, name: {"=*": "AnyName"}}) -> {id: {"==": 2}, name: {"=*": "AnyName"}}}
+//  * normalizeFilter({id: {">": 0, "<": 10}}) -> {"&": [{id: {">": 0}}, {id: {"<": 10}}]}
+//  * ```
+//  */
+// export function normalizeFilter<T extends Model>(filters: Filters<T>): Filters<T> {
+//     return _normalizeFilter(filters)
+// }
+// function _normalizeFilter(filters: any, path?: string): any {
+//     const result = {} as any
+//     for (const [path, v] of Object.entries(filters)) {
+//         switch (path) {
+//             case FilterOp.And:
+//                 if (!Array.isArray(v)) {
+//                     throw new Error("The '&' (AND) operator must have array type")
+//                 }
+//                 if (!result[FilterOp.And]) {
+//                     result[FilterOp.And] = []
+//                 }
+//                 result[FilterOp.And] = result[FilterOp.And].concat(v.map(f => _normalizeFilter(f)))
+//                 break
+//             case FilterOp.Or:
+//                 if (!Array.isArray(v)) {
+//                     throw new Error("The '|' (OR) operator must have array type")
+//                 }
+//                 if (!result[FilterOp.Or]) {
+//                     result[FilterOp.Or] = []
+//                 }
+//                 result[FilterOp.Or] = result[FilterOp.Or].concat(v.map(f => _normalizeFilter(f)))
+//                 break
+//             default:
+//                 for (const entry of asOperators(v)) {
+//                     switch (entry.op) {
+//                         case FilterOp.And:
+//                             if (!result[FilterOp.And]) {
+//                                 result[FilterOp.And] = []
+//                             }
+//                             result[FilterOp.And] = result[FilterOp.And].concat(
+//                                 entry.value.map((v: any) => _normalizeFilter(v, path))
+//                             )
+//                             break
+//                         case FilterOp.Or:
+//                             if (!result[FilterOp.Or]) {
+//                                 result[FilterOp.Or] = []
+//                             }
+//                             result[FilterOp.Or] = result[FilterOp.Or].concat(
+//                                 entry.value.map((v: any) => _normalizeFilter(v, path))
+//                             )
+//                             break
+//                         default:
+//                             if (!result[FilterOp.And]) {
+//                                 result[FilterOp.And] = []
+//                             }
+//                             result[FilterOp.And].push({ path, ...entry })
+//                     }
+//                 }
+//         }
+//     }
+//     return result
+// }
+function _filterCompile(filters) {
+    let getter;
+    const result = [];
+    for (const [pth, value] of Object.entries(filters)) {
+        switch (pth) {
+            case "&" /* FilterOp.And */:
+                if (!Array.isArray(value)) {
+                    throw new Error("Root '&' (AND) operator must have array type");
+                }
+                result.splice(result.length, 0, ...value.map((_filterCompile)));
+                break;
+            case "|" /* FilterOp.Or */:
+                if (!Array.isArray(value)) {
+                    throw new Error("Root '|' (OR) operator must have array type");
+                }
+                result.push(or_(value.map((_filterCompile))));
+                break;
+            default:
+                getter = pathGetterCompile(pth);
+                if (isPlainObject(value)) {
+                    result.push(and_(Object.entries(value).map(([op, opv]) => filterCompileOp(getter, op, opv))));
+                }
+                else {
+                    result.push(filterCompileOp(getter, "==" /* FilterOp.Eq */, value));
+                }
+                break;
+        }
+    }
+    return and_(result);
+}
+function filterCompileOp(getter, op, value) {
+    let lower;
+    let regex;
+    switch (op) {
+        case "==" /* FilterOp.Eq */:
+            // eslint-disable-next-line eqeqeq
+            return matcher(getter, v => v == value);
+        case "===" /* FilterOp.EqStrict */:
+            return matcher(getter, v => v === value);
+        case "==*" /* FilterOp.EqInsesitive */:
+            lower = String(value).toLocaleLowerCase();
+            return matcher(getter, v => String(v).toLocaleLowerCase() === lower);
+        case "!=" /* FilterOp.Neq */:
+            // eslint-disable-next-line eqeqeq
+            return matcher(getter, v => v != value);
+        case "!==" /* FilterOp.NeqStrict */:
+            return matcher(getter, v => v !== value);
+        case "!=*" /* FilterOp.NeqInsesitive */:
+            lower = String(value).toLocaleLowerCase();
+            return matcher(getter, v => String(v).toLocaleLowerCase() !== lower);
+        case ">" /* FilterOp.Gt */:
+            return matcher(getter, v => v > value);
+        case ">*" /* FilterOp.GtInsesitive */:
+            lower = String(value).toLocaleLowerCase();
+            return matcher(getter, v => String(v).toLocaleLowerCase() > lower);
+        case ">=" /* FilterOp.Gte */:
+            return matcher(getter, v => v >= value);
+        case ">=*" /* FilterOp.GteInsesitive */:
+            lower = String(value).toLocaleLowerCase();
+            return matcher(getter, v => String(v).toLocaleLowerCase() >= lower);
+        case "<" /* FilterOp.Lt */:
+            return matcher(getter, v => v < value);
+        case "<*" /* FilterOp.LtInsesitive */:
+            lower = String(value).toLocaleLowerCase();
+            return matcher(getter, v => String(v).toLocaleLowerCase() < lower);
+        case "<=" /* FilterOp.Lte */:
+            return matcher(getter, v => v <= value);
+        case "<=*" /* FilterOp.LteInsesitive */:
+            lower = String(value).toLocaleLowerCase();
+            return matcher(getter, v => String(v).toLocaleLowerCase() <= lower);
+        case "%" /* FilterOp.Contains */:
+            lower = String(value);
+            return matcher(getter, v => (Array.isArray(v) ? v.includes(value) : String(v).includes(lower)));
+        case "%*" /* FilterOp.ContainsInsesitive */:
+            lower = String(value).toLocaleLowerCase();
+            return matcher(getter, v => String(v).toLocaleLowerCase().includes(lower));
+        case "^" /* FilterOp.StartsWith */:
+            lower = String(value);
+            return matcher(getter, v => String(v).startsWith(lower));
+        case "^*" /* FilterOp.StartsWithInsesitive */:
+            lower = String(value).toLocaleLowerCase();
+            return matcher(getter, v => String(v).toLocaleLowerCase().startsWith(lower));
+        case "$" /* FilterOp.EndsWith */:
+            lower = String(value);
+            return matcher(getter, v => String(v).endsWith(lower));
+        case "$*" /* FilterOp.EndsWithInsesitive */:
+            lower = String(value).toLocaleLowerCase();
+            return matcher(getter, v => String(v).toLocaleLowerCase().endsWith(lower));
+        case "~" /* FilterOp.Regexp */:
+            regex = value instanceof RegExp ? value : new RegExp(value, "msv");
+            return matcher(getter, v => regex.test(v));
+        case "~*" /* FilterOp.RegexpInsesitive */:
+            regex = value instanceof RegExp ? value : new RegExp(value, "msvi");
+            return matcher(getter, v => regex.test(v));
+        case "&" /* FilterOp.And */:
+            if (!Array.isArray(value)) {
+                throw new Error("Root '&' (AND) operator must have array type");
+            }
+            return and_(flattenDeep(value.map(v => {
+                if (isPlainObject(v)) {
+                    return Object.entries(v).map(([op, opv]) => filterCompileOp(getter, op, opv));
+                }
+                else {
+                    return filterCompileOp(getter, "==" /* FilterOp.Eq */, v);
+                }
+            })));
+        case "|" /* FilterOp.Or */:
+            if (!Array.isArray(value)) {
+                throw new Error("Root '|' (OR) operator must have array type");
+            }
+            return or_(flattenDeep(value.map(v => {
+                if (isPlainObject(v)) {
+                    return Object.entries(v).map(([op, opv]) => filterCompileOp(getter, op, opv));
+                }
+                else {
+                    return filterCompileOp(getter, "==" /* FilterOp.Eq */, v);
+                }
+            })));
+    }
+    throw new Error(`Unexpected operator: ${op}`);
+}
+function matcher(getter, predict) {
+    return obj => getter(obj).some(predict);
+}
+function and_(fns) {
+    if (fns.length === 0) {
+        return _ => true;
+    }
+    return item => {
+        for (const fn of fns) {
+            if (!fn(item)) {
+                return false;
+            }
+        }
+        return true;
+    };
+}
+function or_(fns) {
+    if (fns.length === 0) {
+        return _ => true;
+    }
+    return item => {
+        for (const fn of fns) {
+            if (fn(item)) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
+export function filterMerge(...filters) {
+    let result = undefined;
+    for (const filter of filters) {
+        if (filter == null) {
+            continue;
+        }
+        if (result == null) {
+            result = deepClone(filter);
+        }
+        else {
+            for (const [k, v] of Object.entries(filter)) {
+                if (v === undefined) {
+                    delete result[k];
+                    continue;
+                }
+                result[k] = deepClone(v);
+            }
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter.js","sourceRoot":"","sources":["../../../../../packages/data/src/query/filter.ts"],"names":[],"mappings":"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","sourcesContent":["import { flattenDeep, intersection } from \"lodash\"\n\nimport { AsPrimitive, deepClone, isPlainObject, MaxRecursion } from \"@ngutil/common\"\n\nimport { Model } from \"../model\"\nimport { PathGetter, pathGetterCompile } from \"./path\"\n\nexport const enum FilterOp {\n    Eq = \"==\",\n    EqStrict = \"===\",\n    EqInsesitive = \"==*\",\n    Neq = \"!=\",\n    NeqStrict = \"!==\",\n    NeqInsesitive = \"!=*\",\n    Gt = \">\",\n    GtInsesitive = \">*\",\n    Gte = \">=\",\n    GteInsesitive = \">=*\",\n    Lt = \"<\",\n    LtInsesitive = \"<*\",\n    Lte = \"<=\",\n    LteInsesitive = \"<=*\",\n    Contains = \"%\",\n    ContainsInsesitive = \"%*\",\n    StartsWith = \"^\",\n    StartsWithInsesitive = \"^*\",\n    EndsWith = \"$\",\n    EndsWithInsesitive = \"$*\",\n    Regexp = \"~\",\n    RegexpInsesitive = \"~*\",\n    Or = \"|\",\n    And = \"&\"\n}\n\nexport const OPERATORS: Array<string> = [\n    FilterOp.Eq,\n    FilterOp.EqStrict,\n    FilterOp.EqInsesitive,\n    FilterOp.Neq,\n    FilterOp.NeqStrict,\n    FilterOp.NeqInsesitive,\n    FilterOp.Gt,\n    FilterOp.GtInsesitive,\n    FilterOp.Gte,\n    FilterOp.GteInsesitive,\n    FilterOp.Lt,\n    FilterOp.LtInsesitive,\n    FilterOp.Lte,\n    FilterOp.LteInsesitive,\n    FilterOp.Contains,\n    FilterOp.ContainsInsesitive,\n    FilterOp.StartsWith,\n    FilterOp.StartsWithInsesitive,\n    FilterOp.EndsWith,\n    FilterOp.EndsWithInsesitive,\n    FilterOp.Regexp,\n    FilterOp.RegexpInsesitive,\n    FilterOp.Or,\n    FilterOp.And\n]\n\nexport function asOperators(value: any): Array<{ op: FilterOp; value: any }> {\n    const ops = intersection(Object.keys(value), OPERATORS) as FilterOp[]\n    if (ops.length > 0) {\n        return ops.map(op => {\n            return { op, value: value[op] }\n        })\n    } else {\n        return [{ op: FilterOp.Eq, value }]\n    }\n}\n\n// export type Filter<T extends Model> = _Filter<Flatten<T>, [], MaxRecursion>\n// TODO: fix recursion\nexport type Filter<T extends Model> = { [key: string]: any }\n\ntype _Filter<F, P extends number[], D extends number> = P[\"length\"] extends D ? never : _ObjectFilter<F, P, D>\n\ntype _ObjectFilter<F, P extends number[], D extends number> = P[\"length\"] extends D\n    ? never\n    : { [K in keyof F]?: Operators<F[K], P, D> }\n\ntype RootOr<F, P extends number[], D extends number> = P[\"length\"] extends D\n    ? never\n    : { [FilterOp.Or]: Array<_Filter<F, [...P, 0], D>> | undefined }\n\ntype RootAnd<F, P extends number[], D extends number> = P[\"length\"] extends D\n    ? never\n    : { [FilterOp.And]: Array<_Filter<F, [...P, 0], D>> | undefined }\n\nexport type Operators<T, P extends number[], D extends number = MaxRecursion> = P[\"length\"] extends D\n    ? never\n    : SimpleOperators<T>\n\ntype LocalOr<T, P extends number[], D extends number> = P[\"length\"] extends D\n    ? never\n    : { [FilterOp.Or]: Array<Operators<T, [...P, 0], D>> | undefined }\n\ntype LocalAnd<T, P extends number[], D extends number> = P[\"length\"] extends D\n    ? never\n    : { [FilterOp.And]: Array<Operators<T, [...P, 0], D>> | undefined }\n\ntype SimpleOperators<T> =\n    | EqStrict<T>\n    | NeqStrict<T>\n    | Eq<T>\n    | Neq<T>\n    | Gt<T>\n    | Gte<T>\n    | Lt<T>\n    | Lte<T>\n    | Contains<T>\n    | StartsWith<T>\n    | EndsWith<T>\n    | Regexp<T>\n    | T\n    | undefined\n    | null\n\ntype EqStrict<T> = Operator<T, T, FilterOp.EqStrict, never, null>\ntype NeqStrict<T> = Operator<T, T, FilterOp.NeqStrict, never, null>\ntype Eq<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Eq, FilterOp.EqInsesitive, null>\ntype Neq<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Neq, FilterOp.NeqInsesitive, null>\ntype Gt<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Gt, FilterOp.GtInsesitive>\ntype Gte<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Gte, FilterOp.GteInsesitive>\ntype Lt<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Lt, FilterOp.LtInsesitive>\ntype Lte<T> = Operator<T, T | AsPrimitive<T>, FilterOp.Lte, FilterOp.LteInsesitive>\ntype Contains<T> = Operator<T, string, FilterOp.Contains, FilterOp.ContainsInsesitive>\ntype StartsWith<T> = Operator<T, string, FilterOp.StartsWith, FilterOp.StartsWithInsesitive>\ntype EndsWith<T> = Operator<T, string, FilterOp.EndsWith, FilterOp.EndsWithInsesitive>\ntype Regexp<T> = Operator<T, string, FilterOp.Regexp, FilterOp.RegexpInsesitive, RegExp>\n\ntype Operator<T, R, OP extends string, OPI extends string = never, ET = never> =\n    | (T extends R ? { [k in OP]: T | ET | R } : never)\n    | (T extends string ? (OPI extends never ? never : { [k in OPI]: string }) : never)\n\nexport type FilterFn<T = any> = (item: T) => boolean\n\n/**\n * @example\n * ```ts\n * items.filter(filterBy({id: 42}))\n * ```\n */\nexport function filterBy<T extends Model>(filters: Filter<T>): FilterFn<T> {\n    return _filterCompile<T>(filters)\n}\n\n// TODO: Normalize filter\n// type _Filter = { path: string; op: FilterOp; value: any }\n// type _Or = { \"|\": Array<_Filter> }\n// type _And = { \"&\": Array<_Filter> }\n// export type NormalizedFilter = _Or | _And\n\n// /**\n//  * @example\n//  * ```ts\n//  * normalizeFilter({id: 2, name: {\"=*\": \"AnyName\"}}) -> {id: {\"==\": 2}, name: {\"=*\": \"AnyName\"}}}\n//  * normalizeFilter({id: {\">\": 0, \"<\": 10}}) -> {\"&\": [{id: {\">\": 0}}, {id: {\"<\": 10}}]}\n//  * ```\n//  */\n// export function normalizeFilter<T extends Model>(filters: Filters<T>): Filters<T> {\n//     return _normalizeFilter(filters)\n// }\n\n// function _normalizeFilter(filters: any, path?: string): any {\n//     const result = {} as any\n\n//     for (const [path, v] of Object.entries(filters)) {\n//         switch (path) {\n//             case FilterOp.And:\n//                 if (!Array.isArray(v)) {\n//                     throw new Error(\"The '&' (AND) operator must have array type\")\n//                 }\n\n//                 if (!result[FilterOp.And]) {\n//                     result[FilterOp.And] = []\n//                 }\n\n//                 result[FilterOp.And] = result[FilterOp.And].concat(v.map(f => _normalizeFilter(f)))\n//                 break\n\n//             case FilterOp.Or:\n//                 if (!Array.isArray(v)) {\n//                     throw new Error(\"The '|' (OR) operator must have array type\")\n//                 }\n\n//                 if (!result[FilterOp.Or]) {\n//                     result[FilterOp.Or] = []\n//                 }\n\n//                 result[FilterOp.Or] = result[FilterOp.Or].concat(v.map(f => _normalizeFilter(f)))\n//                 break\n\n//             default:\n//                 for (const entry of asOperators(v)) {\n//                     switch (entry.op) {\n//                         case FilterOp.And:\n//                             if (!result[FilterOp.And]) {\n//                                 result[FilterOp.And] = []\n//                             }\n\n//                             result[FilterOp.And] = result[FilterOp.And].concat(\n//                                 entry.value.map((v: any) => _normalizeFilter(v, path))\n//                             )\n//                             break\n\n//                         case FilterOp.Or:\n//                             if (!result[FilterOp.Or]) {\n//                                 result[FilterOp.Or] = []\n//                             }\n\n//                             result[FilterOp.Or] = result[FilterOp.Or].concat(\n//                                 entry.value.map((v: any) => _normalizeFilter(v, path))\n//                             )\n//                             break\n\n//                         default:\n//                             if (!result[FilterOp.And]) {\n//                                 result[FilterOp.And] = []\n//                             }\n\n//                             result[FilterOp.And].push({ path, ...entry })\n//                     }\n//                 }\n//         }\n//     }\n\n//     return result\n// }\n\nfunction _filterCompile<T extends Model>(filters: Filter<T>): FilterFn<T> {\n    let getter: PathGetter\n    const result: FilterFn<T>[] = []\n    for (const [pth, value] of Object.entries(filters)) {\n        switch (pth) {\n            case FilterOp.And:\n                if (!Array.isArray(value)) {\n                    throw new Error(\"Root '&' (AND) operator must have array type\")\n                }\n                result.splice(result.length, 0, ...value.map(_filterCompile<T>))\n                break\n\n            case FilterOp.Or:\n                if (!Array.isArray(value)) {\n                    throw new Error(\"Root '|' (OR) operator must have array type\")\n                }\n                result.push(or_(value.map(_filterCompile<T>)))\n                break\n\n            default:\n                getter = pathGetterCompile(pth)\n                if (isPlainObject(value)) {\n                    result.push(and_(Object.entries(value).map(([op, opv]) => filterCompileOp(getter, op as any, opv))))\n                } else {\n                    result.push(filterCompileOp(getter, FilterOp.Eq, value))\n                }\n\n                break\n        }\n    }\n    return and_(result)\n}\n\nfunction filterCompileOp(getter: PathGetter, op: FilterOp, value: any): FilterFn {\n    let lower: string\n    let regex: RegExp\n    switch (op) {\n        case FilterOp.Eq:\n            // eslint-disable-next-line eqeqeq\n            return matcher(getter, v => v == value)\n\n        case FilterOp.EqStrict:\n            return matcher(getter, v => v === value)\n\n        case FilterOp.EqInsesitive:\n            lower = String(value).toLocaleLowerCase()\n            return matcher(getter, v => String(v).toLocaleLowerCase() === lower)\n\n        case FilterOp.Neq:\n            // eslint-disable-next-line eqeqeq\n            return matcher(getter, v => v != value)\n\n        case FilterOp.NeqStrict:\n            return matcher(getter, v => v !== value)\n\n        case FilterOp.NeqInsesitive:\n            lower = String(value).toLocaleLowerCase()\n            return matcher(getter, v => String(v).toLocaleLowerCase() !== lower)\n\n        case FilterOp.Gt:\n            return matcher(getter, v => v > value)\n\n        case FilterOp.GtInsesitive:\n            lower = String(value).toLocaleLowerCase()\n            return matcher(getter, v => String(v).toLocaleLowerCase() > lower)\n\n        case FilterOp.Gte:\n            return matcher(getter, v => v >= value)\n\n        case FilterOp.GteInsesitive:\n            lower = String(value).toLocaleLowerCase()\n            return matcher(getter, v => String(v).toLocaleLowerCase() >= lower)\n\n        case FilterOp.Lt:\n            return matcher(getter, v => v < value)\n\n        case FilterOp.LtInsesitive:\n            lower = String(value).toLocaleLowerCase()\n            return matcher(getter, v => String(v).toLocaleLowerCase() < lower)\n\n        case FilterOp.Lte:\n            return matcher(getter, v => v <= value)\n\n        case FilterOp.LteInsesitive:\n            lower = String(value).toLocaleLowerCase()\n            return matcher(getter, v => String(v).toLocaleLowerCase() <= lower)\n\n        case FilterOp.Contains:\n            lower = String(value)\n            return matcher(getter, v => (Array.isArray(v) ? v.includes(value) : String(v).includes(lower)))\n\n        case FilterOp.ContainsInsesitive:\n            lower = String(value).toLocaleLowerCase()\n            return matcher(getter, v => String(v).toLocaleLowerCase().includes(lower))\n\n        case FilterOp.StartsWith:\n            lower = String(value)\n            return matcher(getter, v => String(v).startsWith(lower))\n\n        case FilterOp.StartsWithInsesitive:\n            lower = String(value).toLocaleLowerCase()\n            return matcher(getter, v => String(v).toLocaleLowerCase().startsWith(lower))\n\n        case FilterOp.EndsWith:\n            lower = String(value)\n            return matcher(getter, v => String(v).endsWith(lower))\n\n        case FilterOp.EndsWithInsesitive:\n            lower = String(value).toLocaleLowerCase()\n            return matcher(getter, v => String(v).toLocaleLowerCase().endsWith(lower))\n\n        case FilterOp.Regexp:\n            regex = value instanceof RegExp ? value : new RegExp(value, \"msv\")\n            return matcher(getter, v => regex.test(v))\n\n        case FilterOp.RegexpInsesitive:\n            regex = value instanceof RegExp ? value : new RegExp(value, \"msvi\")\n            return matcher(getter, v => regex.test(v))\n\n        case FilterOp.And:\n            if (!Array.isArray(value)) {\n                throw new Error(\"Root '&' (AND) operator must have array type\")\n            }\n            return and_(\n                flattenDeep(\n                    value.map(v => {\n                        if (isPlainObject(v)) {\n                            return Object.entries(v).map(([op, opv]) => filterCompileOp(getter, op as any, opv))\n                        } else {\n                            return filterCompileOp(getter, FilterOp.Eq, v)\n                        }\n                    })\n                )\n            )\n\n        case FilterOp.Or:\n            if (!Array.isArray(value)) {\n                throw new Error(\"Root '|' (OR) operator must have array type\")\n            }\n            return or_(\n                flattenDeep(\n                    value.map(v => {\n                        if (isPlainObject(v)) {\n                            return Object.entries(v).map(([op, opv]) => filterCompileOp(getter, op as any, opv))\n                        } else {\n                            return filterCompileOp(getter, FilterOp.Eq, v)\n                        }\n                    })\n                )\n            )\n    }\n\n    throw new Error(`Unexpected operator: ${op}`)\n}\n\nfunction matcher(getter: PathGetter, predict: (value: any) => boolean): FilterFn {\n    return obj => getter(obj).some(predict)\n}\n\nfunction and_(fns: FilterFn[]): FilterFn {\n    if (fns.length === 0) {\n        return _ => true\n    }\n\n    return item => {\n        for (const fn of fns) {\n            if (!fn(item)) {\n                return false\n            }\n        }\n        return true\n    }\n}\n\nfunction or_(fns: FilterFn[]): FilterFn {\n    if (fns.length === 0) {\n        return _ => true\n    }\n\n    return item => {\n        for (const fn of fns) {\n            if (fn(item)) {\n                return true\n            }\n        }\n        return false\n    }\n}\n\nexport function filterMerge(...filters: any[]): any | undefined {\n    let result: { [key: string]: any } | undefined = undefined\n\n    for (const filter of filters) {\n        if (filter == null) {\n            continue\n        }\n        if (result == null) {\n            result = deepClone(filter)\n        } else {\n            for (const [k, v] of Object.entries(filter)) {\n                if (v === undefined) {\n                    delete result[k]\n                    continue\n                }\n\n                result[k] = deepClone(v)\n            }\n        }\n    }\n\n    return result as any\n}\n"]}