@sinequa/atomic-angular 0.0.146

package/esm2022/lib/web-services/preview.service.mjs

@@ -0,0 +1,327 @@
+import { HttpClient } from "@angular/common/http";
+import { EventEmitter, Inject, Injectable, InjectionToken, Injector, inject } from "@angular/core";
+import { DomSanitizer } from "@angular/platform-browser";
+import { getState } from "@ngrx/signals";
+import { EMPTY, Subject, catchError, tap } from "rxjs";
+import { Audit, globalConfig } from "@sinequa/atomic";
+import { SearchService } from "../services/search.service";
+import { AppStore, ApplicationStore, QueryParamsStore, SelectionStore } from "../stores";
+import { HIGHLIGHTS } from "../tokens";
+import { AuditService } from "./audit.service";
+import { QueryService } from "./query.service";
+import * as i0 from "@angular/core";
+const PREVIEW_CONFIG = new InjectionToken("Preview configuration", {
+    factory: () => ({
+        allowWorker: false
+    })
+});
+export 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]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preview.service.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/web-services/preview.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\r\nimport { EventEmitter, Inject, Injectable, InjectionToken, Injector, OnDestroy, inject } from \"@angular/core\";\r\nimport { DomSanitizer } from \"@angular/platform-browser\";\r\nimport { getState } from \"@ngrx/signals\";\r\nimport { EMPTY, Observable, Subject, catchError, tap } from \"rxjs\";\r\n\r\nimport { Article, Audit, AuditEventType, AuditEvents, CustomHighlights, PreviewData, Query, globalConfig } from \"@sinequa/atomic\";\r\n\r\nimport { SearchService } from \"../services/search.service\";\r\nimport { AppStore, ApplicationStore, Extract, QueryParamsStore, SelectionStore } from \"../stores\";\r\nimport { HIGHLIGHTS, PreviewHighlight } from \"../tokens\";\r\nimport { InlineWorker } from \"../utils\";\r\nimport { AuditService } from \"./audit.service\";\r\nimport { QueryService } from \"./query.service\";\r\n\r\n\r\nconst PREVIEW_CONFIG = new InjectionToken(\"Preview configuration\", {\r\n  factory: () => ({\r\n    allowWorker: false\r\n  })\r\n});\r\n\r\ntype ExtractsLocations = Extract & {\r\n  text: string // HTML text\r\n}\r\n\r\nexport type ExtractsEvents = 'fetching' | 'fetched' | 'error';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class PreviewService implements OnDestroy {\r\n  protected readonly http = inject(HttpClient);\r\n  protected readonly injector = inject(Injector);\r\n\r\n  protected readonly API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;\r\n\r\n  protected readonly applicationStore = inject(ApplicationStore);\r\n  protected readonly selectionStore = inject(SelectionStore);\r\n  protected readonly queryParamsStore = inject(QueryParamsStore);\r\n  protected readonly appStore = inject(AppStore);\r\n\r\n  protected readonly sanitizer = inject(DomSanitizer);\r\n\r\n  protected readonly queryService = inject(QueryService);\r\n  protected readonly searchService = inject(SearchService);\r\n  protected readonly auditService = inject(AuditService);\r\n\r\n  events = new EventEmitter<ExtractsEvents>();\r\n\r\n  // ! worker\r\n  onMessage = new Subject<unknown>();\r\n  worker: InlineWorker | undefined;\r\n\r\n  allowWoker = inject(PREVIEW_CONFIG).allowWorker;\r\n\r\n  protected previewData: PreviewData | undefined;\r\n  protected iframe: Window | null | undefined;\r\n\r\n  protected highlightCategory = \"extractslocations\";\r\n\r\n  extracts = [\"matchlocations\", \"extractslocations\", \"matchingpassages\"];\r\n  entities = [\"company\", \"geo\", \"person\"];\r\n\r\n  constructor(\r\n    @Inject(HIGHLIGHTS) public highlights: PreviewHighlight[]) {\r\n    window.addEventListener('message', this.receiveMessage.bind(this), false);\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    window.removeEventListener('message', this.receiveMessage.bind(this), false);\r\n  }\r\n\r\n  /**\r\n   * Handles incoming messages from a MessageEvent.\r\n   *\r\n   * @param event - The MessageEvent containing the message data.\r\n   *\r\n   * The function processes messages of type 'ready' and 'get-html-results'.\r\n   *\r\n   * - For 'ready' messages:\r\n   *   - Initializes the preview iframe with the app name and highlights.\r\n   *   - If preview data is available, retrieves HTML content based on the current selection.\r\n   *\r\n   * - For 'get-html-results' messages:\r\n   *   - Updates the application store with the extracted HTML results.\r\n   *   - If no extracts are found, updates the application store with an empty array.\r\n   */\r\n  receiveMessage(event: MessageEvent) {\r\n    const message = event.data;\r\n    // the webworker needs to be initialized with the app name to be able to load the correct webworker file (worker.js)\r\n    const { app } = globalConfig;\r\n\r\n    // when the iframe is ready, we can send the init message\r\n    if (message.type === 'ready') {\r\n      // Initialize the preview iframe with the app name and highlights\r\n      // app name is used to intialize the webworker\r\n      this.sendMessage({ action: \"init\", highlights: this.highlights, appname: app });\r\n\r\n      if (this.previewData) {\r\n        const { id } = getState(this.selectionStore);\r\n        this.events.emit('fetching');\r\n        this.retrieveHtmlContent(id, this.highlightCategory, this.previewData);\r\n      }\r\n    }\r\n\r\n    // when the iframe sends back the html content of the extracts (no worker)\r\n    if (message.type === 'get-html-results') {\r\n      const { id } = getState(this.selectionStore)\r\n\r\n      if (id) {\r\n        console.info(\"no worker\");\r\n        const extracts = this.fetchExtracts(id, message.data, this.previewData!);\r\n        this.applicationStore.updateExtracts(this.previewData?.record.id || '', extracts);\r\n        this.events.emit('fetched');\r\n      }\r\n    }\r\n\r\n    // when the iframe sends back the html content of the extracts (with worker)\r\n    // we update the extracts in the application store\r\n    if (message.type === 'get-html-results-webworker') {\r\n      console.info(\"with worker\");\r\n\r\n      if (message.data.extracts.length === 0) {\r\n        this.events.emit('fetched');\r\n        this.applicationStore.updateExtracts(this.previewData?.record.id || '', []);\r\n        return;\r\n      }\r\n\r\n      const extracts: Extract[] = message.data.extracts.map((item: ExtractsLocations) => ({\r\n        ...item,\r\n        text: this.sanitizer.bypassSecurityTrustHtml(item.text)\r\n      }));\r\n\r\n      this.applicationStore.updateExtracts(this.previewData?.record.id || '', extracts);\r\n      this.events.emit('fetched');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Generates a preview of the document with the given ID, applying the specified query parameters,\r\n   * custom highlights, and audit events.\r\n   *\r\n   * @param id - The unique identifier of the document to preview.\r\n   * @param q - Partial query parameters to customize the preview request.\r\n   * @param customHighlights - Optional array of custom highlights to apply to the preview.\r\n   * @param audit - Optional audit events to merge with the default audit record.\r\n   * @returns An Observable that emits the preview data.\r\n   */\r\n  preview(id: string, q: Partial<Query>, customHighlights?: CustomHighlights[], audit?: AuditEvents): Observable<PreviewData> {\r\n    const detail = this.getAuditPreviewDetail(id, q);\r\n\r\n    const defaultAudit: AuditEvents = {\r\n      type: \"Doc_Preview\",\r\n      detail\r\n    };\r\n\r\n    // merge the default audit record with the provided audit record\r\n    const $auditRecord = audit ? { auditEvents: [{ ...defaultAudit, ...audit }] } : { auditEvents: [defaultAudit] };\r\n\r\n    const { app } = globalConfig;\r\n    const query = { ...this.queryParamsStore.getQuery(), ...q };\r\n\r\n    const browserUrl = `${window.location.origin}${window.location.pathname}`;\r\n\r\n    const body = {\r\n      app,\r\n      action: \"get\",\r\n      id,\r\n      query: { name: query.name, text: query.text },\r\n      browserUrl,\r\n      customHighlights,\r\n      $auditRecord\r\n    };\r\n\r\n    return this.http.post<PreviewData>(this.API_URL + \"/preview\", body)\r\n      .pipe(\r\n        tap((data: PreviewData) => this.setPreviewData(data)),\r\n        catchError(error => {\r\n          console.error(\"queryService.preview failure - error: \", error);\r\n          return EMPTY;\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Closes the preview with the specified ID and updates the audit log.\r\n   *\r\n   * @param id - The ID of the preview to close.\r\n   * @param query - The partial query object used to retrieve the preview detail.\r\n   */\r\n  close(id: string, query: Partial<Query>) {\r\n    const detail = this.getAuditPreviewDetail(id, query);\r\n    const auditEvent = {\r\n      type: AuditEventType.Preview_Close,\r\n      detail\r\n    }\r\n    Audit.notify(auditEvent);\r\n  }\r\n\r\n  /**\r\n   * Previews an article in a new browser's tab.\r\n   *\r\n   * @param article - The article to preview.\r\n   */\r\n  openExternal(article: Article) {\r\n    const query = this.queryParamsStore.getQuery();\r\n    const detail = this.getAuditPreviewDetail(article.id, query);\r\n    const result = this.searchService.result;\r\n    this.auditService.notifyDocument(\r\n      \"Click_ResultLink\",\r\n      article,\r\n      result || detail.resultid || \"\",\r\n      {\r\n        querytext: detail.querytext,\r\n        querylang: detail.querylang,\r\n        score: detail.score\r\n      },\r\n      {\r\n        queryhash: result ? result.rfmQueryHash : undefined,\r\n        querytext: detail.querytext,\r\n        querylang: detail.querylang\r\n      }\r\n    )\r\n    window.open(article.url1, '_blank', 'noopener noreferrer');\r\n  }\r\n\r\n\r\n  /**\r\n   * Sets the iframe window object.\r\n   *\r\n   * @param iframe - The window object of the iframe or null to unset.\r\n   */\r\n  setIframe(iframe: Window | null) {\r\n    this.iframe = iframe;\r\n  }\r\n\r\n  /**\r\n   * Sets the preview data and updates the highlight category based on the provided data.\r\n   *\r\n   * @param data - The preview data to be set.\r\n   *\r\n   * If the provided data contains highlights per category with 'matchingpassages' having values,\r\n   * the highlight category is set to \"matchingpassages\". Otherwise, it is set to \"extractslocations\".\r\n   */\r\n  setPreviewData(data: PreviewData) {\r\n    this.previewData = data;\r\n\r\n    if (data) {\r\n      this.highlightCategory = data.highlightsPerCategory?.['matchingpassages']?.values.length ? \"matchingpassages\" : \"extractslocations\";\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sends a message to the iframe if it exists.\r\n   *\r\n   * @param message - The message to be sent. It can be of any type.\r\n   */\r\n  sendMessage(message: unknown) {\r\n    if (this.iframe) {\r\n      this.iframe!.postMessage(message, '*');\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get preview id for an entity value for an index\r\n   * @param entity the entity type (i.e. \"geo\")\r\n   * @param value the entity value (i.e. \"AUSTRALIA\")\r\n   * @param index the entity index from its list\r\n   * @returns the html id\r\n   */\r\n  getEntityId(entity: string, value: string, index: number): number | undefined {\r\n    if (!this.previewData) return undefined;\r\n\r\n    return this.previewData.highlightsPerLocation\r\n      .filter(h => h.values.find(v => v === value))[index].positionInCategories[entity];\r\n  }\r\n\r\n  /**\r\n   * Send a message to the prewiew iFrame with the required data to retrieve HTML content for a specific highlight category\r\n   *\r\n   * @param id - The unique identifier for the request.\r\n   * @param highlightCategory - The category of highlights to retrieve.\r\n   * @param previewData - The data containing highlights and their locations.\r\n   */\r\n  retrieveHtmlContent(id: string, highlightCategory: string, previewData: PreviewData) {\r\n    // Generate the list of items we want to retrieve\r\n    const ids = previewData.highlightsPerCategory[highlightCategory]?.values[0]?.locations.map(\r\n      (_, i) => `${highlightCategory}_${i}`\r\n    );\r\n\r\n    if (this.allowWoker) {\r\n      // if the worker is allowed, we send the message to the worker\r\n      this.sendMessage({ action: 'get-html-webworker', id, ids, previewData });\r\n    } else {\r\n      this.sendMessage({ action: 'get-html', id, ids, previewData });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sends a message to zoom in.\r\n   *\r\n   * This method triggers a \"zoom-in\" action by sending a message\r\n   * with the specified action type.\r\n   */\r\n  zoomIn() {\r\n    this.sendMessage({ action: \"zoom-in\" });\r\n  }\r\n\r\n  /**\r\n   * Sends a message to zoom out the preview.\r\n   *\r\n   * This method triggers a \"zoom-out\" action by sending a message\r\n   * to the relevant service or component.\r\n   */\r\n  zoomOut() {\r\n    this.sendMessage({ action: \"zoom-out\" });\r\n  }\r\n\r\n  /**\r\n   * Toggles the highlights based on the provided flags for extracts and entities.\r\n   *\r\n   * @param extracts - A boolean flag indicating whether to include extracts highlights.\r\n   * @param entities - A boolean flag indicating whether to include entities highlights.\r\n   */\r\n  toggle(extracts: boolean, entities: boolean) {\r\n    const extractsHighlights = extracts ? this.highlights.filter(h => this.extracts.includes(h.name)) : [];\r\n    const entitiesHighlights = entities ? this.highlights.filter(h => this.entities.includes(h.name)) : [];\r\n    const highlights = [...extractsHighlights, ...entitiesHighlights];\r\n\r\n    this.sendMessage({ action: \"highlight\", highlights });\r\n  }\r\n\r\n  getAuditPreviewDetail(id: string, q: Partial<Query>) {\r\n    const results = this.searchService.result;\r\n    const queryLanguage = results?.queryAnalysis?.queryLanguage\r\n      || q?.questionLanguage\r\n      || this.appStore.getQueryByName(q.name!)?.questionLanguage;\r\n\r\n    const record = this.previewData?.record;\r\n    const collectionColumn = record?.collection;\r\n    const collection = !!collectionColumn ? collectionColumn[0] : id.split(\"|\")[0];\r\n    const rank = !!record ? record.rank : 0;\r\n    const passages = record?.matchingpassages?.passages;\r\n    const score = passages && passages.length ? passages[0].score : undefined;\r\n    return {\r\n      docid: id,\r\n      rank,\r\n      collection,\r\n      source: collection.split(\"|\")[0],\r\n      resultid: results.id,\r\n      querylang: queryLanguage,\r\n      querytext: q?.text,\r\n      filename: record?.filename,\r\n      fileext: record?.fileext,\r\n      score\r\n    }\r\n  }\r\n\r\n  private fetchExtracts(id: string, extracts: string[], data: PreviewData): Extract[] {\r\n    // extracts contains the html of extracts in chronological order\r\n    // locations contains the list of start positions sorted by score\r\n    const locations = data.highlightsPerCategory[this.highlightCategory]?.values[0]?.locations || [];\r\n\r\n    // first extract all the extracts locations\r\n    let extractslocations = locations.map((l, relevanceIndex) => ({\r\n      startIndex: l.start,\r\n      relevanceIndex\r\n    })) as ExtractsLocations[];\r\n\r\n    // sort them by start index\r\n    extractslocations.sort((a, b) => a.startIndex - b.startIndex);\r\n\r\n    // then extract the text of each extract\r\n    extractslocations = extractslocations.map((ex, textIndex) => ({\r\n      ...ex,\r\n      textIndex: textIndex,\r\n      text: extracts[textIndex] || \"\",\r\n      id: `${this.highlightCategory}_${textIndex}`,\r\n    }));\r\n\r\n    // then sanitize the text and remove empty extracts\r\n    const _extracts = extractslocations.filter(item => item.text.trim().length > 0).map(item => ({\r\n      ...item,\r\n      text: this.sanitizer.bypassSecurityTrustHtml(item.text)\r\n    }));\r\n\r\n    // finally sort them by relevance index\r\n    _extracts.sort((a, b) => a.relevanceIndex - b.relevanceIndex);\r\n\r\n    return _extracts;\r\n  }\r\n}"]}

