@fluid-topics/ft-app-context 1.3.4 → 1.3.6

package/build/ft-app-context.properties.d.ts

@@ -2,6 +2,7 @@ import { FtMessageContext, FtMetadataConfiguration, FtSession, FtUiLocale } from
 export interface FtAppContextProperties {
     baseUrl?: string;
     apiIntegrationIdentifier?: string;
+    apiIntegrationAppVersion?: string;
     uiLocale?: string;
     availableUiLocales?: Array<FtUiLocale>;
     editorMode?: boolean;
@@ -14,4 +15,5 @@ export interface FtAppContextProperties {
     openExternalDocumentInNewTab?: boolean;
     navigatorOnline?: boolean;
     forcedOffline?: boolean;
+    authenticationRequired?: boolean;
 }

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

@@ -1,12 +1,14 @@
 import { FtReduxStore, Optional } from "@fluid-topics/ft-wc-utils";
-import { FtDefaultLocales, FtMetadataConfiguration, FtPrivacyPolicyConfiguration, FtSession, FtUiLocale } from "@fluid-topics/public-api";
+import { FtDefaultLocales, FtMetadataConfiguration, FtPrivacyPolicyConfiguration, FtSearchLocale, FtSession, FtUiLocale } from "@fluid-topics/public-api";
 import { PayloadAction } from "@reduxjs/toolkit";
 export declare const FtAppInfoStoreName = "ft-app-info";
 export interface FtAppInfoState {
     baseUrl: Optional<string>;
     apiIntegrationIdentifier: Optional<string>;
+    apiIntegrationAppVersion: Optional<string>;
     uiLocale: string;
     availableUiLocales: Array<FtUiLocale>;
+    availableContentLocales: Array<FtSearchLocale>;
     defaultLocales: FtDefaultLocales | undefined;
     searchInAllLanguagesAllowed: boolean;
     metadataConfiguration: Optional<FtMetadataConfiguration>;
@@ -18,6 +20,7 @@ export interface FtAppInfoState {
     openExternalDocumentInNewTab: boolean;
     navigatorOnline: boolean;
     forcedOffline: boolean;
+    authenticationRequired: boolean;
 }
 export declare class AuthenticationChangeEvent extends CustomEvent<Optional<FtSession>> {
     static eventName: string;

package/build/redux-stores/FtAppInfoStore.js

@@ -21,8 +21,10 @@ export const ftAppInfoStore = FtReduxStore.get({
     initialState: {
         baseUrl: undefined,
         apiIntegrationIdentifier: undefined,
+        apiIntegrationAppVersion: undefined,
         uiLocale: document.documentElement.lang || "en-US",
         availableUiLocales: [],
+        availableContentLocales: [],
         defaultLocales: undefined,
         searchInAllLanguagesAllowed: false,
         metadataConfiguration: undefined,
@@ -34,5 +36,6 @@ export const ftAppInfoStore = FtReduxStore.get({
         openExternalDocumentInNewTab: false,
         navigatorOnline: true,
         forcedOffline: false,
+        authenticationRequired: false,
     },
 });

package/build/services/FtAnalyticsEventsService.d.ts

@@ -1,10 +1,12 @@
-import type { FtDocumentSearchEvent, FtDocumentStartDisplayEvent, FtKhubSearchEvent, FtTopicStartDisplayEvent, FtSearchPageSelectEvent, FtSearchResultOpenContextMenuEvent } from "@fluid-topics/public-api";
-import { FtService } from "./FtService";
-export declare class FtAnalyticsEventsService extends FtService {
-    sendDocumentStartDisplayEvent(event: FtDocumentStartDisplayEvent): Promise<void>;
-    sendTopicStartDisplayEvent(event: FtTopicStartDisplayEvent): Promise<void>;
-    sendKhubSearchEvent(event: FtKhubSearchEvent): Promise<void>;
-    sendDocumentSearchEvent(event: FtDocumentSearchEvent): Promise<void>;
-    sendSearchPageSelectEvent(event: FtSearchPageSelectEvent): Promise<void>;
-    sendSearchResultOpenContextMenuEvent(event: FtSearchResultOpenContextMenuEvent): Promise<void>;
+import type { FtDocumentSearchEvent, FtDocumentStartDisplayEvent, FtKhubSearchEvent, FtSearchPageSelectEvent, FtSearchResultOpenContextMenuEvent, FtTopicStartDisplayEvent } from "@fluid-topics/public-api";
+import { FtServiceWithCache } from "./FtServiceWithCache";
+export declare class FtAnalyticsEventsService extends FtServiceWithCache {
+    sendDocumentStartDisplayEvent(event: FtDocumentStartDisplayEvent): Promise<string>;
+    sendTopicStartDisplayEvent(event: FtTopicStartDisplayEvent): Promise<string>;
+    sendKhubSearchEvent(event: FtKhubSearchEvent): Promise<string>;
+    sendDocumentSearchEvent(event: FtDocumentSearchEvent): Promise<string>;
+    sendSearchPageSelectEvent(event: FtSearchPageSelectEvent): Promise<string>;
+    sendSearchResultOpenContextMenuEvent(event: FtSearchResultOpenContextMenuEvent): Promise<string>;
+    private sortEventArrays;
+    private sendEvents;
 }

package/build/services/FtAnalyticsEventsService.js

@@ -1,51 +1,58 @@
-import { FtService } from "./FtService";
-export class FtAnalyticsEventsService extends FtService {
+import { FtServiceWithCache } from "./FtServiceWithCache";
+export class FtAnalyticsEventsService extends FtServiceWithCache {
     async sendDocumentStartDisplayEvent(event) {
-        return (await this.awaitApi)
-            .sendEvents([event])
-            .catch(reason => {
-            console.info("Failed to send document.start_display event");
-            console.debug(reason);
-        });
+        return this.sendEvents([this.sortEventArrays(event)], "Failed to send document.start_display event");
     }
     async sendTopicStartDisplayEvent(event) {
-        return (await this.awaitApi)
-            .sendEvents([event])
-            .catch(reason => {
-            console.info("Failed to send topic.start_display event");
-            console.debug(reason);
-        });
+        return this.sendEvents([this.sortEventArrays(event)], "Failed to send topic.start_display event");
     }
     async sendKhubSearchEvent(event) {
-        return (await this.awaitApi)
-            .sendEvents([event])
-            .catch(reason => {
-            console.info("Failed to send khub.search event");
-            console.debug(reason);
-        });
+        return this.sendEvents([this.sortEventArrays(event)], "Failed to send khub.search event");
     }
     async sendDocumentSearchEvent(event) {
-        return (await this.awaitApi)
-            .sendEvents([event])
-            .catch(reason => {
-            console.info("Failed to send document.search event");
-            console.debug(reason);
-        });
+        return this.sendEvents([this.sortEventArrays(event)], "Failed to send document.search event");
     }
     async sendSearchPageSelectEvent(event) {
-        return (await this.awaitApi)
-            .sendEvents([event])
-            .catch(reason => {
-            console.info("Failed to send search_page.select event");
-            console.debug(reason);
-        });
+        return this.sendEvents([this.sortEventArrays(event)], "Failed to send search_page.select event");
     }
     async sendSearchResultOpenContextMenuEvent(event) {
-        return (await this.awaitApi)
-            .sendEvents([event])
-            .catch(reason => {
-            console.info("Failed to send search_result.open_context_menu event");
-            console.debug(reason);
+        return this.sendEvents([this.sortEventArrays(event)], "Failed to send search_result.open_context_menu event");
+    }
+    sortEventArrays(object) {
+        const entries = Object.entries(object).map(([key, value]) => {
+            if (Array.isArray(value)) {
+                return [key, value.map((val) => typeof val === 'object' && val != null && !Array.isArray(val) ? this.sortEventArrays(val) : val)
+                        .sort((a, b) => {
+                        if (typeof a === 'object' && a !== null && 'key' in a) {
+                            return a.key.localeCompare(b.key);
+                        }
+                        else if (typeof a === 'string' && typeof b === 'string') {
+                            return a.localeCompare(b);
+                        }
+                        else {
+                            return String(a).localeCompare(String(b));
+                        }
+                    })];
+            }
+            else if (typeof value === 'object' && value !== null) {
+                return [key, this.sortEventArrays(value)];
+            }
+            else {
+                return [key, value];
+            }
         });
+        return Object.fromEntries(entries);
+    }
+    sendEvents(events, errorMessage) {
+        const fakeResponse = "anything not undefined";
+        return this.cache.get("analytics-event-" + this.hash(events), async () => {
+            return (await this.awaitApi).sendEvents(events)
+                .then(() => fakeResponse)
+                .catch(reason => {
+                console.info(errorMessage);
+                console.debug(reason);
+                return fakeResponse;
+            });
+        }, 1000);
     }
 }

package/build/services/FtRequiredAuthenticationHelper.d.ts

@@ -0,0 +1 @@
+export declare function getOrDefaultIfMissingRequiredAuthentication<T>(provider: () => Promise<T>, defaultValue: T): Promise<T>;

package/build/services/FtRequiredAuthenticationHelper.js

@@ -0,0 +1,9 @@
+import { ftAppInfoStore } from "../redux-stores/FtAppInfoStore";
+const store = ftAppInfoStore;
+export function getOrDefaultIfMissingRequiredAuthentication(provider, defaultValue) {
+    var _a;
+    if (store.getState().authenticationRequired && !((_a = store.getState().session) === null || _a === void 0 ? void 0 : _a.sessionAuthenticated)) {
+        return Promise.resolve(defaultValue);
+    }
+    return provider();
+}

package/build/services/FtServiceWithCache.d.ts

@@ -6,4 +6,6 @@ export declare class FtServiceWithCache extends FtService {
     cache: CacheRegistry;
     constructor(withCommonCache?: boolean, overrideApi?: FluidTopicsApi);
     clearCache(): void;
+    private sortObjectFields;
+    hash(object: any): string;
 }

package/build/services/FtServiceWithCache.js

@@ -4,6 +4,13 @@ export class FtServiceWithCache extends FtService {
     constructor(withCommonCache = true, overrideApi) {
         var _a;
         super(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)));
+        };
         // Have a different cache for each child class
         let constructor = this.constructor;
         constructor.commonCache = (_a = constructor.commonCache) !== null && _a !== void 0 ? _a : new CacheRegistry();
@@ -12,4 +19,8 @@ export class FtServiceWithCache extends FtService {
     clearCache() {
         this.cache.clearAll();
     }
+    hash(object) {
+        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-app-context",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "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": "1.3.4",
+    "@fluid-topics/ft-wc-utils": "1.3.6",
     "lit": "3.1.0"
   },
   "devDependencies": {
     "@fluid-topics/public-api": "1.0.99"
   },
-  "gitHead": "88282019772befe5149b30c92d1ac38067d25c2b"
+  "gitHead": "595e5b638bbf265e174474722661e26767cfbd9d"
 }