@sinequa/atomic-angular 0.0.146

package/lib/stores/user-settings.store.d.ts

@@ -0,0 +1,111 @@
+import { Article, AuditEvents, QueryParams } from '@sinequa/atomic';
+import { Basket, RecentSearch, UserSettings } from '../models/user-settings';
+export type UserSettingsState = UserSettings;
+export declare const UserSettingsStore: import("@angular/core").Type<{
+    bookmarks: import("@angular/core").Signal<import("../models/user-settings").Bookmark[]>;
+    recentSearches: import("@angular/core").Signal<RecentSearch[]>;
+    savedSearches: import("@angular/core").Signal<import("../models/user-settings").SavedSearch[]>;
+    baskets: import("@angular/core").Signal<Basket[]>;
+    assistants: import("@angular/core").Signal<Record<string, unknown>>;
+    language?: import("@angular/core").Signal<string | undefined> | undefined;
+    updateBookmarks: (bookmarks: UserSettings["bookmarks"], auditEvents?: AuditEvents) => Promise<void>;
+    bookmark: (article: Article, queryName?: string) => Promise<void>;
+    unbookmark: (id: string) => Promise<void>;
+    isBookmarked: (article: Partial<Article>) => boolean;
+    toggleBookmark: (article: Article) => Promise<void>;
+    deleteRecentSearch: (index: number) => Promise<void>;
+    updateRecentSearches: (recentSearches: UserSettings["recentSearches"], auditEvents?: AuditEvents) => Promise<void>;
+    addCurrentSearch: (queryParams: QueryParams) => Promise<void>;
+    deleteSavedSearch: (index: number) => Promise<void>;
+    updateSavedSearches: (savedSearches: UserSettings["savedSearches"]) => Promise<void>;
+    deleteBasket: (index: number) => Promise<void>;
+    createBasket: (basket: Basket) => Promise<void>;
+    updateBaskets: (baskets: UserSettings["baskets"]) => Promise<void>;
+    updateBasket: (basket: Basket, index: number) => Promise<void>;
+    addToBasket: (name: string, ids: string | string[]) => Promise<void>;
+    removeFromBasket: (name: string, ids: string | string[]) => Promise<void>;
+    updateAssistantSettings: (assistantSettings: UserSettings["assistants"]) => Promise<void>;
+    updateLanguage: (language: UserSettings["language"], auditEvents?: AuditEvents) => Promise<void>;
+    initialize: () => Promise<void>;
+    reset: () => Promise<void>;
+} & import("@ngrx/signals").StateSource<{
+    bookmarks: import("../models/user-settings").Bookmark[];
+    recentSearches: RecentSearch[];
+    savedSearches: import("../models/user-settings").SavedSearch[];
+    baskets: Basket[];
+    assistants: Record<string, unknown>;
+    language?: string | undefined;
+}>>;
+export declare function withUserSettingsFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
+    state: {
+        bookmarks: import("../models/user-settings").Bookmark[];
+        recentSearches: RecentSearch[];
+        savedSearches: import("../models/user-settings").SavedSearch[];
+        baskets: Basket[];
+        assistants: Record<string, unknown>;
+        language?: string | undefined;
+    };
+    computed: {};
+    methods: {
+        initialize: () => Promise<void>;
+        reset: () => Promise<void>;
+    };
+}>;
+export declare function withBookmarkFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
+    state: {
+        bookmarks: UserSettings["bookmarks"];
+    };
+    computed: {};
+    methods: {
+        updateBookmarks: (bookmarks: UserSettings["bookmarks"], auditEvents?: AuditEvents) => Promise<void>;
+        bookmark: (article: Article, queryName?: string) => Promise<void>;
+        unbookmark: (id: string) => Promise<void>;
+        isBookmarked: (article: Partial<Article>) => boolean;
+        toggleBookmark: (article: Article) => Promise<void>;
+    };
+}>;
+export declare function withRecentSearchFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
+    state: {
+        recentSearches: UserSettings["recentSearches"];
+    };
+    computed: {};
+    methods: {
+        deleteRecentSearch: (index: number) => Promise<void>;
+        updateRecentSearches: (recentSearches: UserSettings["recentSearches"], auditEvents?: AuditEvents) => Promise<void>;
+        addCurrentSearch: (queryParams: QueryParams) => Promise<void>;
+    };
+}>;
+export declare function withSavedSearchFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
+    state: {
+        savedSearches: UserSettings["savedSearches"];
+    };
+    computed: {};
+    methods: {
+        deleteSavedSearch: (index: number) => Promise<void>;
+        updateSavedSearches: (savedSearches: UserSettings["savedSearches"]) => Promise<void>;
+    };
+}>;
+export declare function withBasketsFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
+    state: {
+        baskets: UserSettings["baskets"];
+    };
+    computed: {};
+    methods: {
+        deleteBasket: (index: number) => Promise<void>;
+        createBasket: (basket: Basket) => Promise<void>;
+        updateBaskets: (baskets: UserSettings["baskets"]) => Promise<void>;
+        updateBasket: (basket: Basket, index: number) => Promise<void>;
+        addToBasket: (name: string, ids: string | string[]) => Promise<void>;
+        removeFromBasket: (name: string, ids: string | string[]) => Promise<void>;
+    };
+}>;
+export declare function withAssistantFeatures(): import("@ngrx/signals").SignalStoreFeature<import("@ngrx/signals").EmptyFeatureResult, {
+    state: {
+        assistants: UserSettings["assistants"];
+    };
+    computed: {};
+    methods: {
+        updateAssistantSettings: (assistantSettings: UserSettings["assistants"]) => Promise<void>;
+        updateLanguage: (language: UserSettings["language"], auditEvents?: AuditEvents) => Promise<void>;
+    };
+}>;

