@elderbyte/ngx-starter 22.2.2 → 22.2.3

package/fesm2022/elderbyte-ngx-starter.mjs

@@ -5678,71 +5678,99 @@ class DataContextLifeCycleBinding {
     }
 }
 
-class RequiredFilterContextChangedEvent {
-    constructor(requiredFilters, currentFilters, isValid) {
-        this.requiredFilters = requiredFilters;
-        this.currentFilters = currentFilters;
-        this.isValid = isValid;
+class RequiredFilterMatcher {
+    /***************************************************************************
+     *                                                                         *
+     * Constructor                                                             *
+     *                                                                         *
+     **************************************************************************/
+    constructor(requiredFilters) {
+        this.requiredKeys = new Set(requiredFilters);
     }
-}
-class RequiredFilterEvaluator {
     /***************************************************************************
      *                                                                         *
-     * Fields                                                                  *
+     * Public API                                                              *
      *                                                                         *
      **************************************************************************/
-    constructor(filterContext, requiredFilters) {
-        this._requiredFilters = new BehaviorSubject([]);
-        if (filterContext == null) {
-            throw new Error('filterContext must not be null!');
-        }
-        this._filterContext = filterContext;
-        if (requiredFilters) {
-            this._requiredFilters.next(requiredFilters);
+    matches(currentFilters) {
+        const matchedRequiredFilters = new Set();
+        for (const currentFilter of currentFilters) {
+            const requiredKey = this.findMatchingRequiredKey(currentFilter.key);
+            if (!requiredKey) {
+                continue;
+            }
+            if (!Filter.hasValue(currentFilter)) {
+                return false;
+            }
+            matchedRequiredFilters.add(requiredKey);
         }
-        this.context$ = combineLatest([this._requiredFilters, this._filterContext.filters]).pipe(map(([required, currentFilters]) => this.createEvent(requiredFilters, currentFilters)));
+        return this.allRequiredFiltersMatched(matchedRequiredFilters);
     }
     /***************************************************************************
      *                                                                         *
-     * Properties                                                              *
+     * Private methods                                                         *
      *                                                                         *
      **************************************************************************/
-    get filterContext() {
-        return this._filterContext;
+    findMatchingRequiredKey(currentKey) {
+        if (this.requiredKeys.has(currentKey)) {
+            return currentKey;
+        }
+        const prefix = this.getPrefix(currentKey);
+        return this.requiredKeys.has(prefix) ? prefix : undefined;
     }
-    get requiredFilters$() {
-        return this._requiredFilters.asObservable();
+    getPrefix(key) {
+        const separatorIndex = key.indexOf('.');
+        return separatorIndex === -1 ? key : key.slice(0, separatorIndex);
     }
-    get requiredFilters() {
-        return this._requiredFilters.getValue();
+    allRequiredFiltersMatched(matchedRequiredFilters) {
+        return matchedRequiredFilters.size === this.requiredKeys.size;
+    }
+}
+
+class RequiredFilterMatch {
+    constructor(currentFilters, isValid) {
+        this.currentFilters = currentFilters;
+        this.isValid = isValid;
+    }
+}
+class RequiredFilterEvaluator {
+    /**
+     * Observe the given filters and match them against the required filters.
+     * @param filterContext
+     * @param requiredFilters
+     */
+    static observeMatch(filterContext, requiredFilters) {
+        if (filterContext == null) {
+            throw new Error('filterContext must not be null!');
+        }
+        const evaluator = new RequiredFilterEvaluator(requiredFilters);
+        return filterContext.filters.pipe(map((currentFilters) => evaluator.matchFilters(currentFilters)));
+    }
+    /***************************************************************************
+     *                                                                         *
+     * Fields                                                                  *
+     *                                                                         *
+     **************************************************************************/
+    constructor(requiredFilters) {
+        this.someMatchRequired = (requiredFilters ?? []).map((filterGroup) => new RequiredFilterMatcher(filterGroup));
     }
     /***************************************************************************
      *                                                                         *
      * Public API                                                              *
      *                                                                         *
      **************************************************************************/
+    matchFilters(currentFilters) {
+        return new RequiredFilterMatch(currentFilters, this.allRequiredFiltersPresent(currentFilters));
+    }
     /***************************************************************************
      *                                                                         *
      * Private methods                                                         *
      *                                                                         *
      **************************************************************************/
-    createEvent(requiredFilters, currentFilters) {
-        return new RequiredFilterContextChangedEvent(requiredFilters, currentFilters, this.allRequiredFiltersPresent(requiredFilters, currentFilters));
-    }
-    allRequiredFiltersPresent(requiredFilters, currentFilters) {
-        if (requiredFilters) {
-            return requiredFilters.some((filterGroup) => this.hasAllFilters(filterGroup, currentFilters));
-        }
-        return true;
-    }
-    hasAllFilters(requiredFilters, currentFilters) {
-        const requiredFilterSet = new Set(requiredFilters);
-        const currentFilterKeySet = new Set(currentFilters.map((f) => f.key));
-        const areAllRequiredFiltersPresent = requiredFilters.every((required) => currentFilterKeySet.has(required));
-        const areAllRequiredFiltersHaveValue = currentFilters
-            .filter((f) => requiredFilterSet.has(f.key))
-            .every((currentFilter) => Filter.hasValue(currentFilter));
-        return areAllRequiredFiltersPresent && areAllRequiredFiltersHaveValue;
+    allRequiredFiltersPresent(currentFilters) {
+        if (this.someMatchRequired.length === 0)
+            return true;
+        return this.someMatchRequired.some((groupMatcher) => groupMatcher.matches(currentFilters));
     }
 }
 
@@ -5812,7 +5840,7 @@ class DataContextAutoStarter extends DataContextLifeCycleBinding {
      *                                                                         *
      **************************************************************************/
     buildRequiredFilterConditionObservable() {
-        return new RequiredFilterEvaluator(this._dataContext.filter, this._autoStartSpec.requiredFilters).context$.pipe(map((event) => event.isValid));
+        return RequiredFilterEvaluator.observeMatch(this._dataContext.filter, this._autoStartSpec.requiredFilters).pipe(map((event) => event.isValid));
     }
     startDataContext() {
         this.logger.debug(this._dataContext.id + ': Auto starting ...');