package/esm2022/lib/web-services/principal.service.mjs

@@ -0,0 +1,46 @@
+import { HttpClient, HttpParams } from "@angular/common/http";
+import { Injectable, inject } from "@angular/core";
+import { EMPTY, catchError } from "rxjs";
+import { globalConfig } from "@sinequa/atomic";
+import * as i0 from "@angular/core";
+export 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'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/web-services/query.service.mjs

@@ -0,0 +1,123 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { EMPTY, catchError, map, of, tap } from 'rxjs';
+import { buildPathsAndLevels, globalConfig } from '@sinequa/atomic';
+import { AppStore, QueryParamsStore } from '../stores';
+import * as i0 from "@angular/core";
+const AGGREGATION_MAX_COUNT = 11;
+export 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'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.service.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/web-services/query.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { EMPTY, Observable, catchError, map, of, tap } from 'rxjs';\r\n\r\nimport { Aggregation, Article, AuditEvents, CustomHighlights, PreviewData, Query, Result, TreeAggregation, TreeAggregationNode, buildPathsAndLevels, globalConfig } from '@sinequa/atomic';\r\n\r\nimport { AppStore, QueryParamsStore } from '../stores';\r\n\r\nconst AGGREGATION_MAX_COUNT = 11;\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class QueryService {\r\n  protected readonly http = inject(HttpClient);\r\n\r\n  private readonly appStore = inject(AppStore);\r\n  private readonly queryParamsStore = inject(QueryParamsStore)\r\n\r\n  protected readonly API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;\r\n\r\n  /**\r\n   * Performs a search query.\r\n   *\r\n   * @param q - The partial query object.\r\n   * @param includeQueryParams - Indicates whether to include query parameters automatically in the request.\r\n   * @param audit - The audit events object.\r\n   * @returns An observable that emits the search results.\r\n   */\r\n  search(q?: Partial<Query>, includeQueryParams = true, audit?: AuditEvents): Observable<Result> {\r\n    const $auditRecord = audit ? { auditEvents: [audit] } : undefined;\r\n\r\n    const { app } = globalConfig;\r\n    const currentQuery = q ?? this.queryParamsStore.getQuery();\r\n    const query = includeQueryParams ? { ...this.queryParamsStore.getQuery(), ...currentQuery } : currentQuery;\r\n\r\n    // Check if the search query is empty and if empty searches are allowed\r\n    // If not allowed, return an empty result\r\n    const allowEmptySearch = this.appStore.allowEmptySearch(query?.name || '');\r\n    if (allowEmptySearch === false && query?.text === '') {\r\n      return of({ records: [] as Article[] } as Result);\r\n    }\r\n\r\n    const body = {\r\n      app,\r\n      query,\r\n      $auditRecord\r\n    };\r\n\r\n    return this.http.post<Result>(this.API_URL + \"/query\", body)\r\n      .pipe(\r\n        catchError(error => {\r\n          console.error(\"queryService.getResults failure - error: \", error);\r\n          return of({} as Result);\r\n        }),\r\n        map((result: Result) => {\r\n          // update $hasMore flag\r\n          result.aggregations.forEach((agg: Aggregation) => {\r\n            agg.$hasMore = false;\r\n            if (!agg.isDistribution && !agg.isTree && agg.items) {\r\n              agg.$hasMore = agg.items.length === AGGREGATION_MAX_COUNT;\r\n            }\r\n            if (agg.isTree) {\r\n              buildPathsAndLevels(agg as TreeAggregation);\r\n            }\r\n          });\r\n          return result;\r\n        }),\r\n        map(result => {\r\n          result.records?.map((article: Article) => (Object.assign(article, { value: article.title, type: 'default' })));\r\n          return result;\r\n        }),\r\n        map(result => {\r\n          const r = ({ ...result, nextPage: result.page < Math.ceil(result.rowCount / result.pageSize) ? result.page + 1 : undefined, previousPage: result.page > 1 ? result.page - 1 : undefined })\r\n          return r;\r\n        }),\r\n        tap(response => console.log(\"queryService.getResults success - data: \", response)),\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Performs a bulk search operation.\r\n   *\r\n   * @param q An array of Query objects representing the search queries.\r\n   * @param audit An optional AuditEvents object for auditing purposes.\r\n   * @returns An Observable that emits an array of Result objects.\r\n   */\r\n  bulkSearch(q: Query[], audit?: AuditEvents): Observable<Result[]> {\r\n\r\n    const { app = '' } = globalConfig;\r\n\r\n    const body: {\r\n      methods: {\r\n        method: string,\r\n        app: string,\r\n        query: Query\r\n      }[],\r\n      propagateErrors: true,\r\n      $auditRecord?: { auditEvents: [AuditEvents] }\r\n    } = {\r\n      methods: [],\r\n      propagateErrors: true,\r\n      $auditRecord: { auditEvents: [audit!] }\r\n    };\r\n\r\n    for (const query of q) {\r\n      body.methods.push({\r\n        method: \"query\",\r\n        app,\r\n        query\r\n      });\r\n    }\r\n\r\n    return this.http.post<{ results: Result[] }>(this.API_URL + \"/multi\", body)\r\n      .pipe(\r\n        catchError(error => {\r\n          console.error(\"queryService.bulkSearch failure - error: \", error);\r\n          return EMPTY;\r\n        }),\r\n        map(response => {\r\n          // update $hasMore flag\r\n          response.results.forEach((result: Result) => {\r\n            result.aggregations.forEach((agg: Aggregation) => {\r\n              agg.$hasMore = false;\r\n              if (!agg.isDistribution && !agg.isTree && agg.items) {\r\n                agg.$hasMore = agg.items.length === AGGREGATION_MAX_COUNT;\r\n              }\r\n              if (agg.isTree) {\r\n                buildPathsAndLevels(agg as TreeAggregation);\r\n              }\r\n            });\r\n          })\r\n\r\n          return response.results;\r\n        }),\r\n        map(results => {\r\n          results.forEach(result =>  result.records?.map((article: Article) => (Object.assign(article, { value: article.title, type: 'default' }))));\r\n          return results;\r\n        }),\r\n        map(results => {\r\n          return results.map(result => {\r\n            const r = ({ ...result, nextPage: result.page < Math.ceil(result.rowCount / result.pageSize) ? result.page + 1 : undefined, previousPage: result.page > 1 ? result.page - 1 : undefined })\r\n            return r;\r\n          });\r\n        }),\r\n        // map(response => ResultsSchema.parse(response) as T),\r\n        tap(response => console.log(\"queryService.bulkSearch success - data: \", response)),\r\n      );\r\n\r\n  }\r\n}\r\n"]}