@sinequa/atomic-angular 0.0.140

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

@@ -0,0 +1,104 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { catchError, map, tap, throwError } from 'rxjs';
+import { escapeExpr, globalConfig } from '@sinequa/atomic';
+import { AggregationsStore, AppStore } from '../stores';
+import { QueryService } from './query.service';
+import * as i0 from "@angular/core";
+export class AggregationsService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.queryService = inject(QueryService);
+        this.appStore = inject(AppStore);
+        this.aggregationsStore = inject(AggregationsStore);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    loadMore(query, aggregation, audit) {
+        const { app } = globalConfig;
+        // skip cached items for computation
+        const skip = aggregation.items?.filter(i => !(i.$cached))?.length || 0;
+        const count = 10;
+        const aggregations = { [aggregation.name]: { skip, count } };
+        const q = { ...query, action: "aggregate", aggregations };
+        // add audit record if available
+        const $auditRecord = audit ? { auditEvents: [audit] } : undefined;
+        const body = {
+            app,
+            query: q,
+            $auditRecord
+        };
+        return this.http.post(this.API_URL + "/query", body).pipe(map(result => {
+            const { aggregations } = result;
+            const agg = aggregations[0];
+            if (agg.items) {
+                agg.$hasMore = agg.items.length > count;
+                agg.items = [...aggregation.items, ...agg.items];
+            }
+            else {
+                aggregation.$hasMore = false;
+                return aggregation;
+            }
+            return agg;
+        }), catchError(error => {
+            console.log("aggregation.loadMore failure - error: ", error);
+            return throwError(() => new Error(error));
+        }), tap(response => console.log("aggregation.loadMore success - data: ", response)));
+    }
+    open(query, aggregation, item) {
+        const value = `/${item.$path}/*`;
+        const expression = `${aggregation.column}: ${escapeExpr(value)}`;
+        const q = {
+            ...query,
+            action: "open",
+            open: [{ expression, aggregation: aggregation.name }]
+        };
+        return this.queryService.search(q).pipe(map(results => {
+            // find the node in the tree and replace it with the new one
+            const items = results.aggregations[0].items;
+            const newNode = this.findNode(items, item.$path);
+            if (!newNode) {
+                return aggregation;
+            }
+            // mark the node as opened
+            newNode.$opened = true;
+            return this.replaceInTree(aggregation, item.$path, newNode);
+        }));
+    }
+    findNode(items, path = "") {
+        if (!items || items.length === 0) {
+            return undefined;
+        }
+        for (const item of items) {
+            if (item.$path === path) {
+                return item;
+            }
+            if (item.items) {
+                const found = this.findNode(item.items, path);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return undefined;
+    }
+    replaceInTree(tree, valueToFind = "", newValue) {
+        if (tree.$path === valueToFind) {
+            return newValue;
+        }
+        if (tree.hasChildren && tree.items) {
+            for (let i = 0; i < tree.items.length; i++) {
+                tree.items[i] = this.replaceInTree(tree.items[i], valueToFind, newValue);
+            }
+        }
+        return tree;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AggregationsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AggregationsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AggregationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aggregations.service.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/web-services/aggregations.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { Observable, catchError, map, tap, throwError } from 'rxjs';\r\n\r\nimport { Aggregation, AuditEvents, Query, Result, TreeAggregation, TreeAggregationNode, escapeExpr, globalConfig } from '@sinequa/atomic';\r\n\r\nimport { AggregationsStore, AppStore } from '../stores';\r\nimport { QueryService } from './query.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AggregationsService {\r\n  protected readonly http = inject(HttpClient);\r\n  protected readonly queryService = inject(QueryService);\r\n\r\n  appStore = inject(AppStore);\r\n  aggregationsStore = inject(AggregationsStore);\r\n\r\n  protected API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;\r\n\r\n  loadMore(query: Partial<Query>, aggregation: Aggregation, audit?: AuditEvents): Observable<Aggregation> {\r\n    const { app } = globalConfig;\r\n\r\n    // skip cached items for computation\r\n    const skip = aggregation.items?.filter(i => !(i.$cached))?.length || 0;\r\n    const count = 10;\r\n\r\n    const aggregations = { [aggregation.name]: { skip, count } };\r\n\r\n    const q: Partial<Query> = { ...query, action: \"aggregate\", aggregations }\r\n\r\n    // add audit record if available\r\n    const $auditRecord = audit ? { auditEvents: [audit] } : undefined;\r\n\r\n    const body = {\r\n      app,\r\n      query: q,\r\n      $auditRecord\r\n    };\r\n\r\n    return this.http.post(this.API_URL + \"/query\", body).pipe(\r\n      map(result => {\r\n        const { aggregations } = result as Result;\r\n        const agg = aggregations[0];\r\n\r\n        if (agg.items) {\r\n          agg.$hasMore = agg.items.length > count;\r\n          agg.items = [...aggregation.items, ...agg.items];\r\n        } else {\r\n          aggregation.$hasMore = false;\r\n          return aggregation;\r\n        }\r\n\r\n        return agg;\r\n      }),\r\n      catchError(error => {\r\n        console.log(\"aggregation.loadMore failure - error: \", error);\r\n        return throwError(() => new Error(error));\r\n      }),\r\n      tap(response => console.log(\"aggregation.loadMore success - data: \", response)),\r\n    );\r\n  }\r\n\r\n  open(query: Partial<Query>, aggregation: TreeAggregation, item: TreeAggregationNode): Observable<TreeAggregation> {\r\n    const value = `/${item.$path}/*`;\r\n    const expression = `${aggregation.column}: ${escapeExpr(value)}`;\r\n\r\n    const q: Partial<Query> = {\r\n      ...query,\r\n      action: \"open\",\r\n      open: [{ expression, aggregation: aggregation.name }]\r\n    };\r\n\r\n    return this.queryService.search(q).pipe(\r\n      map(results => {\r\n        // find the node in the tree and replace it with the new one\r\n        const items = results.aggregations[0].items as TreeAggregationNode[];\r\n        const newNode = this.findNode(items, item.$path);\r\n\r\n        if (!newNode) {\r\n          return aggregation;\r\n        }\r\n        // mark the node as opened\r\n        newNode.$opened = true;\r\n        return this.replaceInTree(aggregation, item.$path, newNode) as TreeAggregation;\r\n      })\r\n    )\r\n  }\r\n  private findNode(items: TreeAggregationNode[], path: string = \"\"): TreeAggregationNode | undefined {\r\n    if (!items || items.length === 0) {\r\n      return undefined;\r\n    }\r\n\r\n    for (const item of items) {\r\n      if (item.$path === path) {\r\n        return item;\r\n      }\r\n      if(item.items) {\r\n        const found = this.findNode(item.items, path);\r\n        if (found) {\r\n          return found;\r\n        }\r\n      }\r\n    }\r\n\r\n    return undefined;\r\n  }\r\n\r\n  private replaceInTree(tree: any, valueToFind: string = \"\", newValue: TreeAggregationNode) {\r\n    if (tree.$path === valueToFind) {\r\n      return newValue;\r\n    }\r\n\r\n    if (tree.hasChildren && tree.items) {\r\n      for (let i = 0; i < tree.items.length; i++) {\r\n        tree.items[i] = this.replaceInTree(tree.items[i], valueToFind, newValue);\r\n      }\r\n    }\r\n\r\n    return tree;\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,48 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { catchError, EMPTY } from 'rxjs';
+import { globalConfig } from '@sinequa/atomic';
+import * as i0 from "@angular/core";
+export class AppService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    /**
+     * Retrieves the application configuration from the server.
+     *
+     * @param appName - The name of the application to fetch the configuration for.
+     *
+     * @returns {Observable<CCApp>} An observable that emits the application configuration.
+     *
+     * @remarks
+     * This method constructs an HTTP GET request to fetch the application configuration
+     * using the `app` parameter from the global configuration. If the request fails,
+     * it logs the error to the console and returns an empty observable.
+     *
+     * @example
+     * ```typescript
+     * appService.getApp().subscribe(appConfig => {
+     *   console.log(appConfig);
+     * });
+     * ```
+     */
+    getApp(appName) {
+        const app = appName || globalConfig.app;
+        const params = new HttpParams().set('app', app || '');
+        return this.http.get(this.API_URL + "/app", { params })
+            .pipe(catchError(error => {
+            console.error("AppService.getApp failure - error: ", error);
+            return EMPTY;
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AppService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AppService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AppService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,122 @@
+import { HttpClient } from "@angular/common/http";
+import { Injectable, computed, inject } from "@angular/core";
+import { Router } from "@angular/router";
+import { getState } from "@ngrx/signals";
+import { globalConfig } from "@sinequa/atomic";
+import { AppStore } from '../stores/app.store';
+import * as i0 from "@angular/core";
+export class AuditService {
+    constructor() {
+        this.appStore = inject(AppStore);
+        this.app = computed(() => getState(this.appStore));
+        this.http = inject(HttpClient);
+        this.router = inject(Router);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+        this.lastClickTime = 0;
+    }
+    /**
+     * Notify the Sinequa server of a set of audit events
+     *
+     * @param auditEvents The audit events
+     */
+    notify(auditEvents) {
+        this.http.post(this.API_URL + "/audit.notify", {
+            event: "None", // AuditEventType.None,
+            app: this.app().name,
+            $auditRecord: { auditEvents: [auditEvents] }
+        }).subscribe();
+    }
+    /**
+     * It sends an audit event to the Audit Service.
+     */
+    notifyLogin() {
+        this.notify({
+            type: "Login_Success_Form" // AuditEventType.Search_Login_Success
+        });
+    }
+    /**
+     * Notify logout
+     */
+    notifyLogout() {
+        this.notify({
+            type: "Search_Exit_Logout" // AuditEventType.Search_Exit_Logout
+        });
+    }
+    /**
+       * Notify the Sinequa server of a document event
+       *
+       * @param evt The audit event type
+       * @param doc The document (article) in question
+       * @param resultId The resultid that contain the document
+       * @param parameters Additional parameters
+       */
+    notifyDocument(auditEventType, doc, resultsOrId, parameters, rfmParameters) {
+        let resultId;
+        let result;
+        if (typeof resultsOrId == "string") {
+            resultId = resultsOrId;
+        }
+        else {
+            result = resultsOrId;
+            resultId = result ? result.id : null;
+        }
+        const detail = {
+            docid: doc.id,
+            rank: doc.rank,
+            title: doc.title,
+            source: doc.collection[0].split("/")[0],
+            collection: doc.collection[0],
+            resultId,
+            filename: doc.filename,
+            fileext: doc.fileext,
+            index: doc.databasealias,
+            resultcount: result?.totalRowCount
+        };
+        if (parameters) {
+            Object.keys(parameters).forEach(key => detail[key] = parameters[key]);
+        }
+        const data = {
+            type: auditEventType,
+            detail
+        };
+        if (rfmParameters) {
+            const rfmDetail = {}; // Add index signature
+            Object.keys(rfmParameters).forEach(key => rfmDetail[key] = rfmParameters[key]);
+            data.rfmDetail = rfmDetail;
+        }
+        this.lastClickTime = Date.now();
+        // Listen to the navigation event outside the app
+        document.addEventListener('visibilitychange', () => {
+            // Capture the navigation even triggered just after the click
+            if (document.visibilityState === 'hidden' && (Date.now() - this.lastClickTime) < 1000) {
+                // Second event triggered when we come back
+                document.addEventListener('visibilitychange', () => {
+                    if (document.visibilityState === 'visible') {
+                        this.notify({ type: "Navigation_Return" /* AuditEventType.Navigation_Return */ });
+                    }
+                }, { once: true });
+            }
+        }, { once: true });
+        this.notify(data);
+    }
+    /**
+     * Notify route change
+     */
+    notifyRouteChange(url) {
+        this.notify({
+            type: "Navigation_Route", // AuditEventType.Navigation_Route,
+            detail: {
+                detail: url
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AuditService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AuditService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: AuditService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"audit.service.js","sourceRoot":"","sources":["../../../../../projects/atomic-angular/src/lib/web-services/audit.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from \"@angular/common/http\";\r\nimport { Injectable, computed, inject } from \"@angular/core\";\r\nimport { Router } from \"@angular/router\";\r\nimport { getState } from \"@ngrx/signals\";\r\nimport { Article, AuditEvent, AuditEvents, AuditEventType, AuditEventTypeValues, CCApp, globalConfig, Result } from \"@sinequa/atomic\";\r\nimport { AppStore } from '../stores/app.store';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AuditService {\r\n  appStore = inject(AppStore);\r\n  app = computed(() => getState(this.appStore) as CCApp);\r\n\r\n  protected readonly http = inject(HttpClient);\r\n  protected readonly router = inject(Router);\r\n  protected readonly API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;\r\n\r\n  protected lastClickTime = 0;\r\n\r\n  /**\r\n   * Notify the Sinequa server of a set of audit events\r\n   *\r\n   * @param auditEvents The audit events\r\n   */\r\n  notify(auditEvents: AuditEvents) {\r\n    this.http.post<void>(this.API_URL + \"/audit.notify\", {\r\n      event: \"None\", // AuditEventType.None,\r\n      app: this.app().name,\r\n      $auditRecord: {auditEvents: [auditEvents]}\r\n    }).subscribe();\r\n  }\r\n\r\n  /**\r\n   * It sends an audit event to the Audit Service.\r\n   */\r\n  notifyLogin() {\r\n    this.notify({\r\n      type: \"Login_Success_Form\" // AuditEventType.Search_Login_Success\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Notify logout\r\n   */\r\n  notifyLogout() {\r\n    this.notify({\r\n      type: \"Search_Exit_Logout\" // AuditEventType.Search_Exit_Logout\r\n    });\r\n  }\r\n\r\n  /**\r\n     * Notify the Sinequa server of a document event\r\n     *\r\n     * @param evt The audit event type\r\n     * @param doc The document (article) in question\r\n     * @param resultId The resultid that contain the document\r\n     * @param parameters Additional parameters\r\n     */\r\n  notifyDocument(\r\n    auditEventType: AuditEventType | AuditEventTypeValues | {} & Record<never, never>,\r\n    doc: Article,\r\n    resultsOrId: Result | string,\r\n    parameters?: Record<string, string | number | boolean | undefined>,\r\n    rfmParameters?: Record<string, string | number | boolean | undefined>) {\r\n    let resultId: string | null;\r\n    let result: Result | undefined;\r\n    if (typeof resultsOrId == \"string\") {\r\n      resultId = resultsOrId;\r\n    }\r\n    else {\r\n      result = resultsOrId;\r\n      resultId = result ? result.id : null;\r\n    }\r\n\r\n    const detail: any = {\r\n      docid: doc.id,\r\n      rank: doc.rank,\r\n      title: doc.title,\r\n      source: doc.collection[0].split(\"/\")[0],\r\n      collection: doc.collection[0],\r\n      resultId,\r\n      filename: doc.filename,\r\n      fileext: doc.fileext,\r\n      index: doc.databasealias,\r\n      resultcount: result?.totalRowCount\r\n    };\r\n\r\n    if (parameters) {\r\n      Object.keys(parameters).forEach(key => detail[key] = parameters[key]);\r\n    }\r\n    const data: AuditEvent = {\r\n      type: auditEventType,\r\n      detail\r\n    };\r\n\r\n    if (rfmParameters) {\r\n      const rfmDetail: Record<string, string | number | boolean | undefined> = {}; // Add index signature\r\n      Object.keys(rfmParameters).forEach(key => rfmDetail[key] = rfmParameters[key]);\r\n      data.rfmDetail = rfmDetail;\r\n    }\r\n\r\n    this.lastClickTime = Date.now();\r\n\r\n    // Listen to the navigation event outside the app\r\n    document.addEventListener('visibilitychange', () => {\r\n      // Capture the navigation even triggered just after the click\r\n      if (document.visibilityState === 'hidden' && (Date.now() - this.lastClickTime) < 1000) {\r\n        // Second event triggered when we come back\r\n        document.addEventListener('visibilitychange', () => {\r\n          if (document.visibilityState === 'visible') {\r\n            this.notify({ type: AuditEventType.Navigation_Return });\r\n          }\r\n        }, { once: true });\r\n      }\r\n    }, { once: true });\r\n\r\n    this.notify(data);\r\n  }\r\n\r\n  /**\r\n   * Notify route change\r\n   */\r\n  notifyRouteChange(url: string,) {\r\n    this.notify({\r\n      type: \"Navigation_Route\", // AuditEventType.Navigation_Route,\r\n      detail: {\r\n        detail: url\r\n      }\r\n    });\r\n\r\n  }\r\n}"]}

package/esm2022/lib/web-services/index.mjs

@@ -0,0 +1,10 @@
+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";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hdG9taWMtYW5ndWxhci9zcmMvbGliL3dlYi1zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcclxuZXhwb3J0ICogZnJvbSBcIi4vYWdncmVnYXRpb25zLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vYXBwLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vanNvbi1tZXRob2QtcGx1Z2luLnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vcHJldmlldy5zZXJ2aWNlXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL3ByaW5jaXBhbC5zZXJ2aWNlXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL3F1ZXJ5LnNlcnZpY2VcIjtcclxuZXhwb3J0ICogZnJvbSBcIi4vdGV4dC1jaHVuY2suc2VydmljZVwiO1xyXG5leHBvcnQgKiBmcm9tIFwiLi9hdWRpdC5zZXJ2aWNlXCI7XHJcbmV4cG9ydCAqIGZyb20gXCIuL2F1ZGl0LnNlcnZpY2VcIjsiXX0=

package/esm2022/lib/web-services/json-method-plugin.service.mjs

@@ -0,0 +1,54 @@
+import { HttpClient, HttpParams } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { globalConfig, isObject } from '@sinequa/atomic';
+import { throwError } from 'rxjs';
+import * as i0 from "@angular/core";
+export class JsonMethodPluginService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.API_URL = `${globalConfig.backendUrl}/${globalConfig.apiPath}`;
+    }
+    /**
+     * Call a JsonMethod plugin using an HTTP POST
+     *
+     * @param method The name of the JsonMethod plugin
+     * @param query Parameters to pass to the plugin
+     * @param options HTTP options for the request
+     * @returns An observable of the plugin's return value
+     */
+    post(method, query, options) {
+        if (!isObject(query)) {
+            return throwError(() => ({ error: "invalid query object" }));
+        }
+        return this.http.post(`${this.API_URL}/plugin/${method}`, query, options);
+    }
+    /**
+     * Call a JsonMethod plugin using an HTTP GET
+     *
+     * @param method The name of the JsonMethod plugin
+     * @param query Parameters to pass to the plugin
+     * @param options HTTP options for the request
+     * @returns An observable of the plugin's return value
+     */
+    get(method, query, options) {
+        const params = new HttpParams();
+        for (const key in query) {
+            if (query[key] !== undefined) {
+                params.set(key, query[key]);
+            }
+        }
+        return this.http.get(`${this.API_URL}/plugin/${method}`, {
+            params: params,
+            ...options
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: JsonMethodPluginService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: JsonMethodPluginService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: JsonMethodPluginService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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