@fluid-topics/ft-wc-utils 1.3.0 → 1.3.2

package/build/CacheRegistry.d.ts

@@ -5,26 +5,32 @@ export declare class ClearCacheEvent extends CustomEvent<{
 }> {
     constructor(clearedKeys: string[]);
 }
-export type CachedContent<T = any> = undefined | CancelablePromise<T> | T | Error;
-export declare class CacheRegistry<T = any> extends WithEventBus {
-    private loaders;
+type CachedContentStatus = "REGISTERED" | "LOADING" | "RESOLVED" | "ERROR";
+export type CachedContent = {
+    loader: () => Promise<any>;
+    final: boolean;
+    status: CachedContentStatus;
+    promise?: CancelablePromise<any>;
+    value?: any;
+    error?: Error;
+    clearTimeout?: number;
+};
+export declare class CacheRegistry extends WithEventBus {
     private content;
-    private clearTimeouts;
-    private finalContent;
-    register(key: string, loader: () => Promise<T>): void;
-    registerFinal(key: string, loader: () => Promise<T>): void;
-    clearAll(dispatchEvent?: boolean): void;
+    register(key: string, loader: () => Promise<any>, final?: boolean): void;
+    registerFinal(key: string, loader: () => Promise<any>): void;
+    clearAll(dispatchEvent?: boolean): string[];
     clear(key: string, dispatchEvent?: boolean): string | undefined;
     private forceClear;
     private clearClearTimeout;
-    set(key: string, value: T): void;
-    setFinal(key: string, value: T): void;
-    get<U = T>(key: string, loader?: () => Promise<U>, ttl?: number): Promise<U>;
-    private isResolvedValue;
-    getNow<U = T>(key: string): U | undefined;
+    set(key: string, value: any, final?: boolean): void;
+    setFinal(key: string, value: any): void;
+    get<U = any>(key: string, loader?: () => Promise<U>, ttl?: number): Promise<U>;
+    isRegistered(key: string): boolean;
+    getNow<U = any>(key: string): U | undefined;
     has(key: string): boolean;
     resolvedKeys(): Array<string>;
-    resolvedValues(): Array<T>;
+    resolvedValues<U = any>(): Array<U>;
     keys(): Array<string>;
-    values(): Array<CachedContent<T>>;
 }
+export {};

package/build/CacheRegistry.js

@@ -1,4 +1,4 @@
-import { cancelable, CancelablePromise } from "./CancelablePromise";
+import { cancelable } from "./CancelablePromise";
 import { WithEventBus } from "./events";
 export class ClearCacheEvent extends CustomEvent {
     constructor(clearedKeys) {
@@ -8,22 +8,21 @@ export class ClearCacheEvent extends CustomEvent {
 export class CacheRegistry extends WithEventBus {
     constructor() {
         super(...arguments);
-        this.loaders = {};
         this.content = {};
-        this.clearTimeouts = {};
-        this.finalContent = new Set();
     }
-    register(key, loader) {
-        this.loaders[key] = loader;
-        this.finalContent.delete(key);
+    register(key, loader, final = false) {
+        var _a;
+        const content = this.content[key];
+        const status = (_a = content === null || content === void 0 ? void 0 : content.status) !== null && _a !== void 0 ? _a : "REGISTERED";
+        this.content[key] = { ...content, loader, final, status };
     }
     registerFinal(key, loader) {
-        this.loaders[key] = loader;
-        this.finalContent.add(key);
+        this.forceClear(key); // Force the final content to be reloaded when the loader changes
+        this.register(key, loader, true);
     }
     clearAll(dispatchEvent = true) {
         const clearedKeys = [];
-        for (let key in this.content) {
+        for (const key in this.content) {
             if (this.clear(key, false) != undefined) {
                 clearedKeys.push(key);
             }
@@ -31,9 +30,10 @@ export class CacheRegistry extends WithEventBus {
         if (dispatchEvent && clearedKeys.length > 0) {
             this.dispatchEvent(new ClearCacheEvent(clearedKeys));
         }
+        return clearedKeys;
     }
     clear(key, dispatchEvent = true) {
-        if (!this.finalContent.has(key)) {
+        if (this.content[key] && !this.content[key].final) {
             this.forceClear(key);
             if (dispatchEvent) {
                 this.dispatchEvent(new ClearCacheEvent([key]));
@@ -43,73 +43,91 @@ export class CacheRegistry extends WithEventBus {
         return undefined;
     }
     forceClear(key) {
-        this.clearClearTimeout(key);
-        if (this.content[key] instanceof CancelablePromise) {
-            this.content[key].cancel();
+        var _a;
+        const content = this.content[key];
+        if (content) {
+            this.clearClearTimeout(key);
+            (_a = content.promise) === null || _a === void 0 ? void 0 : _a.cancel();
+            this.content[key] = {
+                loader: content.loader,
+                final: content.final,
+                status: "REGISTERED",
+            };
         }
-        delete this.content[key];
     }
     clearClearTimeout(key) {
-        if (this.clearTimeouts[key] != null) {
-            window.clearTimeout(this.clearTimeouts[key]);
-            delete this.clearTimeouts[key];
+        var _a, _b, _c;
+        if (((_a = this.content[key]) === null || _a === void 0 ? void 0 : _a.clearTimeout) != null) {
+            window.clearTimeout((_b = this.content[key]) === null || _b === void 0 ? void 0 : _b.clearTimeout);
+            (_c = this.content[key]) === null || _c === void 0 ? true : delete _c.clearTimeout;
         }
     }
-    set(key, value) {
+    set(key, value, final = false) {
         this.forceClear(key);
-        this.register(key, async () => value);
-        this.content[key] = value;
+        const loader = async () => value;
+        const status = "RESOLVED";
+        this.content[key] = { loader, final, status, value };
     }
     setFinal(key, value) {
-        this.forceClear(key);
-        this.registerFinal(key, async () => value);
-        this.content[key] = value;
+        return this.set(key, value, true);
     }
     async get(key, loader, ttl) {
-        if (this.content[key] === undefined) {
-            loader = loader !== null && loader !== void 0 ? loader : this.loaders[key];
-            if (loader == undefined) {
+        if (!this.isRegistered(key)) {
+            if (!loader) {
                 throw new Error("Unknown cache key " + key);
             }
-            const cancelablePromise = cancelable(loader());
-            this.content[key] = cancelablePromise;
-            return cancelablePromise
-                .then(v => {
-                this.content[key] = v;
-                if (ttl != null) {
-                    this.clearClearTimeout(key);
-                    this.clearTimeouts[key] = window.setTimeout(() => this.clear(key), ttl);
-                }
-                return v;
-            });
+            this.register(key, loader);
         }
-        if (this.content[key] instanceof Error) {
-            throw this.content[key];
+        const content = this.content[key];
+        switch (content.status) {
+            case "ERROR":
+                throw content.error;
+            case "LOADING":
+                return content.promise;
+            case "RESOLVED":
+                return content.value;
+            case "REGISTERED":
+                loader = loader !== null && loader !== void 0 ? loader : content.loader;
+                content.status = "LOADING";
+                content.promise = cancelable(loader());
+                return content.promise
+                    .then(value => {
+                    content.status = "RESOLVED";
+                    content.value = value;
+                    if (ttl != null) {
+                        this.clearClearTimeout(key);
+                        content.clearTimeout = window.setTimeout(() => this.clear(key), ttl);
+                    }
+                    return value;
+                })
+                    .catch(error => {
+                    var _a;
+                    if (!((_a = content.promise) === null || _a === void 0 ? void 0 : _a.isCanceled)) {
+                        content.status = "ERROR";
+                        content.error = error;
+                    }
+                    throw error;
+                });
         }
-        return this.content[key];
     }
-    isResolvedValue(value) {
-        return value != null && !(value instanceof Promise) && !(value instanceof Error);
+    isRegistered(key) {
+        return this.content[key] != undefined;
     }
     getNow(key) {
-        if (this.isResolvedValue(this.content[key])) {
-            return this.content[key];
-        }
-        return undefined;
+        var _a;
+        return (_a = this.content[key]) === null || _a === void 0 ? void 0 : _a.value;
     }
     has(key) {
-        return this.content[key] != null;
+        var _a, _b;
+        return ((_a = this.content[key]) === null || _a === void 0 ? void 0 : _a.status) === "RESOLVED" || ((_b = this.content[key]) === null || _b === void 0 ? void 0 : _b.status) === "LOADING";
     }
     resolvedKeys() {
-        return Object.keys(this.content).filter(key => this.isResolvedValue(this.content[key]));
+        return Object.keys(this.content).filter(key => { var _a; return ((_a = this.content[key]) === null || _a === void 0 ? void 0 : _a.status) === "RESOLVED"; });
     }
     resolvedValues() {
-        return Object.values(this.content).filter(value => this.isResolvedValue(value));
+        return this.resolvedKeys().map(key => this.content[key].value);
     }
     keys() {
         return Object.keys(this.content);
     }
-    values() {
-        return Object.values(this.content);
-    }
 }

package/build/SearchPlaceConverter.js

@@ -72,7 +72,7 @@ export class SearchPlaceConverter {
             params.append(SearchPlaceQueryParams.QUERY, request.query);
         }
         // Only extract non-negative valueFilter since they are not supported by URLSearchParams
-        const valueFilters = (_c = (_b = request.metadataFilters) === null || _b === void 0 ? void 0 : _b.filter(f => { var _a; return ((_a = f.valueFilter) === null || _a === void 0 ? void 0 : _a.negative) === false; })) !== null && _c !== void 0 ? _c : [];
+        const valueFilters = (_c = (_b = request.metadataFilters) === null || _b === void 0 ? void 0 : _b.filter(f => f.valueFilter && !f.valueFilter.negative)) !== null && _c !== void 0 ? _c : [];
         if (valueFilters.length > 0) {
             const serializedValues = valueFilters.map(f => {
                 var _a, _b;
@@ -109,7 +109,7 @@ export class SearchPlaceConverter {
             params.append(SearchPlaceQueryParams.PER_PAGE, String(request.paging.perPage));
         }
         const otherQueryParams = (_m = request.otherQueryParams) !== null && _m !== void 0 ? _m : {};
-        for (let key in otherQueryParams) {
+        for (const key in otherQueryParams) {
             params.append(key, otherQueryParams[key]);
         }
         // Use encodeURIComponent instead of URLSearchParams.toString() to encode the result
@@ -148,7 +148,7 @@ export class SearchPlaceConverter {
         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()) {
+        for (const key of params.keys()) {
             if (!isSearchPlaceQueryParams(key)) {
                 otherQueryParams[key] = params.get(key);
             }
@@ -163,7 +163,7 @@ export class SearchPlaceConverter {
             facets: [],
             paging: {
                 page: 1,
-                perPage: minmax(1, isNaN(perPage) ? this.defaultPerPage : perPage, 1000)
+                perPage: minmax(1, isNaN(perPage) ? this.defaultPerPage : perPage, 1000),
             },
             otherQueryParams,
         };
@@ -177,7 +177,7 @@ export class SearchPlaceConverter {
         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())
+                ...this.parseLegacyPeriodFilter(((_c = params.get(SearchPlaceQueryParams.PERIOD)) !== null && _c !== void 0 ? _c : "").toUpperCase()),
             ];
         }
         return [
@@ -203,8 +203,8 @@ export class SearchPlaceConverter {
                 values: oneFilterSplit[1].split("_")
                     .map(unquote)
                     .map(value => this.unescapeFilterValue(value)),
-                negative: false
-            }
+                negative: false,
+            },
         }));
     }
     parseDateFilters(s) {
@@ -215,8 +215,8 @@ export class SearchPlaceConverter {
             .map(oneFilterSplit => ({
             key: oneFilterSplit[0],
             dateFilter: {
-                type: FtDateFilterType[oneFilterSplit[1].toUpperCase()]
-            }
+                type: FtDateFilterType[oneFilterSplit[1].toUpperCase()],
+            },
         }));
     }
     parseRangeFilters(s) {
@@ -228,24 +228,24 @@ export class SearchPlaceConverter {
             key: oneFilterSplit[0],
             rangeFilter: {
                 from: oneFilterSplit[1].split("_")[0],
-                to: oneFilterSplit[1].split("_")[1]
-            }
+                to: oneFilterSplit[1].split("_")[1],
+            },
         }));
     }
     escapeFilters(s) {
-        for (let [c, escaped, superEscaped] of this.filtersEscapeMapping) {
+        for (const [c, escaped, _] of this.filtersEscapeMapping) {
             s = s.replaceAll(c, escaped);
         }
         return s;
     }
     superEscapeFilters(s) {
-        for (let [c, escaped, superEscaped] of this.filtersEscapeMapping) {
+        for (const [_, escaped, superEscaped] of this.filtersEscapeMapping) {
             s = s.replaceAll(escaped, superEscaped);
         }
         return s;
     }
     unescapeFilterValue(value) {
-        for (let [c, escaped, superEscaped] of this.filtersEscapeMapping) {
+        for (const [c, _, superEscaped] of this.filtersEscapeMapping) {
             value = value.replace(superEscaped, c);
         }
         return value;
@@ -256,9 +256,9 @@ export class SearchPlaceConverter {
                 {
                     key: "ft:lastEdition",
                     dateFilter: {
-                        type: FtDateFilterType[period]
-                    }
-                }
+                        type: FtDateFilterType[period],
+                    },
+                },
             ];
         }
         if (period.startsWith("CUSTOM_")) {
@@ -268,9 +268,9 @@ export class SearchPlaceConverter {
                     key: "ft:lastEdition",
                     rangeFilter: {
                         from: from,
-                        to: to
-                    }
-                }
+                        to: to,
+                    },
+                },
             ];
         }
         return [];

package/build/ft-input/FtInput.d.ts

@@ -1,6 +1,7 @@
 import { Constructor } from "../generic-types";
 import { ValidationRule } from "./ValidationRules";
 import { FtLitElement } from "../FtLitElement";
+import { TemplateResult } from "lit";
 export type FtInputInterface<V> = {
     warningRules: Array<ValidationRule<V>>;
     errorRules: Array<ValidationRule<V>>;
@@ -23,6 +24,8 @@ export type FtInputInterface<V> = {
     onFocus(): void;
     onBlur(): void;
     triggerValidation(): void;
+    renderMessagesForScreenReader(): TemplateResult;
+    messagesForScreenReaderElementId: string;
 };
 export declare enum ValidateOn {
     blur = "blur",

package/build/ft-input/FtInput.js

@@ -4,7 +4,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { property, state, } from "lit/decorators.js";
+import { property, state } from "lit/decorators.js";
+import { repeat } from "lit/directives/repeat.js";
+import { when } from "lit/directives/when.js";
+import { html } from "lit";
 export var ValidateOn;
 (function (ValidateOn) {
     ValidateOn["blur"] = "blur";
@@ -67,6 +70,25 @@ export function toFtInput(ElementClass) {
             this.status = this.resolveStatus();
             this.dispatchEvent(new InputValidationEvent(this.status));
         }
+        get messagesForScreenReaderElementId() {
+            return "sr-helper-text-list";
+        }
+        renderMessagesForScreenReader() {
+            return html `
+                <ul aria-live="polite" id="${this.messagesForScreenReaderElementId}"
+                    style="position:absolute;left:-10000px;top:auto;width:1px;height:1px;overflow:hidden;list-style:none;">
+                    ${repeat(this.errorMessages, (v) => html `
+                        <li>${v}</li>
+                    `)}
+                    ${repeat(this.warningMessages, (v) => html `
+                        <li>${v}</li>
+                    `)}
+                    ${when((!this.errorMessages.length && !this.warningMessages.length && this.helperText), () => html `
+                        <li>${this.helperText}</li>
+                    `)}
+                </ul>
+            `;
+        }
         resolveStatus() {
             return this.forceStatus ? this.forceStatus :
                 this.errorMessages.length ? Status.error :