@fluid-topics/ft-wc-utils 1.1.112 → 1.1.114

package/build/SearchPlaceConverter.d.ts

@@ -0,0 +1,39 @@
+import { FtSearchRequest, FtSearchSortCriterion } from "@fluid-topics/public-api";
+export interface EnrichedFtSearchRequest extends FtSearchRequest {
+    otherQueryParams?: Record<string, string>;
+}
+/** @deprecated replace with SearchPlaceConverter.serialize  */
+export declare function serializeRequest(baseUrl: string, request: EnrichedFtSearchRequest): string;
+export declare enum SearchPlaceQueryParams {
+    LOCALE = "content-lang",
+    QUERY = "query",
+    SCOPE = "scope",
+    FILTERS = "filters",
+    VIRTUAL_FIELD = "virtual-field",
+    PERIOD = "period",
+    VALUE_FILTERS = "value-filters",
+    DATE_FILTERS = "date-filters",
+    RANGE_FILTERS = "range-filters",
+    SORT = "sort"
+}
+export declare function isSearchPlaceQueryParams(param: string): param is SearchPlaceQueryParams;
+export declare class SearchPlaceConverter {
+    private readonly baseUrl;
+    private readonly predefinedSorts;
+    private readonly scopeMapping;
+    constructor(baseUrl: string, predefinedSorts: Record<string, Array<FtSearchSortCriterion>>);
+    serialize(request: EnrichedFtSearchRequest, searchPage?: string): string;
+    toURLSearchParams(request: EnrichedFtSearchRequest): URLSearchParams;
+    parse(url: string): EnrichedFtSearchRequest;
+    fromURLSearchParams(params: URLSearchParams): EnrichedFtSearchRequest;
+    private parseCompatFilters;
+    private splitUnknownFilter;
+    private parseValueFilters;
+    private parseDateFilters;
+    private parseRangeFilters;
+    private readonly filtersEscapeMapping;
+    private escapeFilters;
+    private superEscapeFilters;
+    private unescapeFilterValue;
+    private parseLegacyPeriodFilter;
+}

package/build/SearchPlaceConverter.js

