feat: change filters host

Author: iobuhov

packages/shared/filter-commons/src/condition-utils.ts

@@ -55,6 +55,7 @@ interface TagCond {
     readonly arg2: TagMarker;
 }
 
+/** @deprecated use for unit tests only */
 export function tag(name: string): TagCond {
     return notEqual(literal(name), literal(MARKER)) as TagCond;
 }

packages/shared/widget-plugin-filtering/src/stores/generic/CombinedFilter.ts

@@ -4,7 +4,7 @@ import { FilterCondition } from "mendix/filters";
 import { autorun, reaction } from "mobx";
 import { fnv1aHash } from "../../utils/fnv-1a-hash";
 
-type ConditionWithMeta = {
+export type ConditionWithMeta = {
     cond: FilterCondition | undefined;
     meta: string;
 };
@@ -110,7 +110,7 @@ export class CombinedFilter {
         return { filter, bag, hash: filter ? this.filterHash(filter) : null };
     }
 
-    saveFilterMeta(hash: string | null, bag: MetaBag): void {
+    private _saveFilterMeta(hash: string | null, bag: MetaBag): void {
         if (!hash) {
             return;
         }
@@ -131,7 +131,7 @@ export class CombinedFilter {
                         this.clearFilterMeta(prev.hash);
                     }
                     if (next.hash) {
-                        this.saveFilterMeta(next.hash, next.bag);
+                        this._saveFilterMeta(next.hash, next.bag);
                     }
                 }
             )

packages/shared/widget-plugin-filtering/src/stores/generic/CustomFilterHost.ts

@@ -1,16 +1,21 @@
-import { tag } from "@mendix/filter-commons/condition-utils";
+import { reduceMap, restoreMap } from "@mendix/filter-commons/condition-utils";
 import { FilterData, FiltersSettingsMap, PlainJs, Serializable } from "@mendix/filter-commons/typings/settings";
 import { FilterCondition } from "mendix/filters";
-import { and } from "mendix/filters/builders";
-import { autorun, makeAutoObservable } from "mobx";
+import { action, autorun, makeAutoObservable } from "mobx";
 import { Filter, ObservableFilterHost } from "../../typings/ObservableFilterHost";
+import { ConditionWithMeta } from "./CombinedFilter";
 
 export class CustomFilterHost implements ObservableFilterHost, Serializable {
     private filters: Map<string, [store: Filter, dispose: () => void]> = new Map();
     private settingsBuffer: FiltersSettingsMap<string> = new Map();
+    private _state: Map<string, FilterCondition | undefined> = new Map();
+
+    readonly metaKey = "custom-filter-host";
 
     constructor() {
-        makeAutoObservable(this);
+        makeAutoObservable(this, {
+            hydrate: action
+        });
     }
 
     get settings(): FiltersSettingsMap<string> {
@@ -21,22 +26,26 @@ export class CustomFilterHost implements ObservableFilterHost, Serializable {
         this.settingsBuffer = data;
     }
 
-    get conditions(): Array<FilterCondition | undefined> {
-        return [...this.filters].map(([key, [{ condition }]]) => {
-            return condition ? and(tag(key), condition) : undefined;
-        });
-    }
-
     observe(key: string, filter: Filter): void {
         this.unobserve(key);
-        const clear = autorun(() => {
+        const clearSettingsSync = autorun(() => {
             if (this.settingsBuffer.has(key)) {
                 filter.fromJSON(this.settingsBuffer.get(key));
             }
         });
+        const clearStateSync = autorun(() => {
+            this._state.set(key, filter.condition);
+        });
+        const skipInit = this.settingsBuffer.has(key);
+        if (!skipInit && this._state.has(key)) {
+            filter.fromViewState(this._state.get(key)!);
+        }
+
         const dispose = (): void => {
-            clear();
+            clearSettingsSync();
+            clearStateSync();
             this.filters.delete(key);
+            this._state.delete(key);
         };
         this.filters.set(key, [filter, dispose]);
     }
@@ -58,4 +67,24 @@ export class CustomFilterHost implements ObservableFilterHost, Serializable {
 
         this.settings = new Map(data as Array<[string, FilterData]>);
     }
+
+    get condWithMeta(): ConditionWithMeta {
+        const conditions: Record<string, FilterCondition | undefined> = {};
+
+        for (const [key, [filter]] of this.filters) {
+            conditions[key] = filter.condition;
+        }
+
+        const [cond, meta] = reduceMap(conditions);
+
+        return {
+            cond,
+            meta
+        };
+    }
+
+    hydrate({ cond, meta }: ConditionWithMeta): void {
+        const map = restoreMap(cond, meta);
+        this._state = new Map(Object.entries(map));
+    }
 }

packages/shared/widget-plugin-filtering/src/typings/ObservableFilterHost.ts

@@ -4,12 +4,12 @@ import { FilterCondition } from "mendix/filters";
 export interface Filter {
     toJSON(): FilterData;
     fromJSON(data: FilterData): void;
+    fromViewState(data: FilterCondition): void;
     condition: FilterCondition | undefined;
     setup?: () => void | void;
 }
 
 export interface ObservableFilterHost {
-    conditions: Array<FilterCondition | undefined>;
     get settings(): FiltersSettingsMap<string>;
     set settings(settings: FiltersSettingsMap<string>);
     observe(key: string, filter: Filter): void;