@sinequa/atomic-angular 0.0.146

package/esm2022/lib/stores/user-settings.store.mjs

@@ -0,0 +1,391 @@
+import { withDevtools } from '@angular-architects/ngrx-toolkit';
+import { patchState, signalStore, signalStoreFeature, withMethods, withState } from '@ngrx/signals';
+import { deleteUserSettings, fetchUserSettings, patchUserSettings } from '@sinequa/atomic';
+export const UserSettingsStore = signalStore({ providedIn: 'root' }, withDevtools('UserSettings'), withBookmarkFeatures(), withRecentSearchFeatures(), withSavedSearchFeatures(), withBasketsFeatures(), withAssistantFeatures(), withUserSettingsFeatures());
+export function withUserSettingsFeatures() {
+    return signalStoreFeature(withState({ language: undefined }), withMethods((store) => ({
+        /**
+         * Initializes the user settings store by fetching the user settings from the backend API
+         * and patching the store with the retrieved settings.
+         *
+         * @returns {Promise<void>} A promise that resolves when the initialization is complete.
+         */
+        async initialize() {
+            // Fetch the user settings from the backend API and patch the store with the result
+            const settings = await fetchUserSettings();
+            patchState(store, settings);
+        },
+        /**
+         * Resets the user settings to the initial state.
+         *
+         * This method performs the following actions:
+         * 1. Deletes the current user settings.
+         * 2. Patches the state with the initial state.
+         *
+         * @returns {Promise<void>} A promise that resolves when the reset operation is complete.
+         */
+        async reset() {
+            // Reset the user settings to the initial state
+            await deleteUserSettings();
+            patchState(store, {
+                bookmarks: [],
+                recentSearches: [],
+                savedSearches: [],
+                baskets: [],
+                assistants: {},
+                language: undefined,
+            });
+        },
+    })));
+}
+export function withBookmarkFeatures() {
+    return signalStoreFeature(withState({ bookmarks: [] }), withMethods((store) => ({
+        /**
+         * Updates the user's bookmarks in the store and optionally logs audit events.
+         *
+         * @param bookmarks - An array of bookmarks to update in the user settings.
+         * @param auditEvents - Optional audit events to log during the update.
+         * @returns A promise that resolves when the update is complete.
+         */
+        async updateBookmarks(bookmarks, auditEvents) {
+            await patchUserSettings({ bookmarks }, auditEvents);
+            patchState(store, (state) => {
+                return { ...state, bookmarks: [...bookmarks] };
+            });
+        },
+        /**
+         * Adds an article to the bookmarks if it is not already bookmarked.
+         *
+         * @param article - The article to be bookmarked.
+         * @param queryName - Optional name of the query associated with the bookmark.
+         * @returns A promise that resolves when the bookmark has been added.
+         */
+        async bookmark(article, queryName) {
+            if (!article.id)
+                return;
+            if (this.isBookmarked(article))
+                return;
+            const bookmark = {
+                id: article.id,
+                label: article.title,
+                source: article.collection[0],
+                author: article.authors?.[0],
+                queryName,
+            };
+            await this.updateBookmarks([...store.bookmarks(), bookmark], {
+                type: "Basket_AddDoc",
+                detail: {
+                    docid: article.id
+                }
+            });
+        },
+        /**
+         * Removes a bookmark by its ID.
+         *
+         * @param id - The ID of the bookmark to remove.
+         * @returns A promise that resolves when the bookmark has been removed and the bookmarks have been updated.
+         *
+         * @remarks
+         * - If the provided ID is falsy, the function will return immediately.
+         * - If the bookmark with the given ID is not found, the function will return immediately.
+         * - The function updates the bookmarks and logs the removal action with a type of "Basket_RemoveDoc".
+         */
+        async unbookmark(id) {
+            if (!id)
+                return;
+            const bookmarks = store.bookmarks();
+            const index = bookmarks?.findIndex((bookmark) => bookmark.id === id);
+            if (index === -1)
+                return;
+            bookmarks.splice(index, 1);
+            await this.updateBookmarks([...bookmarks], {
+                type: "Basket_RemoveDoc",
+                detail: {
+                    docid: id
+                }
+            });
+        },
+        /**
+         * Checks if the given article is bookmarked.
+         *
+         * @param article - An optional partial article object to check.
+         * @returns `true` if the article is bookmarked, `false` otherwise.
+         */
+        isBookmarked(article) {
+            if (!article || !article.id)
+                return false;
+            const bookmarks = store.bookmarks();
+            return !!bookmarks?.find((bookmark) => bookmark.id === article.id);
+        },
+        /**
+         * Toggles the bookmark status of a given article.
+         *
+         * This method checks if the article is currently bookmarked. If it is,
+         * it removes the bookmark. If it is not, it adds a bookmark.
+         *
+         * @param article - The article to toggle the bookmark status for.
+         * @returns A promise that resolves when the bookmark status has been toggled.
+         */
+        async toggleBookmark(article) {
+            const isBookmarked = await this.isBookmarked(article);
+            if (isBookmarked)
+                this.unbookmark(article.id);
+            else
+                this.bookmark(article);
+        },
+    })));
+}
+export function withRecentSearchFeatures() {
+    return signalStoreFeature(withState({ recentSearches: [] }), withMethods((store) => ({
+        /**
+         * Deletes a recent search entry from the user's recent searches list.
+         *
+         * @param {number} index - The index of the recent search to delete.
+         * @returns {Promise<void>} A promise that resolves when the recent search has been deleted and the state has been updated.
+         */
+        async deleteRecentSearch(index) {
+            const recentSearches = store.recentSearches();
+            if (recentSearches) {
+                const recentSearchToDelete = recentSearches.splice(index, 1)[0];
+                await patchUserSettings({ recentSearches }, {
+                    type: "RecentQuery_Delete",
+                    detail: {
+                        recentQuery: recentSearchToDelete.queryParams?.text
+                    }
+                });
+                patchState(store, (state) => {
+                    return { ...state, recentSearches: [...recentSearches] };
+                });
+            }
+        },
+        /**
+         * Updates the recent searches in the user settings.
+         *
+         * @param recentSearches - An array of recent searches to be updated in the user settings.
+         * @param auditEvents - Optional audit events to be logged during the update.
+         * @returns A promise that resolves when the recent searches have been updated.
+         */
+        async updateRecentSearches(recentSearches, auditEvents) {
+            await patchUserSettings({ recentSearches }, auditEvents);
+            patchState(store, (state) => {
+                return { ...state, recentSearches: [...recentSearches] };
+            });
+        },
+        /**
+         * Adds the current search to the recent searches list.
+         *
+         * This method checks if a search with the same label already exists in the recent searches.
+         * If it does, it updates the existing search with the new query parameters and date.
+         * If it does not, it adds a new search to the recent searches list.
+         *
+         * @param queryParams - The parameters of the current search.
+         * @returns A promise that resolves when the recent searches have been updated.
+         */
+        async addCurrentSearch(queryParams) {
+            // fist search if the search is already in the recent searches with the same label
+            const recentSearches = store.recentSearches();
+            const existingSearch = recentSearches.find((search) => search.label === queryParams.text);
+            const url = window.location.hash.substring(1);
+            const path = url.split('?')[0];
+            if (existingSearch) {
+                await this.updateRecentSearches([
+                    {
+                        ...existingSearch,
+                        date: new Date().toISOString(),
+                        url,
+                        path,
+                        queryParams,
+                        filterCount: queryParams.filters?.length
+                    },
+                    ...recentSearches.filter((search) => search.label !== queryParams.text),
+                ], {
+                    type: "RecentQuery_Update",
+                    detail: {
+                        recentQuery: queryParams.text
+                    }
+                });
+            }
+            else {
+                const recentSearch = {
+                    url,
+                    path,
+                    display: queryParams.text,
+                    label: queryParams.text,
+                    filterCount: queryParams.filters?.length,
+                    date: new Date().toISOString(),
+                    queryParams
+                };
+                await this.updateRecentSearches([recentSearch, ...store.recentSearches()], {
+                    type: "RecentQuery_Add",
+                    detail: {
+                        recentQuery: queryParams.text
+                    }
+                });
+            }
+        },
+    })));
+}
+export function withSavedSearchFeatures() {
+    return signalStoreFeature(withState({ savedSearches: [] }), withMethods((store) => ({
+        async deleteSavedSearch(index) {
+            const savedSearches = store.savedSearches();
+            if (savedSearches) {
+                const savedSearchToDelete = savedSearches.splice(index, 1)[0];
+                await patchUserSettings({ savedSearches }, {
+                    type: "SavedQuery_Delete",
+                    detail: {
+                        savedQuery: savedSearchToDelete.display
+                    }
+                });
+                patchState(store, (state) => {
+                    return { ...state, savedSearches: [...savedSearches] };
+                });
+            }
+        },
+        async updateSavedSearches(savedSearches) {
+            await patchUserSettings({ savedSearches }, {
+                type: "SavedQuery_Add",
+                detail: {
+                    savedQuery: savedSearches[0].display
+                }
+            });
+            patchState(store, (state) => {
+                return { ...state, savedSearches: [...savedSearches] };
+            });
+        },
+    })));
+}
+function basketIndex(name, baskets) {
+    if (baskets?.length) {
+        for (let i = 0, ic = baskets.length; i < ic; i++) {
+            const basket = baskets[i];
+            if (basket && basket.name === name) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+export function withBasketsFeatures() {
+    return signalStoreFeature(withState({ baskets: [] }), withMethods((store) => ({
+        async deleteBasket(index) {
+            const baskets = store.baskets();
+            if (baskets) {
+                const basketToDelete = baskets.splice(index, 1)[0];
+                await patchUserSettings({ baskets }, {
+                    type: "Basket_Delete",
+                    detail: {
+                        savedQuery: basketToDelete.name
+                    }
+                });
+                patchState(store, (state) => {
+                    return { ...state, baskets: [...baskets] };
+                });
+            }
+        },
+        async createBasket(basket) {
+            const baskets = store.baskets();
+            if (basketIndex(basket.name) >= 0)
+                return;
+            baskets.unshift(basket);
+            await patchUserSettings({ baskets }, {
+                type: "Basket_Add",
+                detail: {
+                    basket: basket.name
+                }
+            });
+            patchState(store, (state) => {
+                return { ...state, baskets: [...baskets] };
+            });
+        },
+        async updateBaskets(baskets) {
+            await patchUserSettings({ baskets }, {
+                type: "Basket_Update"
+            });
+            patchState(store, (state) => {
+                return { ...state, baskets: [...baskets] };
+            });
+        },
+        async updateBasket(basket, index) {
+            const baskets = store.baskets();
+            const prevIndex = basketIndex(basket.name, baskets);
+            if ((prevIndex !== -1 && index !== prevIndex) // A basket with the same name exists at a different index
+                || index < 0 || index >= baskets.length) // index out of bounds
+                return;
+            baskets.splice(index, 1, basket);
+            await patchUserSettings({ baskets }, {
+                type: "Basket_Update",
+                detail: {
+                    basket: basket.name
+                }
+            });
+            patchState(store, (state) => {
+                return { ...state, baskets: [...baskets] };
+            });
+        },
+        async addToBasket(name, ids) {
+            const baskets = store.baskets();
+            const basket = baskets.find(b => b.name === name);
+            if (!ids || !basket)
+                return;
+            if (!basket.ids)
+                basket.ids = [];
+            ids = Array.isArray(ids) ? ids : [ids];
+            for (let id of ids) {
+                if (!basket.ids.some(i => i === id)) {
+                    basket.ids.push(id);
+                }
+            }
+            await patchUserSettings({ baskets }, {
+                type: "Basket_AddDoc",
+                detail: {
+                    basket: basket.name,
+                    docid: ids[0]
+                }
+            });
+            patchState(store, (state) => {
+                return { ...state, baskets: [...baskets] };
+            });
+        },
+        async removeFromBasket(name, ids) {
+            const baskets = store.baskets();
+            const basket = baskets.find(b => b.name === name);
+            if (!ids || !basket)
+                return;
+            if (!basket.ids)
+                basket.ids = [];
+            ids = Array.isArray(ids) ? ids : [ids];
+            for (let id of ids) {
+                if (!basket.ids.some(i => i === id)) {
+                    basket.ids.push(id);
+                }
+            }
+            await patchUserSettings({ baskets }, {
+                type: "Basket_AddDoc",
+                detail: {
+                    basket: basket.name,
+                    docid: ids[0]
+                }
+            });
+            patchState(store, (state) => {
+                return { ...state, baskets: [...baskets] };
+            });
+        },
+    })));
+}
+export function withAssistantFeatures() {
+    return signalStoreFeature(withState({ assistants: {} }), withMethods((store) => ({
+        async updateAssistantSettings(assistantSettings) {
+            patchState(store, (state) => {
+                return { ...state, assistants: assistantSettings };
+            });
+        },
+        async updateLanguage(language, auditEvents) {
+            await patchUserSettings({ language }, auditEvents);
+            patchState(store, (state) => {
+                return { ...state, language };
+            });
+        },
+    })));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-settings.store.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/stores/user-settings.store.ts"],"names":[],"mappings":"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","sourcesContent":["import { withDevtools } from '@angular-architects/ngrx-toolkit';\nimport { patchState, signalStore, signalStoreFeature, withMethods, withState } from '@ngrx/signals';\n\nimport { Article, AuditEvents, deleteUserSettings, fetchUserSettings, patchUserSettings, QueryParams } from '@sinequa/atomic';\n\nimport { Basket, RecentSearch, UserSettings } from '../models/user-settings';\n\nexport type UserSettingsState = UserSettings;\n\nexport const UserSettingsStore = signalStore(\n  { providedIn: 'root' },\n  withDevtools('UserSettings'),\n\n  withBookmarkFeatures(),\n  withRecentSearchFeatures(),\n  withSavedSearchFeatures(),\n  withBasketsFeatures(),\n  withAssistantFeatures(),\n  withUserSettingsFeatures(),\n)\n\nexport function withUserSettingsFeatures() {\n  return signalStoreFeature(\n    withState({ language: undefined } as UserSettings),\n\n    withMethods((store) => ({\n      /**\n       * Initializes the user settings store by fetching the user settings from the backend API\n       * and patching the store with the retrieved settings.\n       *\n       * @returns {Promise<void>} A promise that resolves when the initialization is complete.\n       */\n      async initialize(): Promise<void> {\n        // Fetch the user settings from the backend API and patch the store with the result\n        const settings = await fetchUserSettings<UserSettings>();\n        patchState(store, settings);\n      },\n      /**\n       * Resets the user settings to the initial state.\n       *\n       * This method performs the following actions:\n       * 1. Deletes the current user settings.\n       * 2. Patches the state with the initial state.\n       *\n       * @returns {Promise<void>} A promise that resolves when the reset operation is complete.\n       */\n      async reset(): Promise<void> {\n        // Reset the user settings to the initial state\n        await deleteUserSettings();\n        patchState(store, {\n          bookmarks: [],\n          recentSearches: [],\n          savedSearches: [],\n          baskets: [],\n          assistants: {},\n          language: undefined,\n        } as UserSettings);\n      },\n    })),\n  )\n}\n\nexport function withBookmarkFeatures() {\n  return signalStoreFeature(\n    withState({ bookmarks: [] as UserSettings['bookmarks'] }),\n\n    withMethods((store) => ({\n      /**\n       * Updates the user's bookmarks in the store and optionally logs audit events.\n       *\n       * @param bookmarks - An array of bookmarks to update in the user settings.\n       * @param auditEvents - Optional audit events to log during the update.\n       * @returns A promise that resolves when the update is complete.\n       */\n      async updateBookmarks(bookmarks: UserSettings['bookmarks'], auditEvents?: AuditEvents) {\n        await patchUserSettings({ bookmarks }, auditEvents);\n        patchState(store, (state) => {\n          return { ...state, bookmarks: [...bookmarks] };\n        })\n      },\n      /**\n       * Adds an article to the bookmarks if it is not already bookmarked.\n       *\n       * @param article - The article to be bookmarked.\n       * @param queryName - Optional name of the query associated with the bookmark.\n       * @returns A promise that resolves when the bookmark has been added.\n       */\n      async bookmark(article: Article, queryName?: string) {\n        if (!article.id) return;\n\n        if (this.isBookmarked(article)) return;\n\n        const bookmark = {\n          id: article.id,\n          label: article.title,\n          source: article.collection[0],\n          author: article.authors?.[0],\n          queryName,\n        };\n        await this.updateBookmarks([...store.bookmarks(), bookmark], {\n          type: \"Basket_AddDoc\",\n          detail: {\n            docid: article.id\n          }\n        });\n      },\n      /**\n       * Removes a bookmark by its ID.\n       *\n       * @param id - The ID of the bookmark to remove.\n       * @returns A promise that resolves when the bookmark has been removed and the bookmarks have been updated.\n       *\n       * @remarks\n       * - If the provided ID is falsy, the function will return immediately.\n       * - If the bookmark with the given ID is not found, the function will return immediately.\n       * - The function updates the bookmarks and logs the removal action with a type of \"Basket_RemoveDoc\".\n       */\n      async unbookmark(id: string) {\n        if (!id) return;\n\n        const bookmarks = store.bookmarks();\n        const index = bookmarks?.findIndex((bookmark) => bookmark.id === id);\n\n        if (index === -1) return;\n\n        bookmarks.splice(index, 1);\n        await this.updateBookmarks([...bookmarks], {\n          type: \"Basket_RemoveDoc\",\n          detail: {\n            docid: id\n          }\n        });\n      },\n      /**\n       * Checks if the given article is bookmarked.\n       *\n       * @param article - An optional partial article object to check.\n       * @returns `true` if the article is bookmarked, `false` otherwise.\n       */\n      isBookmarked(article: Partial<Article>): boolean {\n        if (!article || !article.id) return false;\n        const bookmarks = store.bookmarks();\n\n        return !!bookmarks?.find((bookmark) => bookmark.id === article.id);\n      },\n      /**\n       * Toggles the bookmark status of a given article.\n       *\n       * This method checks if the article is currently bookmarked. If it is,\n       * it removes the bookmark. If it is not, it adds a bookmark.\n       *\n       * @param article - The article to toggle the bookmark status for.\n       * @returns A promise that resolves when the bookmark status has been toggled.\n       */\n      async toggleBookmark(article: Article) {\n        const isBookmarked = await this.isBookmarked(article);\n\n        if (isBookmarked)\n          this.unbookmark(article.id);\n        else\n          this.bookmark(article);\n      },\n    }))\n  )\n}\n\nexport function withRecentSearchFeatures() {\n  return signalStoreFeature(\n    withState({ recentSearches: [] as UserSettings['recentSearches'] }),\n\n    withMethods((store) => ({\n      /**\n       * Deletes a recent search entry from the user's recent searches list.\n       *\n       * @param {number} index - The index of the recent search to delete.\n       * @returns {Promise<void>} A promise that resolves when the recent search has been deleted and the state has been updated.\n       */\n      async deleteRecentSearch(index: number) {\n        const recentSearches = store.recentSearches();\n        if (recentSearches) {\n          const recentSearchToDelete = recentSearches.splice(index, 1)[0];\n          await patchUserSettings({ recentSearches }, {\n            type: \"RecentQuery_Delete\",\n            detail: {\n              recentQuery: recentSearchToDelete.queryParams?.text\n            }\n          });\n\n          patchState(store, (state) => {\n            return { ...state, recentSearches: [...recentSearches] };\n          })\n        }\n      },\n      /**\n       * Updates the recent searches in the user settings.\n       *\n       * @param recentSearches - An array of recent searches to be updated in the user settings.\n       * @param auditEvents - Optional audit events to be logged during the update.\n       * @returns A promise that resolves when the recent searches have been updated.\n       */\n      async updateRecentSearches(recentSearches: UserSettings['recentSearches'], auditEvents?: AuditEvents) {\n        await patchUserSettings({ recentSearches }, auditEvents);\n        patchState(store, (state) => {\n          return { ...state, recentSearches: [...recentSearches] };\n        })\n      },\n      /**\n       * Adds the current search to the recent searches list.\n       *\n       * This method checks if a search with the same label already exists in the recent searches.\n       * If it does, it updates the existing search with the new query parameters and date.\n       * If it does not, it adds a new search to the recent searches list.\n       *\n       * @param queryParams - The parameters of the current search.\n       * @returns A promise that resolves when the recent searches have been updated.\n       */\n      async addCurrentSearch(queryParams: QueryParams) {\n        // fist search if the search is already in the recent searches with the same label\n        const recentSearches = store.recentSearches();\n        const existingSearch = recentSearches.find((search) => search.label === queryParams.text);\n\n        const url = window.location.hash.substring(1);\n        const path = url.split('?')[0];\n        if (existingSearch) {\n          await this.updateRecentSearches([\n            {\n              ...existingSearch,\n              date: new Date().toISOString(),\n              url,\n              path,\n              queryParams,\n              filterCount: queryParams.filters?.length\n            },\n            ...recentSearches.filter((search) => search.label !== queryParams.text),\n          ], {\n            type: \"RecentQuery_Update\",\n            detail: {\n              recentQuery: queryParams.text\n            }\n          });\n        }\n        else {\n          const recentSearch = {\n            url,\n            path,\n            display: queryParams.text,\n            label: queryParams.text,\n            filterCount: queryParams.filters?.length,\n            date: new Date().toISOString(),\n            queryParams\n          } as RecentSearch;\n\n          await this.updateRecentSearches([recentSearch, ...store.recentSearches()], {\n            type: \"RecentQuery_Add\",\n            detail: {\n              recentQuery: queryParams.text\n            }\n          });\n        }\n      },\n    }))\n  )\n}\n\nexport function withSavedSearchFeatures() {\n  return signalStoreFeature(\n    withState({ savedSearches: [] as UserSettings['savedSearches'] }),\n\n    withMethods((store) => ({\n      async deleteSavedSearch(index: number) {\n        const savedSearches = store.savedSearches();\n        if (savedSearches) {\n          const savedSearchToDelete = savedSearches.splice(index, 1)[0];\n          await patchUserSettings({ savedSearches }, {\n            type: \"SavedQuery_Delete\",\n            detail: {\n              savedQuery: savedSearchToDelete.display\n            }\n          });\n\n          patchState(store, (state) => {\n            return { ...state, savedSearches: [...savedSearches] };\n          })\n        }\n      },\n      async updateSavedSearches(savedSearches: UserSettings['savedSearches']) {\n        await patchUserSettings({ savedSearches }, {\n          type: \"SavedQuery_Add\",\n          detail: {\n            savedQuery: savedSearches[0].display\n          }\n        });\n        patchState(store, (state) => {\n          return { ...state, savedSearches: [...savedSearches] };\n        })\n      },\n    }))\n  )\n}\n\nfunction basketIndex(name: string, baskets?: Basket[]): number {\n  if (baskets?.length) {\n    for (let i = 0, ic = baskets.length; i < ic; i++) {\n      const basket = baskets[i];\n      if (basket && basket.name === name) {\n        return i;\n      }\n    }\n  }\n  return -1;\n}\n\nexport function withBasketsFeatures() {\n  return signalStoreFeature(\n    withState({ baskets: [] as UserSettings['baskets'] }),\n    withMethods((store) => ({\n      async deleteBasket(index: number) {\n        const baskets = store.baskets();\n        if (baskets) {\n          const basketToDelete = baskets.splice(index, 1)[0];\n          await patchUserSettings({ baskets }, {\n            type: \"Basket_Delete\",\n            detail: {\n              savedQuery: basketToDelete.name\n            }\n          });\n          patchState(store, (state) => {\n            return { ...state, baskets: [...baskets] };\n          })\n        }\n      },\n      async createBasket(basket: Basket) {\n        const baskets = store.baskets();\n        if (basketIndex(basket.name) >= 0) return;\n        baskets.unshift(basket);\n        await patchUserSettings({ baskets }, {\n          type: \"Basket_Add\",\n          detail: {\n            basket: basket.name\n          }\n        });\n        patchState(store, (state) => {\n          return { ...state, baskets: [...baskets] };\n        })\n      },\n      async updateBaskets(baskets: UserSettings['baskets']) {\n        await patchUserSettings({ baskets }, {\n          type: \"Basket_Update\"\n        });\n        patchState(store, (state) => {\n          return { ...state, baskets: [...baskets] };\n        })\n      },\n      async updateBasket(basket: Basket, index: number) {\n        const baskets = store.baskets();\n        const prevIndex = basketIndex(basket.name, baskets);\n        if ((prevIndex !== -1 && index !== prevIndex)  // A basket with the same name exists at a different index\n          || index < 0 || index >= baskets.length) // index out of bounds\n          return;\n\n        baskets.splice(index, 1, basket);\n\n        await patchUserSettings({ baskets }, {\n          type: \"Basket_Update\",\n          detail: {\n            basket: basket.name\n          }\n        });\n        patchState(store, (state) => {\n          return { ...state, baskets: [...baskets] };\n        })\n      },\n      async addToBasket(name: string, ids: string | string[]) {\n        const baskets = store.baskets();\n        const basket = baskets.find(b => b.name === name);\n        if (!ids || !basket) return;\n\n        if (!basket.ids) basket.ids = [];\n\n        ids = Array.isArray(ids)? ids : [ids];\n        for (let id of ids) {\n          if (!basket.ids.some(i => i === id)) {\n            basket.ids.push(id);\n          }\n        }\n\n        await patchUserSettings({ baskets }, {\n          type: \"Basket_AddDoc\",\n          detail: {\n              basket: basket.name,\n              docid: ids[0]\n          }\n        });\n        patchState(store, (state) => {\n          return { ...state, baskets: [...baskets] };\n        })\n      },\n      async removeFromBasket(name: string, ids: string | string[]) {\n        const baskets = store.baskets();\n        const basket = baskets.find(b => b.name === name);\n        if (!ids || !basket) return;\n\n        if (!basket.ids) basket.ids = [];\n\n        ids = Array.isArray(ids)? ids : [ids];\n        for (let id of ids) {\n          if (!basket.ids.some(i => i === id)) {\n            basket.ids.push(id);\n          }\n        }\n\n        await patchUserSettings({ baskets }, {\n          type: \"Basket_AddDoc\",\n          detail: {\n              basket: basket.name,\n              docid: ids[0]\n          }\n        });\n        patchState(store, (state) => {\n          return { ...state, baskets: [...baskets] };\n        })\n      },\n    }))\n  )\n}\n\nexport function withAssistantFeatures() {\n  return signalStoreFeature(\n    withState({ assistants: {} as UserSettings['assistants'] }),\n    withMethods((store) => ({\n      async updateAssistantSettings(assistantSettings: UserSettings['assistants']) {\n        patchState(store, (state) => {\n          return { ...state, assistants: assistantSettings };\n        })\n      },\n\n      async updateLanguage(language: UserSettings['language'], auditEvents?: AuditEvents) {\n        await patchUserSettings({ language }, auditEvents);\n        patchState(store, (state) => {\n          return { ...state, language };\n        })\n      },\n    }))\n  )\n}"]}

package/esm2022/lib/tokens/highlights.mjs

@@ -0,0 +1,32 @@
+import { InjectionToken } from "@angular/core";
+// pre-configured highlights's colors
+export const HIGHLIGHTS = new InjectionToken('highlights', {
+    factory: () => [
+        {
+            name: 'company',
+            color: 'white',
+            bgColor: '#FF7675'
+        },
+        {
+            name: 'geo',
+            color: 'white',
+            bgColor: '#74B9FF'
+        },
+        {
+            name: 'person',
+            color: 'white',
+            bgColor: '#00ABB5'
+        },
+        {
+            name: 'extractslocations',
+            color: 'black',
+            bgColor: '#fffacd'
+        },
+        {
+            name: 'matchlocations',
+            color: 'black',
+            bgColor: '#ff0'
+        }
+    ],
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tokens/index.mjs

@@ -0,0 +1,2 @@
+export * from "./highlights";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL3Rva2Vucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2hpZ2hsaWdodHNcIjtcclxuIl19

package/esm2022/lib/utils/debounced-signal.mjs

@@ -0,0 +1,38 @@
+import { effect, signal } from "@angular/core";
+/**
+ * Creates a debounced signal that updates its value after a specified timeout.
+ *
+ * @template T - The type of the signal value.
+ * @param Signal<T> input - The input signal whose value will be debounced.
+ * @param number [timeOutMs=0] - The debounce timeout in milliseconds. Defaults to 0.
+ * @returns Signal<T> - A new signal that updates its value after the specified debounce timeout.
+ *
+ * @example
+ * ```ts
+ * const input = signal('');
+ * const debounced = debouncedSignal(input, 1000);
+ *
+ * contructor() {
+ *  effect(() => {
+ *   console.log(debounced());
+ *   // will log the input value after 1 second of inactivity.
+ *  });
+ * }
+ * ...
+ * <input [ngModel]="input()" (ngModelChange)="input.set($event)">
+ * ```
+ */
+export function debouncedSignal(input, timeOutMs = 0) {
+    const debounceSignal = signal(input());
+    let timeout;
+    effect((onCleanUp) => {
+        const value = input();
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            debounceSignal.set(value);
+        }, timeOutMs);
+        onCleanUp(() => clearTimeout(timeout));
+    });
+    return debounceSignal;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/index.mjs

@@ -0,0 +1,8 @@
+export * from './inline-worker';
+export * from './query';
+export * from './routes';
+export * from './tailwind-utils';
+export * from './theme-body-hook';
+export * from './theme-registry';
+export * from './debounced-signal';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW5saW5lLXdvcmtlcic7XG5leHBvcnQgKiBmcm9tICcuL3F1ZXJ5JztcbmV4cG9ydCAqIGZyb20gJy4vcm91dGVzJztcbmV4cG9ydCAqIGZyb20gJy4vdGFpbHdpbmQtdXRpbHMnO1xuZXhwb3J0ICogZnJvbSAnLi90aGVtZS1ib2R5LWhvb2snO1xuZXhwb3J0ICogZnJvbSAnLi90aGVtZS1yZWdpc3RyeSc7XG5leHBvcnQgKiBmcm9tICcuL2RlYm91bmNlZC1zaWduYWwnOyJdfQ==

package/esm2022/lib/utils/inline-worker.mjs

@@ -0,0 +1,40 @@
+import { Subject } from 'rxjs';
+export class InlineWorker {
+    constructor(func) {
+        this.onMessage = new Subject();
+        this.onError = new Subject();
+        const WORKER_ENABLED = !!(Worker);
+        if (WORKER_ENABLED) {
+            const functionBody = func.toString().replace(/^[^{]*{\s*/, '').replace(/\s*}[^}]*$/, '');
+            try {
+                this.worker = new Worker(URL.createObjectURL(new Blob([functionBody], { type: 'text/javascript' })));
+                this.worker.onmessage = (data) => {
+                    this.onMessage.next(data);
+                };
+                this.worker.onerror = (data) => {
+                    this.onError.next(data);
+                };
+            }
+            catch (e) {
+                throw new Error('WebWorker is not enabled');
+            }
+        }
+        else {
+            throw new Error('WebWorker is not enabled');
+        }
+    }
+    postMessage(data) {
+        this.worker.postMessage(data);
+    }
+    onmessage() {
+        return this.onMessage.asObservable();
+    }
+    onerror() {
+        return this.onError.asObservable();
+    }
+    terminate() {
+        if (this.worker)
+            this.worker.terminate();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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