@sinequa/atomic-angular 0.0.146

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"]}

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

@@ -0,0 +1,38 @@
+import { Injectable, inject } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { BackdropService } from './backdrop.service';
+import * as i0 from "@angular/core";
+export class DrawerService {
+    constructor() {
+        this.isOpened = new BehaviorSubject(false);
+        this.isExtended = new BehaviorSubject(false);
+        this.backdrop = inject(BackdropService);
+    }
+    open() {
+        this.isOpened.next(true);
+    }
+    close() {
+        this.collapse();
+        this.isOpened.next(false);
+    }
+    toggle() {
+        this.isOpened.getValue() ? this.close() : this.open();
+    }
+    extend() {
+        this.isExtended.next(true);
+        this.backdrop.show();
+    }
+    collapse() {
+        this.backdrop.hide();
+        this.isExtended.next(false);
+    }
+    toggleExtension() {
+        this.isExtended.getValue() ? this.collapse() : this.extend();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DrawerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DrawerService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DrawerService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/index.mjs

@@ -0,0 +1,12 @@
+export * from "./application.service";
+export * from "./autocomplete.service";
+export * from "./label.service";
+export * from "./navigation.service";
+export * from "./saved-searches.service";
+export * from "./search.service";
+export * from "./selection.service";
+export * from "./selection-history.service";
+export * from "./drawer/drawer-stack.service";
+export * from "./drawer/backdrop.service";
+export * from "./drawer/drawer.service";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyw2QkFBNkIsQ0FBQztBQUU1QyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2FwcGxpY2F0aW9uLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vYXV0b2NvbXBsZXRlLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vbGFiZWwuc2VydmljZVwiO1xyXG5leHBvcnQgKiBmcm9tIFwiLi9uYXZpZ2F0aW9uLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vc2F2ZWQtc2VhcmNoZXMuc2VydmljZVwiO1xyXG5leHBvcnQgKiBmcm9tIFwiLi9zZWFyY2guc2VydmljZVwiO1xyXG5leHBvcnQgKiBmcm9tIFwiLi9zZWxlY3Rpb24uc2VydmljZVwiO1xyXG5leHBvcnQgKiBmcm9tIFwiLi9zZWxlY3Rpb24taGlzdG9yeS5zZXJ2aWNlXCI7XHJcblxyXG5leHBvcnQgKiBmcm9tIFwiLi9kcmF3ZXIvZHJhd2VyLXN0YWNrLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vZHJhd2VyL2JhY2tkcm9wLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vZHJhd2VyL2RyYXdlci5zZXJ2aWNlXCI7XHJcbiJdfQ==

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

@@ -0,0 +1,161 @@
+import { Injectable, inject, signal } from '@angular/core';
+import { AppStore } from '../stores/app.store';
+import { fetchLabels, labels } from '@sinequa/atomic';
+import { from, map, of, switchMap } from 'rxjs';
+import * as i0 from "@angular/core";
+;
+export class LabelService {
+    constructor() {
+        this.appStore = inject(AppStore);
+        this.hasAccess = signal(undefined);
+    }
+    /**
+     * Check user rights to verify if they can access labels handling
+     * @returns if has the rights
+     */
+    async canHandleLabels() {
+        if (this.hasAccess() !== undefined)
+            return this.hasAccess();
+        const service = this.appStore.getWebServiceByType('labels');
+        if (!service)
+            return false;
+        try {
+            const rights = await labels.getUserRights();
+            this.hasAccess.set(rights.canEditPublicLabels || rights.canManagePublicLabels);
+            return this.hasAccess();
+        }
+        catch (error) {
+            console.log("labels.canHandleLabels failure - error: ", error);
+            return false;
+        }
+    }
+    /**
+     * Get relevant config info from the labels web service
+     * @returns the LabelsConfig or undefined if no rights
+     */
+    getLabelsConfig() {
+        return from(this.canHandleLabels())
+            .pipe(map((canHandle) => {
+            if (!canHandle)
+                return undefined;
+            const { allowPublicLabelsCreation, allowPublicLabelsModification, privateLabelsField, publicLabelsField, defaultPublicLabels, labelsAutoSuggestMaxCount, labelsAutoSuggestWildcard } = this.appStore.getWebServiceByType('labels');
+            return {
+                allowPublicLabelsCreation,
+                allowPublicLabelsModification,
+                privateLabelsField,
+                publicLabelsField,
+                defaultPublicLabels,
+                labelsAutoSuggestMaxCount,
+                labelsAutoSuggestWildcard
+            };
+        }));
+    }
+    /**
+     * Fetch labels from string
+     * @param prefix the string prefix to filter with
+     * @param publicOnly whether they should be public or not
+     * @param locale optional locale filtering
+     * @returns list of label strings
+     */
+    fetch(prefix, publicOnly = true, locale) {
+        return from(fetchLabels(prefix, publicOnly, locale));
+    }
+    /**
+     * Add some labels to many documents
+     * @param labelsToAdd list of labels to add
+     * @param ids list of document id to add the label
+     * @param publicOnly whether the operation should be public only
+     * @returns a promise that resolves when the operation is complete
+     */
+    add(labelsToAdd, ids, publicOnly) {
+        return from(this.canHandleLabels())
+            .pipe(switchMap((canHandle) => {
+            if (!canHandle)
+                return of(undefined);
+            return from(labels.add(labelsToAdd, ids, publicOnly));
+        }));
+    }
+    /**
+     * Remove some labels from many documents
+     * @param labelsToRemove list of labels to remove
+     * @param ids list of document id to add the label
+     * @param publicOnly whether the operation should be public only
+     * @returns a promise that resolves when the operation is complete
+     */
+    remove(labelsToRemove, ids, publicOnly) {
+        return from(this.canHandleLabels())
+            .pipe(switchMap((canHandle) => {
+            if (!canHandle)
+                return of(undefined);
+            return from(labels.remove(labelsToRemove, ids, publicOnly));
+        }));
+    }
+    /**
+     * Name some labels to a new name
+     * @param labelsToRename list of labels to rename
+     * @param newLabel the new label name
+     * @param publicOnly whether the operation should be public only
+     * @returns a promise that resolves when the operation is complete
+     */
+    rename(labelsToRename, newLabel, publicOnly) {
+        return from(this.canHandleLabels())
+            .pipe(switchMap((canHandle) => {
+            if (!canHandle)
+                return of(undefined);
+            return from(labels.rename(labelsToRename, newLabel, publicOnly));
+        }));
+    }
+    /**
+     * Delete some labels
+     * @param labelsToDelete the labels to delete
+     * @param publicOnly whether the operation should be public only
+     * @returns a promise that resolves when the operation is complete
+     */
+    delete(labelsToDelete, publicOnly) {
+        return from(this.canHandleLabels())
+            .pipe(switchMap((canHandle) => {
+            if (!canHandle)
+                return of(undefined);
+            return from(labels.delete(labelsToDelete, publicOnly));
+        }));
+    }
+    /**
+     * Create some labels for a query
+     * @param labelstoAdd the labels to create
+     * @param query the query object to which the labels will be added
+     * @param publicOnly whether the operation should be public only
+     * @returns a promise that resolves when the operation is complete
+     */
+    bulkAdd(labelstoAdd, query, publicOnly) {
+        return from(this.canHandleLabels())
+            .pipe(switchMap((canHandle) => {
+            if (!canHandle)
+                return of(undefined);
+            return from(labels.bulkAdd(labelstoAdd, query, publicOnly));
+        }));
+    }
+    /**
+     * Delete some labels from a query
+     * @param labelsToRemove the labels to remove
+     * @param query the query object to which the labels will be removed
+     * @param publicOnly whether the operation should be public only
+     * @returns a promise that resolves when the operation is complete
+     */
+    bulkRemove(labelsToRemove, query, publicOnly) {
+        return from(this.canHandleLabels())
+            .pipe(switchMap((canHandle) => {
+            if (!canHandle)
+                return of(undefined);
+            return from(labels.bulkRemove(labelsToRemove, query, publicOnly));
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: LabelService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: LabelService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: LabelService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"label.service.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/services/label.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, signal } from '@angular/core';\n\nimport { AppStore } from '../stores/app.store';\nimport { CCWebService, fetchLabels, labels, LabelsRights, Query } from '@sinequa/atomic';\nimport { catchError, firstValueFrom, from, map, Observable, of, switchMap, throwError } from 'rxjs';\n\ntype LabelsWebService = CCWebService & LabelsConfig & {\n  allowedWithAnySBA?: boolean,\n  labelsBulkDocLimit?: string,\n  revision?: number,\n  useDistributionRegex?: boolean,\n}\n\nexport interface LabelsConfig {\n  allowPublicLabelsCreation?: boolean;\n  allowPublicLabelsModification?: boolean;\n  privateLabelsField?: string;\n  publicLabelsField?: string;\n  defaultPublicLabels?: string;\n  labelsAutoSuggestMaxCount?: string;\n  labelsAutoSuggestWildcard?: string;\n};\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class LabelService {\n  appStore = inject(AppStore);\n\n  hasAccess = signal<boolean | undefined>(undefined);\n\n  /**\n   * Check user rights to verify if they can access labels handling\n   * @returns if has the rights\n   */\n  async canHandleLabels(): Promise<boolean> {\n    if (this.hasAccess() !== undefined) return this.hasAccess()!;\n\n    const service = (this.appStore.getWebServiceByType('labels') as LabelsWebService);\n    if (!service) return false;\n\n    try {\n      const rights = await labels.getUserRights();\n      this.hasAccess.set(rights.canEditPublicLabels || rights.canManagePublicLabels);\n      return this.hasAccess()!;\n    } catch (error) {\n      console.log(\"labels.canHandleLabels failure - error: \", error);\n      return false;\n    }\n  }\n\n  /**\n   * Get relevant config info from the labels web service\n   * @returns the LabelsConfig or undefined if no rights\n   */\n  getLabelsConfig(): Observable<LabelsConfig | undefined> {\n    return from(this.canHandleLabels())\n      .pipe(\n        map((canHandle: boolean) => {\n          if (!canHandle) return undefined;\n\n          const { allowPublicLabelsCreation, allowPublicLabelsModification, privateLabelsField, publicLabelsField,\n            defaultPublicLabels, labelsAutoSuggestMaxCount, labelsAutoSuggestWildcard } = (this.appStore.getWebServiceByType('labels') as LabelsWebService);\n\n          return {\n            allowPublicLabelsCreation,\n            allowPublicLabelsModification,\n            privateLabelsField,\n            publicLabelsField,\n            defaultPublicLabels,\n            labelsAutoSuggestMaxCount,\n            labelsAutoSuggestWildcard\n          }\n        })\n      );\n  }\n\n  /**\n   * Fetch labels from string\n   * @param prefix the string prefix to filter with\n   * @param publicOnly whether they should be public or not\n   * @param locale optional locale filtering\n   * @returns list of label strings\n   */\n  fetch(prefix: string, publicOnly: boolean = true, locale?: string): Observable<string[]> {\n    return from(fetchLabels(prefix, publicOnly, locale));\n  }\n\n  /**\n   * Add some labels to many documents\n   * @param labelsToAdd list of labels to add\n   * @param ids list of document id to add the label\n   * @param publicOnly whether the operation should be public only\n   * @returns a promise that resolves when the operation is complete\n   */\n  add(labelsToAdd: string[], ids: string[], publicOnly?: boolean): Observable<void> {\n    return from(this.canHandleLabels())\n      .pipe(\n        switchMap((canHandle: boolean) => {\n          if (!canHandle) return of(undefined);\n\n          return from(labels.add(labelsToAdd, ids, publicOnly));\n        })\n      );\n  }\n\n  /**\n   * Remove some labels from many documents\n   * @param labelsToRemove list of labels to remove\n   * @param ids list of document id to add the label\n   * @param publicOnly whether the operation should be public only\n   * @returns a promise that resolves when the operation is complete\n   */\n  remove(labelsToRemove: string[], ids: string[], publicOnly?: boolean): Observable<void> {\n    return from(this.canHandleLabels())\n      .pipe(\n        switchMap((canHandle: boolean) => {\n          if (!canHandle) return of(undefined);\n\n          return from(labels.remove(labelsToRemove, ids, publicOnly));\n        })\n      );\n  }\n\n  /**\n   * Name some labels to a new name\n   * @param labelsToRename list of labels to rename\n   * @param newLabel the new label name\n   * @param publicOnly whether the operation should be public only\n   * @returns a promise that resolves when the operation is complete\n   */\n  rename(labelsToRename: string[], newLabel: string, publicOnly?: boolean): Observable<void> {\n    return from(this.canHandleLabels())\n      .pipe(\n        switchMap((canHandle: boolean) => {\n          if (!canHandle) return of(undefined);\n\n          return from(labels.rename(labelsToRename, newLabel, publicOnly));\n        })\n      );\n  }\n\n  /**\n   * Delete some labels\n   * @param labelsToDelete the labels to delete\n   * @param publicOnly whether the operation should be public only\n   * @returns a promise that resolves when the operation is complete\n   */\n  delete(labelsToDelete: string[], publicOnly?: boolean): Observable<void> {\n    return from(this.canHandleLabels())\n      .pipe(\n        switchMap((canHandle: boolean) => {\n          if (!canHandle) return of(undefined);\n\n          return from(labels.delete(labelsToDelete, publicOnly));\n        })\n      );\n  }\n\n  /**\n   * Create some labels for a query\n   * @param labelstoAdd the labels to create\n   * @param query the query object to which the labels will be added\n   * @param publicOnly whether the operation should be public only\n   * @returns a promise that resolves when the operation is complete\n   */\n  bulkAdd(labelstoAdd: string[], query: Query, publicOnly?: boolean): Observable<void> {\n    return from(this.canHandleLabels())\n      .pipe(\n        switchMap((canHandle: boolean) => {\n          if (!canHandle) return of(undefined);\n\n          return from(labels.bulkAdd(labelstoAdd, query, publicOnly));\n        })\n      );\n  }\n\n  /**\n   * Delete some labels from a query\n   * @param labelsToRemove the labels to remove\n   * @param query the query object to which the labels will be removed\n   * @param publicOnly whether the operation should be public only\n   * @returns a promise that resolves when the operation is complete\n   */\n  bulkRemove(labelsToRemove: string[], query: Query, publicOnly?: boolean): Observable<void> {\n    return from(this.canHandleLabels())\n      .pipe(\n        switchMap((canHandle: boolean) => {\n          if (!canHandle) return of(undefined);\n\n          return from(labels.bulkRemove(labelsToRemove, query, publicOnly));\n        })\n      );\n  }\n}\n"]}

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

@@ -0,0 +1,59 @@
+import { Injectable, inject } from "@angular/core";
+import { NavigationEnd, Router } from "@angular/router";
+import { filter, map, shareReplay, tap } from "rxjs";
+import { getQueryParamsFromUrl } from "@sinequa/atomic";
+import { AuditService } from "../web-services/audit.service";
+import * as i0 from "@angular/core";
+export class NavigationService {
+    constructor() {
+        this.router = inject(Router);
+        this.auditService = inject(AuditService);
+        // The URL after the last navigation event, used to redirect the user after login
+        this.urlAfterNavigation = null;
+        /**
+         * Observable that emits events of type `NavigationEnd` from the Angular Router.
+         *
+         * This observable performs the following operations:
+         * - Maps all router events to `RouterEvent`.
+         * - Filters the events to only include instances of `NavigationEnd`.
+         * - Taps into the event stream to extract the route name from the URL and notify the audit service of route changes,
+         *   excluding the "loading" route and duplicate navigations.
+         * - Updates the `urlAfterNavigation` property with the current URL after navigation.
+         * - Shares the replayed value with a buffer size of 1 to ensure subscribers receive the latest emitted value.
+         *
+         * @type Observable<RouterEvent>
+         */
+        this.navigationEnd$ = this.router.events.pipe(map(event => event), filter((event) => event instanceof NavigationEnd), tap(event => {
+            const url = event.url.slice(1).split('?')[0]; // Extract route name
+            if (url && (url !== "loading" && url !== this.urlAfterNavigation)) {
+                this.auditService.notifyRouteChange(url);
+            }
+        }), tap(event => this.urlAfterNavigation = event.url), shareReplay(1));
+        /**
+         * An observable that emits the tab extracted from the URL pathname or the last part of the URL.
+         *
+         * This observable listens to navigation end events and processes the URL to determine the current tab.
+         * It creates a fake URL object to extract the pathname and then uses the `getQueryParamsFromUrl` function
+         * to extract the tab from the URL pathname or defaults to the last part of the URL if no tab is found.
+         *
+         * @type Observable<string> - An observable that emits the current tab as a string.
+         */
+        this.path$ = this.navigationEnd$.pipe(
+        // create a fake URL object to extract the pathname
+        map((event) => {
+            const url = new URL(`http://localhost${event.url}`);
+            // extract the tab from the URL pathname or use the last part of the URL
+            const { tab = url.pathname.split('/').pop() } = getQueryParamsFromUrl(event.url) || {};
+            return tab;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: NavigationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: NavigationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: NavigationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/saved-searches.service.mjs

@@ -0,0 +1,75 @@
+import { Injectable, inject } from '@angular/core';
+import { toast } from 'ngx-sonner';
+import { getState } from '@ngrx/signals';
+import { QueryParamsStore, UserSettingsStore } from '../stores';
+import * as i0 from "@angular/core";
+const SAVED_SEARCHES_MAX_STORAGE = 100;
+export class SavedSearchesService {
+    constructor() {
+        this.userSettingsStore = inject(UserSettingsStore);
+        this.queryParamsStore = inject(QueryParamsStore);
+    }
+    /**
+     * Retrieves the list of saved searches from the user settings store.
+     *
+     * @returns {SavedSearch[]} An array of saved searches.
+     */
+    getSavedSearches() {
+        return this.userSettingsStore.savedSearches();
+    }
+    /**
+     * Saves the current search query to the user's saved searches.
+     *
+     * This method retrieves the current search text from the query parameters store.
+     * If the search text is empty, it logs an error and exits.
+     * Otherwise, it creates a new saved search object with the current URL, date, and search text.
+     *
+     * The new saved search is added to the beginning of the saved searches array.
+     * If the array exceeds the maximum allowed storage, the oldest search is removed.
+     *
+     * Finally, the updated saved searches array is saved back to the user settings store,
+     * and a success message is displayed to the user.
+     *
+     * @throws {Error} If saving an empty search is attempted.
+     */
+    saveSearch() {
+        const { text } = getState(this.queryParamsStore);
+        if (!text) {
+            console.error('Saving empty search is not allowed');
+            return;
+        }
+        const savedSearch = { url: window.location.hash.substring(1), date: new Date().toISOString(), display: text };
+        const savedSearches = this.userSettingsStore.savedSearches();
+        if (savedSearches.length >= SAVED_SEARCHES_MAX_STORAGE) {
+            savedSearches.pop();
+        }
+        savedSearches.unshift(savedSearch);
+        this.userSettingsStore.updateSavedSearches(savedSearches);
+        toast.success('Search successfully saved');
+    }
+    /**
+     * Updates the saved searches in the user settings store.
+     *
+     * @param savedSearches - An array of SavedSearch objects to update.
+     */
+    updateSavedSearches(savedSearches) {
+        this.userSettingsStore.updateSavedSearches(savedSearches);
+    }
+    /**
+     * Deletes a saved search from the user settings store.
+     *
+     * @param index - The index of the saved search to delete.
+     */
+    deleteSavedSearch(index) {
+        this.userSettingsStore.deleteSavedSearch(index);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SavedSearchesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SavedSearchesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SavedSearchesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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