@sinequa/atomic-angular 0.0.140

package/esm2022/lib/components/metadata/metadata.component.mjs

@@ -0,0 +1,65 @@
+import { NgClass } from "@angular/common";
+import { Component, computed, input, output } from "@angular/core";
+import { getMetadata } from "@sinequa/atomic";
+import { cn } from "../../utils/tailwind-utils";
+import * as i0 from "@angular/core";
+export 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'
+                    }
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/theme/index.mjs

@@ -0,0 +1,3 @@
+export * from './theme-selector.component';
+export * from './theme-toggle.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL2NvbXBvbmVudHMvdGhlbWUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90aGVtZS1zZWxlY3Rvci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi90aGVtZS10b2dnbGUuY29tcG9uZW50JztcblxuIl19

package/esm2022/lib/components/theme/theme-selector.component.mjs

@@ -0,0 +1,67 @@
+import { Component, computed, effect, inject, input, model } from '@angular/core';
+import { NgStyle } from '@angular/common';
+import { THEMES } from '../../resources';
+import { ThemeStore } from '../../stores';
+import { MenuComponent } from '../menu';
+import * as i0 from "@angular/core";
+export 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: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/theme/theme-toggle.component.mjs

@@ -0,0 +1,67 @@
+import { Component, effect, inject, input, model } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { ThemeStore } from '../../stores';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export 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: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/index.mjs

@@ -0,0 +1,5 @@
+export * from './infinite-scroll.directive';
+export * from './select-article-on-click.directive';
+export * from './show-bookmark.directive';
+export * from './theme-provider.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL2RpcmVjdGl2ZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW5maW5pdGUtc2Nyb2xsLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3NlbGVjdC1hcnRpY2xlLW9uLWNsaWNrLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3Nob3ctYm9va21hcmsuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vdGhlbWUtcHJvdmlkZXIuZGlyZWN0aXZlJztcblxuIl19

package/esm2022/lib/directives/infinite-scroll.directive.mjs

