@fluid-topics/ft-wc-utils 1.2.2 → 1.2.3

package/build/CacheRegistry.d.ts

@@ -1,14 +1,20 @@
 import { CancelablePromise } from "./CancelablePromise";
+import { WithEventBus } from "./events";
+export declare class ClearCacheEvent extends CustomEvent<{
+    clearedKeys: string[];
+}> {
+    constructor(clearedKeys: string[]);
+}
 export type CachedContent<T = any> = undefined | CancelablePromise<T> | T | Error;
-export declare class CacheRegistry<T = any> {
+export declare class CacheRegistry<T = any> extends WithEventBus {
     private loaders;
     private content;
     private clearTimeouts;
     private finalContent;
     register(key: string, loader: () => Promise<T>): void;
     registerFinal(key: string, loader: () => Promise<T>): void;
-    clearAll(): void;
-    clear(key: string): void;
+    clearAll(dispatchEvent?: boolean): void;
+    clear(key: string, dispatchEvent?: boolean): string | undefined;
     private forceClear;
     private clearClearTimeout;
     set(key: string, value: T): void;

package/build/CacheRegistry.js

@@ -1,6 +1,13 @@
 import { cancelable, CancelablePromise } from "./CancelablePromise";
-export class CacheRegistry {
+import { WithEventBus } from "./events";
+export class ClearCacheEvent extends CustomEvent {
+    constructor(clearedKeys) {
+        super("clear-cache", { detail: { clearedKeys } });
+    }
+}
+export class CacheRegistry extends WithEventBus {
     constructor() {
+        super(...arguments);
         this.loaders = {};
         this.content = {};
         this.clearTimeouts = {};
@@ -14,15 +21,26 @@ export class CacheRegistry {
         this.loaders[key] = loader;
         this.finalContent.add(key);
     }
-    clearAll() {
+    clearAll(dispatchEvent = true) {
+        const clearedKeys = [];
         for (let key in this.content) {
-            this.clear(key);
+            if (this.clear(key, false) != undefined) {
+                clearedKeys.push(key);
+            }
+        }
+        if (dispatchEvent && clearedKeys.length > 0) {
+            this.dispatchEvent(new ClearCacheEvent(clearedKeys));
         }
     }
-    clear(key) {
+    clear(key, dispatchEvent = true) {
         if (!this.finalContent.has(key)) {
             this.forceClear(key);
+            if (dispatchEvent) {
+                this.dispatchEvent(new ClearCacheEvent([key]));
+            }
+            return key;
         }
+        return undefined;
     }
     forceClear(key) {
         this.clearClearTimeout(key);

package/build/SearchPlaceConverter.d.ts

@@ -14,16 +14,21 @@ export declare enum SearchPlaceQueryParams {
     VALUE_FILTERS = "value-filters",
     DATE_FILTERS = "date-filters",
     RANGE_FILTERS = "range-filters",
-    SORT = "sort"
+    SORT = "sort",
+    PER_PAGE = "per-page"
 }
 export declare function isSearchPlaceQueryParams(param: string): param is SearchPlaceQueryParams;
 export declare class SearchPlaceConverter {
     private readonly baseUrl;
     private readonly predefinedSorts;
+    private readonly defaultPerPage;
+    private readonly allLanguagesAllowed;
+    private readonly defaultContentLocale;
     private readonly scopeMapping;
-    constructor(baseUrl: string, predefinedSorts: Record<string, Array<FtSearchSortCriterion>>);
+    constructor(baseUrl: string, predefinedSorts?: Record<string, Array<FtSearchSortCriterion>>, defaultPerPage?: number, allLanguagesAllowed?: boolean, defaultContentLocale?: string);
     serialize(request: EnrichedFtSearchRequest, searchPage?: string): string;
-    toURLSearchParams(request: EnrichedFtSearchRequest): URLSearchParams;
+    serializeToCurrentPageIfPossible(request: EnrichedFtSearchRequest, searchPage?: string): string;
+    toURLSearchParams(request: EnrichedFtSearchRequest, omitContentLocaleIfDefault?: boolean): URLSearchParams;
     parse(url: string): EnrichedFtSearchRequest;
     fromURLSearchParams(params: URLSearchParams): EnrichedFtSearchRequest;
     private parseCompatFilters;

package/build/SearchPlaceConverter.js

@@ -1,4 +1,5 @@
 import { FtDateFilterType, isFtDateFilterType, isFtVirtualField } from "@fluid-topics/public-api";
+import { minmax } from "./helpers";
 function quote(value) {
     return `"${value}"`;
 }
@@ -10,7 +11,7 @@ function unquote(value) {
 }
 /** @deprecated replace with SearchPlaceConverter.serialize  */
 export function serializeRequest(baseUrl, request) {
-    return new SearchPlaceConverter(baseUrl, {}).serialize(request);
+    return new SearchPlaceConverter(baseUrl).serialize(request);
 }
 export var SearchPlaceQueryParams;
 (function (SearchPlaceQueryParams) {
@@ -24,15 +25,19 @@ export var SearchPlaceQueryParams;
     SearchPlaceQueryParams["DATE_FILTERS"] = "date-filters";
     SearchPlaceQueryParams["RANGE_FILTERS"] = "range-filters";
     SearchPlaceQueryParams["SORT"] = "sort";
+    SearchPlaceQueryParams["PER_PAGE"] = "per-page";
 })(SearchPlaceQueryParams || (SearchPlaceQueryParams = {}));
 const SearchPlaceQueryParamsValues = new Set(Object.values(SearchPlaceQueryParams));
 export function isSearchPlaceQueryParams(param) {
     return SearchPlaceQueryParamsValues.has(param);
 }
 export class SearchPlaceConverter {
-    constructor(baseUrl, predefinedSorts) {
+    constructor(baseUrl, predefinedSorts = {}, defaultPerPage = 20, allLanguagesAllowed = false, defaultContentLocale = "en-US") {
         this.baseUrl = baseUrl;
         this.predefinedSorts = predefinedSorts;
+        this.defaultPerPage = defaultPerPage;
+        this.allLanguagesAllowed = allLanguagesAllowed;
+        this.defaultContentLocale = defaultContentLocale;
         this.scopeMapping = {
             "documents": "DOCUMENTS",
             "topics": "ALL_TOPICS",
@@ -43,16 +48,28 @@ export class SearchPlaceConverter {
             ["_", "\\\\\\\\_", "[ft-escaped-underscore-character]"],
         ];
     }
-    serialize(request, searchPage = `/search`) {
+    serialize(request, searchPage) {
+        return this.serializeToCurrentPageIfPossible(request, searchPage !== null && searchPage !== void 0 ? searchPage : "/search");
+    }
+    serializeToCurrentPageIfPossible(request, searchPage) {
         const queryParams = this.toURLSearchParams(request).toString();
-        return new URL(`${this.baseUrl.replace(/\/+$/, "")}${searchPage}?${queryParams}`).href;
-    }
-    toURLSearchParams(request) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        const params = new URLSearchParams({
-            [SearchPlaceQueryParams.LOCALE]: (_a = request.contentLocale) !== null && _a !== void 0 ? _a : "all",
-        });
-        if (((_b = request.query) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+        const useCurrenLocation = searchPage == null || searchPage.trim().length === 0;
+        const url = new URL(useCurrenLocation ? window.location.href : `${this.baseUrl.replace(/\/+$/, "")}${searchPage}`);
+        url.search = queryParams;
+        return url.toString();
+    }
+    toURLSearchParams(request, omitContentLocaleIfDefault = false) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const params = new URLSearchParams();
+        if (request.contentLocale) {
+            if (!omitContentLocaleIfDefault || request.contentLocale !== this.defaultContentLocale) {
+                params.append(SearchPlaceQueryParams.LOCALE, request.contentLocale);
+            }
+        }
+        else {
+            params.append(SearchPlaceQueryParams.LOCALE, this.allLanguagesAllowed ? "all" : this.defaultContentLocale);
+        }
+        if (((_a = request.query) === null || _a === void 0 ? void 0 : _a.length) > 0) {
             params.append(SearchPlaceQueryParams.QUERY, request.query);
         }
         if (request.scope && request.scope !== "DEFAULT") {
@@ -61,37 +78,40 @@ export class SearchPlaceConverter {
         if (request.virtualField && request.virtualField !== "EVERYWHERE") {
             params.append(SearchPlaceQueryParams.VIRTUAL_FIELD, request.virtualField.toLowerCase());
         }
-        if (((_c = request.sort) === null || _c === void 0 ? void 0 : _c.length) > 0 && request.sort[0].key === "ft:lastEdition") {
+        if (((_b = request.sort) === null || _b === void 0 ? void 0 : _b.length) > 0 && request.sort[0].key === "ft:lastEdition") {
             params.append(SearchPlaceQueryParams.SORT, "last_update");
         }
-        const valueFilters = (_e = (_d = request.metadataFilters) === null || _d === void 0 ? void 0 : _d.filter(f => f.valueFilter)) !== null && _e !== void 0 ? _e : [];
+        const valueFilters = (_d = (_c = request.metadataFilters) === null || _c === void 0 ? void 0 : _c.filter(f => f.valueFilter)) !== null && _d !== void 0 ? _d : [];
         if (valueFilters.length > 0) {
             const serializedValues = valueFilters.map(f => {
                 var _a, _b;
                 const values = ((_b = (_a = f.valueFilter) === null || _a === void 0 ? void 0 : _a.values) !== null && _b !== void 0 ? _b : [])
                     .map(value => this.escapeFilters(value))
-                    .map(value => encodeURIComponent(quote(value)))
+                    .map(value => encodeURIComponent(quote(unquote(value))))
                     .join("_");
                 return `${f.key}~${values}`;
             }).join("*");
             params.append(SearchPlaceQueryParams.VALUE_FILTERS, serializedValues);
         }
-        const dateFilters = (_g = (_f = request.metadataFilters) === null || _f === void 0 ? void 0 : _f.filter(f => f.dateFilter)) !== null && _g !== void 0 ? _g : [];
+        const dateFilters = (_f = (_e = request.metadataFilters) === null || _e === void 0 ? void 0 : _e.filter(f => f.dateFilter)) !== null && _f !== void 0 ? _f : [];
         if (dateFilters.length > 0) {
             const serializedDates = dateFilters.map(f => { var _a; return `${f.key}~${(_a = f.dateFilter) === null || _a === void 0 ? void 0 : _a.type.toLowerCase()}`; })
                 .join("*");
             params.append(SearchPlaceQueryParams.DATE_FILTERS, serializedDates);
         }
-        const rangeFilters = (_j = (_h = request.metadataFilters) === null || _h === void 0 ? void 0 : _h.filter(f => f.rangeFilter)) !== null && _j !== void 0 ? _j : [];
+        const rangeFilters = (_h = (_g = request.metadataFilters) === null || _g === void 0 ? void 0 : _g.filter(f => f.rangeFilter)) !== null && _h !== void 0 ? _h : [];
         if (rangeFilters.length > 0) {
             const serializedRanges = rangeFilters.map(f => { var _a, _b; return `${f.key}~${(_a = f.rangeFilter) === null || _a === void 0 ? void 0 : _a.from}_${(_b = f.rangeFilter) === null || _b === void 0 ? void 0 : _b.to}`; })
                 .join("*");
             params.append(SearchPlaceQueryParams.RANGE_FILTERS, serializedRanges);
         }
-        const otherQueryParams = (_k = request.otherQueryParams) !== null && _k !== void 0 ? _k : {};
+        const otherQueryParams = (_j = request.otherQueryParams) !== null && _j !== void 0 ? _j : {};
         for (let key in otherQueryParams) {
             params.append(key, otherQueryParams[key]);
         }
+        if (((_k = request.paging) === null || _k === void 0 ? void 0 : _k.perPage) && ((_m = (_l = request.paging) === null || _l === void 0 ? void 0 : _l.perPage) !== null && _m !== void 0 ? _m : this.defaultPerPage) != this.defaultPerPage) {
+            params.append(SearchPlaceQueryParams.PER_PAGE, String(request.paging.perPage));
+        }
         return params;
     }
     parse(url) {
@@ -103,9 +123,11 @@ export class SearchPlaceConverter {
     }
     fromURLSearchParams(params) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
+        const contentLocale = params.get(SearchPlaceQueryParams.LOCALE) === "all" ? undefined : params.get(SearchPlaceQueryParams.LOCALE);
         const virtualField = ((_a = params.get(SearchPlaceQueryParams.VIRTUAL_FIELD)) !== null && _a !== void 0 ? _a : "EVERYWHERE").toUpperCase();
         const sortType = ((_b = params.get(SearchPlaceQueryParams.SORT)) !== null && _b !== void 0 ? _b : "DEFAULT").toUpperCase();
         const scope = (_c = params.get(SearchPlaceQueryParams.SCOPE)) !== null && _c !== void 0 ? _c : "default";
+        const perPage = +((_d = params.get(SearchPlaceQueryParams.PER_PAGE)) !== null && _d !== void 0 ? _d : this.defaultPerPage);
         const otherQueryParams = {};
         for (let key of params.keys()) {
             if (!isSearchPlaceQueryParams(key)) {
@@ -113,14 +135,17 @@ export class SearchPlaceConverter {
             }
         }
         return {
-            contentLocale: params.get(SearchPlaceQueryParams.LOCALE) === "all" ? undefined : ((_d = params.get(SearchPlaceQueryParams.LOCALE)) !== null && _d !== void 0 ? _d : undefined),
+            contentLocale: contentLocale !== null && contentLocale !== void 0 ? contentLocale : (this.allLanguagesAllowed ? undefined : this.defaultContentLocale),
             query: decodeURIComponent((_e = params.get(SearchPlaceQueryParams.QUERY)) !== null && _e !== void 0 ? _e : ""),
             scope: (_f = this.scopeMapping[scope]) !== null && _f !== void 0 ? _f : "DEFAULT",
             virtualField: isFtVirtualField(virtualField) ? virtualField : "EVERYWHERE",
             sort: (_h = (_g = this.predefinedSorts[sortType]) !== null && _g !== void 0 ? _g : this.predefinedSorts["DEFAULT"]) !== null && _h !== void 0 ? _h : [],
             metadataFilters: this.parseCompatFilters(params),
             facets: [],
-            paging: { page: 1, perPage: 20 },
+            paging: {
+                page: 1,
+                perPage: minmax(1, isNaN(perPage) ? this.defaultPerPage : perPage, 40)
+            },
             otherQueryParams,
         };
     }

package/build/events.d.ts

@@ -1,3 +1,4 @@
+import { Constructor } from "./generic-types";
 export type FtNotificationType = "info" | "warning" | "error";
 export interface FtNotificationEventDetail {
     type: FtNotificationType;
@@ -12,3 +13,13 @@ export declare class PreResizeEvent extends Event {
 export declare class PostResizeEvent extends Event {
     constructor();
 }
+export interface WithEventBusInterface extends EventTarget {
+    eventBus: EventTarget;
+    addEventListener<T extends Event = Event>(type: string, callback: (e: T) => void, options?: AddEventListenerOptions | boolean): void;
+    removeEventListener<T extends Event = Event>(type: string, callback: (e: T) => void, options?: EventListenerOptions | boolean): void;
+}
+export declare function withEventBus<T extends Constructor>(Base: T, eventBus?: EventTarget): T & Constructor<WithEventBusInterface>;
+declare const WithEventBus_base: ObjectConstructor & Constructor<WithEventBusInterface>;
+export declare class WithEventBus extends WithEventBus_base {
+}
+export {};

package/build/events.js

@@ -13,3 +13,22 @@ export class PostResizeEvent extends Event {
         super("ft-post-resize", { composed: true, bubbles: true });
     }
 }
+export function withEventBus(Base, eventBus) {
+    return class extends Base {
+        constructor() {
+            super(...arguments);
+            this.eventBus = eventBus !== null && eventBus !== void 0 ? eventBus : document.createElement("span");
+        }
+        addEventListener(type, callback, options) {
+            this.eventBus.addEventListener(type, callback, options);
+        }
+        dispatchEvent(event) {
+            return this.eventBus.dispatchEvent(event);
+        }
+        removeEventListener(type, callback, options) {
+            this.eventBus.removeEventListener(type, callback, options);
+        }
+    };
+}
+export class WithEventBus extends withEventBus(Object) {
+}

package/build/generic-types.d.ts

@@ -1,4 +1,4 @@
 export type Optional<T> = T | null | undefined;
-export type Constructor<T> = new (...args: any[]) => T;
+export type Constructor<T = any> = new (...args: any[]) => T;
 export type Provider<T> = () => T;
 export type Consumer<T> = (value: T) => any;