@fluid-topics/ft-app-context 2.0.14 → 2.0.16

package/build/index.d.ts

@@ -6,6 +6,7 @@ export * from "./services";
 export * from "./ft-app-context.styles";
 export * from "./ft-app-context.properties";
 export * from "./ft-app-context";
+export * from "./redux-stores/FtAppStateManager";
 declare global {
     interface Window {
         fluidTopicsBaseUrl?: string;

package/build/index.js

@@ -6,4 +6,5 @@ export * from "./services";
 export * from "./ft-app-context.styles";
 export * from "./ft-app-context.properties";
 export * from "./ft-app-context";
+export * from "./redux-stores/FtAppStateManager";
 import "./define";

package/build/redux-stores/FtAppInfoStore.d.ts

@@ -1,5 +1,5 @@
 import { FtReduxStore, Optional } from "@fluid-topics/ft-wc-utils";
-import { FtDefaultLocales, FtMetadataConfiguration, FtPrivacyPolicyConfiguration, FtSearchLocale, FtSession, FtUiLocale } from "@fluid-topics/public-api";
+import { FtDefaultLocales, FtMetadataConfiguration, FtPrivacyPolicyConfiguration, FtSearchLocale, FtSession, FtUiLocale, FtUserLocaleSummary } from "@fluid-topics/public-api";
 import { PayloadAction } from "@reduxjs/toolkit";
 export declare const FtAppInfoStoreName = "ft-app-info";
 export interface FtAppInfoState {
@@ -11,6 +11,9 @@ export interface FtAppInfoState {
     availableContentLocales: Array<FtSearchLocale>;
     defaultLocales: FtDefaultLocales | undefined;
     searchInAllLanguagesAllowed: boolean;
+    searchLanguageSetsUiLanguage: boolean;
+    uiLanguageSetsSearchLanguage: boolean;
+    uiLanguageSetsReaderLanguage: boolean;
     metadataConfiguration: Optional<FtMetadataConfiguration>;
     privacyPolicyConfiguration: Optional<FtPrivacyPolicyConfiguration>;
     editorMode: boolean;
@@ -26,6 +29,10 @@ export declare class AuthenticationChangeEvent extends CustomEvent<Optional<FtSe
     static eventName: string;
     constructor(session: Optional<FtSession>);
 }
+export declare class UiLocaleChangedEvent extends CustomEvent<FtUserLocaleSummary> {
+    static eventName: string;
+    constructor(localeSummary: FtUserLocaleSummary);
+}
 declare const reducers: {
     session: (state: FtAppInfoState, action: PayloadAction<Optional<FtSession>>) => void;
 };

package/build/redux-stores/FtAppInfoStore.js

@@ -1,12 +1,17 @@
-import { deepEqual, FtReduxStore } from "@fluid-topics/ft-wc-utils";
+import { deepEqual, FtReduxStore, } from "@fluid-topics/ft-wc-utils";
 export const FtAppInfoStoreName = "ft-app-info";
-class AuthenticationChangeEvent extends CustomEvent {
+export class AuthenticationChangeEvent extends CustomEvent {
     constructor(session) {
         super(AuthenticationChangeEvent.eventName, { detail: session });
     }
 }
 AuthenticationChangeEvent.eventName = "authentication-change";
-export { AuthenticationChangeEvent };
+export class UiLocaleChangedEvent extends CustomEvent {
+    constructor(localeSummary) {
+        super(UiLocaleChangedEvent.eventName, { detail: localeSummary });
+    }
+}
+UiLocaleChangedEvent.eventName = "ui-locale-changed";
 const reducers = {
     session: (state, action) => {
         if (!deepEqual(state.session, action.payload)) {
@@ -27,6 +32,9 @@ export const ftAppInfoStore = FtReduxStore.get({
         availableContentLocales: [],
         defaultLocales: undefined,
         searchInAllLanguagesAllowed: false,
+        searchLanguageSetsUiLanguage: false,
+        uiLanguageSetsSearchLanguage: false,
+        uiLanguageSetsReaderLanguage: false,
         metadataConfiguration: undefined,
         privacyPolicyConfiguration: undefined,
         editorMode: false,

package/build/redux-stores/FtAppStateManager.d.ts

@@ -0,0 +1,42 @@
+import { Debouncer, FtReduxStore, FtStateManager } from "@fluid-topics/ft-wc-utils";
+import { FtAppInfoState, FtAppInfoStateReducers } from "./FtAppInfoStore";
+import { FluidTopicsApi, FtLocalesConfiguration, FtMetadataConfiguration, FtSession } from "@fluid-topics/public-api";
+import { UserLocaleService } from "../services/user/UserLocaleService";
+export declare class FtAppStateManager extends FtStateManager {
+    readonly store: FtReduxStore<FtAppInfoState, FtAppInfoStateReducers>;
+    static build(apiProvider?: () => FluidTopicsApi | undefined): FtAppStateManager;
+    readonly apiProvider: () => FluidTopicsApi | undefined;
+    private cache;
+    withManualResources: boolean;
+    localesConfiguration: FtLocalesConfiguration | null;
+    userLocaleService: UserLocaleService;
+    constructor(store: FtReduxStore<FtAppInfoState, FtAppInfoStateReducers>, apiProvider?: () => FluidTopicsApi | undefined);
+    setWithManualResources(withManualResources: boolean): void;
+    initService(): Promise<void>;
+    updateIfNeeded(): Promise<void>;
+    private cleanSessionDebouncer;
+    private updateSession;
+    updateMetadataConfiguration(): Promise<void>;
+    updateLocalesConfiguration(): Promise<void>;
+    updateAvailableContentLocales(): Promise<void>;
+    private reloadConfiguration;
+    setBaseUrl(baseUrl?: string): void;
+    setApiIntegrationIdentifier(apiIntegrationIdentifier: string): void;
+    setApiIntegrationAppVersion(apiIntegrationAppVersion: string): void;
+    setUiLocale(uiLocale: string): void;
+    private setLocalesConfiguration;
+    private setAvailableContentLocales;
+    reloadDebouncer: Debouncer;
+    stopReloadDebouncer(): void;
+    requestUiLocaleUpdate(uiLocale: string): void;
+    setMetadataConfiguration(metadataConfiguration?: FtMetadataConfiguration): void;
+    setNoCustom(noCustom: boolean): void;
+    setEditorMode(editorMode: boolean): void;
+    setNoCustomComponent(noCustomComponent: boolean | string): void;
+    setSession(session?: FtSession): void;
+    setOpenExternalDocumentInNewTab(openExternalDocumentInNewTab: boolean): void;
+    setNavigatorOnline(navigatorOnline: boolean): void;
+    setForcedOffline(forcedOffline: boolean): void;
+    setAuthenticationRequired(authenticationRequired: boolean): void;
+}
+export declare const ftAppStateManager: FtAppStateManager;

package/build/redux-stores/FtAppStateManager.js

@@ -0,0 +1,153 @@
+import { CacheRegistry, Debouncer, FtStateManager, } from "@fluid-topics/ft-wc-utils";
+import { AuthenticationChangeEvent, ftAppInfoStore, UiLocaleChangedEvent, } from "./FtAppInfoStore";
+import { getOrDefaultIfMissingRequiredAuthentication } from "../services/FtRequiredAuthenticationHelper";
+import { FluidTopicsApiProvider } from "../services";
+import { UserLocaleService } from "../services/user/UserLocaleService";
+export class FtAppStateManager extends FtStateManager {
+    static build(apiProvider) {
+        return new FtAppStateManager(ftAppInfoStore, apiProvider);
+    }
+    constructor(store, apiProvider) {
+        super();
+        this.store = store;
+        this.cache = new CacheRegistry();
+        this.withManualResources = true;
+        this.localesConfiguration = null;
+        this.userLocaleService = new UserLocaleService();
+        this.cleanSessionDebouncer = new Debouncer();
+        this.reloadDebouncer = new Debouncer(500);
+        this.apiProvider = apiProvider !== null && apiProvider !== void 0 ? apiProvider : (() => FluidTopicsApiProvider.get());
+    }
+    setWithManualResources(withManualResources) {
+        this.withManualResources = withManualResources;
+        this.updateIfNeeded();
+    }
+    async initService() {
+        this.store.addEventListener(AuthenticationChangeEvent.eventName, this.reloadConfiguration);
+    }
+    async updateIfNeeded() {
+        if (this.apiProvider()) {
+            if (!this.withManualResources) {
+                if (this.store.getState().session == null) {
+                    this.updateSession();
+                }
+                if (this.store.getState().metadataConfiguration == null) {
+                    this.updateMetadataConfiguration();
+                }
+            }
+            if (this.localesConfiguration == null) {
+                this.updateLocalesConfiguration();
+            }
+            if (this.store.getState().availableContentLocales == null || this.store.getState().availableContentLocales.length == 0) {
+                this.updateAvailableContentLocales();
+            }
+        }
+    }
+    async updateSession() {
+        const session = await this.cache.get("session", async () => {
+            const currentSession = await this.apiProvider().getCurrentSession();
+            if (currentSession.idleTimeoutInMillis > 0) {
+                this.cleanSessionDebouncer.run(() => {
+                    this.cache.clear("session");
+                    this.setSession(undefined);
+                }, currentSession.idleTimeoutInMillis);
+            }
+            return currentSession;
+        });
+        this.setSession(session);
+    }
+    async updateMetadataConfiguration() {
+        this.setMetadataConfiguration(await this.cache.get("metadataConfiguration", () => this.apiProvider().getMetadataConfiguration()));
+    }
+    async updateLocalesConfiguration() {
+        this.setLocalesConfiguration(await this.cache.get("localesConfiguration", () => this.apiProvider().getLocalesConfiguration()));
+    }
+    async updateAvailableContentLocales() {
+        var _a;
+        const availableContentLocales = await this.cache.get("availableContentLocales", () => getOrDefaultIfMissingRequiredAuthentication(() => this.apiProvider().getAvailableSearchLocales(), { contentLocales: [] }));
+        this.setAvailableContentLocales((_a = availableContentLocales.contentLocales) !== null && _a !== void 0 ? _a : []);
+    }
+    reloadConfiguration() {
+        var _a;
+        (_a = this.cache) === null || _a === void 0 ? void 0 : _a.clear("availableContentLocales");
+        if (typeof this.updateAvailableContentLocales === "function") {
+            this.updateAvailableContentLocales();
+        }
+    }
+    setBaseUrl(baseUrl) {
+        this.store.actions.baseUrl(baseUrl);
+        window.fluidTopicsBaseUrl = baseUrl;
+    }
+    setApiIntegrationIdentifier(apiIntegrationIdentifier) {
+        this.store.actions.apiIntegrationIdentifier(apiIntegrationIdentifier);
+    }
+    setApiIntegrationAppVersion(apiIntegrationAppVersion) {
+        this.store.actions.apiIntegrationAppVersion(apiIntegrationAppVersion);
+    }
+    setUiLocale(uiLocale) {
+        this.store.actions.uiLocale(uiLocale);
+    }
+    setLocalesConfiguration(localesConfiguration) {
+        var _a, _b, _c, _d, _e;
+        this.localesConfiguration = localesConfiguration;
+        this.store.actions.defaultLocales(this.localesConfiguration.defaultLocales);
+        this.store.actions.availableUiLocales((_a = this.localesConfiguration.availableUiLocales) !== null && _a !== void 0 ? _a : []);
+        this.store.actions.searchInAllLanguagesAllowed((_b = this.localesConfiguration.allLanguagesAllowed) !== null && _b !== void 0 ? _b : false);
+        this.store.actions.searchLanguageSetsUiLanguage((_c = this.localesConfiguration.searchLanguageSetsUiLanguage) !== null && _c !== void 0 ? _c : false);
+        this.store.actions.uiLanguageSetsSearchLanguage((_d = this.localesConfiguration.uiLanguageSetsSearchLanguage) !== null && _d !== void 0 ? _d : false);
+        this.store.actions.uiLanguageSetsReaderLanguage((_e = this.localesConfiguration.uiLanguageSetsReaderLanguage) !== null && _e !== void 0 ? _e : false);
+        setTimeout(() => this.updateIfNeeded());
+    }
+    setAvailableContentLocales(availableContentLocales) {
+        this.store.actions.availableContentLocales(availableContentLocales);
+        setTimeout(() => this.updateIfNeeded());
+    }
+    stopReloadDebouncer() {
+        this.reloadDebouncer.cancel();
+    }
+    requestUiLocaleUpdate(uiLocale) {
+        this.userLocaleService.updateUiLocale({ uiLocale })
+            .then((response) => {
+            if (!response.uiLocaleChanged) {
+                return;
+            }
+            // We trigger a debounced reload, each component who interact with URL before reload (search/reader) stop the debouncer and take care of the reload
+            // Known limitation : If multiple component need to mutate the URL before reload,the faster one will achieved it reload before the other.
+            this.reloadDebouncer.run(() => window.location.reload());
+            this.store.dispatchEvent(new UiLocaleChangedEvent(response));
+        })
+            .catch(() => {
+            // No locale update or error
+        });
+    }
+    setMetadataConfiguration(metadataConfiguration) {
+        this.store.actions.metadataConfiguration(metadataConfiguration);
+        setTimeout(() => this.updateIfNeeded());
+    }
+    setNoCustom(noCustom) {
+        this.store.actions.noCustom(noCustom);
+    }
+    setEditorMode(editorMode) {
+        this.store.actions.editorMode(editorMode);
+    }
+    setNoCustomComponent(noCustomComponent) {
+        this.store.actions.noCustomComponent(noCustomComponent);
+    }
+    setSession(session) {
+        this.store.actions.session(session);
+        setTimeout(() => this.updateIfNeeded());
+    }
+    setOpenExternalDocumentInNewTab(openExternalDocumentInNewTab) {
+        this.store.actions.openExternalDocumentInNewTab(openExternalDocumentInNewTab);
+    }
+    setNavigatorOnline(navigatorOnline) {
+        this.store.actions.navigatorOnline(navigatorOnline);
+    }
+    setForcedOffline(forcedOffline) {
+        this.store.actions.forcedOffline(forcedOffline);
+    }
+    setAuthenticationRequired(authenticationRequired) {
+        this.store.actions.authenticationRequired(authenticationRequired);
+    }
+}
+export const ftAppStateManager = FtAppStateManager.build();

package/build/services/history/HistoryService.models.js

@@ -1,7 +1,6 @@
-class HistoryChangeEvent extends CustomEvent {
+export class HistoryChangeEvent extends CustomEvent {
     constructor(currentItem) {
         super(HistoryChangeEvent.eventName, { detail: { currentItem } });
     }
 }
 HistoryChangeEvent.eventName = "change";
-export { HistoryChangeEvent };

package/build/services/user/UserLocaleService.d.ts

@@ -0,0 +1,5 @@
+import { FtService } from "../FtService";
+import { FtUserLocaleSummary, FtUserUiLocaleUpdateRequest } from "@fluid-topics/public-api";
+export declare class UserLocaleService extends FtService {
+    updateUiLocale(uiLocale: FtUserUiLocaleUpdateRequest): Promise<FtUserLocaleSummary>;
+}

package/build/services/user/UserLocaleService.js

@@ -0,0 +1,6 @@
+import { FtService } from "../FtService";
+export class UserLocaleService extends FtService {
+    async updateUiLocale(uiLocale) {
+        return (await this.awaitApi).updateUiLocale(uiLocale);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fluid-topics/ft-app-context",
-    "version": "2.0.14",
+    "version": "2.0.16",
     "description": "Global application context for Fluid Topics integrations",
     "keywords": [
         "Lit"
@@ -19,11 +19,11 @@
         "url": "ssh://git@scm.mrs.antidot.net:2222/fluidtopics/ft-web-components.git"
     },
     "dependencies": {
-        "@fluid-topics/ft-wc-utils": "2.0.14",
+        "@fluid-topics/ft-wc-utils": "2.0.16",
         "lit": "3.1.0"
     },
     "devDependencies": {
-        "@fluid-topics/public-api": "1.0.119"
+        "@fluid-topics/public-api": "1.0.120"
     },
-    "gitHead": "4c50289bffd5b4b58542856830adc1399b93a70f"
+    "gitHead": "a972b95acf70b2bfab648ae99cec9d9cbe77c86f"
 }