@@ -0,0 +1,47 @@
+import { afterNextRender, Directive, input, output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * 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>
+ * ```
+ *
+ */
+export 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 }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/select-article-on-click.directive.mjs

@@ -0,0 +1,39 @@
+import { Directive, HostListener, inject, input } from '@angular/core';
+import { DrawerStackService } from '../services/drawer/drawer-stack.service';
+import * as i0 from "@angular/core";
+/**
+ * Directive that selects an article on click.
+ */
+export 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']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/show-bookmark.directive.mjs

@@ -0,0 +1,55 @@
+import { Directive, HostListener, computed, effect, inject, input, output, signal } from '@angular/core';
+import { UserSettingsStore } from '../stores/user-settings.store';
+import * as i0 from "@angular/core";
+/**
+ * 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>
+ * ```
+ */
+export 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']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/theme-provider.directive.mjs

@@ -0,0 +1,31 @@
+import { Directive, effect, ElementRef, inject, input } from '@angular/core';
+import { applyThemeToNativeElement, ThemeStore } from '../stores';
+import * as i0 from "@angular/core";
+/**
+ * This directive is used to apply a theme to a native element based on the theme scope.
+ */
+export 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: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/guards/auth.guard.mjs

@@ -0,0 +1,27 @@
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { globalConfig, isAuthenticated } from '@sinequa/atomic';
+/**
+ * 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.
+ */
+export 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;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/guards/index.mjs

@@ -0,0 +1,3 @@
+export * from "./auth.guard";
+export * from "./initialization.guard";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL2d1YXJkcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYXV0aC5ndWFyZFwiO1xyXG5leHBvcnQgKiBmcm9tIFwiLi9pbml0aWFsaXphdGlvbi5ndWFyZFwiO1xyXG4iXX0=

package/esm2022/lib/guards/initialization.guard.mjs

@@ -0,0 +1,41 @@
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { ApplicationStore } from '../stores/application.store';
+/**
+ * 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]
+ *   }
+ * ];
+ */
+export 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;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/interceptors/audit.interceptor.mjs

@@ -0,0 +1,23 @@
+import { HttpParams } from "@angular/common/http";
+import { addAuditAdditionalInfo, globalConfig, isJsonable } from "@sinequa/atomic";
+/**
+ * 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.
+ */
+export 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);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXVkaXQuaW50ZXJjZXB0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL2ludGVyY2VwdG9ycy9hdWRpdC5pbnRlcmNlcHRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQW9DLFVBQVUsRUFBZSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pHLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFHbkY7Ozs7Ozs7Ozs7R0FVRztBQUNILE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFzQixDQUFDLE9BQTZCLEVBQUUsSUFBbUIsRUFBRSxFQUFFO0lBQzFHLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQUMsT0FBUSxDQUFDO1FBQUUsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7SUFFdkUsSUFBSSxVQUFVLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxZQUFZLFVBQVUsQ0FBQyxFQUFFLENBQUM7UUFDdEUsdUVBQXVFO1FBQ3ZFLHNCQUFzQixDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUN2QyxDQUFDO0lBQ0QsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7QUFDdkIsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cEhhbmRsZXJGbiwgSHR0cEludGVyY2VwdG9yRm4sIEh0dHBQYXJhbXMsIEh0dHBSZXF1ZXN0IH0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vbi9odHRwXCI7XHJcbmltcG9ydCB7IGFkZEF1ZGl0QWRkaXRpb25hbEluZm8sIGdsb2JhbENvbmZpZywgaXNKc29uYWJsZSB9IGZyb20gXCJAc2luZXF1YS9hdG9taWNcIjtcclxuXHJcblxyXG4vKipcclxuICogSW50ZXJjZXB0cyBIVFRQIHJlcXVlc3RzIHRvIGFkZCBhdWRpdCBpbmZvcm1hdGlvbiBpZiB0aGUgcmVxdWVzdCBVUkwgaW5jbHVkZXMgdGhlIEFQSSBwYXRoLlxyXG4gKlxyXG4gKiBUaGlzIGludGVyY2VwdG9yIGNoZWNrcyBpZiB0aGUgcmVxdWVzdCBVUkwgY29udGFpbnMgdGhlIHNwZWNpZmllZCBBUEkgcGF0aCBmcm9tIHRoZSBnbG9iYWwgY29uZmlndXJhdGlvbi5cclxuICogSWYgdGhlIHJlcXVlc3QgYm9keSBpcyBKU09OIHNlcmlhbGl6YWJsZSBhbmQgbm90IGFuIGluc3RhbmNlIG9mIGBIdHRwUGFyYW1zYCwgaXQgYWRkcyBhZGRpdGlvbmFsIGF1ZGl0IGluZm9ybWF0aW9uXHJcbiAqIHRvIHRoZSByZXF1ZXN0IGJvZHkgdXNpbmcgdGhlIGBhZGRBdWRpdEFkZGl0aW9uYWxJbmZvYCBmdW5jdGlvbi5cclxuICpcclxuICogQHBhcmFtIHJlcXVlc3QgLSBUaGUgSFRUUCByZXF1ZXN0IHRvIGJlIGludGVyY2VwdGVkLlxyXG4gKiBAcGFyYW0gbmV4dCAtIFRoZSBuZXh0IGhhbmRsZXIgaW4gdGhlIEhUVFAgcmVxdWVzdCBjaGFpbi5cclxuICogQHJldHVybnMgVGhlIG5leHQgaGFuZGxlciBpbiB0aGUgSFRUUCByZXF1ZXN0IGNoYWluLCBwb3RlbnRpYWxseSB3aXRoIG1vZGlmaWVkIHJlcXVlc3QgYm9keS5cclxuICovXHJcbmV4cG9ydCBjb25zdCBhdWRpdEludGVyY2VwdG9yRm46IEh0dHBJbnRlcmNlcHRvckZuID0gKHJlcXVlc3Q6IEh0dHBSZXF1ZXN0PHVua25vd24+LCBuZXh0OiBIdHRwSGFuZGxlckZuKSA9PiB7XHJcbiAgaWYgKCFyZXF1ZXN0LnVybC5pbmNsdWRlcyhnbG9iYWxDb25maWcuYXBpUGF0aCEpKSByZXR1cm4gbmV4dChyZXF1ZXN0KTtcclxuXHJcbiAgaWYgKGlzSnNvbmFibGUocmVxdWVzdC5ib2R5KSAmJiAhKHJlcXVlc3QuYm9keSBpbnN0YW5jZW9mIEh0dHBQYXJhbXMpKSB7XHJcbiAgICAvLyBiZXdhcmUgYWRkQXVkaXRBZGRpdGlvbmFsSW5mbyB1c2UgYSByZWZlcmVuY2UgdG8gdGhlIG9yaWdpbmFsIG9iamVjdFxyXG4gICAgYWRkQXVkaXRBZGRpdGlvbmFsSW5mbyhyZXF1ZXN0LmJvZHkpO1xyXG4gIH1cclxuICByZXR1cm4gbmV4dChyZXF1ZXN0KTtcclxufSJdfQ==

package/esm2022/lib/interceptors/auth.interceptor.mjs

@@ -0,0 +1,49 @@
+import { HttpResponse } from '@angular/common/http';
+import { map } from 'rxjs';
+import { getToken, globalConfig, isAuthenticated, setToken } from '@sinequa/atomic';
+// 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.
+ */
+export 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
+    }));
+};
+//# sourceMappingURL=data:application/json;base64,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