@ngutil/data 0.0.91 → 0.0.93

package/fesm2022/ngutil-data.mjs

@@ -58,6 +58,10 @@ function normalize(obj, normalizer) {
 }
 
 class QueryProperty extends BehaviorSubject {
+    constructor(provider) {
+        super(undefined);
+        this.provider = provider;
+    }
     set(value) {
         this.#nextClone(value != null ? this.norm(value) : undefined);
     }
@@ -93,8 +97,9 @@ class QueryProperty extends BehaviorSubject {
 }
 class QueryPropertySet extends Observable {
     #combined;
-    constructor(...names) {
+    constructor(provider, ...names) {
         super(dest => this.#combined.subscribe(dest));
+        this.provider = provider;
         const observables = [];
         const props = {};
         for (const name of names) {
@@ -109,31 +114,60 @@ class QueryPropertySet extends Observable {
     }
 }
 
+var FilterOp;
+(function (FilterOp) {
+    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["Similarity"] = "**";
+    FilterOp["Regexp"] = "~";
+    FilterOp["RegexpInsesitive"] = "~*";
+    FilterOp["Or"] = "|";
+    FilterOp["And"] = "&";
+})(FilterOp || (FilterOp = {}));
 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 */
+    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.Similarity,
+    FilterOp.Regexp,
+    FilterOp.RegexpInsesitive,
+    FilterOp.Or,
+    FilterOp.And
 ];
 function asOperators(value) {
     const ops = intersection(Object.keys(value), OPERATORS);
@@ -143,7 +177,7 @@ function asOperators(value) {
         });
     }
     else {
-        return [{ op: "==" /* FilterOp.Eq */, value }];
+        return [{ op: FilterOp.Eq, value }];
     }
 }
 /**
@@ -167,7 +201,7 @@ function filterNormalize(filters) {
 }
 function _normalizeFilter(filters, parent) {
     if ("op" in filters && "value" in filters) {
-        if (filters["op"] === "|" /* FilterOp.Or */ || filters["op"] === "&" /* FilterOp.And */) {
+        if (filters["op"] === FilterOp.Or || filters["op"] === FilterOp.And) {
             return { op: filters["op"], value: filters["value"].map((v) => _normalizeFilter(v, parent)) };
         }
         if ("path" in filters) {
@@ -176,16 +210,16 @@ function _normalizeFilter(filters, parent) {
     }
     const norm = flattenDeep(Object.entries(filters).map(([path, value]) => {
         switch (path) {
-            case "&" /* FilterOp.And */:
+            case FilterOp.And:
                 if (!Array.isArray(value)) {
-                    throw new Error(`Operator AND (${"&" /* FilterOp.And */}) must have array type`);
+                    throw new Error(`Operator AND (${FilterOp.And}) must have array type`);
                 }
-                return { op: "&" /* FilterOp.And */, value: value.map(v => _normalizeFilter(v, parent)) };
-            case "|" /* FilterOp.Or */:
+                return { op: FilterOp.And, value: value.map(v => _normalizeFilter(v, parent)) };
+            case FilterOp.Or:
                 if (!Array.isArray(value)) {
-                    throw new Error(`Operator OR (${"|" /* FilterOp.Or */}) must have array type`);
+                    throw new Error(`Operator OR (${FilterOp.Or}) must have array type`);
                 }
-                return { op: "|" /* FilterOp.Or */, value: value.map(v => _normalizeFilter(v, parent)) };
+                return { op: FilterOp.Or, value: value.map(v => _normalizeFilter(v, parent)) };
             // TODO: check all filter, and if not found filter key, taht object maybne not a filter
             default:
                 if (isPlainObject(value)) {
@@ -195,7 +229,7 @@ function _normalizeFilter(filters, parent) {
                     return { path: parent, op: path, value };
                 }
                 else {
-                    return { path, op: "===" /* FilterOp.EqStrict */, value };
+                    return { path, op: FilterOp.EqStrict, value };
                 }
         }
     }));
@@ -206,7 +240,7 @@ function _normalizeFilter(filters, parent) {
         return norm[0];
     }
     else {
-        return { op: "&" /* FilterOp.And */, value: norm };
+        return { op: FilterOp.And, value: norm };
     }
 }
 function _filterCompile(filters) {
@@ -222,9 +256,9 @@ function _filterCompile(filters) {
 }
 function _filterCompileNorm(filter, getPath) {
     switch (filter.op) {
-        case "&" /* FilterOp.And */:
+        case FilterOp.And:
             return and_(filter.value.map(v => _filterCompileNorm(v, getPath)));
-        case "|" /* FilterOp.Or */:
+        case FilterOp.Or:
             return or_(filter.value.map(v => _filterCompileNorm(v, getPath)));
         default:
             return _filterComplileNormPath(getPath(filter.path), filter.op, filter.value, getPath);
@@ -234,68 +268,70 @@ function _filterComplileNormPath(getter, op, value, getPath) {
     let lower;
     let regex;
     switch (op) {
-        case "&" /* FilterOp.And */:
+        case FilterOp.And:
             return and_(value.map(v => _filterCompileNorm(v, getPath)));
-        case "|" /* FilterOp.Or */:
+        case FilterOp.Or:
             return or_(value.map(v => _filterCompileNorm(v, getPath)));
-        case "==" /* FilterOp.Eq */:
+        case FilterOp.Eq:
             // eslint-disable-next-line eqeqeq
             return matcher(getter, v => v == value);
-        case "===" /* FilterOp.EqStrict */:
+        case FilterOp.EqStrict:
             return matcher(getter, v => v === value);
-        case "==*" /* FilterOp.EqInsesitive */:
+        case FilterOp.EqInsesitive:
             lower = String(value).toLocaleLowerCase();
             return matcher(getter, v => String(v).toLocaleLowerCase() === lower);
-        case "!=" /* FilterOp.Neq */:
+        case FilterOp.Neq:
             // eslint-disable-next-line eqeqeq
             return matcher(getter, v => v != value);
-        case "!==" /* FilterOp.NeqStrict */:
+        case FilterOp.NeqStrict:
             return matcher(getter, v => v !== value);
-        case "!=*" /* FilterOp.NeqInsesitive */:
+        case FilterOp.NeqInsesitive:
             lower = String(value).toLocaleLowerCase();
             return matcher(getter, v => String(v).toLocaleLowerCase() !== lower);
-        case ">" /* FilterOp.Gt */:
+        case FilterOp.Gt:
             return matcher(getter, v => v > value);
-        case ">*" /* FilterOp.GtInsesitive */:
+        case FilterOp.GtInsesitive:
             lower = String(value).toLocaleLowerCase();
             return matcher(getter, v => String(v).toLocaleLowerCase() > lower);
-        case ">=" /* FilterOp.Gte */:
+        case FilterOp.Gte:
             return matcher(getter, v => v >= value);
-        case ">=*" /* FilterOp.GteInsesitive */:
+        case FilterOp.GteInsesitive:
             lower = String(value).toLocaleLowerCase();
             return matcher(getter, v => String(v).toLocaleLowerCase() >= lower);
-        case "<" /* FilterOp.Lt */:
+        case FilterOp.Lt:
             return matcher(getter, v => v < value);
-        case "<*" /* FilterOp.LtInsesitive */:
+        case FilterOp.LtInsesitive:
             lower = String(value).toLocaleLowerCase();
             return matcher(getter, v => String(v).toLocaleLowerCase() < lower);
-        case "<=" /* FilterOp.Lte */:
+        case FilterOp.Lte:
             return matcher(getter, v => v <= value);
-        case "<=*" /* FilterOp.LteInsesitive */:
+        case FilterOp.LteInsesitive:
             lower = String(value).toLocaleLowerCase();
             return matcher(getter, v => String(v).toLocaleLowerCase() <= lower);
-        case "%" /* FilterOp.Contains */:
+        case FilterOp.Contains:
             lower = String(value);
             return matcher(getter, v => (Array.isArray(v) ? v.includes(value) : String(v).includes(lower)));
-        case "%*" /* FilterOp.ContainsInsesitive */:
+        case FilterOp.ContainsInsesitive:
+        case FilterOp.Similarity:
+            // TODO: proper similarity test
             lower = String(value).toLocaleLowerCase();
             return matcher(getter, v => String(v).toLocaleLowerCase().includes(lower));
-        case "^" /* FilterOp.StartsWith */:
+        case FilterOp.StartsWith:
             lower = String(value);
             return matcher(getter, v => String(v).startsWith(lower));
-        case "^*" /* FilterOp.StartsWithInsesitive */:
+        case FilterOp.StartsWithInsesitive:
             lower = String(value).toLocaleLowerCase();
             return matcher(getter, v => String(v).toLocaleLowerCase().startsWith(lower));
-        case "$" /* FilterOp.EndsWith */:
+        case FilterOp.EndsWith:
             lower = String(value);
             return matcher(getter, v => String(v).endsWith(lower));
-        case "$*" /* FilterOp.EndsWithInsesitive */:
+        case FilterOp.EndsWithInsesitive:
             lower = String(value).toLocaleLowerCase();
             return matcher(getter, v => String(v).toLocaleLowerCase().endsWith(lower));
-        case "~" /* FilterOp.Regexp */:
+        case FilterOp.Regexp:
             regex = value instanceof RegExp ? value : new RegExp(value, "msv");
             return matcher(getter, v => regex.test(v));
-        case "~*" /* FilterOp.RegexpInsesitive */:
+        case FilterOp.RegexpInsesitive:
             regex = value instanceof RegExp ? value : new RegExp(value, "msvi");
             return matcher(getter, v => regex.test(v));
     }
@@ -340,29 +376,29 @@ function filterMerge(...filters) {
     const value = filters
         .filter(v => v && ((Array.isArray(v) && v.length > 0) || (isPlainObject(v) && Object.keys(v).length > 0)))
         .map(filter => deepClone(filter));
-    return compact({ op: "&" /* FilterOp.And */, value });
+    return compact({ op: FilterOp.And, value });
 }
 class FilterProperty extends QueryProperty {
     merge(a, b) {
-        return filterMerge(a, b);
+        return this.provider.filterMerge(a, b);
     }
     norm(a) {
-        return filterNormalize(a);
+        return this.provider.filterNormalize(a);
     }
 }
 class FilterPropertySet extends QueryPropertySet {
     newProperty() {
-        return new FilterProperty(undefined);
+        return new FilterProperty(this.provider);
     }
     merge(...args) {
-        return filterMerge(...args);
+        return this.provider.filterMerge(...args);
     }
 }
 function filterSimplify(filters) {
     if (isTruthy(filters)) {
         filters = compact(filterNormalize(filters));
         const result = {};
-        if (filters["op"] === "&" /* FilterOp.And */) {
+        if (filters["op"] === FilterOp.And) {
             filters = filters["value"];
             if (filters == null) {
                 return result;
@@ -373,7 +409,7 @@ function filterSimplify(filters) {
         }
         for (const f of filters) {
             if (f["value"] != null &&
-                (f["op"] === "==" /* FilterOp.Eq */ || f["op"] === "===" /* FilterOp.EqStrict */ || f["op"] === "==*" /* FilterOp.EqInsesitive */)) {
+                (f["op"] === FilterOp.Eq || f["op"] === FilterOp.EqStrict || f["op"] === FilterOp.EqInsesitive)) {
                 result[f["path"]] = f["value"];
             }
         }
@@ -384,7 +420,7 @@ function filterSimplify(filters) {
     }
 }
 function compact(filters) {
-    if (filters.op === "&" /* FilterOp.And */ || filters.op === "|" /* FilterOp.Or */) {
+    if (filters.op === FilterOp.And || filters.op === FilterOp.Or) {
         if (isFalsy(filters.value)) {
             return null;
         }
@@ -487,18 +523,18 @@ function grouperNormalize(grouper) { }
 // }
 class GrouperProperty extends QueryProperty {
     norm(a) {
-        return grouperNormalize;
+        return this.provider.grouperNormalize(a);
     }
     merge(a, b) {
-        return grouperMerge(a, b);
+        return this.provider.grouperMerge(a, b);
     }
 }
 class GrouperPropertySet extends QueryPropertySet {
     newProperty() {
-        return new GrouperProperty(undefined);
+        return new GrouperProperty(this.provider);
     }
     merge(...args) {
-        return grouperMerge(...args);
+        return this.provider.grouperMerge(...args);
     }
 }
 
@@ -694,10 +730,10 @@ function sorterMerge(...sorters) {
 }
 class SorterProperty extends QueryProperty {
     norm(a) {
-        return sorterNormalize(a);
+        return this.provider.sorterNormalize(a);
     }
     merge(a, b) {
-        return sorterMerge(a, b);
+        return this.provider.sorterMerge(a, b);
     }
 }
 class SorterPropertySet extends QueryPropertySet {
@@ -711,10 +747,10 @@ class SorterPropertySet extends QueryPropertySet {
         return this.of(name).pipe(map(v => (v != null ? !v.isAsc : undefined)));
     }
     newProperty() {
-        return new SorterProperty(undefined);
+        return new SorterProperty(this.provider);
     }
     merge(...args) {
-        return sorterMerge(...args);
+        return this.provider.sorterMerge(...args);
     }
 }
 
@@ -726,18 +762,18 @@ function slimerCompile(slimer) {
 function slimerMerge(...slimers) { }
 class SlimerProperty extends QueryProperty {
     norm(a) {
-        return slimerNormalize(a);
+        return this.provider.slimerNormalize(a);
     }
     merge(a, b) {
-        return slimerMerge(a, b);
+        return this.provider.slimerMerge(a, b);
     }
 }
 class SlimerPropertySet extends QueryPropertySet {
     newProperty() {
-        return new SlimerProperty(undefined);
+        return new SlimerProperty(this.provider);
     }
     merge(...args) {
-        return slimerMerge(...args);
+        return this.provider.slimerMerge(...args);
     }
 }
 
@@ -804,11 +840,11 @@ function sliceEq(a, b) {
 // TODO: sliceConcat(...slices: Slice[]): Slice[]
 // TODO: sliceDiff(slice: Slice): Slice[]
 
-function querySubject(...names) {
-    const filter = new FilterPropertySet(...names);
-    const sorter = new SorterPropertySet(...names);
-    const slimer = new SlimerPropertySet(...names);
-    const grouper = new GrouperPropertySet(...names);
+function querySubject(provider, ...names) {
+    const filter = new FilterPropertySet(provider, ...names);
+    const sorter = new SorterPropertySet(provider, ...names);
+    const slimer = new SlimerPropertySet(provider, ...names);
+    const grouper = new GrouperPropertySet(provider, ...names);
     const result = combineLatest({ filter, sorter, slimer, grouper }).pipe(shareReplay(1));
     readonlyProp(result, "filter", filter);
     readonlyProp(result, "sorter", sorter);
@@ -974,7 +1010,7 @@ class DataSource extends DataSource$1 {
     #slice;
     #reload;
     #query;
-    constructor(provider, store = new MemoryStore(), query$ = querySubject("normal", "forced")) {
+    constructor(provider, store = new MemoryStore(), query$ = querySubject(provider, "normal", "forced")) {
         super();
         this.provider = provider;
         this.store = store;
@@ -1120,6 +1156,30 @@ class DataProvider {
     clampSlice(slice) {
         return of(slice);
     }
+    filterNormalize(filter) {
+        return filterNormalize(filter);
+    }
+    filterMerge(...filters) {
+        return filterMerge(...filters);
+    }
+    sorterNormalize(sorter) {
+        return sorterNormalize(sorter);
+    }
+    sorterMerge(...sorters) {
+        return sorterMerge(...sorters);
+    }
+    grouperNormalize(grouper) {
+        return grouperNormalize(grouper);
+    }
+    grouperMerge(...groupers) {
+        return grouperMerge(...groupers);
+    }
+    slimerNormalize(slimer) {
+        return slimerNormalize(slimer);
+    }
+    slimerMerge(...slimers) {
+        return slimerMerge(...slimers);
+    }
     /**
      * @returns New data source instance
      */
@@ -1517,5 +1577,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.8", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { ArrayProvider, CollectionStore, DataProvider, DataSource, DataSourceModule, DataSourceProxy, DataSourceProxyBusy, DataSourceProxyFilter, DataSourceProxyGrouper, DataSourceProxySlimer, DataSourceProxySorter, LocalProvider, MemoryStore, ModelMeta, ModelRefByIndex, ModelRefByKey, ModelRefNorm, ObservableProvider, UnknownMeta, filterBy, filterMerge, filterNormalize, filterSimplify, groupBy, grouperMerge, pathGetterCompile, queryExecutor, querySubject, sliceApply, sliceClamp, sliceEq, sliceInsert, sliceMerge, sliceToPages, slimBy, slimerMerge, sortBy, sorterMerge, sorterNormalize };
+export { ArrayProvider, CollectionStore, DataProvider, DataSource, DataSourceModule, DataSourceProxy, DataSourceProxyBusy, DataSourceProxyFilter, DataSourceProxyGrouper, DataSourceProxySlimer, DataSourceProxySorter, FilterOp, LocalProvider, MemoryStore, ModelMeta, ModelRefByIndex, ModelRefByKey, ModelRefNorm, ObservableProvider, UnknownMeta, filterBy, filterMerge, filterNormalize, filterSimplify, groupBy, grouperMerge, pathGetterCompile, queryExecutor, querySubject, sliceApply, sliceClamp, sliceEq, sliceInsert, sliceMerge, sliceToPages, slimBy, slimerMerge, sortBy, sorterMerge, sorterNormalize };
 //# sourceMappingURL=ngutil-data.mjs.map