package/lib/tokens/highlights.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from "@angular/core";
+export type PreviewHighlightName = 'company' | 'geo' | 'person' | 'extractslocations' | 'matchlocations';
+export type PreviewHighlight = {
+    name: PreviewHighlightName;
+    color: string;
+    bgColor: string;
+};
+export declare const HIGHLIGHTS: InjectionToken<PreviewHighlight[]>;

package/lib/tokens/index.d.ts

@@ -0,0 +1 @@
+export * from "./highlights";

package/lib/utils/debounced-signal.d.ts

@@ -0,0 +1,25 @@
+import { Signal } from "@angular/core";
+/**
+ * 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)">
+ * ```
+ */
+export declare function debouncedSignal<T>(input: Signal<T>, timeOutMs?: number): Signal<T>;

package/lib/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './inline-worker';
+export * from './query';
+export * from './routes';
+export * from './tailwind-utils';
+export * from './theme-body-hook';
+export * from './theme-registry';
+export * from './debounced-signal';

package/lib/utils/inline-worker.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+export declare class InlineWorker {
+    private readonly worker;
+    private onMessage;
+    private onError;
+    constructor(func: () => void);
+    postMessage(data: unknown): void;
+    onmessage(): Observable<MessageEvent>;
+    onerror(): Observable<ErrorEvent>;
+    terminate(): void;
+}

package/lib/utils/query.d.ts

@@ -0,0 +1,26 @@
+import { Query } from '@sinequa/atomic';
+/**
+ * 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`.
+ */
+export declare function getQueryNameFromRoute(): string | undefined;
+/**
+ * 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.
+ */
+export declare function buildQuery(query?: Partial<Query>): Query;

package/lib/utils/routes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export declare function getCurrentPath(): string | undefined;
+/**
+ * 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.
+ */
+export declare function getCurrentQueryName(): string | undefined;

package/lib/utils/tailwind-utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/lib/utils/theme-body-hook.d.ts

@@ -0,0 +1,6 @@
+import { ApplicationRef } from "@angular/core";
+export type ThemeBodyHookParameters = {
+    scope: string;
+    theme: string;
+};
+export declare function withThemeBodyHook(app: ApplicationRef, params: ThemeBodyHookParameters | undefined): ApplicationRef;

package/lib/utils/theme-registry.d.ts

@@ -0,0 +1,3 @@
+import { ApplicationRef } from "@angular/core";
+import { Theme } from "../resources";
+export declare function withThemes(app: ApplicationRef, themes: Theme[]): ApplicationRef;

