@sinequa/atomic-angular 0.0.146

package/fesm2022/sinequa-atomic-angular.mjs

@@ -0,0 +1,4420 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, signal, input, viewChild, afterNextRender, Component, HostListener, output, ViewEncapsulation, computed, inject, assertInInjectionContext, runInInjectionContext, effect, Injector, model, Directive, EventEmitter, ElementRef, Pipe, Inject } from '@angular/core';
+import { HubConnectionBuilder, LogLevel } from '@microsoft/signalr';
+import { globalConfig, getMetadata, getQueryParamsFromUrl, queryParamsFromUrl, addConcepts, fetchUserSettings, deleteUserSettings, patchUserSettings, isAuthenticated, isJsonable, addAuditAdditionalInfo, getToken, setToken, login, setGlobalConfig, labels, fetchSuggest, fetchLabels, buildPathsAndLevels, logout, escapeExpr, isObject, Audit } from '@sinequa/atomic';
+import { autoUpdate, computePosition, offset, flip, shift } from '@floating-ui/dom';
+import { NgClass, NgStyle, Location } from '@angular/common';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { withDevtools } from '@angular-architects/ngrx-toolkit';
+import { signalStore, signalStoreFeature, withState, withMethods, patchState, getState, withComputed } from '@ngrx/signals';
+import { catchError, EMPTY, firstValueFrom, map, Subject, filter, tap, shareReplay, BehaviorSubject, Subscription, of, from, forkJoin, switchMap, throwError } from 'rxjs';
+import { HttpClient, HttpParams, HttpResponse } from '@angular/common/http';
+import { ActivatedRoute, Router, NavigationEnd } from '@angular/router';
+import * as i1 from '@angular/forms';
+import { FormsModule } from '@angular/forms';
+import { catchError as catchError$1 } from 'rxjs/operators';
+import { toast } from 'ngx-sonner';
+import highlightWords from 'highlight-words';
+import { DomSanitizer } from '@angular/platform-browser';
+
+/** A token that is used to inject the transports allowed to use by hub connection.
+ *
+ * Expects a {@link HttpTransportType} value.
+*/
+const SIGNAL_R_TRANSPORTS = new InjectionToken('SIGNAL_R_TRANSPORTS');
+/** A token that is used to inject the log level for the hub connection.
+ *
+ * Expects a {@link LogLevel} value.
+*/
+const SIGNAL_R_LOG_LEVEL = new InjectionToken('SIGNAL_R_LOG_LEVEL');
+/**
+ * A service to connect the Sinequa server to the client via SignalR
+ */
+class SignalRWebService {
+    constructor() {
+        this.endpoints = `${globalConfig.backendUrl}/endpoints/v1`;
+    }
+    /**
+     * Builds a SignalR connection to the given endpoint
+     * @param endpointName Name of the endpoint to connect to
+     * @param options  Options for the connection. It must overrides the default options
+     * @param logLevel  The log level for the connection
+     * @param automaticReconnect  Whether the connection should automatically attempt to reconnect
+     * @returns  A SignalR connection
+     */
+    buildConnection(endpointName, options, logLevel = LogLevel.Information, automaticReconnect = false) {
+        const url = `${this.endpoints}/${endpointName}`;
+        const connectionBuilder = new HubConnectionBuilder()
+            .withUrl(url, options)
+            .configureLogging(logLevel);
+        if (automaticReconnect) {
+            connectionBuilder.withAutomaticReconnect();
+        }
+        return connectionBuilder.build();
+    }
+    /**
+     * Starts a SignalR connection.
+     * @param connection  A SignalR connection
+     */
+    async startConnection(connection) {
+        if (!connection) {
+            throw new Error("Please provide a valid connection to start");
+        }
+        try {
+            await connection.start();
+            console.log(`The SignalR connection has been successfully established! \n url: ${connection.baseUrl} \n connectionId: ${connection.connectionId}`);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Stops a SignalR connection.
+     * @param connection A SignalR connection
+     */
+    async stopConnection(connection) {
+        if (!connection) {
+            throw new Error("Please provide a valid connection to stop");
+        }
+        try {
+            await connection.stop();
+            console.log(`The SignalR connection has been successfully stopped! \n url: ${connection.baseUrl} \n connectionId: ${connection.connectionId}`);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SignalRWebService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SignalRWebService, providedIn: "root" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SignalRWebService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root"
+                }]
+        }] });
+
+class DropdownComponent {
+    mouseleave(event) {
+        this.close();
+    }
+    /**
+     * Initializes the dropdown component and sets up automatic updates for its position.
+     *
+     * The constructor uses `afterNextRender` to ensure that the DOM elements are available
+     * before calling `autoUpdate`. The `autoUpdate` function monitors the trigger and dropdown
+     * elements, and if the dropdown is open, it recalculates its position.
+     *
+     * @constructor
+     */
+    constructor() {
+        this.isOpen = signal(false);
+        this.position = input('bottom-start');
+        this.autoClose = input(false);
+        this.disabled = input();
+        this.dropdown = viewChild('dropdownWrapper');
+        this.trigger = viewChild('trigger');
+        this.width = signal(0);
+        afterNextRender(() => {
+            autoUpdate(this.trigger()?.nativeElement, this.dropdown()?.nativeElement, () => {
+                if (!this.isOpen())
+                    return;
+                this.calculatePosition();
+            });
+        });
+    }
+    /**
+     * Toggles the dropdown's open state.
+     * If the dropdown is disabled, the method returns immediately without making any changes.
+     * Otherwise, it updates the `isOpen` state to its opposite value and recalculates the dropdown's position.
+     */
+    toggle() {
+        if (this.disabled())
+            return;
+        this.isOpen.update(() => !this.isOpen());
+        this.calculatePosition();
+    }
+    /**
+     * Closes the dropdown by setting the `isOpen` state to `false`.
+     */
+    close() {
+        this.isOpen.set(false);
+    }
+    /**
+     * Calculates and sets the position of the dropdown element relative to the trigger element.
+     * Utilizes the `computePosition` function with specified middleware for offset, flip, and shift.
+     * Updates the dropdown's `left` and `top` styles based on the computed position.
+     * Also sets the width of the dropdown to match the trigger element's width.
+     *
+     * @returns {void}
+     */
+    calculatePosition() {
+        computePosition(this.trigger()?.nativeElement, this.dropdown()?.nativeElement, {
+            placement: this.position(),
+            middleware: [offset(8), flip(), shift()],
+        }).then(({ x, y }) => {
+            this.dropdown().nativeElement.style.left = x + 'px';
+            this.dropdown().nativeElement.style.top = y + 'px';
+            this.width.set(this.trigger()?.nativeElement.offsetWidth);
+        });
+    }
+    // Onclick outside the dropdown, close it
+    clickout(event) {
+        if (
+        // Check if the click was outside the dropdown
+        // and the dropdown is open
+        // and the click was not on the button
+        // then close the dropdown
+        !this.dropdown()?.nativeElement.contains(event.target)
+            && this.isOpen
+            && !this.trigger()?.nativeElement.contains(event.target)) {
+            this.isOpen.set(false);
+        }
+    }
+    /**
+     * Handles the click event on the dropdown content.
+     * If the `autoClose` method returns true, it triggers the `close` method to close the dropdown.
+     */
+    contentClicked() {
+        if (this.autoClose())
+            this.close();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DropdownComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.5", type: DropdownComponent, isStandalone: true, selector: "sq-dropdown, Dropdown", inputs: { position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, autoClose: { classPropertyName: "autoClose", publicName: "autoClose", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "document:click": "clickout($event)" } }, viewQueries: [{ propertyName: "dropdown", first: true, predicate: ["dropdownWrapper"], descendants: true, isSignal: true }, { propertyName: "trigger", first: true, predicate: ["trigger"], descendants: true, isSignal: true }], ngImport: i0, template: `
+    <div #trigger class="select-none dropdown" (click)="toggle()">
+      <ng-content></ng-content>
+    </div>
+
+    <div #dropdownWrapper
+      class="dropdown-wrapper absolute text-sm min-w-fit"
+      [style.display]="isOpen() ? 'block' : 'none'"
+      [style.width]="width() + 'px'"
+      (click)="contentClicked()"
+      (mouseleave)="mouseleave($event)"
+    >
+      <ng-content select="[dropdown-content]"></ng-content>
+    </div>
+  `, isInline: true, styles: [".dropdown-wrapper{z-index:var(--z-dropdown, 100)}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sq-dropdown, Dropdown', standalone: true, template: `
+    <div #trigger class="select-none dropdown" (click)="toggle()">
+      <ng-content></ng-content>
+    </div>
+
+    <div #dropdownWrapper
+      class="dropdown-wrapper absolute text-sm min-w-fit"
+      [style.display]="isOpen() ? 'block' : 'none'"
+      [style.width]="width() + 'px'"
+      (click)="contentClicked()"
+      (mouseleave)="mouseleave($event)"
+    >
+      <ng-content select="[dropdown-content]"></ng-content>
+    </div>
+  `, styles: [".dropdown-wrapper{z-index:var(--z-dropdown, 100)}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { clickout: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+
+class DropdownListComponent {
+    constructor() {
+        this.items = input.required();
+        this.onClick = output();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DropdownListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.5", type: DropdownListComponent, isStandalone: true, selector: "sq-dropdown-list, DropdownList", inputs: { items: { classPropertyName: "items", publicName: "items", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { onClick: "onClick" }, ngImport: i0, template: `
+@for (item of items(); track $index) {
+  <span class="pill pill-sm pill-ghost bg-primary flex place-content-center items-center font-semibold text-white float-left m-1 select-none"
+    role="button">
+    {{ item.display || item.value }}
+    <i class="ms-1 fa-fw far fa-circle-xmark cursor-pointer" (click)="onClick.emit(item)"></i>
+  </span>
+}
+  `, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DropdownListComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'sq-dropdown-list, DropdownList',
+                    standalone: true,
+                    template: `
+@for (item of items(); track $index) {
+  <span class="pill pill-sm pill-ghost bg-primary flex place-content-center items-center font-semibold text-white float-left m-1 select-none"
+    role="button">
+    {{ item.display || item.value }}
+    <i class="ms-1 fa-fw far fa-circle-xmark cursor-pointer" (click)="onClick.emit(item)"></i>
+  </span>
+}
+  `
+                }]
+        }] });
+
+class DropdownInputComponent {
+    constructor() {
+        this.label = input();
+        this.placeholder = input('Start typing to search...');
+        this.noResultLabel = input('No results to be displayed...');
+        this.suggestions = input([]);
+        this.selected = input.required();
+        this.onFocus = output(); // emits the input value
+        this.onKeyUp = output(); // emits the input value
+        this.removeItem = output();
+        this.addItem = output();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DropdownInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.5", type: DropdownInputComponent, isStandalone: true, selector: "sq-dropdown-input, DropdownInput", inputs: { label: { classPropertyName: "label", publicName: "label", isSignal: true, isRequired: false, transformFunction: null }, placeholder: { classPropertyName: "placeholder", publicName: "placeholder", isSignal: true, isRequired: false, transformFunction: null }, noResultLabel: { classPropertyName: "noResultLabel", publicName: "noResultLabel", isSignal: true, isRequired: false, transformFunction: null }, suggestions: { classPropertyName: "suggestions", publicName: "suggestions", isSignal: true, isRequired: false, transformFunction: null }, selected: { classPropertyName: "selected", publicName: "selected", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { onFocus: "onFocus", onKeyUp: "onKeyUp", removeItem: "removeItem", addItem: "addItem" }, ngImport: i0, template: `
+    @if (label()) {
+      <p class="font-semibold">{{ label() }}</p>
+    }
+    <Dropdown class="w-full block">
+      <input
+        #searchInput
+        class="w-1/2 grow focus:outline-none rounded border border-neutral-200 group-hover:bg-white p-2"
+        type="text"
+        autocomplete="off"
+        spellcheck="false"
+        [attr.aria-label]="placeholder()"
+        [attr.placeholder]="placeholder()"
+        (focus)="onFocus.emit(searchInput.value)"
+        (keyup)="onKeyUp.emit(searchInput.value)"
+        />
+
+      <DropdownList class="mb-4" [items]="selected()" (onClick)="removeItem.emit($event)" />
+        
+      <div dropdown-content class="dropdown-content w-max mt-[-1.5rem]">
+        @if (!suggestions().length) {
+          {{ noResultLabel() }}
+        } @else {
+          <ul class="data-list-xs flex-grow overflow-auto max-h-44 my-2">
+            @for (suggestion of suggestions(); track $index) {
+              <li class="p-2 flex data-list-item items-baseline gap-2 cursor-pointer"
+                (click)="addItem.emit(suggestion)">
+                {{ suggestion.display || suggestion.value }}
+              </li>
+            }
+          </ul>
+        }
+      </div>
+    </Dropdown>
+  `, isInline: true, dependencies: [{ kind: "component", type: DropdownComponent, selector: "sq-dropdown, Dropdown", inputs: ["position", "autoClose", "disabled"] }, { kind: "component", type: DropdownListComponent, selector: "sq-dropdown-list, DropdownList", inputs: ["items"], outputs: ["onClick"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: DropdownInputComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'sq-dropdown-input, DropdownInput',
+                    standalone: true,
+                    imports: [DropdownComponent, DropdownListComponent],
+                    template: `
+    @if (label()) {
+      <p class="font-semibold">{{ label() }}</p>
+    }
+    <Dropdown class="w-full block">
+      <input
+        #searchInput
+        class="w-1/2 grow focus:outline-none rounded border border-neutral-200 group-hover:bg-white p-2"
+        type="text"
+        autocomplete="off"
+        spellcheck="false"
+        [attr.aria-label]="placeholder()"
+        [attr.placeholder]="placeholder()"
+        (focus)="onFocus.emit(searchInput.value)"
+        (keyup)="onKeyUp.emit(searchInput.value)"
+        />
+
+      <DropdownList class="mb-4" [items]="selected()" (onClick)="removeItem.emit($event)" />
+        
+      <div dropdown-content class="dropdown-content w-max mt-[-1.5rem]">
+        @if (!suggestions().length) {
+          {{ noResultLabel() }}
+        } @else {
+          <ul class="data-list-xs flex-grow overflow-auto max-h-44 my-2">
+            @for (suggestion of suggestions(); track $index) {
+              <li class="p-2 flex data-list-item items-baseline gap-2 cursor-pointer"
+                (click)="addItem.emit(suggestion)">
+                {{ suggestion.display || suggestion.value }}
+              </li>
+            }
+          </ul>
+        }
+      </div>
+    </Dropdown>
+  `
+                }]
+        }] });
+
+function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+
+class MenuComponent {
+    constructor() {
+        this.cn = cn;
+        this.default = "z-10 bg-white rounded-md border border-gray-300 shadow absolute text-sm";
+        this.isOpen = signal(false);
+        this.position = input('bottom-start');
+        this.className = input();
+        this.disabled = input();
+        this.autoClose = input(false);
+        this.dropdown = viewChild('dropdown');
+        this.trigger = viewChild('trigger');
+        this.width = signal(0);
+    }
+    ngAfterViewInit() {
+        autoUpdate(this.trigger()?.nativeElement, this.dropdown()?.nativeElement, () => {
+            if (!this.isOpen())
+                return;
+            this.calculatePosition();
+        });
+    }
+    toggle(e) {
+        e.stopPropagation();
+        if (this.disabled())
+            return;
+        this.isOpen.update(() => !this.isOpen());
+        this.calculatePosition();
+    }
+    close() {
+        this.isOpen.set(false);
+    }
+    calculatePosition() {
+        computePosition(this.trigger()?.nativeElement, this.dropdown()?.nativeElement, {
+            placement: this.position(),
+            middleware: [offset(8), flip(), shift()],
+        }).then(({ x, y }) => {
+            this.dropdown().nativeElement.style.left = x + 'px';
+            this.dropdown().nativeElement.style.top = y + 'px';
+            this.width.set(this.trigger()?.nativeElement.offsetWidth);
+        });
+    }
+    contentClicked(e) {
+        e.stopPropagation();
+        if (this.autoClose())
+            this.close();
+    }
+    // Onclick outside the dropdown, close it
+    clickout(event) {
+        if (!this.dropdown()?.nativeElement.contains(event.target) &&
+            this.isOpen &&
+            !this.trigger()?.nativeElement.contains(event.target)) {
+            this.isOpen.set(false);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: MenuComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.5", type: MenuComponent, isStandalone: true, selector: "sq-menu, Menu", inputs: { position: { classPropertyName: "position", publicName: "position", isSignal: true, isRequired: false, transformFunction: null }, className: { classPropertyName: "className", publicName: "className", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null }, autoClose: { classPropertyName: "autoClose", publicName: "autoClose", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "document:click": "clickout($event)" } }, viewQueries: [{ propertyName: "dropdown", first: true, predicate: ["dropdown"], descendants: true, isSignal: true }, { propertyName: "trigger", first: true, predicate: ["trigger"], descendants: true, isSignal: true }], ngImport: i0, template: `
+    <div #trigger class="select-none" (click)="toggle($event)">
+        <ng-content></ng-content>
+    </div>
+    <div #dropdown
+      [ngClass]= "cn(default, className(), disabled() && 'disabled cursor-default opacity-50 hover:bg-transparent')"
+      [style.display]="isOpen() ? 'block' : 'none'"
+      [style.width]="width() + 'px'"
+      (click)="contentClicked($event)"
+    >
+      <ng-content select="[menu-content]"></ng-content>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: MenuComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'sq-menu, Menu',
+                    standalone: true,
+                    imports: [NgClass],
+                    encapsulation: ViewEncapsulation.None,
+                    template: `
+    <div #trigger class="select-none" (click)="toggle($event)">
+        <ng-content></ng-content>
+    </div>
+    <div #dropdown
+      [ngClass]= "cn(default, className(), disabled() && 'disabled cursor-default opacity-50 hover:bg-transparent')"
+      [style.display]="isOpen() ? 'block' : 'none'"
+      [style.width]="width() + 'px'"
+      (click)="contentClicked($event)"
+    >
+      <ng-content select="[menu-content]"></ng-content>
+    </div>
+  `
+                }]
+        }], propDecorators: { clickout: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+
+class MenuItemComponent {
+    constructor(menu) {
+        this.menu = menu;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: MenuItemComponent, deps: [{ token: MenuComponent }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.5", type: MenuItemComponent, isStandalone: true, selector: "sq-menu-item, menu-item, MenuItem", host: { classAttribute: "data-list-item flex gap-2 items-center justify-start py-2 px-4 text-sm cursor-pointer" }, ngImport: i0, template: `
+  <ng-content></ng-content>
+`, isInline: true, styles: [":host[disabled]{cursor:default}\n"] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: MenuItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "sq-menu-item, menu-item, MenuItem", standalone: true, imports: [NgClass], template: `
+  <ng-content></ng-content>
+`, host: {
+                        class: 'data-list-item flex gap-2 items-center justify-start py-2 px-4 text-sm cursor-pointer'
+                    }, styles: [":host[disabled]{cursor:default}\n"] }]
+        }], ctorParameters: () => [{ type: MenuComponent }] });
+
+class MetadataComponent {
+    constructor() {
+        this.cn = cn;
+        this.default = "text-ellipsis";
+        this.override = input(false);
+        this.className = input();
+        this.article = input.required();
+        this.metadata = input.required();
+        this.onMetadataClick = output();
+        this.items = computed(() => getMetadata(this.article(), this.metadata()));
+    }
+    onClick(event, item) {
+        event.stopPropagation();
+        this.onMetadataClick.emit(item);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: MetadataComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.5", type: MetadataComponent, isStandalone: true, selector: "sq-metadata, Metadata", inputs: { override: { classPropertyName: "override", publicName: "override", isSignal: true, isRequired: false, transformFunction: null }, className: { classPropertyName: "className", publicName: "className", isSignal: true, isRequired: false, transformFunction: null }, article: { classPropertyName: "article", publicName: "article", isSignal: true, isRequired: true, transformFunction: null }, metadata: { classPropertyName: "metadata", publicName: "metadata", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { onMetadataClick: "onMetadataClick" }, host: { properties: { "class.hidden": "items().length === 0" } }, exportAs: ["metadata"], ngImport: i0, template: `
+
+  @if(override()) {
+    <ng-content></ng-content>
+  }
+  @else {
+    <ng-content select="[before]"></ng-content>
+    @for(item of items(); track $index) {
+      @if(item.display) {
+        <span [ngClass]="cn(default, className())" (click)="onClick($event, {field: this.metadata() ,value: item.display })">{{ item.display }}</span>
+      }
+    }
+    <ng-content select="[after]"></ng-content>
+  }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: MetadataComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'sq-metadata, Metadata',
+                    exportAs: 'metadata',
+                    standalone: true,
+                    imports: [NgClass],
+                    template: `
+
+  @if(override()) {
+    <ng-content></ng-content>
+  }
+  @else {
+    <ng-content select="[before]"></ng-content>
+    @for(item of items(); track $index) {
+      @if(item.display) {
+        <span [ngClass]="cn(default, className())" (click)="onClick($event, {field: this.metadata() ,value: item.display })">{{ item.display }}</span>
+      }
+    }
+    <ng-content select="[after]"></ng-content>
+  }
+  `,
+                    host: {
+                        '[class.hidden]': 'items().length === 0'
+                    }
+                }]
+        }] });
+
+const THEMES = [
+    {
+        name: "Default",
+        id: "default",
+        private: false,
+        colors: {
+            "button-primary-background": "none",
+            background: "0 0% 100%",
+            foreground: "225 11% 7%",
+            card: "0 0% 100%",
+            "card-foreground": "225 11% 7%",
+            active: "219 97% 54%",
+            "active-foreground": "0 0% 98%",
+            "active-background": "219 97% 54% / 10%",
+            primary: "219 97% 54%",
+            "primary-foreground": "0 0% 98%",
+            secondary: "240 4.8% 95.9%",
+            "secondary-foreground": "240 5.9% 10%",
+            muted: "240 4.8% 95.9%",
+            "muted-foreground": "240 3.8% 46.1%",
+            accent: "240 4.8% 95.9%",
+            "accent-foreground": "240 5.9% 10%",
+            destructive: "0 84.2% 60.2%",
+            "destructive-foreground": "0 0% 98%",
+            border: "240 5.9% 90%",
+            input: "240 5.9% 90%",
+            ring: "225 11% 7%",
+        },
+        colorsDark: {
+            background: "240 10% 3.9%",
+            foreground: "0 0% 98%",
+            card: "240 10% 3.9%",
+            "card-foreground": "0 0% 98%",
+            active: "0 0% 98%",
+            "active-foreground": "240 5.9% 10%",
+            "active-background": "0 0% 98% / 10%",
+            primary: "0 0% 98%",
+            "primary-foreground": "240 5.9% 10%",
+            secondary: "240 3.7% 15.9%",
+            "secondary-foreground": "0 0% 98%",
+            muted: "240 3.7% 15.9%",
+            "muted-foreground": "240 5% 64.9%",
+            accent: "240 3.7% 15.9%",
+            "accent-foreground": "0 0% 98%",
+            destructive: "0 62.8% 30.6%",
+            "destructive-foreground": "0 0% 98%",
+            border: "240 3.7% 15.9%",
+            input: "240 3.7% 15.9%",
+            ring: "240 4.9% 83.9%",
+        },
+    }
+];
+
+const AggregationsStore = signalStore(
+// providing store at the root level
+{ providedIn: 'root' }, withDevtools('Aggregations'), withAggregationsFeatures());
+function withAggregationsFeatures() {
+    return signalStoreFeature(withState({ aggregations: [] }), withMethods((store) => ({
+        /**
+         * Updates the state with the provided aggregations.
+         *
+         * @param {Aggregation[]} aggregations - The new aggregations to update the state with.
+         */
+        update(aggregations) {
+            patchState(store, (state) => {
+                return { ...state, aggregations };
+            });
+        },
+        /**
+         * Updates an existing aggregation in the store.
+         *
+         * @param aggregation - The aggregation object to update.
+         * @returns void
+         */
+        updateAggregation(aggregation) {
+            patchState(store, (state) => {
+                const index = state.aggregations.findIndex((a) => a.name === aggregation.name);
+                if (index !== -1) {
+                    state.aggregations[index] = aggregation;
+                }
+                return { ...state };
+            });
+        },
+        /**
+         * Clears the aggregations in the store by setting the `aggregations` property to an empty array.
+         *
+         * @remarks
+         * This method uses the `patchState` function to update the state of the store.
+         */
+        clear() {
+            patchState(store, (state) => {
+                return { ...state, aggregations: [] };
+            });
+        },
+        /**
+         * Retrieves an aggregation by name or column.
+         *
+         * @param name - The name or column of the aggregation to retrieve.
+         * @param kind - The kind of aggregation to retrieve. Defaults to "name".
+         * @returns The matching aggregation, or undefined if not found.
+         */
+        getAggregation(name, kind = "name") {
+            if (kind === "column") {
+                return getState(store).aggregations.find((aggregation) => aggregation.column === name);
+            }
+            return getState(store).aggregations.find((aggregation) => aggregation.name === name);
+        }
+    })));
+}
+
+class AppService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    /**
+     * Retrieves the application configuration from the server.
+     *
+     * @param appName - The name of the application to fetch the configuration for.
+     *
+     * @returns {Observable<CCApp>} An observable that emits the application configuration.
+     *
+     * @remarks
+     * This method constructs an HTTP GET request to fetch the application configuration
+     * using the `app` parameter from the global configuration. If the request fails,
+     * it logs the error to the console and returns an empty observable.
+     *
+     * @example
+     * ```typescript
+     * appService.getApp().subscribe(appConfig => {
+     *   console.log(appConfig);
+     * });
+     * ```
+     */
+    getApp(appName) {
+        const app = appName || globalConfig.app;
+        const params = new HttpParams().set('app', app || '');
+        return this.http.get(this.API_URL + "/app", { params })
+            .pipe(catchError(error => {
+            console.error("AppService.getApp failure - error: ", error);
+            return EMPTY;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AppService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AppService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AppService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Injection token for a list of facet names to display in the application.
+ *
+ * This token provides a default list of facet names including:
+ * - Geo
+ * - Company
+ * - Person
+ * - DocFormat
+ * - Modified
+ * - Size
+ * - DocumentLanguages
+ * - Concepts
+ *
+ * @constant
+ * @type {InjectionToken<string[]>}
+ */
+const AGGREGATIONS_NAMES_PRESET_DEFAULT = [
+    "Places", "Sources", "Company", "People", "Formats", "Modified", "Sizes", "Languages", "Concepts",
+    "DocFormat", "Geo", "Person", "Treepath", "DocumentLanguages", "Size"
+];
+const AGGREGATIONS_NAMES = new InjectionToken('Facets list to display', { factory: () => AGGREGATIONS_NAMES_PRESET_DEFAULT });
+const AppStore = signalStore({ providedIn: 'root' }, withDevtools('App'), withAppFeatures(), withAppCustomizationFeatures());
+/**
+ * Basic app management features
+ */
+function withAppFeatures() {
+    return signalStoreFeature(withState({ webServices: {}, queries: {} }), 
+    /**
+     * Enhances the application store with various features and methods.
+     *
+     * This function integrates state management, computed properties, and methods
+     * to interact with the CCApp state, including initialization, updates,
+     * and retrieval of specific data such as web services, queries, and customization JSONs.
+     *
+     * Features:
+     * - State management with initial data.
+     * - Computed properties for customization JSON, sources, and filters.
+     * - Methods for initializing and updating the application state.
+     * - Methods for retrieving web services, labels, queries, and customization JSONs.
+     * - Methods for retrieving aggregation icons and customization items.
+     *
+     * @returns The enhanced application store with additional features and methods.
+     */
+    withMethods((store, appService = inject(AppService)) => ({
+        /**
+         * Initializes the application state by fetching the app data from the appService
+         * and updating the store with the retrieved data.
+         *
+         * @returns A promise that resolves when the app data has been fetched and the store has been updated.
+         */
+        initialize() {
+            return firstValueFrom(appService.getApp().pipe(map(app => patchState(store, app))));
+        },
+        /**
+         * Initializes the application state with the provided app name.
+         *
+         * @param appName - The name of the application to fetch the configuration for.
+         *
+         * @returns A promise that resolves when the app data has been fetched and the store has been updated.
+         */
+        initializeWithAppName(appName) {
+            return firstValueFrom(appService.getApp(appName).pipe(map(app => patchState(store, app))));
+        },
+        /**
+         * Updates the application state with the provided CCApp object.
+         *
+         * @param {CCApp} app - The application object containing the new state values.
+         */
+        update(app) {
+            patchState(store, (state) => {
+                return { ...state, ...app };
+            });
+        },
+        /**
+         * Returns the web service by type name
+         *
+         * @param type Web service type name
+         * @returns A {@link CCWebService} object or undefined if not found
+         */
+        getWebServiceByType(type) {
+            let webService = undefined;
+            Object.keys(store.webServices())
+                .forEach((key) => {
+                const w = store.webServices();
+                const ws = w[key];
+                // Check if the web service type matches the specified type in lowercase
+                if (ws.webServiceType.toLowerCase() === type.toLocaleLowerCase())
+                    webService = ws;
+            });
+            return webService;
+        },
+        /**
+         * Retrieves the labels from the web service of type 'Labels'.
+         *
+         * @returns An object containing the private and public labels.
+         *          If the labels are not found, returns an object with empty strings for both fields.
+         */
+        getLabels() {
+            const labels = this.getWebServiceByType('labels');
+            if (!labels)
+                return { private: '', public: '' };
+            const { publicLabelsField, privateLabelsField } = labels;
+            return ({ private: privateLabelsField, public: publicLabelsField });
+        },
+        /**
+         * Retrieves a query by its name from the store.
+         *
+         * @param name - The name of the query to retrieve.
+         * @returns The query object if found, otherwise `undefined`.
+         */
+        getQueryByName(name) {
+            const queries = store.queries();
+            return queries[name.toLowerCase()];
+        },
+        /**
+         * Retrieves a query by its index from the store.
+         *
+         * @param index - The index of the query to retrieve.
+         * @returns The query at the specified index, or `undefined` if the index is out of bounds.
+         */
+        getQueryByIndex(index) {
+            const queries = store.queries();
+            const keys = Object.keys(queries);
+            return queries[keys[index]];
+        },
+        /**
+         * Retrieves the default query.
+         * The default query is always the first query in the list of queries.
+         *
+         * @returns {CCQuery | undefined} The default query if it exists, otherwise undefined.
+         */
+        getDefaultQuery() {
+            return this.getQueryByIndex(0);
+        },
+        /**
+         * Retrieves the allowEmptySearch property for a specific query.
+         * @param queryName - The name of the query for which to retrieve allow empty serach property.
+         * @returns The allowEmptySearch property for the specified query, or false if not found.
+         */
+        allowEmptySearch(queryName) {
+            const queries = store.queries();
+            const keys = Object.keys(queries);
+            if (keys.length === 0)
+                return false;
+            const query = (queryName && queries[queryName.toLocaleLowerCase()]) || queries[keys[0]];
+            return query?.allowEmptySearch || false;
+        },
+        /**
+         * Retrieves the alias for a given column name from the application's state.
+         * If the column has aliases defined, the first alias is returned. Otherwise,
+         * the original column name is returned.
+         *
+         * @param column - The name of the column for which to retrieve the alias.
+         * @returns The alias of the column if it exists, otherwise the original column name.
+         */
+        getColumnAlias(column) {
+            const state = getState(store);
+            const schema = state.indexes?.['_']?.columns;
+            const col = schema[column];
+            if (col) {
+                return col.aliases?.[0] || column;
+            }
+            return column;
+        },
+    })), withMethods((store, aggregationsStore = inject(AggregationsStore), aggregationsNames = inject(AGGREGATIONS_NAMES)) => ({
+        /**
+         * Retrieves the sorted aggregations based on the provided query name.
+         * @param queryName - The name of the query.
+         * @returns An array of sorted aggregations.
+         */
+        getAuthorizedFilters(route) {
+            const { queryName } = route.snapshot.data;
+            const { aggregations = [] } = store.getQueryByName(queryName.toLowerCase()) || {};
+            const agg = [...aggregationsStore.aggregations().filter(aggregation => aggregationsNames.includes(aggregation.name.trim()))];
+            // sort the aggregations based on the query order
+            if (Array.isArray(aggregations)) {
+                const queryAggregationsOrder = aggregations.map(aggregation => aggregation.name.trim()) || [];
+                return agg.toSorted((a, b) => queryAggregationsOrder.indexOf(a.name) - queryAggregationsOrder.indexOf(b.name));
+            }
+            // return the default order
+            return agg;
+        }
+    })));
+}
+/**
+ * Management of customization JSONs features for the app
+ */
+function withAppCustomizationFeatures() {
+    return signalStoreFeature(withState({ customJSONs: [], data: {} }), withComputed(({ customJSONs, data }) => ({
+        customizationJson: computed(() => data()),
+        sources: computed(() => {
+            if (customJSONs() === undefined || Array.isArray(customJSONs()) === false)
+                return data().sources || {};
+            const sourcesJson = customJSONs()?.find(json => json.name === "sources");
+            const sources = sourcesJson?.data['sources'] || {};
+            return sources ?? data().sources ?? {};
+        }),
+        filters: computed(() => {
+            if (customJSONs() === undefined || Array.isArray(customJSONs()) === false)
+                return data().filters || [];
+            const filtersJson = customJSONs()?.find(json => json.name === "filters");
+            const filters = filtersJson?.data['filters'] || [];
+            return filters ?? data().filters ?? [];
+        })
+    })), withMethods((store) => ({
+        /**
+         * Retrieves the customization json by name
+         * @param name - The name of the customization json
+         * @returns The customization json object or undefined if not found
+         */
+        getNamedCustomizationJson(name) {
+            return store.customJSONs().find(data => data.name === name);
+        },
+        /**
+         * Retrieves the icon associated with a given column's aggregation.
+         *
+         * This method searches through the store's filters to find an aggregation
+         * that matches the specified column. If a matching aggregation is found,
+         * its associated icon is returned. If no matching aggregation is found in
+         * the store's filters, the method falls back to searching in the
+         * customizationJson's filters.
+         *
+         * @param column - The name of the column for which to retrieve the aggregation icon.
+         * @returns The icon associated with the specified column's aggregation, or undefined if no matching aggregation is found.
+         */
+        getAggregationIcon(column) {
+            const predicate = (aggregation) => aggregation.column === column;
+            if (store.filters().length > 0) {
+                return store.filters().find(predicate)?.icon;
+            }
+            // fallback to customizationJson
+            return store.customizationJson().filters?.find(predicate)?.icon;
+        },
+        /**
+         * Retrieves the customization items for a given column from the store's filters.
+         * If no items are found in the store's filters, it falls back to the customization JSON.
+         *
+         * @param column - The name of the column for which to retrieve customization items.
+         * @returns An array of `CFilterItem` objects if found, otherwise `undefined`.
+         */
+        getAggregationItemsCustomization(column) {
+            const predicate = (aggregation) => aggregation.column === column;
+            if (store.filters().length > 0) {
+                return store.filters().find(predicate)?.items || [];
+            }
+            // fallback to customizationJson
+            return store.customizationJson().filters?.find(predicate)?.items || [];
+        },
+        /**
+         * Retrieves the customization for a specific aggregation column.
+         * @param column - The column name for which to retrieve the customization.
+         * @returns The customization object for the specified column, or undefined if not found.
+         */
+        getAggregationCustomization(column) {
+            const predicate = (aggregation) => aggregation.column === column;
+            if (store.filters().length > 0) {
+                return store.filters().find(predicate);
+            }
+            // fallback to customizationJson
+            return store.customizationJson().filters?.find(predicate);
+        },
+    })));
+}
+
+const ApplicationStore = signalStore(
+// providing store at the root level
+{ providedIn: 'root', protectedState: false }, withDevtools('Application'), withApplicationFeatures(), withExtractsFeatures());
+/**
+ * Enhances the application store with additional features.
+ *
+ * This function integrates several features into the application store, including state management,
+ * computed properties, and various methods for updating and retrieving application state.
+ *
+ * Features included:
+ * - State initialization with `intialState`.
+ * - Methods for updating the application state:
+ *   - `updateAssistantReady`: Marks the assistant as ready.
+ *   - `updateReadyState`: Sets the application store's ready state to true.
+ *
+ * @returns A configured signal store feature with state, computed properties, and methods.
+ */
+function withApplicationFeatures() {
+    return signalStoreFeature(withState({ assistantReady: false, ready: false, hasLabelsAccess: false }), withMethods((store) => ({
+        /**
+         * Updates the application state to indicate that the assistant is ready.
+         * This function patches the current state by setting the `assistantReady` property to `true`.
+         */
+        updateAssistantReady() {
+            patchState(store, (state) => ({ ...state, assistantReady: true }));
+        },
+        /**
+         * Updates the ready state of the application store to true.
+         * This function patches the current state of the store by setting the `ready` property to `true`.
+         */
+        updateReadyState(value = true) {
+            patchState(store, (state) => ({ ...state, ready: value }));
+        },
+        /**
+         * Updates the `hasLabelsAccess` property in the application store state.
+         *
+         * @param value - A boolean value indicating whether the user has access to labels. Defaults to `true`.
+         */
+        updateHasLabelsAccess(value = true) {
+            patchState(store, (state) => ({ ...state, hasLabelsAccess: value }));
+        }
+    })));
+}
+/**
+ * Provides features related to extracts within the application store.
+ *
+ * This function integrates state management, computed properties, and methods
+ * for handling extracts in the application store.
+ *
+ * Features:
+ * - State management for extracts.
+ * - Computed property to get the count of extracts.
+ * - Methods to update and retrieve extracts.
+ *
+ * @returns A configured signal store feature with state, computed properties, and methods for extracts.
+ */
+function withExtractsFeatures() {
+    return signalStoreFeature(withState({ extracts: new Map() }), withComputed(({ extracts }) => ({
+        extractsCount: computed(() => extracts().size),
+    })), withMethods((store) => ({
+        /**
+         * Updates the extracts for a given ID in the application store.
+         *
+         * @param id - The unique identifier for the extracts to be updated.
+         * @param extracts - An array of Extract objects to be associated with the given ID.
+         */
+        updateExtracts(id, extracts) {
+            patchState(store, (state) => {
+                state.extracts.set(id, extracts);
+                return { ...state };
+            });
+        },
+        /**
+         * Retrieves extracts from the store based on the provided ID.
+         *
+         * @param id - The unique identifier for the extracts to retrieve.
+         * @returns The extracts associated with the given ID.
+         */
+        getExtracts(id) {
+            return store.extracts().get(id);
+        }
+    })));
+}
+
+class PrincipalService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    /**
+     * Retrieves the principal information from the server.
+     *
+     * @returns Observable<Principal> An observable that emits the principal information.
+     *
+     * @remarks
+     * This method sends a GET request to the API endpoint to fetch the principal data.
+     * It includes query parameters to specify the action and to indicate that no authentication is required.
+     * In case of an error, it logs the error to the console and returns an empty observable.
+     *
+     * @example
+     * ```typescript
+     * principalService.getPrincipal().subscribe(principal => {
+     *   console.log(principal);
+     * });
+     * ```
+     */
+    getPrincipal() {
+        const params = new HttpParams().set("action", "get");
+        params.append("noAuthentication", "true");
+        return this.http.get(this.API_URL + "/principal", { params })
+            .pipe(catchError(error => {
+            console.error("PrincipalService.getPrincipal failure - error: ", error);
+            return EMPTY;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: PrincipalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: PrincipalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: PrincipalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+const PrincipalStore = signalStore({ providedIn: 'root' }, withDevtools('Principal'), withState({ principal: {}, userOverrideActive: false }), withComputed(({ principal, userOverrideActive }) => ({
+    allowUserOverride: computed(() => principal().isAdministrator && userOverrideActive() === false),
+    isOverridingUser: computed(() => userOverrideActive() === true)
+})), withPrincipalFeatures());
+/**
+ * Enhances the store with principal-related features.
+ *
+ * This function integrates state, methods, and computed properties related to the principal.
+ *
+ * @returns A feature that can be added to a signal store.
+ *
+ * @feature
+ * - State:
+ *   - `principal`: An object representing the principal.
+ *   - `userOverrideActive`: A boolean indicating if user override is active.
+ *
+ * - Methods:
+ *   - `initialize()`: Initializes the principal state by fetching the principal data from the `PrincipalService`.
+ *
+ * - Computed Properties:
+ *   - `allowUserOverride`: A computed boolean indicating if user override is allowed based on the principal's administrator status and the `userOverrideActive` state.
+ *   - `isOverridingUser`: A computed boolean indicating if the user override is currently active.
+ */
+function withPrincipalFeatures() {
+    return signalStoreFeature(withMethods((store, principalService = inject(PrincipalService)) => ({
+        /**
+         * Initializes the principal store by fetching the principal data from the principal service.
+         * It patches the store with the fetched principal data and a user override active flag from the global configuration.
+         *
+         * @returns A promise that resolves when the principal data has been fetched and the store has been patched.
+         */
+        initialize() {
+            return firstValueFrom(principalService.getPrincipal()
+                .pipe(map(principal => {
+                const { userOverrideActive = false } = globalConfig;
+                patchState(store, { principal, userOverrideActive });
+            })));
+        }
+    })));
+}
+
+class InlineWorker {
+    constructor(func) {
+        this.onMessage = new Subject();
+        this.onError = new Subject();
+        const WORKER_ENABLED = !!(Worker);
+        if (WORKER_ENABLED) {
+            const functionBody = func.toString().replace(/^[^{]*{\s*/, '').replace(/\s*}[^}]*$/, '');
+            try {
+                this.worker = new Worker(URL.createObjectURL(new Blob([functionBody], { type: 'text/javascript' })));
+                this.worker.onmessage = (data) => {
+                    this.onMessage.next(data);
+                };
+                this.worker.onerror = (data) => {
+                    this.onError.next(data);
+                };
+            }
+            catch (e) {
+                throw new Error('WebWorker is not enabled');
+            }
+        }
+        else {
+            throw new Error('WebWorker is not enabled');
+        }
+    }
+    postMessage(data) {
+        this.worker.postMessage(data);
+    }
+    onmessage() {
+        return this.onMessage.asObservable();
+    }
+    onerror() {
+        return this.onError.asObservable();
+    }
+    terminate() {
+        if (this.worker)
+            this.worker.terminate();
+    }
+}
+
+/**
+ * Retrieves the query name from the current route.
+ *
+ * @remarks
+ * This function must be used within an injection context.
+ *
+ * This function traverses the route tree recursively to find the query name.
+ * It first checks for a query parameter `t` in the route's snapshot. If the query name is not found
+ * in the route data, it attempts to find it in the child routes of the "search" route.
+ * If the query name is still not found, it falls back to the `queryName` defined in the route's data.
+ *
+ * @returns {string | undefined} The query name if found, otherwise `undefined`.
+ */
+function getQueryNameFromRoute() {
+    assertInInjectionContext(getQueryNameFromRoute);
+    const route = inject(ActivatedRoute);
+    const routes = inject(Router);
+    const recursive = (route) => {
+        if (route?.firstChild)
+            return recursive(route.firstChild);
+        // Get query name from route data
+        const { t } = route.snapshot.queryParams;
+        // ! This is a workaround for the case where the queryName is not defined in the route data
+        // "search" is the parent route of the search results, and "t" is the query parameter for the tab
+        const { queryName } = routes.config.filter(p => p.path === "search")[0].children?.find(route => route.path === t)?.data || {};
+        if (queryName)
+            return queryName;
+        // fallback to queryName from route data
+        if (route?.snapshot.data['queryName'])
+            return route.snapshot.data['queryName'];
+        return undefined;
+    };
+    return recursive(route);
+}
+/**
+ * Builds a query object based on the provided partial query.
+ * If any properties are missing in the partial query, default values are used.
+ *
+ * @remarks
+ * This function must be used within an injection context.
+ *
+ * @param query - The partial query object.
+ * @returns The complete query object.
+ */
+function buildQuery(query) {
+    assertInInjectionContext(buildQuery);
+    const name = query?.name || getQueryNameFromRoute();
+    const params = getQueryParamsFromUrl(window.location.toString());
+    return {
+        ...params, // default values retrieved from the URL
+        ...query, // override with query
+        name, // override with query name
+    };
+}
+
+/**
+ * Retrieves the current path from the Angular `ActivatedRoute` service.
+ *
+ * @returns {string | undefined} The current path as a string, or `undefined` if the path cannot be determined.
+ */
+function getCurrentPath() {
+    assertInInjectionContext(getCurrentPath);
+    const route = inject(ActivatedRoute);
+    return route?.snapshot.url.toString();
+}
+/**
+ * Retrieves the current query name based on the current path and router configuration.
+ *
+ * This function asserts that it is being called within an injection context and then
+ * uses Angular's dependency injection to get the router configuration. It matches the
+ * current path against the router's configuration to find the corresponding query name.
+ *
+ * @returns {string | undefined} The name of the current query if found, otherwise undefined.
+ */
+function getCurrentQueryName() {
+    assertInInjectionContext(getCurrentQueryName);
+    const routes = inject(Router).config;
+    const path = getCurrentPath();
+    return routes.find(r => r.path === 'search')?.children?.find(r => r.path === path)?.data?.['queryName'];
+}
+
+function withThemeBodyHook(app, params) {
+    runInInjectionContext(app.injector, () => {
+        const themeStore = inject(ThemeStore);
+        const { scope, theme } = params || { scope: 'application', theme: 'Default' };
+        themeStore.setCurrentTheme(scope, theme);
+        applyThemeToNativeElement(window.document.body, themeStore.scopes()?.[scope]?.cssVars?.light);
+        effect(() => {
+            const bodyScope = themeStore.scopes()?.[scope];
+            const vars = bodyScope.darkMode ? bodyScope.cssVars.dark : bodyScope.cssVars.light;
+            if (vars)
+                applyThemeToNativeElement(window.document.body, vars);
+        });
+    });
+    return app;
+}
+
+function withThemes(app, themes) {
+    themes.forEach(theme => THEMES.push(theme));
+    return app;
+}
+
+/**
+ * Creates a debounced signal that updates its value after a specified timeout.
+ *
+ * @template T - The type of the signal value.
+ * @param Signal<T> input - The input signal whose value will be debounced.
+ * @param number [timeOutMs=0] - The debounce timeout in milliseconds. Defaults to 0.
+ * @returns Signal<T> - A new signal that updates its value after the specified debounce timeout.
+ *
+ * @example
+ * ```ts
+ * const input = signal('');
+ * const debounced = debouncedSignal(input, 1000);
+ *
+ * contructor() {
+ *  effect(() => {
+ *   console.log(debounced());
+ *   // will log the input value after 1 second of inactivity.
+ *  });
+ * }
+ * ...
+ * <input [ngModel]="input()" (ngModelChange)="input.set($event)">
+ * ```
+ */
+function debouncedSignal(input, timeOutMs = 0) {
+    const debounceSignal = signal(input());
+    let timeout;
+    effect((onCleanUp) => {
+        const value = input();
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            debounceSignal.set(value);
+        }, timeOutMs);
+        onCleanUp(() => clearTimeout(timeout));
+    });
+    return debounceSignal;
+}
+
+const QueryParamsStore = signalStore({ providedIn: 'root' }, withDevtools('QueryParams'), withQueryParamsFeatures());
+function withQueryParamsFeatures() {
+    return signalStoreFeature(withState({}), withMethods((store, injector = inject(Injector)) => ({
+        /**
+         * Sets the state from the given URL by extracting query parameters and updating the store.
+         *
+         * @param url - The URL containing query parameters to set the state from.
+         *
+         * The function performs the following steps:
+         * 1. Extracts the path from the URL.
+         * 2. Parses the query parameters from the URL.
+         * 3. Decodes and parses the filters from the query parameters.
+         * 4. Converts the page parameter to a number if it exists.
+         * 5. Updates the store state with the extracted and parsed values.
+         */
+        setFromUrl(url) {
+            const path = url.split('?')[0];
+            const { q: text, f, id, p, s: sort, c, t: tab } = queryParamsFromUrl(url);
+            const filters = f ? JSON.parse(decodeURIComponent(f)) : [];
+            const spellingCorrectionMode = c;
+            let page;
+            if (p) {
+                page = parseInt(p, 10);
+            }
+            patchState(store, (state) => {
+                return { ...state, path, text, filters, id, page, sort, spellingCorrectionMode, tab };
+            });
+        },
+        /**
+         * Adds a filter to the store's state.
+         *
+         * @param filter - The filter to be added to the state.
+         *
+         * The function calls the `updateFilter` method to add the filter to the state.
+         */
+        addFilter(filter) {
+            this.updateFilter(filter);
+        },
+        /**
+         * Updates the filter in the store's state.
+         *
+         * @param filter - The filter to be updated. If the filter is `undefined`, the state remains unchanged.
+         *
+         * The function performs the following operations:
+         * - Adds the filter to the state if it doesn't already exist and has values.
+         * - Removes the filter if the 'between' operator is selected but no values are provided.
+         * - Removes the filter if no values are selected and the operator is not 'between'.
+         * - Updates the filter values if the filter already exists.
+         *
+         * @remarks
+         * - If the filter is `undefined`, the state remains unchanged.
+         * - If the filter's operator is 'between' and both `start` and `end` are `undefined`, the filter is removed.
+         * - If the filter's operator is not 'between' and `filters`, `value`, and `values` are all `undefined`, the filter is removed.
+         * - If the filter already exists, its values are updated.
+         */
+        updateFilter(filter) {
+            patchState(store, (state) => {
+                if (filter === undefined)
+                    return state;
+                const allFilters = state.filters || [];
+                const existing = allFilters.findIndex((f) => f.field === filter.field);
+                // Add filter if it doesn't exist and has values
+                if (existing === -1) {
+                    return ({ ...state, filters: [...allFilters || [], filter] });
+                }
+                if (existing >= 0) {
+                    // remove filter if between operator is selected but no values are selected
+                    if (filter.operator === 'between' && filter.start === undefined && filter.end === undefined) {
+                        return ({ ...state, filters: allFilters.filter(f => f.field !== filter.field) });
+                    }
+                    // Remove filter if no values are selected
+                    if (filter.operator !== 'between' && filter.filters === undefined && filter.value === undefined && filter.values === undefined) {
+                        return ({ ...state, filters: (allFilters || []).filter(f => f?.field !== filter.field) });
+                    }
+                    // Update filter values
+                    if (existing >= 0) {
+                        const filters = allFilters.toSpliced(existing, 1, filter);
+                        return ({ ...state, filters });
+                    }
+                }
+                return state;
+            });
+        },
+        /**
+         * Removes a filter from the store based on the specified field.
+         *
+         * @param field - The field of the filter to be removed.
+         */
+        removeFilter(field) {
+            if (!field)
+                return;
+            patchState(store, (state) => {
+                const filters = state.filters?.filter(f => f.field !== field);
+                return { ...state, filters };
+            });
+        },
+        /**
+         * Removes a filter from the state by its name.
+         *
+         * @param name - The name of the filter to be removed.
+         */
+        removeFilterByName(name) {
+            if (!name)
+                return;
+            patchState(store, (state) => {
+                const filters = state.filters?.filter(f => f.name !== name);
+                return { ...state, filters };
+            });
+        },
+        /**
+         * Clears all filters from the state.
+         *
+         * This method updates the state by setting the `filters` property to an empty array.
+         * It uses the `patchState` function to apply the state change.
+         */
+        clearFilters() {
+            patchState(store, (state) => {
+                return { ...state, filters: [] };
+            });
+        },
+        /**
+         * Updates the current state with the provided query parameters.
+         *
+         * @param params - A partial object containing the query parameters to be updated.
+         */
+        patch(params) {
+            patchState(store, (state) => {
+                return { ...state, ...params };
+            });
+        },
+        /**
+         * Retrieves a filter object based on the provided field or name.
+         *
+         * @param {string} fieldOrName - The field or name to search for in the filters.
+         * @returns {Partial<LegacyFilter & {count: number}> | null} - The filter object with an additional count property, or null if not found.
+         *
+         * The method performs the following steps:
+         * 1. Checks if the `fieldOrName` parameter is provided. If not, returns null.
+         * 2. Searches for a filter with a matching field in the store's filters.
+         * 3. If no filter is found by field, searches for a filter with a matching name.
+         * 4. If a filter is found and has a `value` property, returns the filter with a count of 1.
+         * 5. If a filter is found and does not have an array of filters, returns the filter with a count of 1.
+         * 6. If a filter is found and has a `values` property, returns the filter with the count set to the length of the `values` array.
+         * 7. If a filter is found and has an array of filters, returns the filter with the count set to the length of the `filters` array.
+         * 8. If none of the above conditions are met, returns the filter with a count of 0.
+         */
+        getFilter(fieldOrName) {
+            if (!fieldOrName)
+                return null;
+            let filter = getState(store).filters?.find(f => f?.field === fieldOrName);
+            // if not found, return checks for the filter name
+            if (!filter)
+                filter = getState(store).filters?.find(f => f?.name === fieldOrName);
+            // if filter is found, return null
+            if (!filter)
+                return null;
+            if (filter.operator && filter.operator === 'or') {
+                const count = Array.isArray(filter.filters) ? filter.filters.length : 1;
+                return ({ ...filter, count });
+            }
+            if (filter.operator && filter.operator === 'and') {
+                return ({ ...filter, count: 1 });
+            }
+            if (filter && filter.value)
+                return ({ ...filter, count: 1 });
+            if (filter && filter.values)
+                return ({ ...filter, count: filter.values.length });
+            if (filter && Array.isArray(filter.filters) === false)
+                return ({ ...filter, count: 1 });
+            if (filter && Array.isArray(filter.filters))
+                return ({ ...filter, count: filter.filters.length });
+            return ({ ...filter, count: 0 });
+        },
+        /**
+         * Constructs and returns a query object based on the current state of the store.
+         *
+         * This method retrieves various parameters from the store's state, such as filters, sort order, tab, query text, query name, and spelling correction mode.
+         * It processes the filters to separate out "concepts" filters and incorporates them into the query text.
+         * The remaining filters are combined appropriately.
+         * Finally, it builds and returns the query object using the processed parameters.
+         *
+         * @returns Query The constructed query object.
+         */
+        getQuery() {
+            const { filters: allFilters = [], sort, tab, text: queryText = '', name, spellingCorrectionMode } = getState(store);
+            let text = queryText;
+            // remove concepts filters from the query to add them in the query expression
+            const [conceptsFilters] = allFilters.filter(f => f.field === "concepts");
+            if (conceptsFilters) {
+                const concepts = conceptsFilters.filters ? conceptsFilters.filters.map(f => f.value) : [conceptsFilters.value];
+                text = addConcepts(queryText, concepts);
+            }
+            const filters = allFilters.filter(f => f.field !== "concepts");
+            const f = filters.length > 1
+                ? { operator: "and", filters }
+                : filters[0];
+            const query = runInInjectionContext(injector, () => buildQuery({ filters: f, name, sort, spellingCorrectionMode, tab, text }));
+            return query;
+        }
+    })));
+}
+
+/**
+ * @constant
+ * @name SelectionStore
+ * @description
+ * A store that manages the selection state of articles. It is provided in the root of the application and includes
+ * development tools for easier debugging. The store maintains the state with the following properties:
+ * - `article`: The selected article.
+ * - `id`: The ID of the selected article.
+ * - `queryText`: The query text associated with the selection.
+ *
+ * @methods
+ * - `update(article: Article, queryText?: string)`: Updates the store with a new article and optional query text.
+ * - `updateQueryText(queryText: string)`: Updates the query text in the store.
+ * - `clear()`: Clears the selection state, setting `article`, `id`, and `queryText` to `undefined`.
+ */
+const SelectionStore = signalStore({ providedIn: 'root' }, withDevtools('Selection'), withSelectionFeatures());
+function withSelectionFeatures() {
+    return signalStoreFeature(withState({}), withMethods((store) => ({
+        /**
+         * Updates the state with the provided article and optional query text.
+         *
+         * @param article - The article object to update the state with.
+         * @param queryText - Optional query text to update the state with.
+         */
+        update(newState) {
+            patchState(store, (state) => {
+                return { ...state, ...newState };
+            });
+        },
+        /**
+         * Clears the current selection state by setting the `article`, `id`, and `queryText` properties to `undefined`.
+         *
+         * @remarks
+         * This method uses the `patchState` function to update the state of the store.
+         */
+        clear() {
+            patchState(store, () => {
+                return ({ article: undefined, id: undefined, queryText: undefined, previewHighlights: undefined });
+            });
+        }
+    })));
+}
+
+const ThemeStore = signalStore({ providedIn: 'root' }, withDevtools('Theme'), withThemesFeatures());
+function withThemesFeatures() {
+    return signalStoreFeature(withState({ scopes: {} }), withMethods((store) => ({
+        loadDefaultTheme(scope, darkMode) {
+            this.setCurrentTheme(scope, 'Default', darkMode);
+        },
+        /**
+         * Sets the current theme for a given scope.
+         *
+         * @param {string} scope - The scope for which the theme is being set.
+         * @param {string} themeName - The name of the theme to be applied.
+         * @param {boolean} [darkMode] - Optional. Specifies whether dark mode should be enabled. If not provided, it defaults to the current scope's dark mode setting or false.
+         * @returns {void}
+         */
+        setCurrentTheme(scope, themeName, darkMode) {
+            const cssVars = processCssVars(themeName);
+            const currentScope = store.scopes()[scope];
+            patchState(store, (state => ({
+                ...state,
+                scopes: {
+                    ...store.scopes(),
+                    [scope]: {
+                        cssVars,
+                        darkMode: darkMode ?? currentScope?.darkMode ?? false,
+                        themeName: themeName
+                    }
+                }
+            })));
+        },
+        /**
+         * Sets the dark mode preference for a given scope.
+         *
+         * @param scope - The scope for which to set the dark mode preference.
+         * @param darkMode - A boolean indicating whether dark mode should be enabled (true) or disabled (false).
+         *
+         * This function updates the state by patching it with the new dark mode setting for the specified scope.
+         * It retains the existing CSS variables and theme name for the scope.
+         */
+        setDarkMode(scope, darkMode) {
+            const currentScope = store.scopes()[scope];
+            patchState(store, (state => ({
+                ...state,
+                scopes: {
+                    ...store.scopes(),
+                    [scope]: {
+                        cssVars: currentScope?.cssVars ?? {},
+                        darkMode,
+                        themeName: currentScope?.themeName
+                    }
+                }
+            })));
+        },
+    })));
+}
+/**
+ * Processes the CSS variables for a given theme name.
+ *
+ * @param themeName - The name of the theme to process.
+ * @returns An object containing the CSS variables for both light and dark themes.
+ * @throws Will throw an error if the theme with the specified name is not found.
+ */
+function processCssVars(themeName) {
+    const theme = THEMES.find(theme => theme.name === themeName);
+    if (!theme)
+        throw new Error(`Theme "${themeName}" not found`);
+    const cssVars = {
+        light: themeColorsToCssVariables(theme.colors),
+        dark: themeColorsToCssVariables(theme.colorsDark)
+    };
+    return cssVars;
+}
+/**
+ * Converts an object of theme colors to CSS variables.
+ *
+ * @param colors - An object where keys are theme color names and values are the corresponding color values.
+ * @returns An object where keys are CSS variable names and values are the corresponding color values.
+ */
+function themeColorsToCssVariables(colors) {
+    const cssVars = colors
+        ? Object.fromEntries(Object.entries(colors).map(([name, value]) => {
+            if (value === undefined)
+                return [];
+            const cssName = themeColorNameToCssVariable(name);
+            return [cssName, value];
+        }))
+        : {};
+    return cssVars;
+}
+/**
+ * Converts a camelCase theme color name to a CSS variable format.
+ *
+ * This function takes a camelCase string and transforms it into a CSS variable
+ * name by inserting hyphens between lowercase and uppercase letters and converting
+ * the entire string to lowercase.
+ *
+ * @param name - The camelCase theme color name to be converted.
+ * @returns The corresponding CSS variable name in kebab-case.
+ */
+function themeColorNameToCssVariable(name) {
+    return `--${name.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase()}`;
+}
+/**
+ * Applies a set of CSS variables to a given HTML element.
+ *
+ * @param element - The HTML element to which the CSS variables will be applied.
+ * @param cssVars - An optional record of CSS variable names and their corresponding values.
+ */
+function applyThemeToNativeElement(element, cssVars) {
+    if (!cssVars)
+        return;
+    Object.keys(cssVars).forEach((key) => element.style.setProperty(key, cssVars[key]));
+}
+
+const UserSettingsStore = signalStore({ providedIn: 'root' }, withDevtools('UserSettings'), withBookmarkFeatures(), withRecentSearchFeatures(), withSavedSearchFeatures(), withBasketsFeatures(), withAssistantFeatures(), withUserSettingsFeatures());
+function withUserSettingsFeatures() {
+    return signalStoreFeature(withState({ language: undefined }), withMethods((store) => ({
+        /**
+         * Initializes the user settings store by fetching the user settings from the backend API
+         * and patching the store with the retrieved settings.
+         *
+         * @returns {Promise<void>} A promise that resolves when the initialization is complete.
+         */
+        async initialize() {
+            // Fetch the user settings from the backend API and patch the store with the result
+            const settings = await fetchUserSettings();
+            patchState(store, settings);
+        },
+        /**
+         * Resets the user settings to the initial state.
+         *
+         * This method performs the following actions:
+         * 1. Deletes the current user settings.
+         * 2. Patches the state with the initial state.
+         *
+         * @returns {Promise<void>} A promise that resolves when the reset operation is complete.
+         */
+        async reset() {
+            // Reset the user settings to the initial state
+            await deleteUserSettings();
+            patchState(store, {
+                bookmarks: [],
+                recentSearches: [],
+                savedSearches: [],
+                baskets: [],
+                assistants: {},
+                language: undefined,
+            });
+        },
+    })));
+}
+function withBookmarkFeatures() {
+    return signalStoreFeature(withState({ bookmarks: [] }), withMethods((store) => ({
+        /**
+         * Updates the user's bookmarks in the store and optionally logs audit events.
+         *
+         * @param bookmarks - An array of bookmarks to update in the user settings.
+         * @param auditEvents - Optional audit events to log during the update.
+         * @returns A promise that resolves when the update is complete.
+         */
+        async updateBookmarks(bookmarks, auditEvents) {
+            await patchUserSettings({ bookmarks }, auditEvents);
+            patchState(store, (state) => {
+                return { ...state, bookmarks: [...bookmarks] };
+            });
+        },
+        /**
+         * Adds an article to the bookmarks if it is not already bookmarked.
+         *
+         * @param article - The article to be bookmarked.
+         * @param queryName - Optional name of the query associated with the bookmark.
+         * @returns A promise that resolves when the bookmark has been added.
+         */
+        async bookmark(article, queryName) {
+            if (!article.id)
+                return;
+            if (this.isBookmarked(article))
+                return;
+            const bookmark = {
+                id: article.id,
+                label: article.title,
+                source: article.collection[0],
+                author: article.authors?.[0],
+                queryName,
+            };
+            await this.updateBookmarks([...store.bookmarks(), bookmark], {
+                type: "Basket_AddDoc",
+                detail: {
+                    docid: article.id
+                }
+            });
+        },
+        /**
+         * Removes a bookmark by its ID.
+         *
+         * @param id - The ID of the bookmark to remove.
+         * @returns A promise that resolves when the bookmark has been removed and the bookmarks have been updated.
+         *
+         * @remarks
+         * - If the provided ID is falsy, the function will return immediately.
+         * - If the bookmark with the given ID is not found, the function will return immediately.
+         * - The function updates the bookmarks and logs the removal action with a type of "Basket_RemoveDoc".
+         */
+        async unbookmark(id) {
+            if (!id)
+                return;
+            const bookmarks = store.bookmarks();
+            const index = bookmarks?.findIndex((bookmark) => bookmark.id === id);
+            if (index === -1)
+                return;
+            bookmarks.splice(index, 1);
+            await this.updateBookmarks([...bookmarks], {
+                type: "Basket_RemoveDoc",
+                detail: {
+                    docid: id
+                }
+            });
+        },
+        /**
+         * Checks if the given article is bookmarked.
+         *
+         * @param article - An optional partial article object to check.
+         * @returns `true` if the article is bookmarked, `false` otherwise.
+         */
+        isBookmarked(article) {
+            if (!article || !article.id)
+                return false;
+            const bookmarks = store.bookmarks();
+            return !!bookmarks?.find((bookmark) => bookmark.id === article.id);
+        },
+        /**
+         * Toggles the bookmark status of a given article.
+         *
+         * This method checks if the article is currently bookmarked. If it is,
+         * it removes the bookmark. If it is not, it adds a bookmark.
+         *
+         * @param article - The article to toggle the bookmark status for.
+         * @returns A promise that resolves when the bookmark status has been toggled.
+         */
+        async toggleBookmark(article) {
+            const isBookmarked = await this.isBookmarked(article);
+            if (isBookmarked)
+                this.unbookmark(article.id);
+            else
+                this.bookmark(article);
+        },
+    })));
+}
+function withRecentSearchFeatures() {
+    return signalStoreFeature(withState({ recentSearches: [] }), withMethods((store) => ({
+        /**
+         * Deletes a recent search entry from the user's recent searches list.
+         *
+         * @param {number} index - The index of the recent search to delete.
+         * @returns {Promise<void>} A promise that resolves when the recent search has been deleted and the state has been updated.
+         */
+        async deleteRecentSearch(index) {
+            const recentSearches = store.recentSearches();
+            if (recentSearches) {
+                const recentSearchToDelete = recentSearches.splice(index, 1)[0];
+                await patchUserSettings({ recentSearches }, {
+                    type: "RecentQuery_Delete",
+                    detail: {
+                        recentQuery: recentSearchToDelete.queryParams?.text
+                    }
+                });
+                patchState(store, (state) => {
+                    return { ...state, recentSearches: [...recentSearches] };
+                });
+            }
+        },
+        /**
+         * Updates the recent searches in the user settings.
+         *
+         * @param recentSearches - An array of recent searches to be updated in the user settings.
+         * @param auditEvents - Optional audit events to be logged during the update.
+         * @returns A promise that resolves when the recent searches have been updated.
+         */
+        async updateRecentSearches(recentSearches, auditEvents) {
+            await patchUserSettings({ recentSearches }, auditEvents);
+            patchState(store, (state) => {
+                return { ...state, recentSearches: [...recentSearches] };
+            });
+        },
+        /**
+         * Adds the current search to the recent searches list.
+         *
+         * This method checks if a search with the same label already exists in the recent searches.
+         * If it does, it updates the existing search with the new query parameters and date.
+         * If it does not, it adds a new search to the recent searches list.
+         *
+         * @param queryParams - The parameters of the current search.
+         * @returns A promise that resolves when the recent searches have been updated.
+         */
+        async addCurrentSearch(queryParams) {
+            // fist search if the search is already in the recent searches with the same label
+            const recentSearches = store.recentSearches();
+            const existingSearch = recentSearches.find((search) => search.label === queryParams.text);
+            const url = window.location.hash.substring(1);
+            const path = url.split('?')[0];
+            if (existingSearch) {
+                await this.updateRecentSearches([
+                    {
+                        ...existingSearch,
+                        date: new Date().toISOString(),
+                        url,
+                        path,
+                        queryParams,
+                        filterCount: queryParams.filters?.length
+                    },
+                    ...recentSearches.filter((search) => search.label !== queryParams.text),
+                ], {
+                    type: "RecentQuery_Update",
+                    detail: {
+                        recentQuery: queryParams.text
+                    }
+                });
+            }
+            else {
+                const recentSearch = {
+                    url,
+                    path,
+                    display: queryParams.text,
+                    label: queryParams.text,
+                    filterCount: queryParams.filters?.length,
+                    date: new Date().toISOString(),
+                    queryParams
+                };
+                await this.updateRecentSearches([recentSearch, ...store.recentSearches()], {
+                    type: "RecentQuery_Add",
+                    detail: {
+                        recentQuery: queryParams.text
+                    }
+                });
+            }
+        },
+    })));
+}
+function withSavedSearchFeatures() {
+    return signalStoreFeature(withState({ savedSearches: [] }), withMethods((store) => ({
+        async deleteSavedSearch(index) {
+            const savedSearches = store.savedSearches();
+            if (savedSearches) {
+                const savedSearchToDelete = savedSearches.splice(index, 1)[0];
+                await patchUserSettings({ savedSearches }, {
+                    type: "SavedQuery_Delete",
+                    detail: {
+                        savedQuery: savedSearchToDelete.display
+                    }
+                });
+                patchState(store, (state) => {
+                    return { ...state, savedSearches: [...savedSearches] };
+                });
+            }
+        },
+        async updateSavedSearches(savedSearches) {
+            await patchUserSettings({ savedSearches }, {
+                type: "SavedQuery_Add",
+                detail: {
+                    savedQuery: savedSearches[0].display
+                }
+            });
+            patchState(store, (state) => {
+                return { ...state, savedSearches: [...savedSearches] };
+            });
+        },
+    })));
+}
+function basketIndex(name, baskets) {
+    if (baskets?.length) {
+        for (let i = 0, ic = baskets.length; i < ic; i++) {
+            const basket = baskets[i];
+            if (basket && basket.name === name) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function withBasketsFeatures() {
+    return signalStoreFeature(withState({ baskets: [] }), withMethods((store) => ({
+        async deleteBasket(index) {
+            const baskets = store.baskets();
+            if (baskets) {
+                const basketToDelete = baskets.splice(index, 1)[0];
+                await patchUserSettings({ baskets }, {
+                    type: "Basket_Delete",
+                    detail: {
+                        savedQuery: basketToDelete.name
+                    }
+                });
+                patchState(store, (state) => {
+                    return { ...state, baskets: [...baskets] };
+                });
+            }
+        },
+        async createBasket(basket) {
+            const baskets = store.baskets();
+            if (basketIndex(basket.name) >= 0)
+                return;
+            baskets.unshift(basket);
+            await patchUserSettings({ baskets }, {
+                type: "Basket_Add",
+                detail: {
+                    basket: basket.name
+                }
+            });
+            patchState(store, (state) => {
+                return { ...state, baskets: [...baskets] };
+            });
+        },
+        async updateBaskets(baskets) {
+            await patchUserSettings({ baskets }, {
+                type: "Basket_Update"
+            });
+            patchState(store, (state) => {
+                return { ...state, baskets: [...baskets] };
+            });
+        },
+        async updateBasket(basket, index) {
+            const baskets = store.baskets();
+            const prevIndex = basketIndex(basket.name, baskets);
+            if ((prevIndex !== -1 && index !== prevIndex) // A basket with the same name exists at a different index
+                || index < 0 || index >= baskets.length) // index out of bounds
+                return;
+            baskets.splice(index, 1, basket);
+            await patchUserSettings({ baskets }, {
+                type: "Basket_Update",
+                detail: {
+                    basket: basket.name
+                }
+            });
+            patchState(store, (state) => {
+                return { ...state, baskets: [...baskets] };
+            });
+        },
+        async addToBasket(name, ids) {
+            const baskets = store.baskets();
+            const basket = baskets.find(b => b.name === name);
+            if (!ids || !basket)
+                return;
+            if (!basket.ids)
+                basket.ids = [];
+            ids = Array.isArray(ids) ? ids : [ids];
+            for (let id of ids) {
+                if (!basket.ids.some(i => i === id)) {
+                    basket.ids.push(id);
+                }
+            }
+            await patchUserSettings({ baskets }, {
+                type: "Basket_AddDoc",
+                detail: {
+                    basket: basket.name,
+                    docid: ids[0]
+                }
+            });
+            patchState(store, (state) => {
+                return { ...state, baskets: [...baskets] };
+            });
+        },
+        async removeFromBasket(name, ids) {
+            const baskets = store.baskets();
+            const basket = baskets.find(b => b.name === name);
+            if (!ids || !basket)
+                return;
+            if (!basket.ids)
+                basket.ids = [];
+            ids = Array.isArray(ids) ? ids : [ids];
+            for (let id of ids) {
+                if (!basket.ids.some(i => i === id)) {
+                    basket.ids.push(id);
+                }
+            }
+            await patchUserSettings({ baskets }, {
+                type: "Basket_AddDoc",
+                detail: {
+                    basket: basket.name,
+                    docid: ids[0]
+                }
+            });
+            patchState(store, (state) => {
+                return { ...state, baskets: [...baskets] };
+            });
+        },
+    })));
+}
+function withAssistantFeatures() {
+    return signalStoreFeature(withState({ assistants: {} }), withMethods((store) => ({
+        async updateAssistantSettings(assistantSettings) {
+            patchState(store, (state) => {
+                return { ...state, assistants: assistantSettings };
+            });
+        },
+        async updateLanguage(language, auditEvents) {
+            await patchUserSettings({ language }, auditEvents);
+            patchState(store, (state) => {
+                return { ...state, language };
+            });
+        },
+    })));
+}
+
+class ThemeSelectorComponent {
+    constructor() {
+        this.scope = input.required();
+        this.showPrivate = input(false);
+        this.themes = computed(() => THEMES.filter(theme => this.showPrivate() ? true : !theme.private));
+        this.selectedTheme = model();
+        this.themeStore = inject(ThemeStore);
+        effect(() => {
+            const currentTheme = this.themeStore.scopes()[this.scope()];
+            if (!currentTheme)
+                return;
+            this.selectedTheme.set(this.themeStore.scopes()[this.scope()].themeName);
+        }, { allowSignalWrites: true });
+    }
+    selectTheme(theme) {
+        if (typeof theme !== 'string')
+            theme = theme.name;
+        this.themeStore.setCurrentTheme(this.scope(), theme);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ThemeSelectorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.5", type: ThemeSelectorComponent, isStandalone: true, selector: "theme-selector", inputs: { scope: { classPropertyName: "scope", publicName: "scope", isSignal: true, isRequired: true, transformFunction: null }, showPrivate: { classPropertyName: "showPrivate", publicName: "showPrivate", isSignal: true, isRequired: false, transformFunction: null }, selectedTheme: { classPropertyName: "selectedTheme", publicName: "selectedTheme", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { selectedTheme: "selectedThemeChange" }, ngImport: i0, template: `
+    <sq-menu>
+      <ng-content></ng-content>
+      
+      <div menu-content>
+        <ul class="p-2 flex flex-col gap-1 divide-y">
+          @for (theme of themes(); track $index) {
+            <li class="p-2" (click)="selectTheme(theme)">
+              <div class="flex gap-2 items-baseline">
+                <span class="size-3 rounded-full" [ngStyle]="{ 'background-color': 'hsl(' + theme.colors.primary + ')' }" aria-hidden="true"></span>
+                <span>{{ theme.name }}</span>
+              </div>
+            </li>
+          }
+        </ul>
+      </div>
+    </sq-menu>
+  `, isInline: true, styles: [""], dependencies: [{ kind: "component", type: MenuComponent, selector: "sq-menu, Menu", inputs: ["position", "className", "disabled", "autoClose"] }, { kind: "directive", type: NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ThemeSelectorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'theme-selector', standalone: true, imports: [MenuComponent, NgStyle], template: `
+    <sq-menu>
+      <ng-content></ng-content>
+      
+      <div menu-content>
+        <ul class="p-2 flex flex-col gap-1 divide-y">
+          @for (theme of themes(); track $index) {
+            <li class="p-2" (click)="selectTheme(theme)">
+              <div class="flex gap-2 items-baseline">
+                <span class="size-3 rounded-full" [ngStyle]="{ 'background-color': 'hsl(' + theme.colors.primary + ')' }" aria-hidden="true"></span>
+                <span>{{ theme.name }}</span>
+              </div>
+            </li>
+          }
+        </ul>
+      </div>
+    </sq-menu>
+  ` }]
+        }], ctorParameters: () => [] });
+
+class ThemeToggleComponent {
+    constructor() {
+        this.scope = input.required();
+        this.darkMode = model();
+        this.themeStore = inject(ThemeStore);
+        effect(() => {
+            const currentTheme = this.themeStore.scopes()[this.scope()];
+            if (!currentTheme)
+                return;
+            this.darkMode.set(currentTheme.darkMode ?? false);
+        }, { allowSignalWrites: true });
+    }
+    toggleDarkMode(status) {
+        const scope = this.themeStore.scopes()?.[this.scope()];
+        if (!scope || !scope.cssVars)
+            return;
+        this.themeStore.setDarkMode(this.scope(), status);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ThemeToggleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.5", type: ThemeToggleComponent, isStandalone: true, selector: "theme-toggle", inputs: { scope: { classPropertyName: "scope", publicName: "scope", isSignal: true, isRequired: true, transformFunction: null }, darkMode: { classPropertyName: "darkMode", publicName: "darkMode", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { darkMode: "darkModeChange" }, ngImport: i0, template: `
+    <label class="flex gap-2 items-center select-none cursor-pointer">
+      @if (darkMode()) {
+        <i class="fa-fw far fa-toggle-large-on text-primary"></i>
+      } 
+      @else {
+        <i class="fa-fw far fa-toggle-large-on fa-flip-horizontal"></i>
+      }
+    
+      <span>Dark mode</span>
+
+      <input
+        type="checkbox"
+        class="hidden"
+        [(ngModel)]="darkMode"
+        (ngModelChange)="toggleDarkMode($event)"
+      />
+    </label>
+  `, isInline: true, styles: [""], dependencies: [{ kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ThemeToggleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'theme-toggle', standalone: true, imports: [FormsModule], template: `
+    <label class="flex gap-2 items-center select-none cursor-pointer">
+      @if (darkMode()) {
+        <i class="fa-fw far fa-toggle-large-on text-primary"></i>
+      } 
+      @else {
+        <i class="fa-fw far fa-toggle-large-on fa-flip-horizontal"></i>
+      }
+    
+      <span>Dark mode</span>
+
+      <input
+        type="checkbox"
+        class="hidden"
+        [(ngModel)]="darkMode"
+        (ngModelChange)="toggleDarkMode($event)"
+      />
+    </label>
+  ` }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Represents a directive that enables infinite scrolling behavior.
+ * This directive listens for the intersection of the element with the viewport
+ * and emits a `loadMore` event when the element becomes visible.
+ *
+ * @remarks
+ * This directive requires the `IntersectionObserver` API to be available in the browser.
+ *
+ * @example
+ * ```html
+ * <div infinityScroll (onScroll)="loadMore()">
+ *   <!-- Content to be scrolled -->
+ * </div>
+ * ```
+ *
+ */
+class InfinityScrollDirective {
+    constructor(el) {
+        this.el = el;
+        this.options = input({ root: null });
+        this.onScroll = output();
+        this.observer = new IntersectionObserver(([entry]) => {
+            if (entry.isIntersecting) {
+                this.onScroll.emit();
+            }
+        }, this.options());
+        afterNextRender(() => {
+            this.observer.observe(this.el.nativeElement);
+        });
+    }
+    ngOnDestroy() {
+        this.observer.disconnect();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: InfinityScrollDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.5", type: InfinityScrollDirective, isStandalone: true, selector: "[infinity-scroll]", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onScroll: "onScroll" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: InfinityScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[infinity-scroll]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+
+class SelectionService {
+    constructor() {
+        this.route = inject(ActivatedRoute);
+        this.router = inject(Router);
+        this.location = inject(Location);
+        this.selectionStore = inject(SelectionStore);
+        this.queryParamsStore = inject(QueryParamsStore);
+    }
+    /**
+     * Sets the current article in the selection store and optionally updates the query text.
+     * If the provided article is undefined, it clears the current article.
+     *
+     * @param article - The article to set as the current article. If undefined, the current article is cleared.
+     * @param withQueryText - A boolean indicating whether to update the query text in the selection store. Defaults to true.
+     *
+     * @returns void
+     */
+    setCurrentArticle(article, withQueryText = true) {
+        if (!article) {
+            this.clearCurrentArticle();
+            return;
+        }
+        // update selection store with article and query text
+        const { text } = getState(this.queryParamsStore);
+        this.selectionStore.update({ article, id: article.id, queryText: withQueryText ? text : undefined });
+        if (article?.id)
+            this.updateArticleIdInQueryParams(article.id);
+    }
+    /**
+     * Clears the current article selection from the selection store and
+     * removes the article ID from the query parameters.
+     *
+     * @remarks
+     * This method performs two main actions:
+     * 1. Clears the current selection from the `selectionStore`.
+     * 2. Removes the article ID from the query parameters to ensure
+     *    the URL does not reference the cleared article.
+     *
+     * @public
+     */
+    clearCurrentArticle() {
+        this.selectionStore.clear();
+        this.clearArticleIdFromQueryParams();
+    }
+    /**
+     * Updates the article ID in the query parameters of the current route.
+     * If the provided ID is undefined, it will remove the ID from the query parameters.
+     *
+     * @param id - The article ID to be set in the query parameters. If undefined, the ID will be removed.
+     */
+    updateArticleIdInQueryParams(id) {
+        const url = this.router
+            .createUrlTree([], { relativeTo: this.route, queryParams: { id }, queryParamsHandling: 'merge' })
+            .toString();
+        this.location.replaceState(url);
+    }
+    /**
+     * Clears the 'id' parameter from the current route's query parameters.
+     *
+     * This method creates a copy of the current query parameters, removes the 'id' parameter,
+     * and then updates the browser's URL to reflect the change without reloading the page.
+     *
+     * @private
+     */
+    clearArticleIdFromQueryParams() {
+        const queryParams = Object.assign({}, this.route.snapshot.queryParams);
+        delete queryParams['id'];
+        const url = this.router.createUrlTree([], { relativeTo: this.route, queryParams }).toString();
+        this.location.replaceState(url);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SelectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SelectionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SelectionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/*
+ * 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
+ */
+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: () => [] });
+
+class AuditService {
+    constructor() {
+        this.appStore = inject(AppStore);
+        this.app = computed(() => getState(this.appStore));
+        this.http = inject(HttpClient);
+        this.router = inject(Router);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+        this.lastClickTime = 0;
+    }
+    /**
+     * Notify the Sinequa server of a set of audit events
+     *
+     * @param auditEvents The audit events
+     */
+    notify(auditEvents) {
+        this.http.post(this.API_URL + "/audit.notify", {
+            event: "None", // AuditEventType.None,
+            app: this.app().name,
+            $auditRecord: { auditEvents: [auditEvents] }
+        }).subscribe();
+    }
+    /**
+     * It sends an audit event to the Audit Service.
+     */
+    notifyLogin() {
+        this.notify({
+            type: "Login_Success_Form" // AuditEventType.Search_Login_Success
+        });
+    }
+    /**
+     * Notify logout
+     */
+    notifyLogout() {
+        this.notify({
+            type: "Search_Exit_Logout" // AuditEventType.Search_Exit_Logout
+        });
+    }
+    /**
+       * Notify the Sinequa server of a document event
+       *
+       * @param evt The audit event type
+       * @param doc The document (article) in question
+       * @param resultId The resultid that contain the document
+       * @param parameters Additional parameters
+       */
+    notifyDocument(auditEventType, doc, resultsOrId, parameters, rfmParameters) {
+        let resultId;
+        let result;
+        if (typeof resultsOrId == "string") {
+            resultId = resultsOrId;
+        }
+        else {
+            result = resultsOrId;
+            resultId = result ? result.id : null;
+        }
+        const detail = {
+            docid: doc.id,
+            rank: doc.rank,
+            title: doc.title,
+            source: doc.collection[0].split("/")[0],
+            collection: doc.collection[0],
+            resultId,
+            filename: doc.filename,
+            fileext: doc.fileext,
+            index: doc.databasealias,
+            resultcount: result?.totalRowCount
+        };
+        if (parameters) {
+            Object.keys(parameters).forEach(key => detail[key] = parameters[key]);
+        }
+        const data = {
+            type: auditEventType,
+            detail
+        };
+        if (rfmParameters) {
+            const rfmDetail = {}; // Add index signature
+            Object.keys(rfmParameters).forEach(key => rfmDetail[key] = rfmParameters[key]);
+            data.rfmDetail = rfmDetail;
+        }
+        this.lastClickTime = Date.now();
+        // Listen to the navigation event outside the app
+        document.addEventListener('visibilitychange', () => {
+            // Capture the navigation even triggered just after the click
+            if (document.visibilityState === 'hidden' && (Date.now() - this.lastClickTime) < 1000) {
+                // Second event triggered when we come back
+                document.addEventListener('visibilitychange', () => {
+                    if (document.visibilityState === 'visible') {
+                        this.notify({ type: "Navigation_Return" /* AuditEventType.Navigation_Return */ });
+                    }
+                }, { once: true });
+            }
+        }, { once: true });
+        this.notify(data);
+    }
+    /**
+     * Notify route change
+     */
+    notifyRouteChange(url) {
+        this.notify({
+            type: "Navigation_Route", // AuditEventType.Navigation_Route,
+            detail: {
+                detail: url
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AuditService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AuditService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AuditService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+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'
+                }]
+        }] });
+
+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'
+                }]
+        }] });
+
+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: () => [] });
+
+/**
+ * Directive that selects an article on click.
+ */
+class SelectArticleOnClickDirective {
+    constructor() {
+        this.drawerStack = inject(DrawerStackService);
+        this.article = input.required();
+        this.strategy = input('stack');
+    }
+    onClick() {
+        if (!this.article())
+            return;
+        switch (this.strategy()) {
+            case 'replace':
+                this.drawerStack.replace(this.article());
+                break;
+            case 'stack':
+            default:
+                this.drawerStack.stack(this.article());
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SelectArticleOnClickDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.5", type: SelectArticleOnClickDirective, isStandalone: true, selector: "[appSelectArticleOnClick],[selectArticleOnClick]", inputs: { article: { classPropertyName: "article", publicName: "article", isSignal: true, isRequired: true, transformFunction: null }, strategy: { classPropertyName: "strategy", publicName: "strategy", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "click": "onClick()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SelectArticleOnClickDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appSelectArticleOnClick],[selectArticleOnClick]',
+                    standalone: true,
+                }]
+        }], propDecorators: { onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+
+/**
+ * Directive that handles the behavior of showing a bookmark for an article.
+ *
+ * @remarks
+ * This directive listens to mouse enter and mouse leave events to determine when to show the bookmark.
+ * It also checks the user's settings to determine if the article is bookmarked.
+ *
+ * @example
+ * ```html
+ * <div showBookmark [article]="currentArticle" (showBookmark)="onShowBookmark($event)"></div>
+ * ```
+ */
+class ShowBookmarkDirective {
+    mouseEnter() {
+        this.bookmarkHovered.set(true);
+    }
+    mouseLeave() {
+        this.bookmarkHovered.set(false);
+    }
+    constructor() {
+        this.bookmarkHovered = signal(false);
+        this.userSettingsStore = inject(UserSettingsStore);
+        this.isBookmarked = computed(() => {
+            if (!this.article())
+                return false;
+            return this.userSettingsStore.isBookmarked(this.article());
+        });
+        this.article = input.required();
+        this.showBookmark = output();
+        effect(() => {
+            const bookmarkHovered = this.bookmarkHovered();
+            const isBookmarked = this.isBookmarked();
+            this.showBookmark.emit(bookmarkHovered || isBookmarked);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ShowBookmarkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.5", type: ShowBookmarkDirective, isStandalone: true, selector: "[appShowBookmark],[showBookmark]", inputs: { article: { classPropertyName: "article", publicName: "article", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { showBookmark: "showBookmark" }, host: { listeners: { "mouseenter": "mouseEnter()", "mouseleave": "mouseLeave()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ShowBookmarkDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[appShowBookmark],[showBookmark]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { mouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], mouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+
+/**
+ * This directive is used to apply a theme to a native element based on the theme scope.
+ */
+class ThemeProviderDirective {
+    constructor() {
+        this.themeProvider = input.required();
+        this.host = inject(ElementRef);
+        this.themeStore = inject(ThemeStore);
+        effect(() => {
+            const scope = this.themeStore.scopes()?.[this.themeProvider()];
+            if (!scope)
+                return;
+            const vars = scope.darkMode ? scope.cssVars.dark : scope.cssVars.light;
+            if (vars)
+                applyThemeToNativeElement(this.host.nativeElement, vars);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ThemeProviderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.5", type: ThemeProviderDirective, isStandalone: true, selector: "[themeProvider]", inputs: { themeProvider: { classPropertyName: "themeProvider", publicName: "themeProvider", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ThemeProviderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[themeProvider]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Returns a guard function that checks if the user is authenticated.
+ * If the user is not authenticated, it navigates to the login page.
+ * @returns The guard function.
+ */
+function AuthGuard() {
+    return (_, state) => {
+        const router = inject(Router);
+        const { loginPath, useCredentials, useSSO } = globalConfig;
+        if (isAuthenticated())
+            return true;
+        // when using SSO authentication, the application is already authenticated
+        if (useSSO)
+            return true;
+        if (useCredentials) {
+            router.navigate([loginPath], { queryParams: { returnUrl: state.url } });
+        }
+        else {
+            router.navigate(['loading'], { queryParams: { returnUrl: state.url } });
+        }
+        return false;
+    };
+}
+
+/**
+ * InitializationGuard is a route guard that ensures the application is ready before allowing navigation to a requested page.
+ *
+ * This guard checks if the application is fully initialized by verifying the readiness of the ApplicationStore.
+ * If the application is not ready, it redirects the user to a loading page and prevents navigation to the requested page.
+ *
+ * @returns {CanActivateFn} A function that returns true if the application is ready, false otherwise.
+ *
+ * @example
+ * // Usage in a routing module
+ * const routes: Routes = [
+ *   {
+ *     path: 'some-path',
+ *     component: SomeComponent,
+ *     canActivate: [InitializationGuard]
+ *   }
+ * ];
+ */
+function InitializationGuard() {
+    return (_, state) => {
+        const route = inject(Router);
+        const app = inject(ApplicationStore);
+        /**
+         * If the app is not ready, navigate to the loading page.
+         * This is useful when the app is loading and the user tries to access a page that requires the app to be ready.
+         *
+         * We need to wait appStore, PrincipalStore and UserSettingsStore to be initialized before we can navigate to the requested page.
+         *
+         * @returns True if the app is ready, false otherwise.
+         */
+        if (!app.ready()) {
+            route.navigate(['/loading'], { queryParams: { returnUrl: state.url } });
+            return false;
+        }
+        return true;
+    };
+}
+
+/**
+ * Intercepts HTTP requests to add audit information if the request URL includes the API path.
+ *
+ * This interceptor checks if the request URL contains the specified API path from the global configuration.
+ * If the request body is JSON serializable and not an instance of `HttpParams`, it adds additional audit information
+ * to the request body using the `addAuditAdditionalInfo` function.
+ *
+ * @param request - The HTTP request to be intercepted.
+ * @param next - The next handler in the HTTP request chain.
+ * @returns The next handler in the HTTP request chain, potentially with modified request body.
+ */
+const auditInterceptorFn = (request, next) => {
+    if (!request.url.includes(globalConfig.apiPath))
+        return next(request);
+    if (isJsonable(request.body) && !(request.body instanceof HttpParams)) {
+        // beware addAuditAdditionalInfo use a reference to the original object
+        addAuditAdditionalInfo(request.body);
+    }
+    return next(request);
+};
+
+// TODO: Replace with your locale name
+// const LOCALE_NAME = "fr";
+/**
+ * Intercepts HTTP requests to add authentication headers and handle CSRF tokens.
+ *
+ * This interceptor checks if the user is logged in and adds necessary headers
+ * to the request, including a CSRF token. If user override is active, it sets
+ * the override user and domain headers instead. It also updates the CSRF token
+ * from the response headers if present.
+ *
+ * @param request - The outgoing HTTP request.
+ * @param next - The next handler in the HTTP request pipeline.
+ * @returns An observable of the HTTP event stream.
+ */
+const authInterceptorFn = (request, next) => {
+    const { userOverride, userOverrideActive, useSSO } = globalConfig;
+    // add auth header with jwt if user is logged in and request is to the api url
+    const isLoggedIn = isAuthenticated() || useSSO;
+    const csrfToken = getToken();
+    let headers = {
+        'Sinequa-Force-Camel-Case': 'true',
+        'accept': 'application/json',
+        'Sinequa-csrf-token': `${csrfToken}`,
+        // "x-language": LOCALE_NAME
+    };
+    if (userOverride && userOverrideActive) {
+        headers = {
+            ...headers,
+            'sinequa-override-user': userOverride.username,
+            'sinequa-override-domain': userOverride.domain,
+        };
+    }
+    request = request.clone({
+        setHeaders: headers
+    });
+    return next(request).pipe(map(event => {
+        if (event instanceof HttpResponse) {
+            const csrfToken = event.headers.get('sinequa-csrf-token');
+            if (csrfToken) {
+                setToken(csrfToken);
+            }
+        }
+        return event; // Add this line to fix the return type
+    }));
+};
+
+/**
+ * Interceptor function that modifies the request body by appending a "locale" parameter with the value "fr".
+ * If the request body is of type FormData, the "locale" parameter is appended directly.
+ * If the request body is an object, a new object is created with the "locale" parameter added.
+ *
+ * @param request - The HTTP request object.
+ * @param next - The HTTP handler function.
+ * @returns The modified request object.
+ */
+const bodyInterceptorFn = (request, next) => {
+    const LOCALE_NAME = "fr";
+    if (request.body instanceof FormData) {
+        request.body.append("ui-language", LOCALE_NAME);
+        request = request.clone();
+    }
+    else {
+        const body = { ...request.body, "ui-language": LOCALE_NAME };
+        request = request.clone({
+            body
+        });
+    }
+    return next(request);
+};
+
+const ROUTE_COMPONENTS = new InjectionToken('ROUTE_COMPONENTS', { factory: () => [] });
+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.&nbsp;&nbsp;
+     * * 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'
+                }]
+        }] });
+
+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'
+                }]
+        }] });
+
+;
+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'
+                }]
+        }] });
+
+const SAVED_SEARCHES_MAX_STORAGE = 100;
+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'
+                }]
+        }] });
+
+const AGGREGATION_MAX_COUNT = 11;
+class QueryService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.appStore = inject(AppStore);
+        this.queryParamsStore = inject(QueryParamsStore);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    /**
+     * Performs a search query.
+     *
+     * @param q - The partial query object.
+     * @param includeQueryParams - Indicates whether to include query parameters automatically in the request.
+     * @param audit - The audit events object.
+     * @returns An observable that emits the search results.
+     */
+    search(q, includeQueryParams = true, audit) {
+        const $auditRecord = audit ? { auditEvents: [audit] } : undefined;
+        const { app } = globalConfig;
+        const currentQuery = q ?? this.queryParamsStore.getQuery();
+        const query = includeQueryParams ? { ...this.queryParamsStore.getQuery(), ...currentQuery } : currentQuery;
+        // Check if the search query is empty and if empty searches are allowed
+        // If not allowed, return an empty result
+        const allowEmptySearch = this.appStore.allowEmptySearch(query?.name || '');
+        if (allowEmptySearch === false && query?.text === '') {
+            return of({ records: [] });
+        }
+        const body = {
+            app,
+            query,
+            $auditRecord
+        };
+        return this.http.post(this.API_URL + "/query", body)
+            .pipe(catchError(error => {
+            console.error("queryService.getResults failure - error: ", error);
+            return of({});
+        }), map((result) => {
+            // update $hasMore flag
+            result.aggregations.forEach((agg) => {
+                agg.$hasMore = false;
+                if (!agg.isDistribution && !agg.isTree && agg.items) {
+                    agg.$hasMore = agg.items.length === AGGREGATION_MAX_COUNT;
+                }
+                if (agg.isTree) {
+                    buildPathsAndLevels(agg);
+                }
+            });
+            return result;
+        }), map(result => {
+            result.records?.map((article) => (Object.assign(article, { value: article.title, type: 'default' })));
+            return result;
+        }), map(result => {
+            const r = ({ ...result, nextPage: result.page < Math.ceil(result.rowCount / result.pageSize) ? result.page + 1 : undefined, previousPage: result.page > 1 ? result.page - 1 : undefined });
+            return r;
+        }), tap(response => console.log("queryService.getResults success - data: ", response)));
+    }
+    /**
+     * Performs a bulk search operation.
+     *
+     * @param q An array of Query objects representing the search queries.
+     * @param audit An optional AuditEvents object for auditing purposes.
+     * @returns An Observable that emits an array of Result objects.
+     */
+    bulkSearch(q, audit) {
+        const { app = '' } = globalConfig;
+        const body = {
+            methods: [],
+            propagateErrors: true,
+            $auditRecord: { auditEvents: [audit] }
+        };
+        for (const query of q) {
+            body.methods.push({
+                method: "query",
+                app,
+                query
+            });
+        }
+        return this.http.post(this.API_URL + "/multi", body)
+            .pipe(catchError(error => {
+            console.error("queryService.bulkSearch failure - error: ", error);
+            return EMPTY;
+        }), map(response => {
+            // update $hasMore flag
+            response.results.forEach((result) => {
+                result.aggregations.forEach((agg) => {
+                    agg.$hasMore = false;
+                    if (!agg.isDistribution && !agg.isTree && agg.items) {
+                        agg.$hasMore = agg.items.length === AGGREGATION_MAX_COUNT;
+                    }
+                    if (agg.isTree) {
+                        buildPathsAndLevels(agg);
+                    }
+                });
+            });
+            return response.results;
+        }), map(results => {
+            results.forEach(result => result.records?.map((article) => (Object.assign(article, { value: article.title, type: 'default' }))));
+            return results;
+        }), map(results => {
+            return results.map(result => {
+                const r = ({ ...result, nextPage: result.page < Math.ceil(result.rowCount / result.pageSize) ? result.page + 1 : undefined, previousPage: result.page > 1 ? result.page - 1 : undefined });
+                return r;
+            });
+        }), 
+        // map(response => ResultsSchema.parse(response) as T),
+        tap(response => console.log("queryService.bulkSearch success - data: ", response)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: QueryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: QueryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: QueryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+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'
+                }]
+        }] });
+
+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
+        }] });
+
+/**
+ * Interceptor function that handles HTTP errors by logging out the user and redirecting to the login page.
+ *
+ * @param request - The HTTP request object.
+ * @param next - The HTTP handler function.
+ * @returns The modified request object.
+ */
+const errorInterceptorFn = (request, next) => {
+    const { useCredentials, loginPath, userOverrideActive } = globalConfig;
+    const router = inject(Router);
+    const lastUrlAfterNavigation = inject(NavigationService).urlAfterNavigation;
+    if (request.url.includes('api/v1/audit.notify')) {
+        return next(request);
+    }
+    return next(request).pipe(catchError$1((err) => {
+        if ([401, 403].includes(err.status)) {
+            // auto logout if 401 or 403 response returned from api
+            if (useCredentials && !userOverrideActive) {
+                logout();
+                router.navigate([loginPath], { queryParams: { returnUrl: lastUrlAfterNavigation } });
+            }
+            else if (!userOverrideActive) {
+                // logout the user and navigate to login page
+                logout().then(() => login());
+            }
+        }
+        return Promise.reject(err);
+    }));
+};
+
+/**
+ * Intercepts HTTP requests and handles errors by displaying toast notifications.
+ *
+ * This interceptor checks if the request URL includes 'api/v1/audit.notify'. If it does,
+ * the request is passed through without any modifications. For other requests, it catches
+ * errors and displays a toast notification for specific HTTP status codes (400, 403, 500, 503).
+ *
+ * @param request - The outgoing HTTP request.
+ * @param next - The next handler in the HTTP request pipeline.
+ * @returns An observable that either passes the request through or handles errors with toast notifications.
+ */
+const toastInterceptorFn = (request, next) => {
+    if (request.url.includes('api/v1/audit.notify')) {
+        return next(request);
+    }
+    return next(request).pipe(catchError$1((err) => {
+        const { status, statusText, error } = err;
+        if ([400, 403, 500, 503].includes(status)) {
+            const { errorMessage = err.statusText, errorCodeText = `Error ${status}` } = error;
+            toast.error(statusText, { description: `${errorCodeText}: ${errorMessage}`, closeButton: true, duration: 5000 });
+        }
+        return Promise.reject(err);
+    }));
+};
+
+// export * from "./audit.interceptor";
+
+/**
+ * The HighlightWordPipe class is a custom pipe in the Atomic Angular library.
+ * It is used to highlight a specific word within a given text.
+ *
+ * @remarks
+ * This pipe takes in a `value` string, a `word` string to highlight, and an optional `clipBy` number to limit the length of the highlighted text.
+ * It returns an array of `HighlightWords.Chunk` objects representing the highlighted portions of the text.
+ *
+ * @example
+ * ```html
+ * <div [innerHTML]="text | highlightWord:'search':10"></div>
+ * ```
+ *
+ */
+class HighlightWordPipe {
+    transform(value, word, clipBy) {
+        return highlightWords({ text: value, query: word, clipBy });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: HighlightWordPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.5", ngImport: i0, type: HighlightWordPipe, isStandalone: true, name: "highlightWord" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: HighlightWordPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'highlightWord',
+                    standalone: true,
+                    pure: true
+                }]
+        }] });
+
+/**
+ * Pipe that transforms a collection of strings into a corresponding icon class.
+ *
+ * This pipe uses the first element of the collection to determine the icon class
+ * based on the source name. If the collection is empty or undefined, it returns
+ * a default icon class.
+ *
+ * @deprecated This pipe is deprecated and will be removed in the future.
+ *
+ * @param collection - An array of strings representing the collection.
+ * @returns A string representing the icon class.
+ */
+class SourceIconPipe {
+    constructor() {
+        this.appStore = inject(AppStore);
+    }
+    transform(collection) {
+        if (collection === undefined || collection.length === 0) {
+            return 'far fa-file';
+        }
+        const name = collection[0].split("/")[1];
+        const sources = this.appStore.sources();
+        // workplace search uses a different format for sources
+        if (Array.isArray(sources)) {
+            return sources.find((source) => source.name === name)?.icon || 'far fa-file';
+        }
+        return 'far fa-file';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SourceIconPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.5", ngImport: i0, type: SourceIconPipe, isStandalone: true, name: "sourceIcon" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: SourceIconPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'sourceIcon',
+                    standalone: true,
+                    pure: true
+                }]
+        }] });
+
+/**
+ * Resolves the name of the default query from the application store.
+ *
+ * @param route - The current route snapshot.
+ * @param state - The current router state snapshot.
+ * @returns The name of the default query or an empty string if not available.
+ */
+const queryNameResolver = (route, state) => {
+    const appStore = inject(AppStore);
+    return appStore.getDefaultQuery()?.name || '';
+};
+
+// pre-configured highlights's colors
+const HIGHLIGHTS = new InjectionToken('highlights', {
+    factory: () => [
+        {
+            name: 'company',
+            color: 'white',
+            bgColor: '#FF7675'
+        },
+        {
+            name: 'geo',
+            color: 'white',
+            bgColor: '#74B9FF'
+        },
+        {
+            name: 'person',
+            color: 'white',
+            bgColor: '#00ABB5'
+        },
+        {
+            name: 'extractslocations',
+            color: 'black',
+            bgColor: '#fffacd'
+        },
+        {
+            name: 'matchlocations',
+            color: 'black',
+            bgColor: '#ff0'
+        }
+    ],
+});
+
+class AggregationsService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.queryService = inject(QueryService);
+        this.appStore = inject(AppStore);
+        this.aggregationsStore = inject(AggregationsStore);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    loadMore(query, aggregation, audit) {
+        const { app } = globalConfig;
+        // skip cached items for computation
+        const skip = aggregation.items?.filter(i => !(i.$cached))?.length || 0;
+        const count = 10;
+        const aggregations = { [aggregation.name]: { skip, count } };
+        const q = { ...query, action: "aggregate", aggregations };
+        // add audit record if available
+        const $auditRecord = audit ? { auditEvents: [audit] } : undefined;
+        const body = {
+            app,
+            query: q,
+            $auditRecord
+        };
+        return this.http.post(this.API_URL + "/query", body).pipe(map(result => {
+            const { aggregations } = result;
+            const agg = aggregations[0];
+            if (agg.items) {
+                agg.$hasMore = agg.items.length > count;
+                agg.items = [...aggregation.items, ...agg.items];
+            }
+            else {
+                aggregation.$hasMore = false;
+                return aggregation;
+            }
+            return agg;
+        }), catchError(error => {
+            console.log("aggregation.loadMore failure - error: ", error);
+            return throwError(() => new Error(error));
+        }), tap(response => console.log("aggregation.loadMore success - data: ", response)));
+    }
+    open(query, aggregation, item) {
+        const value = `/${item.$path}/*`;
+        const expression = `${aggregation.column}: ${escapeExpr(value)}`;
+        const q = {
+            ...query,
+            action: "open",
+            open: [{ expression, aggregation: aggregation.name }]
+        };
+        return this.queryService.search(q).pipe(map(results => {
+            // find the node in the tree and replace it with the new one
+            const items = results.aggregations[0].items;
+            const newNode = this.findNode(items, item.$path);
+            if (!newNode) {
+                return aggregation;
+            }
+            // mark the node as opened
+            newNode.$opened = true;
+            return this.replaceInTree(aggregation, item.$path, newNode);
+        }));
+    }
+    findNode(items, path = "") {
+        if (!items || items.length === 0) {
+            return undefined;
+        }
+        for (const item of items) {
+            if (item.$path === path) {
+                return item;
+            }
+            if (item.items) {
+                const found = this.findNode(item.items, path);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return undefined;
+    }
+    replaceInTree(tree, valueToFind = "", newValue) {
+        if (tree.$path === valueToFind) {
+            return newValue;
+        }
+        if (tree.hasChildren && tree.items) {
+            for (let i = 0; i < tree.items.length; i++) {
+                tree.items[i] = this.replaceInTree(tree.items[i], valueToFind, newValue);
+            }
+        }
+        return tree;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AggregationsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AggregationsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AggregationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class JsonMethodPluginService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    /**
+     * Call a JsonMethod plugin using an HTTP POST
+     *
+     * @param method The name of the JsonMethod plugin
+     * @param query Parameters to pass to the plugin
+     * @param options HTTP options for the request
+     * @returns An observable of the plugin's return value
+     */
+    post(method, query, options) {
+        if (!isObject(query)) {
+            return throwError(() => ({ error: "invalid query object" }));
+        }
+        return this.http.post(`${this.API_URL}/plugin/${method}`, query, options);
+    }
+    /**
+     * Call a JsonMethod plugin using an HTTP GET
+     *
+     * @param method The name of the JsonMethod plugin
+     * @param query Parameters to pass to the plugin
+     * @param options HTTP options for the request
+     * @returns An observable of the plugin's return value
+     */
+    get(method, query, options) {
+        const params = new HttpParams();
+        for (const key in query) {
+            if (query[key] !== undefined) {
+                params.set(key, query[key]);
+            }
+        }
+        return this.http.get(`${this.API_URL}/plugin/${method}`, {
+            params: params,
+            ...options
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: JsonMethodPluginService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: JsonMethodPluginService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: JsonMethodPluginService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+const PREVIEW_CONFIG = new InjectionToken("Preview configuration", {
+    factory: () => ({
+        allowWorker: false
+    })
+});
+class PreviewService {
+    constructor(highlights) {
+        this.highlights = highlights;
+        this.http = inject(HttpClient);
+        this.injector = inject(Injector);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+        this.applicationStore = inject(ApplicationStore);
+        this.selectionStore = inject(SelectionStore);
+        this.queryParamsStore = inject(QueryParamsStore);
+        this.appStore = inject(AppStore);
+        this.sanitizer = inject(DomSanitizer);
+        this.queryService = inject(QueryService);
+        this.searchService = inject(SearchService);
+        this.auditService = inject(AuditService);
+        this.events = new EventEmitter();
+        // ! worker
+        this.onMessage = new Subject();
+        this.allowWoker = inject(PREVIEW_CONFIG).allowWorker;
+        this.highlightCategory = "extractslocations";
+        this.extracts = ["matchlocations", "extractslocations", "matchingpassages"];
+        this.entities = ["company", "geo", "person"];
+        window.addEventListener('message', this.receiveMessage.bind(this), false);
+    }
+    ngOnDestroy() {
+        window.removeEventListener('message', this.receiveMessage.bind(this), false);
+    }
+    /**
+     * Handles incoming messages from a MessageEvent.
+     *
+     * @param event - The MessageEvent containing the message data.
+     *
+     * The function processes messages of type 'ready' and 'get-html-results'.
+     *
+     * - For 'ready' messages:
+     *   - Initializes the preview iframe with the app name and highlights.
+     *   - If preview data is available, retrieves HTML content based on the current selection.
+     *
+     * - For 'get-html-results' messages:
+     *   - Updates the application store with the extracted HTML results.
+     *   - If no extracts are found, updates the application store with an empty array.
+     */
+    receiveMessage(event) {
+        const message = event.data;
+        // the webworker needs to be initialized with the app name to be able to load the correct webworker file (worker.js)
+        const { app } = globalConfig;
+        // when the iframe is ready, we can send the init message
+        if (message.type === 'ready') {
+            // Initialize the preview iframe with the app name and highlights
+            // app name is used to intialize the webworker
+            this.sendMessage({ action: "init", highlights: this.highlights, appname: app });
+            if (this.previewData) {
+                const { id } = getState(this.selectionStore);
+                this.events.emit('fetching');
+                this.retrieveHtmlContent(id, this.highlightCategory, this.previewData);
+            }
+        }
+        // when the iframe sends back the html content of the extracts (no worker)
+        if (message.type === 'get-html-results') {
+            const { id } = getState(this.selectionStore);
+            if (id) {
+                console.info("no worker");
+                const extracts = this.fetchExtracts(id, message.data, this.previewData);
+                this.applicationStore.updateExtracts(this.previewData?.record.id || '', extracts);
+                this.events.emit('fetched');
+            }
+        }
+        // when the iframe sends back the html content of the extracts (with worker)
+        // we update the extracts in the application store
+        if (message.type === 'get-html-results-webworker') {
+            console.info("with worker");
+            if (message.data.extracts.length === 0) {
+                this.events.emit('fetched');
+                this.applicationStore.updateExtracts(this.previewData?.record.id || '', []);
+                return;
+            }
+            const extracts = message.data.extracts.map((item) => ({
+                ...item,
+                text: this.sanitizer.bypassSecurityTrustHtml(item.text)
+            }));
+            this.applicationStore.updateExtracts(this.previewData?.record.id || '', extracts);
+            this.events.emit('fetched');
+        }
+    }
+    /**
+     * Generates a preview of the document with the given ID, applying the specified query parameters,
+     * custom highlights, and audit events.
+     *
+     * @param id - The unique identifier of the document to preview.
+     * @param q - Partial query parameters to customize the preview request.
+     * @param customHighlights - Optional array of custom highlights to apply to the preview.
+     * @param audit - Optional audit events to merge with the default audit record.
+     * @returns An Observable that emits the preview data.
+     */
+    preview(id, q, customHighlights, audit) {
+        const detail = this.getAuditPreviewDetail(id, q);
+        const defaultAudit = {
+            type: "Doc_Preview",
+            detail
+        };
+        // merge the default audit record with the provided audit record
+        const $auditRecord = audit ? { auditEvents: [{ ...defaultAudit, ...audit }] } : { auditEvents: [defaultAudit] };
+        const { app } = globalConfig;
+        const query = { ...this.queryParamsStore.getQuery(), ...q };
+        const browserUrl = `${window.location.origin}${window.location.pathname}`;
+        const body = {
+            app,
+            action: "get",
+            id,
+            query: { name: query.name, text: query.text },
+            browserUrl,
+            customHighlights,
+            $auditRecord
+        };
+        return this.http.post(this.API_URL + "/preview", body)
+            .pipe(tap((data) => this.setPreviewData(data)), catchError(error => {
+            console.error("queryService.preview failure - error: ", error);
+            return EMPTY;
+        }));
+    }
+    /**
+     * Closes the preview with the specified ID and updates the audit log.
+     *
+     * @param id - The ID of the preview to close.
+     * @param query - The partial query object used to retrieve the preview detail.
+     */
+    close(id, query) {
+        const detail = this.getAuditPreviewDetail(id, query);
+        const auditEvent = {
+            type: "Preview_Close" /* AuditEventType.Preview_Close */,
+            detail
+        };
+        Audit.notify(auditEvent);
+    }
+    /**
+     * Previews an article in a new browser's tab.
+     *
+     * @param article - The article to preview.
+     */
+    openExternal(article) {
+        const query = this.queryParamsStore.getQuery();
+        const detail = this.getAuditPreviewDetail(article.id, query);
+        const result = this.searchService.result;
+        this.auditService.notifyDocument("Click_ResultLink", article, result || detail.resultid || "", {
+            querytext: detail.querytext,
+            querylang: detail.querylang,
+            score: detail.score
+        }, {
+            queryhash: result ? result.rfmQueryHash : undefined,
+            querytext: detail.querytext,
+            querylang: detail.querylang
+        });
+        window.open(article.url1, '_blank', 'noopener noreferrer');
+    }
+    /**
+     * Sets the iframe window object.
+     *
+     * @param iframe - The window object of the iframe or null to unset.
+     */
+    setIframe(iframe) {
+        this.iframe = iframe;
+    }
+    /**
+     * Sets the preview data and updates the highlight category based on the provided data.
+     *
+     * @param data - The preview data to be set.
+     *
+     * If the provided data contains highlights per category with 'matchingpassages' having values,
+     * the highlight category is set to "matchingpassages". Otherwise, it is set to "extractslocations".
+     */
+    setPreviewData(data) {
+        this.previewData = data;
+        if (data) {
+            this.highlightCategory = data.highlightsPerCategory?.['matchingpassages']?.values.length ? "matchingpassages" : "extractslocations";
+        }
+    }
+    /**
+     * Sends a message to the iframe if it exists.
+     *
+     * @param message - The message to be sent. It can be of any type.
+     */
+    sendMessage(message) {
+        if (this.iframe) {
+            this.iframe.postMessage(message, '*');
+        }
+    }
+    /**
+     * Get preview id for an entity value for an index
+     * @param entity the entity type (i.e. "geo")
+     * @param value the entity value (i.e. "AUSTRALIA")
+     * @param index the entity index from its list
+     * @returns the html id
+     */
+    getEntityId(entity, value, index) {
+        if (!this.previewData)
+            return undefined;
+        return this.previewData.highlightsPerLocation
+            .filter(h => h.values.find(v => v === value))[index].positionInCategories[entity];
+    }
+    /**
+     * Send a message to the prewiew iFrame with the required data to retrieve HTML content for a specific highlight category
+     *
+     * @param id - The unique identifier for the request.
+     * @param highlightCategory - The category of highlights to retrieve.
+     * @param previewData - The data containing highlights and their locations.
+     */
+    retrieveHtmlContent(id, highlightCategory, previewData) {
+        // Generate the list of items we want to retrieve
+        const ids = previewData.highlightsPerCategory[highlightCategory]?.values[0]?.locations.map((_, i) => `${highlightCategory}_${i}`);
+        if (this.allowWoker) {
+            // if the worker is allowed, we send the message to the worker
+            this.sendMessage({ action: 'get-html-webworker', id, ids, previewData });
+        }
+        else {
+            this.sendMessage({ action: 'get-html', id, ids, previewData });
+        }
+    }
+    /**
+     * Sends a message to zoom in.
+     *
+     * This method triggers a "zoom-in" action by sending a message
+     * with the specified action type.
+     */
+    zoomIn() {
+        this.sendMessage({ action: "zoom-in" });
+    }
+    /**
+     * Sends a message to zoom out the preview.
+     *
+     * This method triggers a "zoom-out" action by sending a message
+     * to the relevant service or component.
+     */
+    zoomOut() {
+        this.sendMessage({ action: "zoom-out" });
+    }
+    /**
+     * Toggles the highlights based on the provided flags for extracts and entities.
+     *
+     * @param extracts - A boolean flag indicating whether to include extracts highlights.
+     * @param entities - A boolean flag indicating whether to include entities highlights.
+     */
+    toggle(extracts, entities) {
+        const extractsHighlights = extracts ? this.highlights.filter(h => this.extracts.includes(h.name)) : [];
+        const entitiesHighlights = entities ? this.highlights.filter(h => this.entities.includes(h.name)) : [];
+        const highlights = [...extractsHighlights, ...entitiesHighlights];
+        this.sendMessage({ action: "highlight", highlights });
+    }
+    getAuditPreviewDetail(id, q) {
+        const results = this.searchService.result;
+        const queryLanguage = results?.queryAnalysis?.queryLanguage
+            || q?.questionLanguage
+            || this.appStore.getQueryByName(q.name)?.questionLanguage;
+        const record = this.previewData?.record;
+        const collectionColumn = record?.collection;
+        const collection = !!collectionColumn ? collectionColumn[0] : id.split("|")[0];
+        const rank = !!record ? record.rank : 0;
+        const passages = record?.matchingpassages?.passages;
+        const score = passages && passages.length ? passages[0].score : undefined;
+        return {
+            docid: id,
+            rank,
+            collection,
+            source: collection.split("|")[0],
+            resultid: results.id,
+            querylang: queryLanguage,
+            querytext: q?.text,
+            filename: record?.filename,
+            fileext: record?.fileext,
+            score
+        };
+    }
+    fetchExtracts(id, extracts, data) {
+        // extracts contains the html of extracts in chronological order
+        // locations contains the list of start positions sorted by score
+        const locations = data.highlightsPerCategory[this.highlightCategory]?.values[0]?.locations || [];
+        // first extract all the extracts locations
+        let extractslocations = locations.map((l, relevanceIndex) => ({
+            startIndex: l.start,
+            relevanceIndex
+        }));
+        // sort them by start index
+        extractslocations.sort((a, b) => a.startIndex - b.startIndex);
+        // then extract the text of each extract
+        extractslocations = extractslocations.map((ex, textIndex) => ({
+            ...ex,
+            textIndex: textIndex,
+            text: extracts[textIndex] || "",
+            id: `${this.highlightCategory}_${textIndex}`,
+        }));
+        // then sanitize the text and remove empty extracts
+        const _extracts = extractslocations.filter(item => item.text.trim().length > 0).map(item => ({
+            ...item,
+            text: this.sanitizer.bypassSecurityTrustHtml(item.text)
+        }));
+        // finally sort them by relevance index
+        _extracts.sort((a, b) => a.relevanceIndex - b.relevanceIndex);
+        return _extracts;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: PreviewService, deps: [{ token: HIGHLIGHTS }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: PreviewService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: PreviewService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [HIGHLIGHTS]
+                }] }] });
+
+class TextChunkService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    /**
+     * Retrieves text chunks based on the provided parameters.
+     *
+     * @param id - The ID of the record.
+     * @param textChunks - An array of TextLocation objects representing the location of the text chunks.
+     * @param highlights - An array of strings representing the highlights to be applied to the text chunks.
+     * @param query - The query used to retrieve the text chunks.
+     * @param leftSentencesCount - The number of sentences to include before the text chunks.
+     * @param rightSentencesCount - The number of sentences to include after the text chunks.
+     * @returns An Observable that emits an array of TextChunk objects.
+     */
+    getTextChunks(id, textChunks, highlights, query, leftSentencesCount, rightSentencesCount) {
+        const body = {
+            id,
+            textChunks,
+            highlights,
+            query,
+            leftSentencesCount,
+            rightSentencesCount
+        };
+        return this.http.post(this.API_URL + "/doc.textchunks", body)
+            .pipe(map((response) => response.chunks), catchError(error => {
+            console.error("TextChunkService.getTextChunks failure - error: ", error);
+            return [];
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: TextChunkService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: TextChunkService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: TextChunkService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/*
+ * Public API Surface of atomic
+ */
+
+/*
+ * Public API Surface of atomic
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AGGREGATIONS_NAMES, AGGREGATIONS_NAMES_PRESET_DEFAULT, AggregationsService, AggregationsStore, AppService, AppStore, ApplicationService, ApplicationStore, AuditService, AuthGuard, AutocompleteService, BackdropService, DrawerService, DrawerStackService, DropdownComponent, DropdownInputComponent, DropdownListComponent, HIGHLIGHTS, HighlightWordPipe, InfinityScrollDirective, InitializationGuard, InlineWorker, JsonMethodPluginService, LabelService, MenuComponent, MenuItemComponent, MetadataComponent, NavigationService, PreviewService, PrincipalService, PrincipalStore, QueryParamsStore, QueryService, ROUTE_COMPONENTS, SIGNAL_R_LOG_LEVEL, SIGNAL_R_TRANSPORTS, SavedSearchesService, SearchService, SelectArticleOnClickDirective, SelectionHistoryService, SelectionService, SelectionStore, ShowBookmarkDirective, SignalRWebService, SourceIconPipe, THEMES, TextChunkService, ThemeProviderDirective, ThemeSelectorComponent, ThemeStore, ThemeToggleComponent, UserSettingsStore, applyThemeToNativeElement, auditInterceptorFn, authInterceptorFn, bodyInterceptorFn, buildQuery, cn, debouncedSignal, errorInterceptorFn, getCurrentPath, getCurrentQueryName, getQueryNameFromRoute, processCssVars, queryNameResolver, themeColorNameToCssVariable, themeColorsToCssVariables, toastInterceptorFn, withAggregationsFeatures, withAppCustomizationFeatures, withAppFeatures, withApplicationFeatures, withAssistantFeatures, withBasketsFeatures, withBookmarkFeatures, withExtractsFeatures, withPrincipalFeatures, withQueryParamsFeatures, withRecentSearchFeatures, withSavedSearchFeatures, withSelectionFeatures, withThemeBodyHook, withThemes, withThemesFeatures, withUserSettingsFeatures };
+//# sourceMappingURL=sinequa-atomic-angular.mjs.map