@fluid-topics/ft-app-context 1.3.5 → 1.3.7

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/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./mixins/withDateFormat";
 export * from "./redux-stores/FtAppInfoStore";
 export * from "./redux-stores/FtUserAssetsStore";
+export * from "./redux-stores/selectors/UserAssetSelectors";
 export * from "./services";
 export * from "./ft-app-context.styles";
 export * from "./ft-app-context.properties";

package/build/index.js

@@ -3,6 +3,7 @@ import { FtAppContext } from "./ft-app-context";
 export * from "./mixins/withDateFormat";
 export * from "./redux-stores/FtAppInfoStore";
 export * from "./redux-stores/FtUserAssetsStore";
+export * from "./redux-stores/selectors/UserAssetSelectors";
 export * from "./services";
 export * from "./ft-app-context.styles";
 export * from "./ft-app-context.properties";

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

@@ -5,6 +5,7 @@ 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>;
@@ -19,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,6 +21,7 @@ export const ftAppInfoStore = FtReduxStore.get({
     initialState: {
         baseUrl: undefined,
         apiIntegrationIdentifier: undefined,
+        apiIntegrationAppVersion: undefined,
         uiLocale: document.documentElement.lang || "en-US",
         availableUiLocales: [],
         availableContentLocales: [],
@@ -35,5 +36,6 @@ export const ftAppInfoStore = FtReduxStore.get({
         openExternalDocumentInNewTab: false,
         navigatorOnline: true,
         forcedOffline: false,
+        authenticationRequired: false,
     },
 });

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

@@ -1,26 +1,62 @@
-import { FtBookmark, FtMySearch } from "@fluid-topics/public-api";
-import { EmptyReducers, FtReduxStore, Optional } from "@fluid-topics/ft-wc-utils";
+import { FtBookmark, FtMySearch, FtUserAssetCount, FtUserAssetType } from "@fluid-topics/public-api";
+import { FtReduxStore, Optional } from "@fluid-topics/ft-wc-utils";
+import { UserAssetsCountService } from "../services/user-assets/UserAssetCountService";
 export declare const FtUserAssetsStoreName = "ft-user-assets";
+export interface AssetCounts {
+    allAsset: Record<FtUserAssetType, number | undefined>;
+    bookmarkByMap: {
+        [mapId: string]: number;
+    };
+}
 export interface FtUserAssetsState {
     savedSearches: Optional<Array<FtMySearch>>;
     bookmarks: Optional<Array<FtBookmark>>;
+    assetCounts: AssetCounts;
 }
-export type FtUserAssetsStore = FtReduxStore<FtUserAssetsState, EmptyReducers>;
+declare const reducers: {
+    setAssetCount: (state: FtUserAssetsState, action: {
+        payload: {
+            assetCount: FtUserAssetCount;
+        };
+        type: string;
+    }) => void;
+    clearAssetCount: (state: FtUserAssetsState) => void;
+    setBookmarkCountByMap: (state: FtUserAssetsState, action: {
+        payload: {
+            count: number;
+            mapId: string;
+        };
+        type: string;
+    }) => void;
+    clearBookmarkCountByMap: (state: FtUserAssetsState) => void;
+};
+export type FtUserAssetsStateReducers = typeof reducers;
+export type FtUserAssetsStore = FtReduxStore<FtUserAssetsState, FtUserAssetsStateReducers>;
 export declare const ftUserAssetsStore: FtUserAssetsStore;
-declare class UserAssetsActions {
+export declare class UserAssetsActions {
+    private assetCountsService;
     private currentSession;
     private bookmarksAreUsed;
     private bookmarksService;
     private savedSearchesService;
-    constructor();
+    constructor(assetCountsService?: UserAssetsCountService);
     private reloadWhenUserSessionChanges;
+    clearUserAssetCounts(): void;
     clear(): void;
     clearMySearches(): void;
     private clearMyBookmarks;
     reloadMySearches(): Promise<void>;
     reloadBookmarks(): Promise<void>;
+    loadAssetCount(assetType: FtUserAssetType): Promise<void>;
+    loadBookmarkByMapId(mapId: string): Promise<void>;
+    reloadAssetCount(assetType: FtUserAssetType): Promise<void>;
     registerBookmarkComponent(): Promise<void>;
     private updateBookmarksIfUsed;
 }
+declare global {
+    interface Window {
+        FluidTopicsUserAssetsActions: UserAssetsActions;
+    }
+}
 export declare const userAssetsActions: UserAssetsActions;
 export {};

package/build/redux-stores/FtUserAssetsStore.js

@@ -1,17 +1,42 @@
+import { FtUserAssetType } from "@fluid-topics/public-api";
 import { deepEqual, FtReduxStore } from "@fluid-topics/ft-wc-utils";
 import { SavedSearchesService } from "../services/SavedSearchesService";
 import { BookmarksService } from "../services/BookmarksService";
 import { ftAppInfoStore } from "./FtAppInfoStore";
+import { UserAssetsCountService } from "../services/user-assets/UserAssetCountService";
 export const FtUserAssetsStoreName = "ft-user-assets";
+const reducers = {
+    setAssetCount: (state, action) => {
+        const { userAssetType, count } = action.payload.assetCount;
+        state.assetCounts.allAsset[userAssetType] = count;
+    },
+    clearAssetCount: (state) => {
+        Object.values(FtUserAssetType).forEach(type => {
+            state.assetCounts.allAsset[type] = undefined;
+        });
+    },
+    setBookmarkCountByMap: (state, action) => {
+        const mapId = action.payload.mapId;
+        state.assetCounts.bookmarkByMap[mapId] = action.payload.count;
+    },
+    clearBookmarkCountByMap: (state) => {
+        state.assetCounts.bookmarkByMap = {};
+    },
+};
 export const ftUserAssetsStore = FtReduxStore.get({
     name: FtUserAssetsStoreName,
+    reducers: reducers,
     initialState: {
         savedSearches: undefined,
         bookmarks: undefined,
+        assetCounts: {
+            allAsset: Object.fromEntries(Object.values(FtUserAssetType).map(key => [key, undefined])), bookmarkByMap: {},
+        },
     },
 });
-class UserAssetsActions {
-    constructor() {
+export class UserAssetsActions {
+    constructor(assetCountsService = new UserAssetsCountService()) {
+        this.assetCountsService = assetCountsService;
         this.currentSession = ftAppInfoStore.getState().session;
         this.bookmarksAreUsed = false;
         this.bookmarksService = new BookmarksService();
@@ -25,8 +50,13 @@ class UserAssetsActions {
             this.currentSession = session;
             this.clearMySearches(); // The search context automatically reload
             this.reloadBookmarks();
+            this.clearUserAssetCounts();
         }
     }
+    clearUserAssetCounts() {
+        ftUserAssetsStore.actions.clearAssetCount();
+        ftUserAssetsStore.actions.clearBookmarkCountByMap();
+    }
     clear() {
         this.clearMySearches();
         this.clearMyBookmarks();
@@ -48,6 +78,30 @@ class UserAssetsActions {
         this.bookmarksService.clearCache();
         await this.updateBookmarksIfUsed();
     }
+    async loadAssetCount(assetType) {
+        const assetCount = await this.assetCountsService.getUserAssetCount(assetType);
+        if (assetCount) {
+            ftUserAssetsStore.actions.setAssetCount({ assetCount: assetCount });
+        }
+    }
+    async loadBookmarkByMapId(mapId) {
+        const bookmarkCount = await this.assetCountsService.getUserBookmarkCountByMap(mapId);
+        if (bookmarkCount) {
+            ftUserAssetsStore.actions.setBookmarkCountByMap({ count: bookmarkCount.count, mapId: mapId });
+        }
+    }
+    // Used in GWT
+    async reloadAssetCount(assetType) {
+        this.assetCountsService.clearCache();
+        const isBookmarkByMapStored = Object.keys(ftUserAssetsStore.getState().assetCounts.bookmarkByMap).length !== 0;
+        if (assetType === FtUserAssetType.BOOKMARKS && isBookmarkByMapStored) {
+            ftUserAssetsStore.actions.clearBookmarkCountByMap();
+        }
+        const isAssetCountStored = ftUserAssetsStore.getState().assetCounts.allAsset[assetType] !== undefined;
+        if (isAssetCountStored) {
+            await this.loadAssetCount(assetType);
+        }
+    }
     async registerBookmarkComponent() {
         this.bookmarksAreUsed = true;
         await this.updateBookmarksIfUsed();
@@ -61,3 +115,6 @@ class UserAssetsActions {
     }
 }
 export const userAssetsActions = new UserAssetsActions();
+if (window.FluidTopicsUserAssetsActions == null) {
+    window.FluidTopicsUserAssetsActions = userAssetsActions;
+}

package/build/redux-stores/selectors/UserAssetSelectors.d.ts

@@ -0,0 +1,2 @@
+import { FtUserAssetType } from "@fluid-topics/public-api";
+export declare const selectAssetCount: (type?: FtUserAssetType, mapId?: string) => number | undefined;

package/build/redux-stores/selectors/UserAssetSelectors.js

@@ -0,0 +1,23 @@
+import { FtUserAssetType } from "@fluid-topics/public-api";
+import { ftUserAssetsStore } from "../FtUserAssetsStore";
+export const selectAssetCount = (type, mapId) => {
+    if (type === undefined) {
+        return undefined;
+    }
+    if (type === FtUserAssetType.BOOKMARKS && mapId) {
+        return resolveBookmarkByMapCount(mapId);
+    }
+    return resolveAssetCount(type);
+};
+const resolveBookmarkByMapCount = (mapId) => {
+    if (ftUserAssetsStore.getState().assetCounts.bookmarkByMap[mapId] === undefined) {
+        window.FluidTopicsUserAssetsActions.loadBookmarkByMapId(mapId);
+    }
+    return ftUserAssetsStore.getState().assetCounts.bookmarkByMap[mapId];
+};
+const resolveAssetCount = (type) => {
+    if (ftUserAssetsStore.getState().assetCounts.allAsset[type] === undefined) {
+        window.FluidTopicsUserAssetsActions.loadAssetCount(type);
+    }
+    return ftUserAssetsStore.getState().assetCounts.allAsset[type];
+};

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/build/services/user-assets/UserAssetCountService.d.ts

@@ -0,0 +1,8 @@
+import { FtUserAssetCount, FtUserAssetType } from "@fluid-topics/public-api";
+import { FtServiceWithCache } from "../FtServiceWithCache";
+export declare class UserAssetsCountService extends FtServiceWithCache {
+    private readonly CACHE_DURATION;
+    getUserAssetCount(userAssetType: FtUserAssetType): Promise<FtUserAssetCount | undefined>;
+    getUserBookmarkCountByMap(mapId: string): Promise<FtUserAssetCount | undefined>;
+    private isAuthenticated;
+}

package/build/services/user-assets/UserAssetCountService.js

@@ -0,0 +1,24 @@
+import { ftAppInfoStore } from "../../redux-stores/FtAppInfoStore";
+import { FtServiceWithCache } from "../FtServiceWithCache";
+export class UserAssetsCountService extends FtServiceWithCache {
+    constructor() {
+        super(...arguments);
+        this.CACHE_DURATION = 3 * 60 * 1000;
+    }
+    async getUserAssetCount(userAssetType) {
+        if (!this.isAuthenticated()) {
+            return undefined;
+        }
+        return this.cache.get(`user-asset-count-${userAssetType}`, async () => (await this.awaitApi).get(`/internal/api/webapp/user/assets/count/${userAssetType}`), this.CACHE_DURATION);
+    }
+    async getUserBookmarkCountByMap(mapId) {
+        if (!this.isAuthenticated()) {
+            return undefined;
+        }
+        return this.cache.get(`user-bookmark-count-by-map-${mapId}`, async () => (await this.awaitApi).get(`/internal/api/webapp/user/assets/count/BOOKMARKS/${mapId}`), this.CACHE_DURATION);
+    }
+    isAuthenticated() {
+        const session = ftAppInfoStore.getState().session;
+        return Boolean(session === null || session === void 0 ? void 0 : session.sessionAuthenticated);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluid-topics/ft-app-context",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "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.5",
+    "@fluid-topics/ft-wc-utils": "1.3.7",
     "lit": "3.1.0"
   },
   "devDependencies": {
     "@fluid-topics/public-api": "1.0.99"
   },
-  "gitHead": "87377b99617257593de238b08c41d2638617f501"
+  "gitHead": "83a6f0c292e6669cc067b7aa40fea8a4a0a61b7f"
 }