package/lib/web-services/aggregations.service.d.ts

@@ -0,0 +1,57 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Aggregation, AuditEvents, Query, TreeAggregation, TreeAggregationNode } from '@sinequa/atomic';
+import { QueryService } from './query.service';
+import * as i0 from "@angular/core";
+export declare class AggregationsService {
+    protected readonly http: HttpClient;
+    protected readonly queryService: QueryService;
+    appStore: {
+        webServices: import("@ngrx/signals").DeepSignal<{}>;
+        queries: import("@ngrx/signals").DeepSignal<{}>;
+        customJSONs: import("@angular/core").Signal<import("@sinequa/atomic-angular").SideCJson[]>;
+        data: import("@ngrx/signals").DeepSignal<{}>;
+        customizationJson: import("@angular/core").Signal<import("@sinequa/atomic-angular").CJsonMint>;
+        sources: import("@angular/core").Signal<any>;
+        filters: import("@angular/core").Signal<any>;
+        initialize: () => Promise<void>;
+        initializeWithAppName: (appName: string) => Promise<void>;
+        update: (app: import("@sinequa/atomic").CCApp) => void;
+        getWebServiceByType: (type: import("@sinequa/atomic").CCWebService["webServiceType"]) => import("@sinequa/atomic").CCWebService | undefined;
+        getLabels: () => {
+            private: string;
+            public: string;
+        };
+        getQueryByName: (name: string) => import("@sinequa/atomic").CCQuery | undefined;
+        getQueryByIndex: (index: number) => import("@sinequa/atomic").CCQuery | undefined;
+        getDefaultQuery: () => import("@sinequa/atomic").CCQuery | undefined;
+        allowEmptySearch: (queryName: string) => boolean;
+        getColumnAlias: (column: string) => string;
+        getAuthorizedFilters: (route: import("@angular/router").ActivatedRoute) => Aggregation[];
+        getNamedCustomizationJson: (name: string) => any | undefined;
+        getAggregationIcon: (column: string) => string | undefined;
+        getAggregationItemsCustomization: (column: string) => import("@sinequa/atomic-angular").CFilterItem[] | undefined;
+        getAggregationCustomization: (column: string) => import("@sinequa/atomic-angular").CFilter | undefined;
+    } & import("@ngrx/signals").StateSource<{
+        webServices: {};
+        queries: {};
+        customJSONs: import("@sinequa/atomic-angular").SideCJson[];
+        data: {};
+    }>;
+    aggregationsStore: {
+        aggregations: import("@angular/core").Signal<Aggregation[]>;
+        update: (aggregations: Aggregation[]) => void;
+        updateAggregation: (aggregation: Aggregation) => void;
+        clear: () => void;
+        getAggregation: (name: string, kind?: "column" | "name") => Aggregation | undefined;
+    } & import("@ngrx/signals").StateSource<{
+        aggregations: Aggregation[];
+    }>;
+    protected API_URL: string;
+    loadMore(query: Partial<Query>, aggregation: Aggregation, audit?: AuditEvents): Observable<Aggregation>;
+    open(query: Partial<Query>, aggregation: TreeAggregation, item: TreeAggregationNode): Observable<TreeAggregation>;
+    private findNode;
+    private replaceInTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AggregationsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AggregationsService>;
+}

package/lib/web-services/app.service.d.ts

