@sinequa/assistant 3.8.0 → 3.9.0

package/esm2022/chat/documents-upload/documents-upload.service.mjs

@@ -0,0 +1,291 @@
+import { Injectable, inject } from '@angular/core';
+import { BehaviorSubject, catchError, filter, from, map, take } from 'rxjs';
+import { HttpClient, HttpEventType, HttpHeaders } from '@angular/common/http';
+import { AppService } from '../services/app.service';
+import { getToken, globalConfig, post } from '@sinequa/atomic';
+import * as i0 from "@angular/core";
+export class DocumentsUploadService {
+    constructor() {
+        /** Documents' upload configuration. */
+        this.uploadConfig$ = new BehaviorSubject(undefined);
+        this.appService = inject(AppService);
+        this.http = inject(HttpClient);
+    }
+    /**
+     * Initializes the file upload service with the provided chat service instance.
+     *
+     * @param chatService - An instance of ChatService. If not provided, an error is thrown.
+     * @throws {Error} If the chatService instance is not provided or if there is an error during initialization.
+     */
+    init(chatService) {
+        if (!chatService)
+            throw new Error('A chatService instance must be provided');
+        this.chatService = chatService;
+        try {
+            this.getRequestsUrl();
+            this.getUploadConfig();
+        }
+        catch (error) {
+            throw new Error(error);
+        }
+    }
+    /**
+     * Fetch the endpoint to use for the file upload related requests
+     * @throws {Error} If the property 'restEndpoint' is not provided in the assistant configuration
+     */
+    getRequestsUrl() {
+        if (!!this.chatService.assistantConfig$.value.connectionSettings.restEndpoint) {
+            this.REQUEST_URL = this.chatService.assistantConfig$.value.connectionSettings.restEndpoint;
+        }
+        else {
+            throw new Error(`The property 'restEndpoint' must be provided when attempting to use 'REST' in assistant instance`);
+        }
+    }
+    /**
+     * Retrieves the upload configuration for documents.
+     * The response, which contains the upload configuration, is emitted to the `uploadConfig$` observable.
+     *
+     * @throws {Error} If there is an error invoking the `documentsUploadConfigGet` action.
+     */
+    getUploadConfig() {
+        const data = {
+            action: "documentsUploadConfigGet",
+            appName: this.appService.appName,
+            debug: this.chatService.assistantConfig$.value.defaultValues.debug
+        };
+        from(post(`plugin/${this.REQUEST_URL}`, data)).pipe(take(1), catchError((error) => {
+            throw new Error(`Error invoking documentsUploadConfigGet: ${error}`);
+        })).subscribe((res) => this.uploadConfig$.next(res));
+    }
+    /**
+     * Uploads documents to the server.
+     *
+     * This method takes a FormData object which should contain all files to be uploaded.
+     * Each file should be appended to the FormData object with its original name.
+     *
+     * For example:
+     * ```typescript
+     * const formData = new FormData();
+     * formData.append(file.name, file.file);
+     * ```
+     *
+     * @param formData - The FormData object containing the files to be uploaded.
+     * - Each file should be appended to the FormData object with its original name.
+     * For example:
+     * ```typescript
+     * const formData = new FormData();
+     * formData.append(file.name, file.file);
+     * ```
+     *
+     * @param enableProgress - (Optional) A boolean parameter that controls whether progress reporting is enabled.
+     * - Defaults to `true`.
+     * - If `true`, the `reportProgress` option is set in the request options, enabling the track of upload progress based on the underlying browser's progress events.
+     * - If `false`, progress events are not reported.
+     *
+     * @returns An Observable that emits events of type `UploadEvent`:
+     * - `UploadProgressEvent`: Emitted during the upload process, containing:
+     *   - *  `type`: "uploadProgress" - The type of the event.
+     *   - *  `loaded`: number - The number of bytes uploaded so far.
+     *   - *  `total`: number - The total number of bytes to be uploaded (if available).
+     *   - *  `progress`: number - The percentage of upload progress (calculated as `(loaded / total) * 100`).
+     * - `UploadResponseEvent`: Emitted when the upload is complete, containing:
+     *   - *  `type`: "response" - The type of the event.
+     *   - *  `body`: `UploadResponse` - The server's response, including:
+     *     - * - * `statusToken`: string - A token to track the status of the indexing process.
+     *     - * - *  `executionTime`: string - The time taken to execute the upload.
+     *     - * - *  `connectorResponse` (optional): Additional response data from the connector, containing:
+     *       - * - * - *  `collection`: string - The collection name.
+     *       - * - * - *  `action`: string - The action performed.
+     *       - * - * - *  `stats`: object - Statistics about the upload, including:
+     *         - * - * - * - * `nbDocUpdated`: number - The number of documents updated.
+     *
+     * @throws {Error} If there is an error invoking the `documentsupload` action.
+     *
+     * Example usage:
+     * ```typescript
+     * const formData = new FormData();
+     * formData.append(file.name, file.file);
+     * this.documentsUploadService.uploadDocuments(formData).subscribe(event => {
+     *   if (event.type === 'uploadProgress') {
+     *     console.log(`Progress: ${event.progress}%`);
+     *   } else if (event.type === 'response') {
+     *     console.log('Upload complete:', event.body);
+     *   }
+     * });
+     * ```
+     */
+    uploadDocuments(formData, enableProgress = true) {
+        // Add the required "data" field as a JSON string
+        const data = {
+            action: "documentsupload",
+            appName: this.appService.appName,
+            debug: this.chatService.assistantConfig$.value.defaultValues.debug
+        };
+        formData.append('data', JSON.stringify(data));
+        let headers = new HttpHeaders({ 'Accept': 'application/json' });
+        const token = getToken();
+        if (token) {
+            headers = headers.append('sinequa-csrf-token', token);
+        }
+        const options = {
+            headers: headers,
+            observe: 'events',
+        };
+        if (enableProgress)
+            options['reportProgress'] = true;
+        const url = `${globalConfig.backendUrl}/${globalConfig.apiPath}/plugin/${this.REQUEST_URL}`;
+        /**
+         * Need to use the HttpClient directly to avoid the JSONMethodPluginService's behavior
+         * because it is altering the request and thus making it unable to properly set the Content-Type header with the boundary
+         */
+        return this.http.post(url, formData, options).pipe(filter((event) => event.type === HttpEventType.Response || (enableProgress && event.type === HttpEventType.UploadProgress)), map((event) => {
+            switch (event.type) {
+                case HttpEventType.UploadProgress: {
+                    const { loaded = 0, total = 0 } = event;
+                    return { type: 'uploadProgress', loaded, total, progress: total > 0 ? Math.round((loaded / total) * 100) : 0 };
+                }
+                case HttpEventType.Response:
+                    return { type: 'response', body: event.body };
+                default:
+                    throw new Error("Unexpected event type"); // Should not reach here, but for typescript sake.
+            }
+        }), catchError((error) => {
+            throw new Error(`Error invoking documentsupload: ${error}`);
+        }));
+    }
+    /**
+     * Retrieves the indexing status of a predefined uploaded document(s)
+     * based on the provided status token returned from the upload process.
+     *
+     * @param token - The status token used to track the indexing process.
+     * @returns An Observable that emits the server response of type `IndexingResponse`.
+     * The `IndexingResponse` object contains:
+     * - `docs`: array - An array of document status objects, each containing:
+     *   - * `id`: string - The document ID.
+     *   - * `fileName`: string - The name of the file.
+     *   - * `operation`: "Add" | "Update" - The operation performed on the document.
+     *   - * `status`: "Indexing" | "Indexed" | "Error" - The status of the document.
+     *   - * `previousIndexationTime`: string | null - The previous indexation time.
+     *   - * `currentIndexationTime`: string | null - The current indexation time.
+     * - `executionTime`: string - The time taken to retrieve the indexing status.
+     * @throws {Error} If there is an error invoking the `documentsUploadStatus` action.
+     */
+    getIndexingStatus(token) {
+        const data = {
+            action: "documentsUploadStatus",
+            appName: this.appService.appName,
+            statusToken: token,
+            debug: this.chatService.assistantConfig$.value.defaultValues.debug
+        };
+        return from(post(`plugin/${this.REQUEST_URL}`, data)).pipe(catchError((error) => {
+            throw new Error(`Error invoking documentsUploadStatus: ${error}`);
+        }));
+    }
+    /**
+     * Retrieves a list of uploaded documents.
+     *
+     * @param {string[]} [columns] - Optional array of additional index columns to include for each document.
+     * @param {number} [skip] - Optional number of documents to skip for pagination. If set, count also needs to be set. No skip if not set.
+     * @param {number} [count] - Optional number of documents to take for pagination (unlimited if not set).
+     * @returns {Observable<UploadedDocuments>} An observable that emits the list of uploaded documents.
+     * The `UploadedDocuments` object contains:
+     * - `docs`: array - An array of objects representing a single document with the following properties:
+     *   - * `id`: string - A unique identifier for the document.
+     *   - * `fileName`: string - The name of the file.
+     *   - * `title`: string - The title of the document.
+     *   - * `fileExt`: string - The file extension of the document.
+     *   - * `indexationTime`: string - The time when the document was indexed.
+     *   - * `size`: number - The size of the document.
+     *   - * `sizeDisplay`: string - A human-readable representation of the document size.
+     *   - * `[key: string]`: any - Additional columns asked in the request, value of the column for the document.
+     * - `count`: number - The count of documents in the current batch or subset.
+     * - `totalCount`: number - The total count of documents available.
+     * - `executionTime`: string - The time taken to process the documents.
+     * @throws {Error} Throws an error if the request fails.
+     */
+    getDocumentsList(columns, skip, count) {
+        const data = {
+            action: "documentsList",
+            appName: this.appService.appName,
+            debug: this.chatService.assistantConfig$.value.defaultValues.debug
+        };
+        if (columns)
+            data["columns"] = columns;
+        if (skip)
+            data["skip"] = skip;
+        if (count)
+            data["count"] = count;
+        return from(post(`plugin/${this.REQUEST_URL}`, data)).pipe(catchError((error) => {
+            throw new Error(`Error invoking documentsList: ${error}`);
+        }));
+    }
+    /**
+     * Deletes the uploaded documents with the specified IDs.
+     *
+     * @param docIds - An array of document IDs to delete.
+     * @returns An observable that emits the server response of type `deleteDocumentsResponse`.
+     * The `deleteDocumentsResponse` object contains:
+     * - `deletedCount`: number - The number of deleted documents.
+     * - `executionTime`: string - The time taken to delete the documents.
+     * @throws {Error} If there is an error invoking the `documentsDelete` action.
+     */
+    deleteDocuments(docIds) {
+        const data = {
+            action: "documentsDelete",
+            docIds,
+            appName: this.appService.appName,
+            debug: this.chatService.assistantConfig$.value.defaultValues.debug
+        };
+        return from(post(`plugin/${this.REQUEST_URL}`, data)).pipe(catchError((error) => {
+            throw new Error(`Error invoking documentsDelete: ${error}`);
+        }));
+    }
+    /**
+     * Deletes all uploaded documents.
+     *
+     * @returns An observable that emits the server response of type `deleteDocumentsResponse`.
+     * The `deleteDocumentsResponse` object contains:
+     * - `deletedCount`: number - The number of deleted documents.
+     * - `executionTime`: string - The time taken to delete the documents.
+     * @throws {Error} If there is an error invoking the `documentsDeleteAll` action.
+     */
+    deleteAllDocuments() {
+        const data = {
+            action: "documentsDeleteAll",
+            appName: this.appService.appName,
+            debug: this.chatService.assistantConfig$.value.defaultValues.debug
+        };
+        return from(post(`plugin/${this.REQUEST_URL}`, data)).pipe(catchError((error) => {
+            throw new Error(`Error invoking documentsDeleteAll: ${error}`);
+        }));
+    }
+    /**
+     * Formats the given file size in bytes into a human-readable string.
+     *
+     * @param bytes - The size of the file in bytes.
+     * @returns A string representing the file size in a human-readable format (e.g., "10.24 KB", "1.00 MB").
+     */
+    formatFileSize(bytes) {
+        if (bytes === 0)
+            return "0 Bytes";
+        const k = 1024;
+        const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return (Number.parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i]);
+    }
+    /**
+     * Converts the given file size in bytes into megabytes.
+     *
+     * @param bytes - The size of the file in bytes.
+     * @returns The size of the file in megabytes.
+     */
+    convertBytesToMB(bytes) {
+        return bytes / (1024 * 1024);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentsUploadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentsUploadService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DocumentsUploadService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"documents-upload.service.js","sourceRoot":"","sources":["../../../../../projects/assistant/chat/documents-upload/documents-upload.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { ChatService } from '../chat.service';\nimport { BehaviorSubject, catchError, filter, from, map, Observable, take } from 'rxjs';\nimport { deleteDocumentsResponse, IndexingInfos, UploadConfig, UploadedDocuments, UploadEvent } from './documents-upload.model';\nimport { HttpClient, HttpEventType, HttpHeaders, HttpResponse, HttpUploadProgressEvent } from '@angular/common/http';\nimport { AppService } from '../services/app.service';\nimport { getToken, globalConfig, post } from '@sinequa/atomic';\n\n@Injectable()\nexport class DocumentsUploadService {\n\n  /** Name of the assistant plugin. */\n  public REQUEST_URL: string;\n  /** Documents' upload configuration. */\n  uploadConfig$ = new BehaviorSubject<UploadConfig | undefined>(undefined);\n  public chatService: ChatService;\n\n  public appService = inject(AppService);\n  public http = inject(HttpClient);\n\n  /**\n   * Initializes the file upload service with the provided chat service instance.\n   *\n   * @param chatService - An instance of ChatService. If not provided, an error is thrown.\n   * @throws {Error} If the chatService instance is not provided or if there is an error during initialization.\n   */\n  init(chatService: ChatService | undefined): void {\n    if (!chatService) throw new Error('A chatService instance must be provided');\n\n    this.chatService = chatService;\n    try {\n      this.getRequestsUrl();\n      this.getUploadConfig();\n    } catch (error) {\n      throw new Error(error);\n    }\n  }\n\n  /**\n   * Fetch the endpoint to use for the file upload related requests\n   * @throws {Error} If the property 'restEndpoint' is not provided in the assistant configuration\n   */\n  getRequestsUrl() {\n    if (!!this.chatService.assistantConfig$.value!.connectionSettings.restEndpoint) {\n      this.REQUEST_URL = this.chatService.assistantConfig$.value!.connectionSettings.restEndpoint;\n    } else {\n      throw new Error(`The property 'restEndpoint' must be provided when attempting to use 'REST' in assistant instance`);\n    }\n  }\n\n  /**\n   * Retrieves the upload configuration for documents.\n   * The response, which contains the upload configuration, is emitted to the `uploadConfig$` observable.\n   *\n   * @throws {Error} If there is an error invoking the `documentsUploadConfigGet` action.\n   */\n  public getUploadConfig(): void {\n    const data = {\n      action: \"documentsUploadConfigGet\",\n      appName: this.appService.appName,\n      debug: this.chatService.assistantConfig$.value!.defaultValues.debug\n    };\n\n    from(post<UploadConfig>(`plugin/${this.REQUEST_URL}`, data)).pipe(\n      take(1),\n      catchError((error) => {\n        throw new Error(`Error invoking documentsUploadConfigGet: ${error}`);\n      })\n    ).subscribe((res: UploadConfig) => this.uploadConfig$.next(res));\n  }\n\n  /**\n   * Uploads documents to the server.\n   *\n   * This method takes a FormData object which should contain all files to be uploaded.\n   * Each file should be appended to the FormData object with its original name.\n   *\n   * For example:\n   * ```typescript\n   * const formData = new FormData();\n   * formData.append(file.name, file.file);\n   * ```\n   *\n   * @param formData - The FormData object containing the files to be uploaded.\n   * - Each file should be appended to the FormData object with its original name.\n   * For example:\n   * ```typescript\n   * const formData = new FormData();\n   * formData.append(file.name, file.file);\n   * ```\n   *\n   * @param enableProgress - (Optional) A boolean parameter that controls whether progress reporting is enabled.\n   * - Defaults to `true`.\n   * - If `true`, the `reportProgress` option is set in the request options, enabling the track of upload progress based on the underlying browser's progress events.\n   * - If `false`, progress events are not reported.\n   *\n   * @returns An Observable that emits events of type `UploadEvent`:\n   * - `UploadProgressEvent`: Emitted during the upload process, containing:\n   *   - *  `type`: \"uploadProgress\" - The type of the event.\n   *   - *  `loaded`: number - The number of bytes uploaded so far.\n   *   - *  `total`: number - The total number of bytes to be uploaded (if available).\n   *   - *  `progress`: number - The percentage of upload progress (calculated as `(loaded / total) * 100`).\n   * - `UploadResponseEvent`: Emitted when the upload is complete, containing:\n   *   - *  `type`: \"response\" - The type of the event.\n   *   - *  `body`: `UploadResponse` - The server's response, including:\n   *     - * - * `statusToken`: string - A token to track the status of the indexing process.\n   *     - * - *  `executionTime`: string - The time taken to execute the upload.\n   *     - * - *  `connectorResponse` (optional): Additional response data from the connector, containing:\n   *       - * - * - *  `collection`: string - The collection name.\n   *       - * - * - *  `action`: string - The action performed.\n   *       - * - * - *  `stats`: object - Statistics about the upload, including:\n   *         - * - * - * - * `nbDocUpdated`: number - The number of documents updated.\n   *\n   * @throws {Error} If there is an error invoking the `documentsupload` action.\n   *\n   * Example usage:\n   * ```typescript\n   * const formData = new FormData();\n   * formData.append(file.name, file.file);\n   * this.documentsUploadService.uploadDocuments(formData).subscribe(event => {\n   *   if (event.type === 'uploadProgress') {\n   *     console.log(`Progress: ${event.progress}%`);\n   *   } else if (event.type === 'response') {\n   *     console.log('Upload complete:', event.body);\n   *   }\n   * });\n   * ```\n   */\n  public uploadDocuments(formData: FormData, enableProgress: boolean = true): Observable<UploadEvent> {\n    // Add the required \"data\" field as a JSON string\n    const data = {\n      action: \"documentsupload\",\n      appName: this.appService.appName,\n      debug: this.chatService.assistantConfig$.value!.defaultValues.debug\n    };\n    formData.append('data', JSON.stringify(data));\n\n    let headers = new HttpHeaders({ 'Accept': 'application/json' });\n    const token = getToken();\n    if(token){\n      headers = headers.append('sinequa-csrf-token',token);\n    }\n    const options: any  = {\n      headers: headers,\n      observe: 'events',\n    };\n    if (enableProgress) options['reportProgress'] = true;\n\n    const url = `${globalConfig.backendUrl}/${globalConfig.apiPath}/plugin/${this.REQUEST_URL}`;\n    /**\n     * Need to use the HttpClient directly to avoid the JSONMethodPluginService's behavior\n     * because it is altering the request and thus making it unable to properly set the Content-Type header with the boundary\n     */\n    return this.http.post<any>(url, formData, options).pipe(\n      filter((event): event is HttpUploadProgressEvent | HttpResponse<any> =>\n        event.type === HttpEventType.Response || (enableProgress && event.type === HttpEventType.UploadProgress)\n      ),\n      map((event): UploadEvent => {\n        switch (event.type) {\n          case HttpEventType.UploadProgress: {\n            const { loaded = 0, total = 0 } = event;\n            return { type: 'uploadProgress', loaded, total, progress: total > 0 ? Math.round((loaded / total) * 100) : 0 };\n          }\n          case HttpEventType.Response:\n            return { type: 'response', body: event.body };\n          default:\n            throw new Error(\"Unexpected event type\"); // Should not reach here, but for typescript sake.\n        }\n      }),\n      catchError((error) => {\n        throw new Error(`Error invoking documentsupload: ${error}`);\n      })\n    );\n  }\n\n  /**\n   * Retrieves the indexing status of a predefined uploaded document(s)\n   * based on the provided status token returned from the upload process.\n   *\n   * @param token - The status token used to track the indexing process.\n   * @returns An Observable that emits the server response of type `IndexingResponse`.\n   * The `IndexingResponse` object contains:\n   * - `docs`: array - An array of document status objects, each containing:\n   *   - * `id`: string - The document ID.\n   *   - * `fileName`: string - The name of the file.\n   *   - * `operation`: \"Add\" | \"Update\" - The operation performed on the document.\n   *   - * `status`: \"Indexing\" | \"Indexed\" | \"Error\" - The status of the document.\n   *   - * `previousIndexationTime`: string | null - The previous indexation time.\n   *   - * `currentIndexationTime`: string | null - The current indexation time.\n   * - `executionTime`: string - The time taken to retrieve the indexing status.\n   * @throws {Error} If there is an error invoking the `documentsUploadStatus` action.\n   */\n  public getIndexingStatus(token: string): Observable<IndexingInfos> {\n    const data = {\n      action: \"documentsUploadStatus\",\n      appName: this.appService.appName,\n      statusToken: token,\n      debug: this.chatService.assistantConfig$.value!.defaultValues.debug\n    };\n\n    return from(post<IndexingInfos>(`plugin/${this.REQUEST_URL}`, data)).pipe(\n      catchError((error) => {\n        throw new Error(`Error invoking documentsUploadStatus: ${error}`);\n      })\n    );\n  }\n\n  /**\n   * Retrieves a list of uploaded documents.\n   *\n   * @param {string[]} [columns] - Optional array of additional index columns to include for each document.\n   * @param {number} [skip] - Optional number of documents to skip for pagination. If set, count also needs to be set. No skip if not set.\n   * @param {number} [count] - Optional number of documents to take for pagination (unlimited if not set).\n   * @returns {Observable<UploadedDocuments>} An observable that emits the list of uploaded documents.\n   * The `UploadedDocuments` object contains:\n   * - `docs`: array - An array of objects representing a single document with the following properties:\n   *   - * `id`: string - A unique identifier for the document.\n   *   - * `fileName`: string - The name of the file.\n   *   - * `title`: string - The title of the document.\n   *   - * `fileExt`: string - The file extension of the document.\n   *   - * `indexationTime`: string - The time when the document was indexed.\n   *   - * `size`: number - The size of the document.\n   *   - * `sizeDisplay`: string - A human-readable representation of the document size.\n   *   - * `[key: string]`: any - Additional columns asked in the request, value of the column for the document.\n   * - `count`: number - The count of documents in the current batch or subset.\n   * - `totalCount`: number - The total count of documents available.\n   * - `executionTime`: string - The time taken to process the documents.\n   * @throws {Error} Throws an error if the request fails.\n   */\n  public getDocumentsList(columns?: string[], skip?: number, count?: number): Observable<UploadedDocuments> {\n    const data = {\n      action: \"documentsList\",\n      appName: this.appService.appName,\n      debug: this.chatService.assistantConfig$.value!.defaultValues.debug\n    };\n\n    if (columns) data[\"columns\"] = columns;\n    if (skip) data[\"skip\"] = skip;\n    if (count) data[\"count\"] = count;\n\n    return from(post<UploadedDocuments>(`plugin/${this.REQUEST_URL}`, data)).pipe(\n      catchError((error) => {\n        throw new Error(`Error invoking documentsList: ${error}`);\n      })\n    );\n  }\n\n  /**\n   * Deletes the uploaded documents with the specified IDs.\n   *\n   * @param docIds - An array of document IDs to delete.\n   * @returns An observable that emits the server response of type `deleteDocumentsResponse`.\n   * The `deleteDocumentsResponse` object contains:\n   * - `deletedCount`: number - The number of deleted documents.\n   * - `executionTime`: string - The time taken to delete the documents.\n   * @throws {Error} If there is an error invoking the `documentsDelete` action.\n   */\n  public deleteDocuments(docIds: string[]): Observable<deleteDocumentsResponse> {\n    const data = {\n      action: \"documentsDelete\",\n      docIds,\n      appName: this.appService.appName,\n      debug: this.chatService.assistantConfig$.value!.defaultValues.debug\n    };\n\n    return from(post<deleteDocumentsResponse>(`plugin/${this.REQUEST_URL}`, data)).pipe(\n      catchError((error) => {\n        throw new Error(`Error invoking documentsDelete: ${error}`);\n      })\n    );\n  }\n\n  /**\n   * Deletes all uploaded documents.\n   *\n   * @returns An observable that emits the server response of type `deleteDocumentsResponse`.\n   * The `deleteDocumentsResponse` object contains:\n   * - `deletedCount`: number - The number of deleted documents.\n   * - `executionTime`: string - The time taken to delete the documents.\n   * @throws {Error} If there is an error invoking the `documentsDeleteAll` action.\n   */\n  public deleteAllDocuments(): Observable<deleteDocumentsResponse> {\n    const data = {\n      action: \"documentsDeleteAll\",\n      appName: this.appService.appName,\n      debug: this.chatService.assistantConfig$.value!.defaultValues.debug\n    };\n\n    return from(post<deleteDocumentsResponse>(`plugin/${this.REQUEST_URL}`, data)).pipe(\n      catchError((error) => {\n        throw new Error(`Error invoking documentsDeleteAll: ${error}`);\n      })\n    );\n  }\n\n  /**\n   * Formats the given file size in bytes into a human-readable string.\n   *\n   * @param bytes - The size of the file in bytes.\n   * @returns A string representing the file size in a human-readable format (e.g., \"10.24 KB\", \"1.00 MB\").\n   */\n  public formatFileSize(bytes: number): string {\n    if (bytes === 0) return \"0 Bytes\";\n    const k = 1024;\n    const sizes = [\"Bytes\", \"KB\", \"MB\", \"GB\", \"TB\"];\n    const i = Math.floor(Math.log(bytes) / Math.log(k));\n    return (\n      Number.parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + \" \" + sizes[i]\n    );\n  }\n\n  /**\n   * Converts the given file size in bytes into megabytes.\n   *\n   * @param bytes - The size of the file in bytes.\n   * @returns The size of the file in megabytes.\n   */\n  public convertBytesToMB(bytes: number): number {\n    return bytes / (1024 * 1024);\n  }\n\n}\n"]}

