@fluid-topics/ft-search-context 1.2.21 → 1.2.22

package/build/store/FtSearchStateManager.d.ts

@@ -1,7 +1,7 @@
 import { FtSearchPageState } from "./model";
-import { FtReduxStore } from "@fluid-topics/ft-wc-utils";
+import { FtReduxStore, ReduxWatcher } from "@fluid-topics/ft-wc-utils";
 import { FtSearchPageStateReducers } from "./redux";
-import { FtDateFilterTypeKeys, FtMetadataFilter, FtPublicClusterSortCriterion, FtSearchRequest, FtSearchScope, FtSearchSortCriterion, FtVirtualField } from "@fluid-topics/public-api";
+import { FtDateFilterTypeKeys, FtMetadataFilter, FtPublicClusterSortCriterion, FtSearchRequest, FtSearchScope, FtSearchSortCriterion, FtSuggestRequest, FtVirtualField } from "@fluid-topics/public-api";
 import { FtSearchService } from "./utils/FtSearchService";
 export declare const searchInDocumentTitlesOnlySelector: (s: FtSearchPageState) => boolean;
 export declare class ClearAllFiltersEvent extends Event {
@@ -9,12 +9,14 @@ export declare class ClearAllFiltersEvent extends Event {
     constructor();
 }
 export declare class FtSearchStateManager {
-    store: FtReduxStore<FtSearchPageState, FtSearchPageStateReducers>;
+    readonly store: FtReduxStore<FtSearchPageState, FtSearchPageStateReducers>;
     static build(id: string, service?: FtSearchService): FtSearchStateManager;
-    service: FtSearchService;
+    readonly service: FtSearchService;
     errorHandler?: (e: Error) => void;
     ignoreEmptyQuery: boolean;
     openExternalDocumentInNewTab: boolean;
+    protected readonly searchWatcher: ReduxWatcher<FtSearchPageState, FtSearchRequest>;
+    protected readonly suggestWatcher: ReduxWatcher<FtSearchPageState, FtSuggestRequest>;
     constructor(store: FtReduxStore<FtSearchPageState, FtSearchPageStateReducers>, service?: FtSearchService);
     initService(): Promise<boolean>;
     setQuery(query: string): void;
@@ -49,11 +51,13 @@ export declare class FtSearchStateManager {
     private localesDebouncer;
     updateLocales(): Promise<boolean>;
     private searchDebouncer;
-    launchSearch(): Promise<boolean>;
-    private suggestDebouncer;
-    launchSuggest(): Promise<boolean>;
+    launchSearch: (request?: FtSearchRequest) => Promise<boolean>;
+    private buildSearchRequest;
     private cancelableSearch;
     private fetchSearchData;
+    private suggestDebouncer;
+    launchSuggest: (request?: FtSuggestRequest) => Promise<boolean>;
+    private buildSuggestRequest;
     private cancelableSuggest;
     private fetchSuggestData;
     clear(): void;

package/build/store/FtSearchStateManager.js

@@ -1,4 +1,4 @@
-import { cancelable, CanceledPromiseError, Debouncer } from "@fluid-topics/ft-wc-utils";
+import { cancelable, CanceledPromiseError, Debouncer, watch } from "@fluid-topics/ft-wc-utils";
 import { createSearchPageStore } from "./redux";
 import { FtSearchScope, FtVirtualField } from "@fluid-topics/public-api";
 import { FtSearchService } from "./utils/FtSearchService";
@@ -21,13 +21,36 @@ export class FtSearchStateManager {
         this.openExternalDocumentInNewTab = false;
         this.localesDebouncer = new Debouncer(10);
         this.searchDebouncer = new Debouncer(100);
+        this.launchSearch = (request) => {
+            return this.searchDebouncer.run(() => this.fetchSearchData(request !== null && request !== void 0 ? request : this.buildSearchRequest(this.store.getState())));
+        };
+        this.buildSearchRequest = (state) => {
+            return {
+                ...state.request,
+                facets: this.facetIds.map(id => ({ id })),
+            };
+        };
         this.suggestDebouncer = new Debouncer(300);
+        this.launchSuggest = (request) => {
+            return this.suggestDebouncer.run(() => this.fetchSuggestData(request !== null && request !== void 0 ? request : this.buildSuggestRequest(this.store.getState())));
+        };
+        this.buildSuggestRequest = (state) => {
+            return {
+                input: state.liveQuery,
+                metadataFilters: state.request.metadataFilters,
+                sort: state.request.sort,
+                contentLocale: state.request.contentLocale,
+                scope: state.request.scope,
+            };
+        };
         this.service = service !== null && service !== void 0 ? service : new FtSearchService();
         this.service.cache.addEventListener("clear-cache", (e) => {
             if (e.detail.clearedKeys.includes("available-locales")) {
                 this.updateLocales();
             }
         });
+        this.searchWatcher = watch(store, this.buildSearchRequest, this.launchSearch);
+        this.suggestWatcher = watch(store, this.buildSuggestRequest, this.launchSuggest);
     }
     async initService() {
         this.updateLocales();
@@ -37,7 +60,6 @@ export class FtSearchStateManager {
         this.store.actions.setRequestQuery(query);
         this.store.actions.liveQuery(query);
         this.store.actions.setPageNumber(1);
-        this.launchSearch();
     }
     setContentLocale(contentLocale) {
         var _a;
@@ -53,36 +75,29 @@ export class FtSearchStateManager {
             this.store.actions.setRequestContentLocale(contentLocale);
             this.store.actions.setPageNumber(1);
             this.store.actions.setRequestFilters([]);
-            this.launchSearch();
         }
         return contentLocale;
     }
     forceContentLocale(contentLocale) {
         this.store.actions.setRequestContentLocale(contentLocale);
-        this.launchSearch();
     }
     setPageSize(pageSize) {
         this.store.actions.setPageSize(pageSize);
-        this.launchSearch();
     }
     setPageNumber(pageNumber) {
         this.store.actions.setPageNumber(pageNumber);
-        this.launchSearch();
     }
     setSort(sort) {
         this.store.actions.setRequestSort(sort);
         this.store.actions.setPageNumber(1);
-        this.launchSearch();
     }
     setFilters(filters) {
         const cleanFilters = filters.filter(f => !f.valueFilter || f.valueFilter.values.length > 0);
         this.store.actions.setRequestFilters(cleanFilters);
         this.store.actions.setPageNumber(1);
-        this.launchSearch();
     }
     setClusterSortCriterion(criterions) {
         this.store.actions.setRequestClusterSortCriterion(criterions);
-        this.launchSearch();
     }
     setSearchInDocumentTitlesOnly(searchInDocumentTitleOnly) {
         if (searchInDocumentTitleOnly) {
@@ -93,11 +108,9 @@ export class FtSearchStateManager {
             this.store.actions.setRequestVirtualField(FtVirtualField.EVERYWHERE);
             this.store.actions.setRequestScope(FtSearchScope.DEFAULT);
         }
-        this.launchSearch();
     }
     setVirtualField(virtualField) {
         this.store.actions.setRequestVirtualField(virtualField);
-        this.launchSearch();
     }
     get searchInDocumentTitlesOnly() {
         return searchInDocumentTitlesOnlySelector(this.store.getState());
@@ -109,7 +122,6 @@ export class FtSearchStateManager {
     }
     addFacet(id) {
         this.facetIds = [...this.facetIds, id];
-        this.launchSearch();
     }
     replaceFacet(oldId, newId) {
         let facetIds = this.facetIds.filter(id => id != oldId);
@@ -117,7 +129,6 @@ export class FtSearchStateManager {
             facetIds.push(newId);
         }
         this.facetIds = facetIds;
-        this.launchSearch();
     }
     get facetIds() {
         var _a;
@@ -203,7 +214,6 @@ export class FtSearchStateManager {
     }
     setLiveQuery(query) {
         this.store.actions.liveQuery(query);
-        this.launchSuggest();
     }
     setRequest(request) {
         this.store.actions.setRequest({
@@ -212,18 +222,15 @@ export class FtSearchStateManager {
         });
         this.store.actions.liveQuery(request.query);
         this.store.actions.setPageNumber(1);
-        this.launchSearch();
     }
     setScope(scope) {
         this.store.actions.setRequestScope(scope);
-        this.launchSearch();
     }
     setOtherQueryParams(params) {
         this.store.actions.setOtherQueryParams(params);
     }
     setIgnoreEmptyQuery(ignoreEmptyQuery) {
         this.ignoreEmptyQuery = ignoreEmptyQuery;
-        this.launchSearch();
     }
     setOpenExternalDocumentInNewTab(openExternalDocumentInNewTab) {
         this.openExternalDocumentInNewTab = openExternalDocumentInNewTab;
@@ -231,21 +238,10 @@ export class FtSearchStateManager {
     updateLocales() {
         return this.localesDebouncer.run(async () => this.store.actions.locales((await this.service.getAvailableSearchLocales()).contentLocales));
     }
-    launchSearch() {
-        this.launchSuggest();
-        return this.searchDebouncer.run(() => this.fetchSearchData());
-    }
-    launchSuggest() {
-        return this.suggestDebouncer.run(() => this.fetchSuggestData());
-    }
-    async fetchSearchData() {
+    async fetchSearchData(request) {
         var _a, _b;
         try {
             (_a = this.cancelableSearch) === null || _a === void 0 ? void 0 : _a.cancel();
-            let request = {
-                ...this.store.getState().request,
-                facets: this.facetIds.map(id => ({ id })),
-            };
             this.store.actions.paging(undefined);
             if (this.ignoreEmptyQuery && request.query.length == 0) {
                 this.store.actions.results(undefined);
@@ -273,18 +269,9 @@ export class FtSearchStateManager {
             }
         }
     }
-    async fetchSuggestData() {
+    async fetchSuggestData(request) {
         var _a;
         try {
-            const searchState = this.store.getState();
-            const searchRequest = searchState.request;
-            const request = {
-                input: searchState.liveQuery,
-                metadataFilters: searchRequest.metadataFilters,
-                sort: searchRequest.sort,
-                contentLocale: searchRequest.contentLocale,
-                scope: searchRequest.scope,
-            };
             (_a = this.cancelableSuggest) === null || _a === void 0 ? void 0 : _a.cancel();
             this.cancelableSuggest = cancelable(this.service.launchSuggest(request));
             let results = await this.cancelableSuggest;

package/build/store/utils/FtSearchService.d.ts

@@ -1,8 +1,11 @@
-import type { FtSearchLocales, FtSearchRequest, FtSearchResults, FtSuggestRequest, FtSuggestResults } from "@fluid-topics/public-api";
+import { type FluidTopicsApi, FtSearchLocales, FtSearchRequest, FtSearchResults, FtSuggestRequest, FtSuggestResults } from "@fluid-topics/public-api";
 import { FtServiceWithCache } from "@fluid-topics/ft-app-context";
 export declare class FtSearchService extends FtServiceWithCache {
+    constructor(overrideApi?: FluidTopicsApi);
     launchSearch(request: FtSearchRequest): Promise<FtSearchResults>;
     launchSuggest(request: FtSuggestRequest): Promise<FtSuggestResults>;
     getAvailableSearchLocales(): Promise<FtSearchLocales>;
+    private sortFilters;
+    private sortObjectFields;
     hash(object: any): string;
 }

package/build/store/utils/FtSearchService.js

@@ -1,15 +1,46 @@
 import { FtServiceWithCache } from "@fluid-topics/ft-app-context";
 export class FtSearchService extends FtServiceWithCache {
+    constructor(overrideApi) {
+        super(true, overrideApi);
+        this.sortObjectFields = (_, value) => {
+            if (typeof value !== "object" || value == null || Array.isArray(value)) {
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value)
+                .sort(([ka], [kb]) => ka.localeCompare(kb)));
+        };
+    }
     async launchSearch(request) {
-        return this.cache.get(this.hash(request), async () => (await this.awaitApi).search(request), 2 * 60 * 1000);
+        const sortedRequest = {
+            ...request,
+            metadataFilters: this.sortFilters(request.metadataFilters),
+            facets: [...request.facets].sort((a, b) => a.id.localeCompare(b.id)),
+        };
+        return this.cache.get(this.hash(sortedRequest), async () => (await this.awaitApi).search(request), 2 * 60 * 1000);
     }
     async launchSuggest(request) {
-        return this.cache.get(this.hash(request), async () => (await this.awaitApi).getSuggestions(request), 2 * 60 * 1000);
+        const sortedRequest = {
+            ...request,
+            metadataFilters: this.sortFilters(request.metadataFilters)
+        };
+        return this.cache.get(this.hash(sortedRequest), async () => (await this.awaitApi).getSuggestions(request), 2 * 60 * 1000);
     }
     async getAvailableSearchLocales() {
         return this.cache.get("available-locales", async () => (await this.awaitApi).getAvailableSearchLocales());
     }
+    sortFilters(filters) {
+        return filters
+            .map(f => f.valueFilter == null ? f : {
+            ...f,
+            valueFilter: {
+                ...f.valueFilter,
+                values: f.valueFilter.values.sort((a, b) => a.localeCompare(b))
+            }
+        })
+            .sort((a, b) => a.key.localeCompare(b.key));
+    }
     hash(object) {
-        return "" + Array.from(JSON.stringify(object)).reduce((hash, char) => 0 | (31 * hash + char.charCodeAt(0)), 0);
+        return String(Array.from(JSON.stringify(object, this.sortObjectFields))
+            .reduce((hash, char) => 0 | (31 * hash + char.charCodeAt(0)), 0));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluid-topics/ft-search-context",
-  "version": "1.2.21",
+  "version": "1.2.22",
   "description": "Context block for integrated search components",
   "keywords": [
     "Lit"
@@ -19,12 +19,12 @@
     "url": "ssh://git@scm.mrs.antidot.net:2222/fluidtopics/ft-web-components.git"
   },
   "dependencies": {
-    "@fluid-topics/ft-app-context": "1.2.21",
-    "@fluid-topics/ft-wc-utils": "1.2.21",
+    "@fluid-topics/ft-app-context": "1.2.22",
+    "@fluid-topics/ft-wc-utils": "1.2.22",
     "lit": "3.1.0"
   },
   "devDependencies": {
     "@fluid-topics/public-api": "1.0.82"
   },
-  "gitHead": "d5ad6e93693f963ea69c3ee8aed39f9c6f0d569a"
+  "gitHead": "29f6269b3af8af4c82f5ab2228d52b493ac3ddea"
 }