@sinequa/atomic-angular 0.0.140

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

@@ -0,0 +1,272 @@
+import { withDevtools } from '@angular-architects/ngrx-toolkit';
+import { patchState, signalStore, signalStoreFeature, withMethods, withState } from '@ngrx/signals';
+import { deleteUserSettings, fetchUserSettings, patchUserSettings } from '@sinequa/atomic';
+const initialState = {
+    bookmarks: [],
+    recentSearches: [],
+    savedSearches: [],
+    assistants: {},
+    language: undefined,
+};
+export const UserSettingsStore = signalStore({ providedIn: 'root' }, withDevtools('UserSettings'), withState(initialState), withUserSettingsFeatures(), withBookmarkFeatures(), withRecentSearchFeatures(), withSavedSearchFeatures(), withAssistantFeatures());
+export function withUserSettingsFeatures() {
+    return signalStoreFeature(withState(initialState), 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, initialState);
+        },
+    })));
+}
+export function withBookmarkFeatures() {
+    return signalStoreFeature(withState(initialState), 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(initialState), 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(initialState), 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] };
+            });
+        },
+    })));
+}
+export function withAssistantFeatures() {
+    return signalStoreFeature(withState(initialState), 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 { RecentSearch, UserSettings } from '../models/user-settings';\n\n\n\nconst initialState: UserSettings = {\n  bookmarks: [],\n  recentSearches: [],\n  savedSearches: [],\n  assistants: {},\n  language: undefined,\n};\n\nexport const UserSettingsStore = signalStore(\n  { providedIn: 'root' },\n  withDevtools('UserSettings'),\n  withState(initialState),\n  withUserSettingsFeatures(),\n  withBookmarkFeatures(),\n  withRecentSearchFeatures(),\n  withSavedSearchFeatures(),\n  withAssistantFeatures()\n)\n\nexport function withUserSettingsFeatures() {\n  return signalStoreFeature(\n    withState(initialState),\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, initialState);\n      },\n    })),\n  )\n}\n\nexport function withBookmarkFeatures() {\n  return signalStoreFeature(\n    withState(initialState),\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(initialState),\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            { ...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(initialState),\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\nexport function withAssistantFeatures() {\n  return signalStoreFeature(\n    withState(initialState),\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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVib3VuY2VkLXNpZ25hbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2F0b21pYy1hbmd1bGFyL3NyYy9saWIvdXRpbHMvZGVib3VuY2VkLXNpZ25hbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBVSxNQUFNLGVBQWUsQ0FBQztBQUV2RDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQUksS0FBZ0IsRUFBRSxTQUFTLEdBQUcsQ0FBQztJQUNoRSxNQUFNLGNBQWMsR0FBRyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztJQUN2QyxJQUFJLE9BQVksQ0FBQztJQUNqQixNQUFNLENBQUMsQ0FBQyxTQUFTLEVBQUUsRUFBRTtRQUNuQixNQUFNLEtBQUssR0FBRyxLQUFLLEVBQUUsQ0FBQztRQUN0QixZQUFZLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDdEIsT0FBTyxHQUFHLFVBQVUsQ0FBQyxHQUFHLEVBQUU7WUFDeEIsY0FBYyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUM1QixDQUFDLEVBQUUsU0FBUyxDQUFDLENBQUM7UUFDZCxTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsWUFBWSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUE7SUFDeEMsQ0FBQyxDQUFDLENBQUM7SUFDSCxPQUFPLGNBQWMsQ0FBQztBQUN4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZWZmZWN0LCBzaWduYWwsIFNpZ25hbCB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcblxyXG4vKipcclxuICogQ3JlYXRlcyBhIGRlYm91bmNlZCBzaWduYWwgdGhhdCB1cGRhdGVzIGl0cyB2YWx1ZSBhZnRlciBhIHNwZWNpZmllZCB0aW1lb3V0LlxyXG4gKlxyXG4gKiBAdGVtcGxhdGUgVCAtIFRoZSB0eXBlIG9mIHRoZSBzaWduYWwgdmFsdWUuXHJcbiAqIEBwYXJhbSBTaWduYWw8VD4gaW5wdXQgLSBUaGUgaW5wdXQgc2lnbmFsIHdob3NlIHZhbHVlIHdpbGwgYmUgZGVib3VuY2VkLlxyXG4gKiBAcGFyYW0gbnVtYmVyIFt0aW1lT3V0TXM9MF0gLSBUaGUgZGVib3VuY2UgdGltZW91dCBpbiBtaWxsaXNlY29uZHMuIERlZmF1bHRzIHRvIDAuXHJcbiAqIEByZXR1cm5zIFNpZ25hbDxUPiAtIEEgbmV3IHNpZ25hbCB0aGF0IHVwZGF0ZXMgaXRzIHZhbHVlIGFmdGVyIHRoZSBzcGVjaWZpZWQgZGVib3VuY2UgdGltZW91dC5cclxuICpcclxuICogQGV4YW1wbGVcclxuICogYGBgdHNcclxuICogY29uc3QgaW5wdXQgPSBzaWduYWwoJycpO1xyXG4gKiBjb25zdCBkZWJvdW5jZWQgPSBkZWJvdW5jZWRTaWduYWwoaW5wdXQsIDEwMDApO1xyXG4gKlxyXG4gKiBjb250cnVjdG9yKCkge1xyXG4gKiAgZWZmZWN0KCgpID0+IHtcclxuICogICBjb25zb2xlLmxvZyhkZWJvdW5jZWQoKSk7XHJcbiAqICAgLy8gd2lsbCBsb2cgdGhlIGlucHV0IHZhbHVlIGFmdGVyIDEgc2Vjb25kIG9mIGluYWN0aXZpdHkuXHJcbiAqICB9KTtcclxuICogfVxyXG4gKiAuLi5cclxuICogPGlucHV0IFtuZ01vZGVsXT1cImlucHV0KClcIiAobmdNb2RlbENoYW5nZSk9XCJpbnB1dC5zZXQoJGV2ZW50KVwiPlxyXG4gKiBgYGBcclxuICovXHJcbmV4cG9ydCBmdW5jdGlvbiBkZWJvdW5jZWRTaWduYWw8VD4oaW5wdXQ6IFNpZ25hbDxUPiwgdGltZU91dE1zID0gMCk6IFNpZ25hbDxUPiB7XHJcbiAgY29uc3QgZGVib3VuY2VTaWduYWwgPSBzaWduYWwoaW5wdXQoKSk7XHJcbiAgbGV0IHRpbWVvdXQ6IGFueTtcclxuICBlZmZlY3QoKG9uQ2xlYW5VcCkgPT4ge1xyXG4gICAgY29uc3QgdmFsdWUgPSBpbnB1dCgpO1xyXG4gICAgY2xlYXJUaW1lb3V0KHRpbWVvdXQpO1xyXG4gICAgdGltZW91dCA9IHNldFRpbWVvdXQoKCkgPT4ge1xyXG4gICAgICBkZWJvdW5jZVNpZ25hbC5zZXQodmFsdWUpO1xyXG4gICAgfSwgdGltZU91dE1zKTtcclxuICAgIG9uQ2xlYW5VcCgoKSA9PiBjbGVhclRpbWVvdXQodGltZW91dCkpXHJcbiAgfSk7XHJcbiAgcmV0dXJuIGRlYm91bmNlU2lnbmFsO1xyXG59Il19

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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

package/esm2022/lib/utils/query.mjs

@@ -0,0 +1,58 @@
+import { assertInInjectionContext, inject } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { getQueryParamsFromUrl } from '@sinequa/atomic';
+/**
+ * Retrieves the query name from the current route.
+ *
+ * @remarks
+ * This function must be used within an injection context.
+ *
+ * This function traverses the route tree recursively to find the query name.
+ * It first checks for a query parameter `t` in the route's snapshot. If the query name is not found
+ * in the route data, it attempts to find it in the child routes of the "search" route.
+ * If the query name is still not found, it falls back to the `queryName` defined in the route's data.
+ *
+ * @returns {string | undefined} The query name if found, otherwise `undefined`.
+ */
+export function getQueryNameFromRoute() {
+    assertInInjectionContext(getQueryNameFromRoute);
+    const route = inject(ActivatedRoute);
+    const routes = inject(Router);
+    const recursive = (route) => {
+        if (route?.firstChild)
+            return recursive(route.firstChild);
+        // Get query name from route data
+        const { t } = route.snapshot.queryParams;
+        // ! This is a workaround for the case where the queryName is not defined in the route data
+        // "search" is the parent route of the search results, and "t" is the query parameter for the tab
+        const { queryName } = routes.config.filter(p => p.path === "search")[0].children?.find(route => route.path === t)?.data || {};
+        if (queryName)
+            return queryName;
+        // fallback to queryName from route data
+        if (route?.snapshot.data['queryName'])
+            return route.snapshot.data['queryName'];
+        return undefined;
+    };
+    return recursive(route);
+}
+/**
+ * Builds a query object based on the provided partial query.
+ * If any properties are missing in the partial query, default values are used.
+ *
+ * @remarks
+ * This function must be used within an injection context.
+ *
+ * @param query - The partial query object.
+ * @returns The complete query object.
+ */
+export function buildQuery(query) {
+    assertInInjectionContext(buildQuery);
+    const name = query?.name || getQueryNameFromRoute();
+    const params = getQueryParamsFromUrl(window.location.toString());
+    return {
+        ...params, // default values retrieved from the URL
+        ...query, // override with query
+        name, // override with query name
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/routes.mjs

@@ -0,0 +1,28 @@
+import { assertInInjectionContext, inject } from "@angular/core";
+import { ActivatedRoute, Router } from "@angular/router";
+/**
+ * Retrieves the current path from the Angular `ActivatedRoute` service.
+ *
+ * @returns {string | undefined} The current path as a string, or `undefined` if the path cannot be determined.
+ */
+export function getCurrentPath() {
+    assertInInjectionContext(getCurrentPath);
+    const route = inject(ActivatedRoute);
+    return route?.snapshot.url.toString();
+}
+/**
+ * Retrieves the current query name based on the current path and router configuration.
+ *
+ * This function asserts that it is being called within an injection context and then
+ * uses Angular's dependency injection to get the router configuration. It matches the
+ * current path against the router's configuration to find the corresponding query name.
+ *
+ * @returns {string | undefined} The name of the current query if found, otherwise undefined.
+ */
+export function getCurrentQueryName() {
+    assertInInjectionContext(getCurrentQueryName);
+    const routes = inject(Router).config;
+    const path = getCurrentPath();
+    return routes.find(r => r.path === 'search')?.children?.find(r => r.path === path)?.data?.['queryName'];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/tailwind-utils.mjs

@@ -0,0 +1,6 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFpbHdpbmQtdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL3V0aWxzL3RhaWx3aW5kLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBbUIsSUFBSSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQzdDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUV6QyxNQUFNLFVBQVUsRUFBRSxDQUFDLEdBQUcsTUFBb0I7SUFDeEMsT0FBTyxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7QUFDL0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHR5cGUgQ2xhc3NWYWx1ZSwgY2xzeCB9IGZyb20gJ2Nsc3gnO1xyXG5pbXBvcnQgeyB0d01lcmdlIH0gZnJvbSAndGFpbHdpbmQtbWVyZ2UnO1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIGNuKC4uLmlucHV0czogQ2xhc3NWYWx1ZVtdKSB7XHJcbiAgcmV0dXJuIHR3TWVyZ2UoY2xzeChpbnB1dHMpKTtcclxufVxyXG4iXX0=

package/esm2022/lib/utils/theme-body-hook.mjs

@@ -0,0 +1,18 @@
+import { effect, inject, runInInjectionContext } from "@angular/core";
+import { applyThemeToNativeElement, ThemeStore } from "../stores";
+export function withThemeBodyHook(app, params) {
+    runInInjectionContext(app.injector, () => {
+        const themeStore = inject(ThemeStore);
+        const { scope, theme } = params || { scope: 'application', theme: 'Default' };
+        themeStore.setCurrentTheme(scope, theme);
+        applyThemeToNativeElement(window.document.body, themeStore.scopes()?.[scope]?.cssVars?.light);
+        effect(() => {
+            const bodyScope = themeStore.scopes()?.[scope];
+            const vars = bodyScope.darkMode ? bodyScope.cssVars.dark : bodyScope.cssVars.light;
+            if (vars)
+                applyThemeToNativeElement(window.document.body, vars);
+        });
+    });
+    return app;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/theme-registry.mjs

@@ -0,0 +1,6 @@
+import { THEMES } from "../resources";
+export function withThemes(app, themes) {
+    themes.forEach(theme => THEMES.push(theme));
+    return app;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlbWUtcmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL3V0aWxzL3RoZW1lLXJlZ2lzdHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBUyxNQUFNLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFN0MsTUFBTSxVQUFVLFVBQVUsQ0FBQyxHQUFtQixFQUFFLE1BQWU7SUFDN0QsTUFBTSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUU1QyxPQUFPLEdBQUcsQ0FBQztBQUNiLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBcHBsaWNhdGlvblJlZiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5cbmltcG9ydCB7IFRoZW1lLCBUSEVNRVMgfSBmcm9tIFwiLi4vcmVzb3VyY2VzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiB3aXRoVGhlbWVzKGFwcDogQXBwbGljYXRpb25SZWYsIHRoZW1lczogVGhlbWVbXSk6IEFwcGxpY2F0aW9uUmVmIHtcbiAgdGhlbWVzLmZvckVhY2godGhlbWUgPT4gVEhFTUVTLnB1c2godGhlbWUpKTtcblxuICByZXR1cm4gYXBwO1xufVxuIl19