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

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/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/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.6",
+  "version": "1.3.8",
   "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.6",
+    "@fluid-topics/ft-wc-utils": "1.3.8",
     "lit": "3.1.0"
   },
   "devDependencies": {
     "@fluid-topics/public-api": "1.0.99"
   },
-  "gitHead": "595e5b638bbf265e174474722661e26767cfbd9d"
+  "gitHead": "cafb3e5814e9a916392cb95050a9e0f36d30227f"
 }