@elderbyte/ngx-starter 19.14.1 → 19.15.0

package/fesm2022/elderbyte-ngx-starter.mjs

@@ -2601,14 +2601,6 @@ class Filter {
     }
 }
 
-class UnreachableCaseError extends Error {
-    constructor(value) {
-        super('Unreachable case unhandled value: ' + value);
-        this.value = value;
-        Object.setPrototypeOf(this, UnreachableCaseError.prototype);
-    }
-}
-
 class ObjectPathResolver {
     static { this.log = LoggerFactory.getLogger(ObjectPathResolver.constructor.name); }
     /***************************************************************************
@@ -2654,6 +2646,124 @@ class ObjectPathResolver {
     }
 }
 
+class UnreachableCaseError extends Error {
+    constructor(value) {
+        super('Unreachable case unhandled value: ' + value);
+        this.value = value;
+        Object.setPrototypeOf(this, UnreachableCaseError.prototype);
+    }
+}
+
+class ObjectFieldMatcher {
+    static of(entity) {
+        return new ObjectFieldMatcher(entity);
+    }
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(entity) {
+        this.entity = entity;
+    }
+    /***************************************************************************
+     *                                                                         *
+     * Public API                                                              *
+     *                                                                         *
+     **************************************************************************/
+    matchesAll(fieldPaths, spec) {
+        if (fieldPaths.length === 0)
+            return false;
+        for (const fieldPath of fieldPaths) {
+            if (!this.matches(fieldPath, spec)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    matchesAny(fieldPaths, spec) {
+        for (const fieldPath of fieldPaths) {
+            if (this.matches(fieldPath, spec)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    matches(fieldPath, spec) {
+        const resolvedValue = ObjectPathResolver.resolveValue(this.entity, fieldPath);
+        if (!spec.options.exclude) {
+            return this.matchesGenericInclude(spec, resolvedValue);
+        }
+        else {
+            return this.matchesGenericExclude(spec, resolvedValue);
+        }
+    }
+    /***************************************************************************
+     *                                                                         *
+     * Private methods                                                         *
+     *                                                                         *
+     **************************************************************************/
+    matchesGenericExclude(spec, resolvedValue) {
+        let exclusions;
+        if (Array.isArray(spec.needle)) {
+            exclusions = spec.needle;
+        }
+        else {
+            exclusions = [spec.needle];
+        }
+        if (exclusions.length > 0) {
+            return !exclusions.some((excluded) => {
+                if (Array.isArray(resolvedValue)) {
+                    return resolvedValue.some((v) => v === excluded); // TODO use matchesSingleValue
+                }
+                else {
+                    return resolvedValue === excluded; // TODO use matchesSingleValue
+                }
+            });
+        }
+        else {
+            return true;
+        }
+    }
+    matchesGenericInclude(spec, resolvedValue) {
+        if (Array.isArray(spec.needle)) {
+            for (const val of spec.needle) {
+                if (this.matchesSingleValue(resolvedValue, val, spec.options)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else {
+            return this.matchesSingleValue(resolvedValue, spec.needle, spec.options);
+        }
+    }
+    matchesSingleValue(resolvedValue, filterValue, options) {
+        if (resolvedValue === filterValue) {
+            return true;
+        }
+        if (resolvedValue === null || resolvedValue === undefined) {
+            return false;
+        }
+        let resolvedValueStr = String(resolvedValue);
+        let filterValueStr = filterValue;
+        if (!options.caseSensitive) {
+            resolvedValueStr = resolvedValueStr.toLowerCase();
+            filterValueStr = filterValueStr.toLowerCase();
+        }
+        switch (options.mode) {
+            case 'start':
+                return resolvedValueStr.startsWith(filterValueStr);
+            case 'full':
+                return resolvedValueStr === filterValueStr;
+            case 'anywhere':
+                return resolvedValueStr.indexOf(filterValueStr) >= 0;
+            default:
+                throw new UnreachableCaseError(options.mode);
+        }
+    }
+}
+
 class TargetValue {
     constructor(entity, resolvedValue) {
         this.entity = entity;
@@ -2781,73 +2891,14 @@ class LocalDataFilter {
         }
     }
     matchesResolvedValueGeneric(filter, target) {
-        if (this.isExclude(filter)) {
-            return this.matchesGenericExclude(filter, target);
-        }
-        else {
-            return this.matchesGenericInclude(filter, target);
-        }
-    }
-    matchesGenericInclude(filter, target) {
-        const resolvedValue = target.resolvedValue;
-        if (Array.isArray(filter.value)) {
-            for (const val of filter.value) {
-                if (this.matchesSingleValue(resolvedValue, val)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        else {
-            return this.matchesSingleValue(resolvedValue, filter.value);
-        }
-    }
-    matchesGenericExclude(filter, target) {
-        const resolvedValue = target.resolvedValue;
-        let exclusions;
-        if (Array.isArray(filter.value)) {
-            exclusions = filter.value;
-        }
-        else {
-            exclusions = [filter.value];
-        }
-        if (exclusions.length > 0) {
-            return !exclusions.some((excluded) => {
-                if (Array.isArray(resolvedValue)) {
-                    return resolvedValue.some((v) => v === excluded);
-                }
-                else {
-                    return resolvedValue === excluded;
-                }
-            });
-        }
-        else {
-            return true;
-        }
-    }
-    matchesSingleValue(resolvedValue, filterValue) {
-        if (resolvedValue === filterValue) {
-            return true;
-        }
-        if (resolvedValue === null || resolvedValue === undefined) {
-            return false;
-        }
-        let resolvedValueStr = String(resolvedValue);
-        let filterValueStr = filterValue;
-        if (!this.genericOptions.caseSensitive) {
-            resolvedValueStr = resolvedValueStr.toLowerCase();
-            filterValueStr = filterValueStr.toLowerCase();
-        }
-        switch (this.genericOptions.mode) {
-            case 'start':
-                return resolvedValueStr.startsWith(filterValueStr);
-            case 'full':
-                return resolvedValueStr === filterValueStr;
-            case 'anywhere':
-                return resolvedValueStr.indexOf(filterValueStr) >= 0;
-            default:
-                throw new UnreachableCaseError(this.genericOptions.mode);
-        }
+        return ObjectFieldMatcher.of(target.entity).matches(this.resolveObjectPath(filter), {
+            options: {
+                caseSensitive: this.genericOptions.caseSensitive,
+                mode: this.genericOptions.mode,
+                exclude: this.isExclude(filter),
+            },
+            needle: filter.value,
+        });
     }
 }
 
@@ -23644,7 +23695,7 @@ class ElderSelectComponent extends ElderSelectBase {
                 this.entityS.set(newEntity);
             }
             else {
-                this.logger.warn('Ignored written entity as it is already set to entity$!');
+                this.logger.debug('Ignored written entity as it is already set to entity$.');
             }
         }
         super.writeToControl(value);
@@ -27235,7 +27286,7 @@ class ElderSearchContextDirective {
         this.saveInitialFilters(filters);
         if (filters.length > 0) {
             const inputsByKey = this.searchInputsByQueryKey();
-            this.log.warn('applyFiltersToInputs [' + Array.from(inputsByKey.keys()) + ']', {
+            this.log.debug('applyFiltersToInputs [' + Array.from(inputsByKey.keys()) + ']', {
                 filters: filters,
                 inputsByQueryKey: inputsByKey,
             });