@sinequa/atomic-angular 0.0.140

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

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

@@ -0,0 +1,89 @@
+import { Injectable, Injector, inject } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { getState } from '@ngrx/signals';
+import { catchError, map, of } from 'rxjs';
+import { QueryParamsStore, UserSettingsStore } from '../stores';
+import { QueryService } from '../web-services/query.service';
+import * as i0 from "@angular/core";
+export class SearchService {
+    constructor() {
+        this.router = inject(Router);
+        this.route = inject(ActivatedRoute);
+        this.queryService = inject(QueryService);
+        // Represents the last result of a search operation with getResult().
+        this.result = {};
+        this.queryParamsStore = inject(QueryParamsStore);
+        this.userSettingsStore = inject(UserSettingsStore);
+        this.injector = inject(Injector);
+    }
+    /**
+     * Executes a search operation with the given commands and options.
+     *
+     * @param commands - An array of strings representing the search commands.
+     * @param options - An optional object containing search options.
+     * @param options.appendFilters - A boolean indicating whether to append existing filters to the search query. Defaults to true.
+     * @param options.audit - An optional audit trail object to be stored in the navigation state.
+     *
+     * The method constructs query parameters based on the current state and the provided options,
+     * then navigates to the specified commands with the constructed query parameters and audit trail.
+     */
+    search(commands, options = { appendFilters: true }) {
+        const queryParams = {};
+        const { text, filters = [], page, sort, tab } = getState(this.queryParamsStore);
+        const { audit, appendFilters } = options;
+        this.audit = audit;
+        if (appendFilters) {
+            queryParams.f = filters.length > 0 ? JSON.stringify(filters) : undefined;
+            queryParams.p = page;
+            queryParams.s = sort;
+            queryParams.t = tab;
+            queryParams.q = text;
+        }
+        // navigation state store the audit trail
+        this.router.navigate(commands, { relativeTo: this.route, queryParamsHandling: 'merge', queryParams, state: { audit } });
+    }
+    /**
+     * Retrieves the search result based on the provided query.
+     *
+     * @param q - A partial query object containing search parameters.
+     * @returns An Observable of the search result.
+     *
+     * This method performs the following actions:
+     * - Creates an audit event with the type "Search_Text" and the query text.
+     * - Resets the audit property to undefined.
+     * - Calls the search method of the queryService with the query, a flag to include the query name in records, and the audit event.
+     * - Handles any errors by returning an empty Result object.
+     * - Maps the search result to the service's result property.
+     */
+    getResult(q) {
+        const audit = { type: "Search_Text", detail: { querytext: q?.text }, ...this.audit };
+        this.audit = undefined;
+        // add the query name to records, to have it available if we bookmark one
+        return this.queryService.search(q, true, audit)
+            .pipe(catchError(() => of({})), map((result) => this.result = result));
+    }
+    /**
+     * Navigates to the specified page and returns the search result.
+     * @param page - The page number to navigate to.
+     * @returns A promise that resolves to the search result.
+     */
+    gotoPage(page) {
+        this.queryParamsStore.patch({ page });
+        this.search([], { audit: {
+                type: "Search_GotoPage",
+                detail: {
+                    page: page,
+                    fromresultid: this.result ? this.result.id : null
+                }
+            } });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SearchService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SearchService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SearchService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/services/search.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, inject, runInInjectionContext } from '@angular/core';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { getState } from '@ngrx/signals';\nimport { Observable, catchError, map, of, tap } from 'rxjs';\n\nimport { Article, AuditEvents, Query, Result } from '@sinequa/atomic';\n\nimport { QueryParamsStore, UserSettingsStore } from '../stores';\nimport { QueryService } from '../web-services/query.service';\n\n\nexport type SearchOptions = {\n  appendFilters?: boolean;\n  audit?: AuditEvents\n}\n\ntype QueryParams = {\n  f?: string; // filters list\n  p?: number; // page number\n  s?: string; // sort name\n  t?: string; // tab name\n  q?: string; // query text\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SearchService {\n  private readonly router = inject(Router);\n  private readonly route = inject(ActivatedRoute);\n  private readonly queryService = inject(QueryService);\n\n  // Represents the last result of a search operation with getResult().\n  public result: Result = {} as Result;\n  public audit?: AuditEvents;\n\n  protected readonly queryParamsStore = inject(QueryParamsStore);\n  protected readonly userSettingsStore = inject(UserSettingsStore);\n  protected readonly injector = inject(Injector);\n\n\n  /**\n   * Executes a search operation with the given commands and options.\n   *\n   * @param commands - An array of strings representing the search commands.\n   * @param options - An optional object containing search options.\n   * @param options.appendFilters - A boolean indicating whether to append existing filters to the search query. Defaults to true.\n   * @param options.audit - An optional audit trail object to be stored in the navigation state.\n   *\n   * The method constructs query parameters based on the current state and the provided options,\n   * then navigates to the specified commands with the constructed query parameters and audit trail.\n   */\n  public search(commands: string[], options: SearchOptions = { appendFilters: true }): void {\n    const queryParams: QueryParams = {};\n    const { text, filters = [], page, sort, tab } = getState(this.queryParamsStore);\n    const { audit, appendFilters } = options;\n\n    this.audit = audit;\n\n    if (appendFilters) {\n      queryParams.f = filters.length > 0 ? JSON.stringify(filters) : undefined;\n      queryParams.p = page;\n      queryParams.s = sort;\n      queryParams.t = tab;\n      queryParams.q = text;\n    }\n\n    // navigation state store the audit trail\n    this.router.navigate(commands, { relativeTo: this.route, queryParamsHandling: 'merge', queryParams, state: { audit } });\n  }\n\n\n\n  /**\n   * Retrieves the search result based on the provided query.\n   *\n   * @param q - A partial query object containing search parameters.\n   * @returns An Observable of the search result.\n   *\n   * This method performs the following actions:\n   * - Creates an audit event with the type \"Search_Text\" and the query text.\n   * - Resets the audit property to undefined.\n   * - Calls the search method of the queryService with the query, a flag to include the query name in records, and the audit event.\n   * - Handles any errors by returning an empty Result object.\n   * - Maps the search result to the service's result property.\n   */\n  public getResult(q: Partial<Query>): Observable<Result> {\n    const audit: AuditEvents = { type: \"Search_Text\", detail: { querytext: q?.text },  ...this.audit};\n    this.audit = undefined;\n    // add the query name to records, to have it available if we bookmark one\n    return this.queryService.search(q, true, audit)\n      .pipe(\n        catchError(() => of({} as Result)),\n        map((result: Result) => this.result = result)\n      );\n  }\n\n  /**\n   * Navigates to the specified page and returns the search result.\n   * @param page - The page number to navigate to.\n   * @returns A promise that resolves to the search result.\n   */\n  public gotoPage(page: number) {\n    this.queryParamsStore.patch({ page });\n    this.search([], { audit: {\n      type: \"Search_GotoPage\",\n      detail: {\n        page: page,\n        fromresultid: this.result ? this.result.id : null\n    }\n    }});\n  }\n}\n"]}

package/esm2022/lib/services/selection-history.service.mjs

@@ -0,0 +1,92 @@
+import { EventEmitter, Injectable, effect, inject } from '@angular/core';
+import { getState } from '@ngrx/signals';
+import { SelectionStore } from '../stores';
+import { SelectionService } from './selection.service';
+import * as i0 from "@angular/core";
+/*
+ * The `SelectionHistoryService` class is responsible for managing the selection history.
+ *
+ * It keeps track of the history of selected articles and provides methods to navigate through the history.
+ * The service also emits events when the selection history changes.
+ * This service is used by the Drawer
+ */
+export class SelectionHistoryService {
+    constructor() {
+        this.selectionHistoryEvent = new EventEmitter();
+        this.selectionService = inject(SelectionService);
+        this.selectionStore = inject(SelectionStore);
+        this.history = [];
+        effect(() => {
+            const { article } = getState(this.selectionStore);
+            if (!!article && article !== this.history[this.history.length - 1]) {
+                this.history.push(article);
+                this.selectionHistoryEvent.next('new');
+            }
+        });
+    }
+    /**
+     * Retrieves the index of the current selection.
+     *
+     * @returns {number} The index of the current selection, which is the last element in the history array.
+     */
+    getCurrentSelectionIndex() {
+        return this.history.length - 1;
+    }
+    /**
+     * Retrieves an article from the selection history at the specified index.
+     *
+     * @param index - The index of the article to retrieve.
+     * @returns The article at the specified index, or `undefined` if the index is out of bounds.
+     */
+    getSelection(index) {
+        if (index < 0 || index >= this.history.length)
+            return undefined;
+        return this.history[index];
+    }
+    /**
+     * Retrieves the length of the history array.
+     *
+     * @returns {number} The number of entries in the history.
+     */
+    getHistoryLength() {
+        return this.history.length;
+    }
+    /**
+     * Clears the selection history and resets the current article selection.
+     *
+     * This method performs the following actions:
+     * - Empties the history array.
+     * - Calls the `clearCurrentArticle` method on the `selectionService` to reset the current article selection.
+     */
+    clearHistory() {
+        this.history.length = 0;
+        this.selectionService.clearCurrentArticle();
+    }
+    /**
+     * Navigates back in the selection history.
+     *
+     * Removes the most recent entry from the history. If the history is empty after this operation,
+     * it returns `undefined`. Otherwise, it sets the current article to the last entry in the history,
+     * triggers a 'back' event, and returns the last entry.
+     *
+     * @returns {Article | undefined} The last article in the history, or `undefined` if the history is empty.
+     */
+    back() {
+        this.history.pop();
+        if (this.history.length === 0)
+            return undefined;
+        const last = this.history[this.history.length - 1];
+        this.selectionService.setCurrentArticle(last);
+        this.selectionHistoryEvent.next('back');
+        return last;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SelectionHistoryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SelectionHistoryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SelectionHistoryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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