@sinequa/atomic-angular 0.0.140

package/esm2022/lib/services/application.service.mjs

@@ -0,0 +1,245 @@
+import { computed, inject, Injectable, InjectionToken } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { getState } from '@ngrx/signals';
+import { toast } from 'ngx-sonner';
+import { globalConfig, labels, login, setGlobalConfig } from '@sinequa/atomic';
+import { AuthGuard, InitializationGuard } from '../guards';
+import { AppStore } from '../stores/app.store';
+import { PrincipalStore } from '../stores/principal.store';
+import { UserSettingsStore } from '../stores/user-settings.store';
+import { AppService } from '../web-services/app.service';
+import { AuditService } from '../web-services/audit.service';
+import { ApplicationStore } from '../stores/application.store';
+import * as i0 from "@angular/core";
+export const ROUTE_COMPONENTS = new InjectionToken('ROUTE_COMPONENTS', { factory: () => [] });
+export class ApplicationService {
+    constructor() {
+        this.userSettingsStore = inject(UserSettingsStore);
+        this.principalStore = inject(PrincipalStore);
+        this.appService = inject(AppService);
+        this.appStore = inject(AppStore);
+        this.applicationStore = inject(ApplicationStore);
+        this.route = inject(ActivatedRoute);
+        this.router = inject(Router);
+        this.auditService = inject(AuditService);
+        this.components = inject(ROUTE_COMPONENTS);
+        this.defaultComponent = computed(() => this.components.find(c => c.path === 'all')?.component);
+        this.defaultLayoutComponent = computed(() => this.components.find(c => c.isRoot)?.component);
+    }
+    /**
+     * Registers a list of components.
+     *
+     * * For each path, the corresponding component is registered.
+     * * The default component is the component registered with the path 'all'.
+     * * The default layout component is the component registered with the isLayout flag set to true.
+     * * If no layout component is registered, the default layout component is the default component.
+     * * If no default component is registered, the default component is the first component in the list.
+     *
+     * Those components will be used to create the routes.
+     *
+     * @deprecated use the ROUTE_COMPONENTS injection token instead
+     *
+     * @param components - An array of ComponentMapping objects to be registered.
+     */
+    register(components) {
+        this.components = [...components];
+    }
+    /**
+     * Authenticates the user with the provided credentials, initializes and creates routes.  
+     * * in case of failure, it rejects with an error message.
+     * * in case of success, it resolves with `true`, shows a toast notification to welcome the user,
+     * and updates the application state to ready.
+     *
+     * @param {Credentials} [credentials] - The user's login credentials.
+     * @returns {Promise<boolean>} - A promise that resolves to `true` if login is successful,
+     *                               or rejects with an error message if login fails.
+     * @throws {Error} - Throws an error if the login process fails.
+     */
+    async autoLogin({ credentials, withCreateRoutes = true } = {}) {
+        const { useCredentialsOrSSO } = globalConfig;
+        try {
+            const authenticated = await login(credentials);
+            if (authenticated) {
+                await this.initAndCreateRoutes(withCreateRoutes).catch((error) => {
+                    console.warn('Error initializing the application (authenticated)', error);
+                    return Promise.reject(error);
+                });
+                // Show a toast notification to welcome the user
+                // and the application is ready to use
+                const { fullName, name } = getState(this.principalStore).principal;
+                toast(`Welcome back ${fullName || name}!`, { duration: 2000 });
+                this.applicationStore.updateReadyState();
+                return Promise.resolve(true);
+            }
+            else {
+                return Promise.reject('Login failed');
+            }
+        }
+        catch (error) {
+            console.error('Error logging in', error);
+            if (useCredentialsOrSSO) {
+                await this.initAndCreateRoutes(withCreateRoutes).catch((error) => {
+                    console.warn('Error initializing the application (useCredentialsOrSSO)', error);
+                    setGlobalConfig({ useCredentials: true });
+                    return Promise.reject(error);
+                });
+                setGlobalConfig({ useSSO: true });
+                // Show a toast notification to welcome the user
+                // and the application is ready to use
+                const { fullName, name } = getState(this.principalStore).principal;
+                toast(`Welcome back ${fullName || name}!`, { duration: 2000 });
+                this.applicationStore.updateReadyState();
+                return Promise.resolve(true);
+            }
+            else {
+                return Promise.reject(error);
+            }
+        }
+    }
+    /**
+     * Initializes the application.
+     * - Fetches the application configuration.
+     * - Sets the fetched application configuration in the app store.
+     * - Loads the user settings and logs the state of the user settings store.
+     */
+    async init() {
+        // Fetch the application configuration
+        await this.appStore.initialize();
+        console.log("appStore", getState(this.appStore));
+        // Load the principal (user information)
+        await this.principalStore.initialize();
+        console.log("principalStore", getState(this.principalStore));
+        // Load the user settings
+        await this.userSettingsStore.initialize();
+        console.log("userSettingsStore", getState(this.userSettingsStore));
+        // Labels access
+        const service = (this.appStore.getWebServiceByType('labels'));
+        if (!service) {
+            this.applicationStore.updateHasLabelsAccess(false);
+            return;
+        }
+        try {
+            const rights = await labels.getUserRights();
+            this.applicationStore.updateHasLabelsAccess(rights.canEditPublicLabels || rights.canManagePublicLabels);
+        }
+        catch (error) {
+            console.log("labels.canHandleLabels failure - error: ", error);
+            this.applicationStore.updateHasLabelsAccess(false);
+        }
+    }
+    /**
+     * Initializes the application and creates routes.
+     *
+     * This method performs the following actions:
+     * 1. Calls the `init` method to initialize the application.
+     * 2. Calls the `createRoutes` method to set up the application routes.
+     * 3. Notifies the audit service of a login event.
+     *
+     * @returns {Promise<void>} A promise that resolves when the initialization and route creation are complete.
+     */
+    async initAndCreateRoutes(withCreateRoutes = true) {
+        // throw an error if no components are registered and withCreateRoutes is true
+        // components are required to create the routes
+        if (withCreateRoutes && !this.components.length)
+            throw new Error('No components registered');
+        await this.init();
+        if (withCreateRoutes) {
+            this.createRoutes();
+        }
+    }
+    /**
+     * Creates dynamic routes based on the application's queries and custom JSON configurations.
+     *
+     * This method performs the following steps:
+     * 1. Retrieves the queries and custom JSON data from the application state.
+     * 2. Maps the queries to an array of objects containing query names and tabs.
+     * 3. Throws an error if no queries are found.
+     * 4. Retrieves route data from custom JSONs or falls back to default data.
+     * 5. Creates routes for each tab in each query, or uses the query name if no tabs are found.
+     * 6. Removes the current search route from the router configuration.
+     * 7. Creates child routes based on the provided routes data or the first query's tabs.
+     * 8. Updates the search route with the new child routes.
+     * 9. Resets the router configuration with the new routes.
+     *
+     * @throws {Error} If no queries are found.
+     */
+    createRoutes() {
+        // Now we can create the dynamic routes based on the queries's tabs
+        const { queries, data: custom, customJSONs = [] } = getState(this.appStore);
+        // contains an array of objects with the query name and the tabs
+        const queriesMap = Object.entries(queries).map(([key, value]) => ({ key, ...value }));
+        // ! if no queries are found, throw an error
+        if (!queriesMap.length) {
+            throw new Error('No queries found');
+        }
+        // Retrieves the routes data from the custom JSONs array or fall back to the default data (custom json).
+        let { data: cjRoutes } = Array.isArray(customJSONs) ? customJSONs?.find((c => c.name === 'routes')) || {} : { data: custom?.['routes'] };
+        // check if cjRoutes is an array and not an object to avoid errors
+        if (cjRoutes && !Array.isArray(cjRoutes)) {
+            cjRoutes = undefined;
+        }
+        const routes = (cjRoutes || custom?.['routes']);
+        // take only first query
+        const firstQuery = queriesMap[0];
+        // We need to create a route for each tab in each query
+        // if a query has no tabs, we create a route with the query name as the tab name
+        const firstQueryConfig = { tabs: firstQuery.tabSearch.tabs || [{ name: firstQuery.name }] };
+        // We need to remove the current search route from the router config
+        // the route exists in the router config because it was created in the app-routing.module.ts and we need it
+        // to be able to navigate to the search page. We will recreate it with the new tabs
+        const currentConfig = this.router.config.filter(route => route.path !== 'search');
+        let children = [];
+        // if the routes data is provided, we create the children routes based on the routes data
+        if (routes) {
+            // update routes pathDisplayName with the query display name when not provided
+            // for each path we need to find the corresponding query and tab in the firstQuery object
+            // and create a child route with the query name and tab name
+            const displayNamesMap = firstQuery.tabSearch.tabs.reduce((acc, tab) => {
+                acc[tab.name] = { display: tab.display };
+                return acc;
+            }, {});
+            children = routes.map((route) => {
+                return ({
+                    path: route.path,
+                    component: this.components.find(c => c.path === route.path)?.component || this.defaultComponent(),
+                    data: {
+                        queryName: route.wsName || firstQuery.name,
+                        display: route.pathDisplayName || displayNamesMap[route.wsQueryTab]?.display || route.path,
+                        wsQueryTab: route.wsQueryTab,
+                        iconClass: route.icon
+                    }
+                });
+            });
+        }
+        else {
+            // if the routes data is not provided, we create the children routes based on the first query's tabs
+            // create the children routes for the search route
+            children = firstQueryConfig.tabs.map(tab => ({
+                path: tab.name,
+                component: this.components.find(c => c.path === tab.name)?.component || this.defaultComponent(),
+                data: { queryName: firstQuery.name, display: tab.display || tab.name }
+            }));
+        }
+        const searchPath = this.router.config.find(route => route.path === 'search')
+            || {
+                path: 'search',
+                component: this.components.find(c => c.path === 'search')?.component || this.defaultLayoutComponent(),
+                canActivate: [AuthGuard(), InitializationGuard()],
+                children: []
+            };
+        searchPath.component = this.components.find(c => c.path === 'search')?.component || this.defaultLayoutComponent();
+        searchPath.children = [...children, { path: '**', redirectTo: 'all', pathMatch: 'full' }];
+        const newConfig = [searchPath, ...currentConfig];
+        // finally we reset the router config with the new routes
+        this.router.resetConfig(newConfig);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ApplicationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ApplicationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ApplicationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application.service.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/services/application.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { computed, inject, Injectable, InjectionToken, signal, Type } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { getState } from '@ngrx/signals';\nimport { toast } from 'ngx-sonner';\n\nimport { CCApp, Credentials, globalConfig, labels, login, setGlobalConfig } from '@sinequa/atomic';\n\nimport { AuthGuard, InitializationGuard } from '../guards';\nimport { AppStore } from '../stores/app.store';\nimport { PrincipalStore } from '../stores/principal.store';\nimport { UserSettingsStore } from '../stores/user-settings.store';\nimport { AppService } from '../web-services/app.service';\nimport { AuditService } from '../web-services/audit.service';\nimport { ApplicationStore } from '../stores/application.store';\n\nexport const ROUTE_COMPONENTS = new InjectionToken<ComponentMapping[]>('ROUTE_COMPONENTS', { factory: () => [] });\n\nexport type ComponentMapping = {\n  path: string,\n  component: Type<unknown>\n  isRoot?: boolean\n};\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ApplicationService {\n\n  userSettingsStore = inject(UserSettingsStore);\n  principalStore = inject(PrincipalStore);\n\n  appService = inject(AppService);\n  appStore = inject(AppStore);\n  applicationStore = inject(ApplicationStore);\n\n  route = inject(ActivatedRoute);\n  router = inject(Router);\n\n  auditService = inject(AuditService);\n\n  components = inject(ROUTE_COMPONENTS);\n  defaultComponent = computed(() => this.components.find(c => c.path === 'all')?.component);\n  defaultLayoutComponent = computed(() => this.components.find(c => c.isRoot)?.component);\n\n  /**\n   * Registers a list of components.\n   *\n   * * For each path, the corresponding component is registered.\n   * * The default component is the component registered with the path 'all'.\n   * * The default layout component is the component registered with the isLayout flag set to true.\n   * * If no layout component is registered, the default layout component is the default component.\n   * * If no default component is registered, the default component is the first component in the list.\n   *\n   * Those components will be used to create the routes.\n   *\n   * @deprecated use the ROUTE_COMPONENTS injection token instead\n   *\n   * @param components - An array of ComponentMapping objects to be registered.\n   */\n  register(components: ComponentMapping[]) {\n    this.components = [...components];\n  }\n\n  /**\n   * Authenticates the user with the provided credentials, initializes and creates routes.&nbsp;&nbsp;\n   * * in case of failure, it rejects with an error message.\n   * * in case of success, it resolves with `true`, shows a toast notification to welcome the user,\n   * and updates the application state to ready.\n   *\n   * @param {Credentials} [credentials] - The user's login credentials.\n   * @returns {Promise<boolean>} - A promise that resolves to `true` if login is successful,\n   *                               or rejects with an error message if login fails.\n   * @throws {Error} - Throws an error if the login process fails.\n   */\n  async autoLogin({ credentials, withCreateRoutes = true }: { credentials?: Credentials; withCreateRoutes?: boolean; } = {}): Promise<boolean> {\n    const { useCredentialsOrSSO } = globalConfig;\n    try {\n      const authenticated = await login(credentials);\n      if (authenticated) {\n        await this.initAndCreateRoutes(withCreateRoutes).catch((error) => {\n          console.warn('Error initializing the application (authenticated)', error);\n          return Promise.reject(error);\n        });\n\n        // Show a toast notification to welcome the user\n        // and the application is ready to use\n        const { fullName, name } = getState(this.principalStore).principal;\n        toast(`Welcome back ${fullName || name}!`, { duration: 2000 })\n        this.applicationStore.updateReadyState();\n\n        return Promise.resolve(true);\n      }\n      else {\n        return Promise.reject('Login failed');\n      }\n    }\n    catch (error) {\n      console.error('Error logging in', error);\n      if (useCredentialsOrSSO) {\n        await this.initAndCreateRoutes(withCreateRoutes).catch((error) => {\n          console.warn('Error initializing the application (useCredentialsOrSSO)', error);\n          setGlobalConfig({ useCredentials: true });\n          return Promise.reject(error);\n        })\n\n        setGlobalConfig({ useSSO: true });\n        // Show a toast notification to welcome the user\n        // and the application is ready to use\n        const { fullName, name } = getState(this.principalStore).principal;\n        toast(`Welcome back ${fullName || name}!`, { duration: 2000 })\n        this.applicationStore.updateReadyState();\n\n        return Promise.resolve(true);\n      }\n      else {\n        return Promise.reject(error);\n      }\n    }\n  }\n\n  /**\n   * Initializes the application.\n   * - Fetches the application configuration.\n   * - Sets the fetched application configuration in the app store.\n   * - Loads the user settings and logs the state of the user settings store.\n   */\n  async init() {\n    // Fetch the application configuration\n    await this.appStore.initialize();\n    console.log(\"appStore\", getState(this.appStore));\n\n    // Load the principal (user information)\n    await this.principalStore.initialize()\n    console.log(\"principalStore\", getState(this.principalStore))\n\n    // Load the user settings\n    await this.userSettingsStore.initialize();\n    console.log(\"userSettingsStore\", getState(this.userSettingsStore))\n\n    // Labels access\n    const service = (this.appStore.getWebServiceByType('labels'));\n    if (!service) {\n      this.applicationStore.updateHasLabelsAccess(false);\n      return;\n    }\n    try {\n      const rights = await labels.getUserRights();\n      this.applicationStore.updateHasLabelsAccess(rights.canEditPublicLabels || rights.canManagePublicLabels);\n    } catch (error) {\n      console.log(\"labels.canHandleLabels failure - error: \", error);\n      this.applicationStore.updateHasLabelsAccess(false);\n    }\n  }\n\n\n  /**\n   * Initializes the application and creates routes.\n   *\n   * This method performs the following actions:\n   * 1. Calls the `init` method to initialize the application.\n   * 2. Calls the `createRoutes` method to set up the application routes.\n   * 3. Notifies the audit service of a login event.\n   *\n   * @returns {Promise<void>} A promise that resolves when the initialization and route creation are complete.\n   */\n  async initAndCreateRoutes(withCreateRoutes = true) {\n    // throw an error if no components are registered and withCreateRoutes is true\n    // components are required to create the routes\n    if (withCreateRoutes && !this.components.length) throw new Error('No components registered');\n\n    await this.init();\n    if (withCreateRoutes) {\n      this.createRoutes();\n    }\n  }\n\n  /**\n   * Creates dynamic routes based on the application's queries and custom JSON configurations.\n   *\n   * This method performs the following steps:\n   * 1. Retrieves the queries and custom JSON data from the application state.\n   * 2. Maps the queries to an array of objects containing query names and tabs.\n   * 3. Throws an error if no queries are found.\n   * 4. Retrieves route data from custom JSONs or falls back to default data.\n   * 5. Creates routes for each tab in each query, or uses the query name if no tabs are found.\n   * 6. Removes the current search route from the router configuration.\n   * 7. Creates child routes based on the provided routes data or the first query's tabs.\n   * 8. Updates the search route with the new child routes.\n   * 9. Resets the router configuration with the new routes.\n   *\n   * @throws {Error} If no queries are found.\n   */\n  private createRoutes() {\n    // Now we can create the dynamic routes based on the queries's tabs\n    const { queries, data: custom, customJSONs = [] } = getState(this.appStore) as CCApp;\n\n    // contains an array of objects with the query name and the tabs\n    const queriesMap = Object.entries(queries).map(([key, value]) => ({ key, ...value }));\n\n    // ! if no queries are found, throw an error\n    if (!queriesMap.length) {\n      throw new Error('No queries found');\n    }\n\n    // Retrieves the routes data from the custom JSONs array or fall back to the default data (custom json).\n    let { data: cjRoutes } = Array.isArray(customJSONs) ? customJSONs?.find((c => c.name === 'routes')) || {} : { data: custom?.['routes'] };\n    // check if cjRoutes is an array and not an object to avoid errors\n    if (cjRoutes && !Array.isArray(cjRoutes)) {\n      cjRoutes = undefined;\n    }\n    const routes = (cjRoutes || custom?.['routes']) as { path: string, wsName: string, wsQueryTab: string, pathDisplayName: string, icon: string }[];\n\n    // take only first query\n    const firstQuery = queriesMap[0];\n\n    // We need to create a route for each tab in each query\n    // if a query has no tabs, we create a route with the query name as the tab name\n    const firstQueryConfig = { tabs: firstQuery.tabSearch.tabs || [{ name: firstQuery.name }] };\n\n    // We need to remove the current search route from the router config\n    // the route exists in the router config because it was created in the app-routing.module.ts and we need it\n    // to be able to navigate to the search page. We will recreate it with the new tabs\n    const currentConfig = this.router.config.filter(route => route.path !== 'search');\n\n    let children = [];\n\n    // if the routes data is provided, we create the children routes based on the routes data\n    if (routes) {\n      // update routes pathDisplayName with the query display name when not provided\n      // for each path we need to find the corresponding query and tab in the firstQuery object\n      // and create a child route with the query name and tab name\n      const displayNamesMap = firstQuery.tabSearch.tabs.reduce((acc, tab) => {\n        acc[tab.name] = { display: tab.display };\n        return acc;\n      }, {} as Record<string, { display: string }>);\n\n      children = routes.map((route) => {\n        return ({\n          path: route.path,\n          component: this.components.find(c => c.path === route.path)?.component || this.defaultComponent(),\n          data: {\n            queryName: route.wsName || firstQuery.name,\n            display: route.pathDisplayName || displayNamesMap[route.wsQueryTab]?.display || route.path,\n            wsQueryTab: route.wsQueryTab,\n            iconClass: route.icon\n          }\n        })\n      });\n    }\n    else {\n      // if the routes data is not provided, we create the children routes based on the first query's tabs\n      // create the children routes for the search route\n      children = firstQueryConfig.tabs.map(tab => ({\n        path: tab.name,\n        component: this.components.find(c => c.path === tab.name)?.component || this.defaultComponent(),\n        data: { queryName: firstQuery.name, display: tab.display || tab.name }\n      }));\n    }\n\n    const searchPath = this.router.config.find(route => route.path === 'search')\n      || {\n      path: 'search',\n      component: this.components.find(c => c.path === 'search')?.component || this.defaultLayoutComponent(),\n      canActivate: [AuthGuard(), InitializationGuard()],\n      children: []\n    };\n\n    searchPath.component = this.components.find(c => c.path === 'search')?.component || this.defaultLayoutComponent();\n    searchPath.children = [...children, { path: '**', redirectTo: 'all', pathMatch: 'full' }];\n\n    const newConfig = [searchPath, ...currentConfig];\n    // finally we reset the router config with the new routes\n    this.router.resetConfig(newConfig);\n  }\n}"]}

package/esm2022/lib/services/autocomplete.service.mjs

@@ -0,0 +1,85 @@
+import { Injectable, Injector, inject, signal } from '@angular/core';
+import { forkJoin, from, of } from 'rxjs';
+import { getState } from '@ngrx/signals';
+import { fetchSuggest } from '@sinequa/atomic';
+import { UserSettingsStore } from '../stores/user-settings.store';
+import { AppStore } from '../stores/app.store';
+import * as i0 from "@angular/core";
+export class AutocompleteService {
+    constructor() {
+        this.opened = signal(false);
+        this.injector = inject(Injector);
+        this.userSettingsStore = inject(UserSettingsStore);
+        this.appStore = inject(AppStore);
+    }
+    /**
+     * Retrieves autocomplete items for the given text, max count for each
+     * category handled by the service can be specified in the admin
+     *
+     * @param text Text to retrieve autocomplete items for
+     * @returns An observable of an array of {@link Suggestion} arrays grouped by
+     * suggestion queries configured in the admin
+     */
+    getFromSuggestQueriesForText(text) {
+        // Do not ask for autocomplete items if the text is empty
+        if (!text)
+            return of([]);
+        const queries = this.appStore.getWebServiceByType('autocomplete')?.suggestQueries?.split(',') ?? [];
+        const obss = queries.reduce((acc, curr) => {
+            acc.push(from(fetchSuggest(curr, text)));
+            return acc;
+        }, []);
+        return forkJoin(obss);
+    }
+    /**
+     * Retrieves autocomplete items for the given text from the user settings
+     *
+     * @param text Text to retrieve autocomplete items for
+     * @param maxCount Maximum number of items to retrieve
+     * @returns An observable of an array of {@link Suggestion} arrays grouped by
+     * `recent-searches`, `saved-searches`, `bookmarks` from the user settings
+     */
+    getFromUserSettingsForText(text, maxCount) {
+        const { bookmarks, recentSearches, savedSearches } = getState(this.userSettingsStore);
+        const items = [];
+        if (typeof maxCount === 'number')
+            maxCount = { recentSearches: maxCount, savedSearches: maxCount, bookmarks: maxCount };
+        if (recentSearches) {
+            // don't filter if the text is empty
+            const matchingRecentSearches = text
+                ? recentSearches.filter(recentSearch => recentSearch.display?.toLocaleLowerCase().includes(text.toLocaleLowerCase()))
+                : recentSearches;
+            const searches = matchingRecentSearches.slice(0, maxCount?.recentSearches);
+            if (searches.length > 0)
+                items.push(...searches.map(search => ({ category: 'recent-search', ...search })));
+        }
+        if (savedSearches) {
+            // don't filter if the text is empty
+            const matchingSavedSearches = text
+                ? savedSearches.filter(savedSearch => savedSearch.display?.toLocaleLowerCase().includes(text.toLocaleLowerCase()))
+                : savedSearches;
+            const searches = matchingSavedSearches.slice(0, maxCount?.savedSearches);
+            if (searches.length > 0)
+                items.push(...searches.map(search => ({ category: 'saved-search', ...search })));
+        }
+        if (bookmarks) {
+            // don't filter if the text is empty
+            const matchingBookmarks = text
+                ? bookmarks.filter(bookmark => bookmark.label?.toLowerCase().includes(text.toLowerCase()))
+                : bookmarks;
+            const searches = matchingBookmarks.slice(0, maxCount?.bookmarks);
+            if (searches.length > 0)
+                items.push(...searches.map(search => ({ category: 'bookmark', display: search.label ?? '', ...search })));
+        }
+        return items;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AutocompleteService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AutocompleteService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AutocompleteService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete.service.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/services/autocomplete.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, inject, signal } from '@angular/core';\nimport { Observable, forkJoin, from, of } from 'rxjs';\nimport { getState } from '@ngrx/signals';\n\nimport { CCWebService, Suggestion, fetchSuggest } from '@sinequa/atomic';\n\nimport { UserSettingsStore } from '../stores/user-settings.store';\nimport { AppStore } from '../stores/app.store';\nimport { Autocomplete } from '../models/autocomplete';\n\n\ntype AutocompleteWebService = CCWebService & {\n  allowedWithAnySBA?: boolean,\n  revision?: number,\n  suggestQueries?: string,\n  useDistributionRegex?: boolean,\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AutocompleteService {\n  readonly opened = signal(false);\n\n  readonly injector = inject(Injector)\n\n  userSettingsStore = inject(UserSettingsStore);\n  appStore = inject(AppStore);\n\n  /**\n   * Retrieves autocomplete items for the given text, max count for each\n   * category handled by the service can be specified in the admin\n   *\n   * @param text Text to retrieve autocomplete items for\n   * @returns An observable of an array of {@link Suggestion} arrays grouped by\n   * suggestion queries configured in the admin\n   */\n  getFromSuggestQueriesForText(text: string): Observable<Suggestion[][]> {\n    // Do not ask for autocomplete items if the text is empty\n    if (!text) return of([]);\n\n    const queries = (this.appStore.getWebServiceByType('autocomplete') as AutocompleteWebService)?.suggestQueries?.split(',') ?? [];\n    const obss = queries.reduce((acc: Observable<Suggestion[]>[], curr: string) => {\n      acc.push(from(fetchSuggest(curr, text)));\n      return acc;\n    }, [] as Observable<Suggestion[]>[]);\n\n    return forkJoin<Suggestion[][]>(obss);\n  }\n\n  /**\n   * Retrieves autocomplete items for the given text from the user settings\n   *\n   * @param text Text to retrieve autocomplete items for\n   * @param maxCount Maximum number of items to retrieve\n   * @returns An observable of an array of {@link Suggestion} arrays grouped by\n   * `recent-searches`, `saved-searches`, `bookmarks` from the user settings\n   */\n  getFromUserSettingsForText(text: string, maxCount?: number | Autocomplete): Suggestion[] {\n    const { bookmarks, recentSearches, savedSearches } = getState(this.userSettingsStore);\n    const items: Suggestion[] = [];\n\n    if (typeof maxCount === 'number')\n      maxCount = { recentSearches: maxCount, savedSearches: maxCount, bookmarks: maxCount };\n\n    if (recentSearches) {\n\n      // don't filter if the text is empty\n      const matchingRecentSearches = text\n        ? recentSearches.filter(recentSearch => recentSearch.display?.toLocaleLowerCase().includes(text.toLocaleLowerCase()))\n        : recentSearches;\n\n      const searches = matchingRecentSearches.slice(0, maxCount?.recentSearches);\n\n      if (searches.length > 0)\n        items.push(...searches.map(search => ({ category: 'recent-search', ...search })));\n    }\n\n    if (savedSearches) {\n\n      // don't filter if the text is empty\n      const matchingSavedSearches = text\n        ? savedSearches.filter(savedSearch => savedSearch.display?.toLocaleLowerCase().includes(text.toLocaleLowerCase()))\n        : savedSearches;\n\n      const searches = matchingSavedSearches.slice(0, maxCount?.savedSearches);\n\n      if (searches.length > 0)\n        items.push(...searches.map(search => ({ category: 'saved-search', ...search })));\n    }\n\n    if (bookmarks) {\n\n      // don't filter if the text is empty\n      const matchingBookmarks = text\n        ? bookmarks.filter(bookmark => bookmark.label?.toLowerCase().includes(text.toLowerCase()))\n        : bookmarks;\n\n      const searches = matchingBookmarks.slice(0, maxCount?.bookmarks);\n\n      if (searches.length > 0)\n        items.push(...searches.map(search => ({ category: 'bookmark', display: search.label ?? '', ...search })));\n    }\n\n    return items;\n  }\n}\n"]}

package/esm2022/lib/services/drawer/backdrop.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class BackdropService {
+    constructor() {
+        this.isVisible = new BehaviorSubject(false);
+    }
+    show() {
+        this.isVisible.next(true);
+    }
+    hide() {
+        this.isVisible.next(false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BackdropService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BackdropService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: BackdropService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFja2Ryb3Auc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2F0b21pYy1hbmd1bGFyL3NyYy9saWIvc2VydmljZXMvZHJhd2VyL2JhY2tkcm9wLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sTUFBTSxDQUFDOztBQUt2QyxNQUFNLE9BQU8sZUFBZTtJQUg1QjtRQUlTLGNBQVMsR0FBRyxJQUFJLGVBQWUsQ0FBVSxLQUFLLENBQUMsQ0FBQztLQVN4RDtJQVBRLElBQUk7UUFDVCxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM1QixDQUFDO0lBRU0sSUFBSTtRQUNULElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQzdCLENBQUM7OEdBVFUsZUFBZTtrSEFBZixlQUFlLGNBRmQsTUFBTTs7MkZBRVAsZUFBZTtrQkFIM0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QgfSBmcm9tICdyeGpzJztcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgQmFja2Ryb3BTZXJ2aWNlIHtcbiAgcHVibGljIGlzVmlzaWJsZSA9IG5ldyBCZWhhdmlvclN1YmplY3Q8Ym9vbGVhbj4oZmFsc2UpO1xuXG4gIHB1YmxpYyBzaG93KCk6IHZvaWQge1xuICAgIHRoaXMuaXNWaXNpYmxlLm5leHQodHJ1ZSk7XG4gIH1cblxuICBwdWJsaWMgaGlkZSgpOiB2b2lkIHtcbiAgICB0aGlzLmlzVmlzaWJsZS5uZXh0KGZhbHNlKTtcbiAgfVxufVxuIl19

package/esm2022/lib/services/drawer/drawer-stack.service.mjs

@@ -0,0 +1,152 @@
+import { EventEmitter, Injectable, inject } from '@angular/core';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { getState } from '@ngrx/signals';
+import { SelectionHistoryService } from '../selection-history.service';
+import { SelectionService } from '../selection.service';
+import { NavigationService } from '../navigation.service';
+import { SelectionStore } from '../../stores/selection.store';
+import { BackdropService } from './backdrop.service';
+import * as i0 from "@angular/core";
+export class DrawerStackService {
+    constructor() {
+        this.isOpened = new BehaviorSubject(false);
+        this.toggleTopDrawerExtension$ = new EventEmitter();
+        this.forceTopDrawerCollapse$ = new EventEmitter();
+        this.closeTopDrawer$ = new EventEmitter();
+        this.closeAllDrawers$ = new EventEmitter();
+        this.isChatOpened = new BehaviorSubject(false);
+        this.openChatDrawer$ = new EventEmitter();
+        this.closeChatDrawer$ = new EventEmitter();
+        this.askAI$ = new EventEmitter();
+        this.selection = inject(SelectionService);
+        this.selectionHistory = inject(SelectionHistoryService);
+        this.selectionStore = inject(SelectionStore);
+        this.navigationService = inject(NavigationService);
+        this.backdropService = inject(BackdropService);
+        this.subscriptions = new Subscription();
+        // on new search, close all drawers including chat drawer
+        this.subscriptions.add(this.navigationService.navigationEnd$.subscribe(() => {
+            this.closeAssistant();
+            this.closeAll();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.unsubscribe();
+    }
+    /**
+     * Sets current drawer stack status to open
+     */
+    open(componentType) {
+        this.componentType = componentType;
+        this.isOpened.next(true);
+    }
+    /**
+     * Emits event to extend the top drawer
+     */
+    extend() {
+        this.toggleTopDrawerExtension$.next();
+    }
+    /**
+     * Emits event to close the top drawer, checks if history is empty, if so,
+     * sets current drawer stack status to closed and clears history and current
+     * selection
+     */
+    close() {
+        this.closeTopDrawer$.next();
+        if (this.selectionHistory.getCurrentSelectionIndex() === -1) {
+            this.isOpened.next(false);
+            this.selectionHistory.clearHistory();
+        }
+    }
+    /**
+     * Emits event to close the top drawer
+     */
+    closeTop() {
+        this.closeTopDrawer$.next();
+    }
+    /**
+     * Sets current drawer stack status to closed, clears history and emits event
+     * to close all drawers
+     *
+     * @param keepDrawerOpen if true, do not trigger layout animation
+     */
+    closeAll(keepDrawerOpen = false) {
+        if (!keepDrawerOpen)
+            this.isOpened.next(false);
+        this.selectionHistory.clearHistory();
+        this.closeAllDrawers$.next();
+    }
+    /**
+     * Replace the current selection with the given article by closing all
+     * drawers and opening the drawer with the new selection without triggering
+     * layout animation
+     *
+     * @param article the article to replace the current selection with
+     */
+    replace(article) {
+        const { id } = getState(this.selectionStore);
+        if (id && (!article || article.id === id))
+            return;
+        // close everything without trigger layout animation
+        this.closeAll(true);
+        // set selection
+        this.selection.setCurrentArticle(article);
+        // open drawer
+        this.open();
+    }
+    /**
+     * Stack the given article by setting the current selection and opening the
+     * drawer
+     *
+     * @param article the article to stack
+     */
+    stack(article, withQueryText) {
+        const { id } = getState(this.selectionStore);
+        if (id && (!article || article.id === id))
+            return;
+        // force top drawer to collapse
+        this.forceTopDrawerCollapse$.next();
+        // set selection
+        this.selection.setCurrentArticle(article, withQueryText);
+        // open drawer
+        this.open();
+    }
+    toggleAssistant() {
+        if (this.isChatOpened.getValue()) {
+            this.backdropService.hide();
+            this.closeAssistant();
+        }
+        else {
+            this.backdropService.show();
+            this.openAssistant();
+        }
+    }
+    openAssistant() {
+        this.isChatOpened.next(true);
+        this.isOpened.next(true);
+        this.openChatDrawer$.next();
+        this.backdropService.show();
+    }
+    closeAssistant(keepDrawerOpen = false) {
+        this.isChatOpened.next(false);
+        if (!keepDrawerOpen && this.selectionHistory.getCurrentSelectionIndex() === -1) {
+            this.isOpened.next(false);
+            this.closeAllDrawers$.next();
+        }
+        this.closeChatDrawer$.next();
+        this.backdropService.hide();
+    }
+    askAI(text) {
+        this.openAssistant();
+        this.askAI$.next(text);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DrawerStackService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DrawerStackService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DrawerStackService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drawer-stack.service.js","sourceRoot":"","sources":["../../../../../../projects/atomic-angular/src/lib/services/drawer/drawer-stack.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter, Injectable, OnDestroy, Type, inject } from '@angular/core';\nimport { BehaviorSubject, Subscription } from 'rxjs';\nimport { getState } from '@ngrx/signals';\n\nimport { Article } from '@sinequa/atomic';\n\nimport { SelectionHistoryService } from '../selection-history.service';\nimport { SelectionService } from '../selection.service';\nimport { NavigationService } from '../navigation.service';\nimport { SelectionStore } from '../../stores/selection.store';\nimport { BackdropService } from './backdrop.service';\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DrawerStackService implements OnDestroy {\n  public readonly isOpened = new BehaviorSubject<boolean>(false);\n  public readonly toggleTopDrawerExtension$ = new EventEmitter<void>();\n  public readonly forceTopDrawerCollapse$ = new EventEmitter<void>();\n  public readonly closeTopDrawer$ = new EventEmitter<void>();\n  public readonly closeAllDrawers$ = new EventEmitter<void>();\n\n  public readonly isChatOpened = new BehaviorSubject<boolean>(false);\n  public readonly openChatDrawer$ = new EventEmitter<void>();\n  public readonly closeChatDrawer$ = new EventEmitter<void>();\n  public readonly askAI$ = new EventEmitter<string>();\n\n  private readonly selection = inject(SelectionService);\n  private readonly selectionHistory = inject(SelectionHistoryService);\n  private readonly selectionStore = inject(SelectionStore);\n  private readonly navigationService = inject(NavigationService);\n  private readonly backdropService = inject(BackdropService);\n\n  private readonly subscriptions = new Subscription();\n\n  public componentType?: Type<any>;\n\n  constructor() {\n    // on new search, close all drawers including chat drawer\n    this.subscriptions.add(\n      this.navigationService.navigationEnd$.subscribe(() => {\n        this.closeAssistant();\n        this.closeAll();\n      })\n    );\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.unsubscribe();\n  }\n\n  /**\n   * Sets current drawer stack status to open\n   */\n  public open(componentType?: Type<any>): void {\n    this.componentType = componentType;\n    this.isOpened.next(true);\n  }\n\n  /**\n   * Emits event to extend the top drawer\n   */\n  public extend(): void {\n    this.toggleTopDrawerExtension$.next();\n  }\n\n  /**\n   * Emits event to close the top drawer, checks if history is empty, if so,\n   * sets current drawer stack status to closed and clears history and current\n   * selection\n   */\n  public close(): void {\n    this.closeTopDrawer$.next();\n\n    if (this.selectionHistory.getCurrentSelectionIndex() === -1) {\n      this.isOpened.next(false);\n      this.selectionHistory.clearHistory();\n    }\n  }\n\n  /**\n   * Emits event to close the top drawer\n   */\n  public closeTop(): void {\n    this.closeTopDrawer$.next();\n  }\n\n  /**\n   * Sets current drawer stack status to closed, clears history and emits event\n   * to close all drawers\n   *\n   * @param keepDrawerOpen if true, do not trigger layout animation\n   */\n  public closeAll(keepDrawerOpen: boolean = false): void {\n    if (!keepDrawerOpen) this.isOpened.next(false);\n\n    this.selectionHistory.clearHistory();\n\n    this.closeAllDrawers$.next();\n  }\n\n  /**\n   * Replace the current selection with the given article by closing all\n   * drawers and opening the drawer with the new selection without triggering\n   * layout animation\n   *\n   * @param article the article to replace the current selection with\n   */\n  public replace(article: Article | undefined): void {\n    const { id } = getState(this.selectionStore);\n\n    if (id && (!article || article.id === id)) return;\n\n    // close everything without trigger layout animation\n    this.closeAll(true);\n\n    // set selection\n    this.selection.setCurrentArticle(article);\n    // open drawer\n    this.open();\n  }\n\n  /**\n   * Stack the given article by setting the current selection and opening the\n   * drawer\n   *\n   * @param article the article to stack\n   */\n  public stack(article: Article | undefined, withQueryText?: boolean): void {\n    const { id } = getState(this.selectionStore);\n\n    if (id && (!article || article.id === id)) return;\n\n    // force top drawer to collapse\n    this.forceTopDrawerCollapse$.next();\n    // set selection\n    this.selection.setCurrentArticle(article, withQueryText);\n    // open drawer\n    this.open();\n  }\n\n  public toggleAssistant(): void {\n    if (this.isChatOpened.getValue()) {\n      this.backdropService.hide();\n      this.closeAssistant();\n    } else {\n      this.backdropService.show();\n      this.openAssistant();\n    }\n  }\n\n  public openAssistant(): void {\n    this.isChatOpened.next(true);\n    this.isOpened.next(true);\n    this.openChatDrawer$.next();\n\n    this.backdropService.show();\n  }\n\n  public closeAssistant(keepDrawerOpen: boolean = false): void {\n    this.isChatOpened.next(false);\n\n    if (!keepDrawerOpen && this.selectionHistory.getCurrentSelectionIndex() === -1) {\n      this.isOpened.next(false);\n      this.closeAllDrawers$.next();\n    }\n\n    this.closeChatDrawer$.next();\n    this.backdropService.hide();\n  }\n\n  public askAI(text: string): void {\n    this.openAssistant();\n    this.askAI$.next(text);\n  }\n}\n"]}