@@ -0,0 +1,234 @@
+import { FtDateFilterType, isFtDateFilterType, isFtVirtualField } from "@fluid-topics/public-api";
+function quote(value) {
+    return `"${value}"`;
+}
+function unquote(value) {
+    if (value.startsWith("\"") && value.endsWith("\"")) {
+        return value.replace(/(^"+)|("+$)/g, "");
+    }
+    return value;
+}
+/** @deprecated replace with SearchPlaceConverter.serialize  */
+export function serializeRequest(baseUrl, request) {
+    return new SearchPlaceConverter(baseUrl, {}).serialize(request);
+}
+export var SearchPlaceQueryParams;
+(function (SearchPlaceQueryParams) {
+    SearchPlaceQueryParams["LOCALE"] = "content-lang";
+    SearchPlaceQueryParams["QUERY"] = "query";
+    SearchPlaceQueryParams["SCOPE"] = "scope";
+    SearchPlaceQueryParams["FILTERS"] = "filters";
+    SearchPlaceQueryParams["VIRTUAL_FIELD"] = "virtual-field";
+    SearchPlaceQueryParams["PERIOD"] = "period";
+    SearchPlaceQueryParams["VALUE_FILTERS"] = "value-filters";
+    SearchPlaceQueryParams["DATE_FILTERS"] = "date-filters";
+    SearchPlaceQueryParams["RANGE_FILTERS"] = "range-filters";
+    SearchPlaceQueryParams["SORT"] = "sort";
+})(SearchPlaceQueryParams || (SearchPlaceQueryParams = {}));
+const SearchPlaceQueryParamsValues = new Set(Object.values(SearchPlaceQueryParams));
+export function isSearchPlaceQueryParams(param) {
+    return SearchPlaceQueryParamsValues.has(param);
+}
+export class SearchPlaceConverter {
+    constructor(baseUrl, predefinedSorts) {
+        this.baseUrl = baseUrl;
+        this.predefinedSorts = predefinedSorts;
+        this.scopeMapping = {
+            "documents": "DOCUMENTS",
+            "topics": "ALL_TOPICS",
+        };
+        this.filtersEscapeMapping = [
+            ["*", "\\*", "[ft-escaped-star-character]"],
+            ["~", "\\\\~", "[ft-escaped-tilde-character]"],
+            ["_", "\\\\\\\\_", "[ft-escaped-underscore-character]"],
+        ];
+    }
+    serialize(request, searchPage = `/search`) {
+        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) {
+            params.append(SearchPlaceQueryParams.QUERY, request.query);
+        }
+        if (request.scope && request.scope !== "DEFAULT") {
+            params.append(SearchPlaceQueryParams.SCOPE, request.scope.toLowerCase());
+        }
+        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") {
+            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 : [];
+        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)))
+                    .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 : [];
+        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 : [];
+        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 : {};
+        for (let key in otherQueryParams) {
+            params.append(key, otherQueryParams[key]);
+        }
+        return params;
+    }
+    parse(url) {
+        var _a;
+        const urlSplit = url.split("?");
+        const fromParams = this.fromURLSearchParams(new URLSearchParams(urlSplit.slice(1).join("?")));
+        const maybeScopeFromPath = urlSplit[0].split("/search/")[1];
+        return maybeScopeFromPath == null ? fromParams : { ...fromParams, scope: (_a = this.scopeMapping[maybeScopeFromPath]) !== null && _a !== void 0 ? _a : fromParams.scope };
+    }
+    fromURLSearchParams(params) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        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 otherQueryParams = {};
+        for (let key of params.keys()) {
+            if (!isSearchPlaceQueryParams(key)) {
+                otherQueryParams[key] = params.get(key);
+            }
+        }
+        return {
+            contentLocale: params.get(SearchPlaceQueryParams.LOCALE) === "all" ? undefined : ((_d = params.get(SearchPlaceQueryParams.LOCALE)) !== null && _d !== void 0 ? _d : undefined),
+            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 },
+            otherQueryParams,
+        };
+    }
+    parseCompatFilters(params) {
+        var _a, _b, _c, _d, _e, _f;
+        let legacyFilters = [];
+        if (params.has(SearchPlaceQueryParams.FILTERS)) {
+            legacyFilters = this.parseValueFilters((_a = params.get(SearchPlaceQueryParams.FILTERS)) !== null && _a !== void 0 ? _a : "");
+        }
+        if ((_b = params.has(SearchPlaceQueryParams.PERIOD)) !== null && _b !== void 0 ? _b : "") {
+            legacyFilters = [
+                ...legacyFilters,
+                ...this.parseLegacyPeriodFilter(((_c = params.get(SearchPlaceQueryParams.PERIOD)) !== null && _c !== void 0 ? _c : "").toUpperCase())
+            ];
+        }
+        return [
+            ...legacyFilters,
+            ...this.parseValueFilters((_d = params.get(SearchPlaceQueryParams.VALUE_FILTERS)) !== null && _d !== void 0 ? _d : ""),
+            ...this.parseDateFilters((_e = params.get(SearchPlaceQueryParams.DATE_FILTERS)) !== null && _e !== void 0 ? _e : ""),
+            ...this.parseRangeFilters((_f = params.get(SearchPlaceQueryParams.RANGE_FILTERS)) !== null && _f !== void 0 ? _f : ""),
+        ];
+    }
+    splitUnknownFilter(s) {
+        return this.superEscapeFilters(decodeURIComponent(s))
+            .split("*")
+            .map(oneFilter => oneFilter.split("~"));
+    }
+    parseValueFilters(s) {
+        if (s.length === 0) {
+            return [];
+        }
+        return this.splitUnknownFilter(s)
+            .map(oneFilterSplit => ({
+            key: oneFilterSplit[0],
+            valueFilter: {
+                values: oneFilterSplit[1].split("_")
+                    .map(unquote)
+                    .map(value => this.unescapeFilterValue(value)),
+                negative: false
+            }
+        }));
+    }
+    parseDateFilters(s) {
+        if (s.length === 0) {
+            return [];
+        }
+        return this.splitUnknownFilter(s)
+            .map(oneFilterSplit => ({
+            key: oneFilterSplit[0],
+            dateFilter: {
+                type: FtDateFilterType[oneFilterSplit[1].toUpperCase()]
+            }
+        }));
+    }
+    parseRangeFilters(s) {
+        if (s.length === 0) {
+            return [];
+        }
+        return this.splitUnknownFilter(s)
+            .map(oneFilterSplit => ({
+            key: oneFilterSplit[0],
+            rangeFilter: {
+                from: oneFilterSplit[1].split("_")[0],
+                to: oneFilterSplit[1].split("_")[1]
+            }
+        }));
+    }
+    escapeFilters(s) {
+        for (let [c, escaped, superEscaped] of this.filtersEscapeMapping) {
+            s = s.replaceAll(c, escaped);
+        }
+        return s;
+    }
+    superEscapeFilters(s) {
+        for (let [c, escaped, superEscaped] of this.filtersEscapeMapping) {
+            s = s.replaceAll(escaped, superEscaped);
+        }
+        return s;
+    }
+    unescapeFilterValue(value) {
+        for (let [c, escaped, superEscaped] of this.filtersEscapeMapping) {
+            value = value.replace(superEscaped, c);
+        }
+        return value;
+    }
+    parseLegacyPeriodFilter(period) {
+        if (isFtDateFilterType(period)) {
+            return [
+                {
+                    key: "ft:lastEdition",
+                    dateFilter: {
+                        type: FtDateFilterType[period]
+                    }
+                }
+            ];
+        }
+        if (period.startsWith("CUSTOM_")) {
+            const [_, from, to] = period.split("_");
+            return [
+                {
+                    key: "ft:lastEdition",
+                    rangeFilter: {
+                        from: from,
+                        to: to
+                    }
+                }
+            ];
+        }
+        return [];
+    }
+}