package/{esm2020 → esm2022}/chat/format-icon/format-icon.component.mjs

@@ -1,23 +1,23 @@
-import { Component, Input, ViewEncapsulation } from '@angular/core';
-import { defaultFormatIcons } from './icons';
-import { CommonModule } from '@angular/common';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
-export class FormatIconComponent {
-    constructor() {
-        this._formatIcons = defaultFormatIcons;
-    }
-    ngOnChanges() {
-        const icon = this.extension ? this._formatIcons[this.extension] : undefined;
-        this.icon = icon?.icon || this._formatIcons.file.icon;
-    }
-}
-FormatIconComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: FormatIconComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-FormatIconComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.0.6", type: FormatIconComponent, isStandalone: true, selector: "sq-format-icon", inputs: { extension: "extension" }, usesOnChanges: true, ngImport: i0, template: "<span *ngIf=\"icon\" class=\"{{icon}}\"></span>", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], encapsulation: i0.ViewEncapsulation.None });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.0.6", ngImport: i0, type: FormatIconComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'sq-format-icon', encapsulation: ViewEncapsulation.None, standalone: true, imports: [CommonModule], template: "<span *ngIf=\"icon\" class=\"{{icon}}\"></span>" }]
-        }], propDecorators: { extension: [{
-                type: Input
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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
+import { Component, Input, ViewEncapsulation } from '@angular/core';
+import { defaultFormatIcons } from './icons';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class FormatIconComponent {
+    constructor() {
+        this._formatIcons = defaultFormatIcons;
+    }
+    ngOnChanges() {
+        const icon = this.extension ? this._formatIcons[this.extension] : undefined;
+        this.icon = icon?.icon || this._formatIcons.file.icon;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormatIconComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: FormatIconComponent, isStandalone: true, selector: "sq-format-icon", inputs: { extension: "extension" }, usesOnChanges: true, ngImport: i0, template: "<span *ngIf=\"icon\" class=\"{{icon}}\"></span>", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormatIconComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sq-format-icon', encapsulation: ViewEncapsulation.None, standalone: true, imports: [CommonModule], template: "<span *ngIf=\"icon\" class=\"{{icon}}\"></span>" }]
+        }], propDecorators: { extension: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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