@@ -0,0 +1,30 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { CCApp } from '@sinequa/atomic';
+import * as i0 from "@angular/core";
+export declare class AppService {
+    protected readonly http: HttpClient;
+    protected readonly API_URL: string;
+    /**
+     * 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?: string): Observable<CCApp>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
+}

package/lib/web-services/audit.service.d.ts

@@ -0,0 +1,72 @@
+import { HttpClient } from "@angular/common/http";
+import { Router } from "@angular/router";
+import { Article, AuditEvents, AuditEventType, AuditEventTypeValues, CCApp, Result } from "@sinequa/atomic";
+import * as i0 from "@angular/core";
+export declare class AuditService {
+    appStore: {
+        webServices: import("@ngrx/signals").DeepSignal<{}>;
+        queries: import("@ngrx/signals").DeepSignal<{}>;
+        customJSONs: import("@angular/core").Signal<import("@sinequa/atomic-angular").SideCJson[]>;
+        data: import("@ngrx/signals").DeepSignal<{}>;
+        customizationJson: import("@angular/core").Signal<import("@sinequa/atomic-angular").CJsonMint>;
+        sources: import("@angular/core").Signal<any>;
+        filters: import("@angular/core").Signal<any>;
+        initialize: () => Promise<void>;
+        initializeWithAppName: (appName: string) => Promise<void>;
+        update: (app: CCApp) => void;
+        getWebServiceByType: (type: import("@sinequa/atomic").CCWebService["webServiceType"]) => import("@sinequa/atomic").CCWebService | undefined;
+        getLabels: () => {
+            private: string;
+            public: string;
+        };
+        getQueryByName: (name: string) => import("@sinequa/atomic").CCQuery | undefined;
+        getQueryByIndex: (index: number) => import("@sinequa/atomic").CCQuery | undefined;
+        getDefaultQuery: () => import("@sinequa/atomic").CCQuery | undefined;
+        allowEmptySearch: (queryName: string) => boolean;
+        getColumnAlias: (column: string) => string;
+        getAuthorizedFilters: (route: import("@angular/router").ActivatedRoute) => import("@sinequa/atomic").Aggregation[];
+        getNamedCustomizationJson: (name: string) => any | undefined;
+        getAggregationIcon: (column: string) => string | undefined;
+        getAggregationItemsCustomization: (column: string) => import("@sinequa/atomic-angular").CFilterItem[] | undefined;
+        getAggregationCustomization: (column: string) => import("@sinequa/atomic-angular").CFilter | undefined;
+    } & import("@ngrx/signals").StateSource<{
+        webServices: {};
+        queries: {};
+        customJSONs: import("@sinequa/atomic-angular").SideCJson[];
+        data: {};
+    }>;
+    app: import("@angular/core").Signal<CCApp>;
+    protected readonly http: HttpClient;
+    protected readonly router: Router;
+    protected readonly API_URL: string;
+    protected lastClickTime: number;
+    /**
+     * Notify the Sinequa server of a set of audit events
+     *
+     * @param auditEvents The audit events
+     */
+    notify(auditEvents: AuditEvents): void;
+    /**
+     * It sends an audit event to the Audit Service.
+     */
+    notifyLogin(): void;
+    /**
+     * Notify logout
+     */
+    notifyLogout(): void;
+    /**
+       * 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: AuditEventType | AuditEventTypeValues | {} & Record<never, never>, doc: Article, resultsOrId: Result | string, parameters?: Record<string, string | number | boolean | undefined>, rfmParameters?: Record<string, string | number | boolean | undefined>): void;
+    /**
+     * Notify route change
+     */
+    notifyRouteChange(url: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuditService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuditService>;
+}

package/lib/web-services/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./aggregations.service";
+export * from "./app.service";
+export * from "./json-method-plugin.service";
+export * from "./preview.service";
+export * from "./principal.service";
+export * from "./query.service";
+export * from "./text-chunck.service";
+export * from "./audit.service";
+export * from "./audit.service";

package/lib/web-services/json-method-plugin.service.d.ts

@@ -0,0 +1,41 @@
+import { HttpClient, HttpContext, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+type Options = {
+    headers?: HttpHeaders | {
+        [header: string]: string | string[];
+    };
+    context?: HttpContext;
+    observe?: 'body' | 'events' | 'response';
+    params?: HttpParams | {
+        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+    };
+    reportProgress?: boolean;
+    responseType: 'arraybuffer' | 'blob' | 'text' | 'json';
+    withCredentials?: boolean;
+};
+export declare class JsonMethodPluginService {
+    protected readonly http: HttpClient;
+    protected readonly API_URL: string;
+    /**
+     * 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<U>(method: string, query: U, options?: Options): Observable<any>;
+    /**
+     * 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<U extends Record<string, string | boolean | number | Date | object | undefined>>(method: string, query: U, options?: Options): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonMethodPluginService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JsonMethodPluginService>;
+}
+export {};