@sisense/sdk-ui-angular 1.33.0 → 2.0.0

package/dist/esm2020/lib/services/dashboard.service.mjs

@@ -1,7 +1,10 @@
 import { __decorate } from "tslib";
 import { Injectable } from '@angular/core';
-import { getDashboardModel, getDashboardModels, } from '@sisense/sdk-ui-preact';
+import { createHookApiFacade, getDashboardModel, getDashboardModels, HookAdapter, useComposedDashboardInternal, } from '@sisense/sdk-ui-preact';
+import { BehaviorSubject } from 'rxjs';
+import { createSisenseContextConnector } from '../component-wrapper-helpers';
 import { TrackableService } from '../decorators/trackable.decorator';
+import { translateFromPreactDashboardProps, translateToPreactDashboardProps, } from '../helpers/dashboard-props-preact-translator';
 import * as i0 from "@angular/core";
 import * as i1 from "./sisense-context.service";
 /**
@@ -37,6 +40,87 @@ let DashboardService = class DashboardService {
         const app = await this.sisenseContextService.getApp();
         return getDashboardModels(app.httpClient, options);
     }
+    /**
+     * Сomposes dashboard or separate dashboard elements into a coordinated dashboard
+     * with cross filtering, and change detection.
+     *
+     * @example
+     * An example of using the `createComposedDashboard` to construct a composed dashboard and render it:
+     * ```html
+      <!--Component HTML template in example.component.html-->
+      <div *ngIf="dashboard$ | async as dashboard">
+        <csdk-filter-tile
+          *ngFor="let filter of getDashboardFilters(dashboard); trackBy: trackByIndex"
+          [filter]="filter"
+        />
+        <csdk-widget
+          *ngFor="let widget of dashboard.widgets; trackBy: trackByIndex"
+          [id]="widget.id"
+          [widgetType]="widget.widgetType"
+          [chartType]="widget.chartType"
+          [pluginType]="widget.pluginType"
+          [dataSource]="widget.dataSource"
+          [dataOptions]="widget.dataOptions"
+          [filters]="widget.filters"
+          [highlights]="widget.highlights"
+          [styleOptions]="widget.styleOptions"
+          [drilldownOptions]="widget.drilldownOptions"
+          [title]="widget.title"
+          [description]="widget.description"
+          [beforeMenuOpen]="widget.beforeMenuOpen"
+          (dataPointClick)="widget.dataPointClick?.($event)"
+          (dataPointContextMenu)="widget.dataPointContextMenu?.($event)"
+          (dataPointsSelect)="widget.dataPointsSelect?.($event)"
+        />
+      </div>
+     * ```
+     *
+     * ```ts
+      // Component behavior in example.component.ts
+      import { Component } from '@angular/core';
+      import { BehaviorSubject } from 'rxjs';
+      import { DashboardService, type DashboardProps } from '@sisense/sdk-ui-angular';
+  
+      @Component({
+        selector: 'example',
+        templateUrl: './example.component.html',
+        styleUrls: ['./example.component.scss'],
+      })
+      export class ExampleComponent {
+        dashboard$: BehaviorSubject<DashboardProps> | undefined;
+  
+        constructor(private dashboardService: DashboardService) {}
+  
+        ngOnInit() {
+          const initialDashboard: DashboardProps = { ... };
+          const composedDashboard = this.dashboardService.createComposedDashboard(initialDashboard);
+          this.dashboard$ = composedDashboard.dashboard$;
+        }
+  
+        trackByIndex = (index: number) => index;
+  
+        getDashboardFilters = ({ filters }: DashboardProps) => Array.isArray(filters) ? filters : [];
+      }
+     * ```
+     * @param initialDashboard - Initial dashboard
+     * @param options - Configuration options
+     * @returns Reactive composed dashboard object and API methods for interacting with it
+     */
+    createComposedDashboard(initialDashboard, options = {}) {
+        const hookAdapter = new HookAdapter((useComposedDashboardInternal), [createSisenseContextConnector(this.sisenseContextService)]);
+        const dashboard$ = new BehaviorSubject(initialDashboard);
+        hookAdapter.subscribe(({ dashboard }) => {
+            dashboard$.next(translateFromPreactDashboardProps(dashboard));
+        });
+        hookAdapter.run(translateToPreactDashboardProps(initialDashboard), options);
+        const setFilters = createHookApiFacade(hookAdapter, 'setFilters', true);
+        const setWidgetsLayout = createHookApiFacade(hookAdapter, 'setWidgetsLayout', true);
+        return {
+            dashboard$,
+            setFilters,
+            setWidgetsLayout,
+        };
+    }
 };
 DashboardService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DashboardService, deps: [{ token: i1.SisenseContextService }], target: i0.ɵɵFactoryTarget.Injectable });
 DashboardService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DashboardService, providedIn: 'root' });
@@ -50,4 +134,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i1.SisenseContextService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.service.js","sourceRoot":"","sources":["../../../../src/lib/services/dashboard.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAEL,mBAAmB,EAEnB,iBAAiB,EAEjB,kBAAkB,EAElB,WAAW,EACX,4BAA4B,GAG7B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAEvC,OAAO,EAAE,6BAA6B,EAAE,MAAM,8BAA8B,CAAC;AAG7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,EACL,iCAAiC,EACjC,+BAA+B,GAChC,MAAM,8CAA8C,CAAC;;;AAOtD;;;;;;;GAOG;AAKI,IAAM,gBAAgB,GAAtB,MAAM,gBAAgB;IAC3B,YAAoB,qBAA4C;QAA5C,0BAAqB,GAArB,qBAAqB,CAAuB;IAAG,CAAC;IAEpE;;;;;;OAMG;IACH,KAAK,CAAC,iBAAiB,CAAC,YAAoB,EAAE,OAAkC;QAC9E,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,CAAC;QACtD,OAAO,iBAAiB,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,kBAAkB,CAAC,OAAmC;QAC1D,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,CAAC;QACtD,OAAO,kBAAkB,CAAC,GAAG,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACrD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiEG;IACH,uBAAuB,CACrB,gBAAmB,EACnB,UAAuC,EAAE;QAMzC,MAAM,WAAW,GAAG,IAAI,WAAW,CACjC,CAAA,4BAAmF,CAAA,EACnF,CAAC,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAC5D,CAAC;QACF,MAAM,UAAU,GAAG,IAAI,eAAe,CAAI,gBAAgB,CAAC,CAAC;QAE5D,WAAW,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE;YACtC,UAAU,CAAC,IAAI,CAAC,iCAAiC,CAAC,SAAS,CAAM,CAAC,CAAC;QACrE,CAAC,CAAC,CAAC;QAEH,WAAW,CAAC,GAAG,CACb,+BAA+B,CAAC,gBAAgB,CAExB,EACxB,OAAO,CACR,CAAC;QAEF,MAAM,UAAU,GAAG,mBAAmB,CAAC,WAAW,EAAE,YAAY,EAAE,IAAI,CAAC,CAAC;QACxE,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,WAAW,EAAE,kBAAkB,EAAE,IAAI,CAAC,CAAC;QAEpF,OAAO;YACL,UAAU;YACV,UAAU;YACV,gBAAgB;SACjB,CAAC;IACJ,CAAC;;8GA7HU,gBAAgB;kHAAhB,gBAAgB,cAHf,MAAM;AAGP,gBAAgB;IAD5B,gBAAgB,CAAmB,CAAC,mBAAmB,EAAE,oBAAoB,CAAC,CAAC;GACnE,gBAAgB,CA8H5B;SA9HY,gBAAgB;4FAAhB,gBAAgB;kBAJ5B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Filter, FilterRelations } from '@sisense/sdk-data';\nimport {\n  type ComposableDashboardProps as ComposableDashboardPropsPreact,\n  createHookApiFacade,\n  type DashboardProps as DashboardPropsPreact,\n  getDashboardModel,\n  type GetDashboardModelOptions,\n  getDashboardModels,\n  type GetDashboardModelsOptions,\n  HookAdapter,\n  useComposedDashboardInternal,\n  UseComposedDashboardOptions,\n  WidgetsPanelLayout,\n} from '@sisense/sdk-ui-preact';\nimport { BehaviorSubject } from 'rxjs';\n\nimport { createSisenseContextConnector } from '../component-wrapper-helpers';\nimport { type DashboardProps } from '../components/dashboard/dashboard.component';\nimport { type WidgetProps } from '../components/widgets/widget.component';\nimport { TrackableService } from '../decorators/trackable.decorator';\nimport {\n  translateFromPreactDashboardProps,\n  translateToPreactDashboardProps,\n} from '../helpers/dashboard-props-preact-translator';\nimport { SisenseContextService } from './sisense-context.service';\n\nexport interface ComposableDashboardProps extends Omit<ComposableDashboardPropsPreact, 'widgets'> {\n  widgets: WidgetProps[];\n}\n\n/**\n * Service for working with Sisense Fusion dashboards.\n *\n * **Note:** Dashboard and Widget extensions based on JS scripts and add-ons in Fusion – for example, Blox and Jump To Dashboard – are not supported.\n *\n * @group Fusion Assets\n * @fusionEmbed\n */\n@Injectable({\n  providedIn: 'root',\n})\n@TrackableService<DashboardService>(['getDashboardModel', 'getDashboardModels'])\nexport class DashboardService {\n  constructor(private sisenseContextService: SisenseContextService) {}\n\n  /**\n   * Retrieves an existing dashboard model from the Sisense instance.\n   *\n   * @param dashboardOid - Identifier of the dashboard\n   * @param options - Advanced configuration options\n   * @returns Dashboard model\n   */\n  async getDashboardModel(dashboardOid: string, options?: GetDashboardModelOptions) {\n    const app = await this.sisenseContextService.getApp();\n    return getDashboardModel(app.httpClient, dashboardOid, options);\n  }\n\n  /**\n   * Retrieves existing dashboard models from the Sisense instance.\n   *\n   * @param options - Advanced configuration options\n   * @returns Dashboard models array\n   */\n  async getDashboardModels(options?: GetDashboardModelsOptions) {\n    const app = await this.sisenseContextService.getApp();\n    return getDashboardModels(app.httpClient, options);\n  }\n\n  /**\n   * Сomposes dashboard or separate dashboard elements into a coordinated dashboard\n   * with cross filtering, and change detection.\n   *\n   * @example\n   * An example of using the `createComposedDashboard` to construct a composed dashboard and render it:\n   * ```html\n    <!--Component HTML template in example.component.html-->\n    <div *ngIf=\"dashboard$ | async as dashboard\">\n      <csdk-filter-tile\n        *ngFor=\"let filter of getDashboardFilters(dashboard); trackBy: trackByIndex\"\n        [filter]=\"filter\"\n      />\n      <csdk-widget\n        *ngFor=\"let widget of dashboard.widgets; trackBy: trackByIndex\"\n        [id]=\"widget.id\"\n        [widgetType]=\"widget.widgetType\"\n        [chartType]=\"widget.chartType\"\n        [pluginType]=\"widget.pluginType\"\n        [dataSource]=\"widget.dataSource\"\n        [dataOptions]=\"widget.dataOptions\"\n        [filters]=\"widget.filters\"\n        [highlights]=\"widget.highlights\"\n        [styleOptions]=\"widget.styleOptions\"\n        [drilldownOptions]=\"widget.drilldownOptions\"\n        [title]=\"widget.title\"\n        [description]=\"widget.description\"\n        [beforeMenuOpen]=\"widget.beforeMenuOpen\"\n        (dataPointClick)=\"widget.dataPointClick?.($event)\"\n        (dataPointContextMenu)=\"widget.dataPointContextMenu?.($event)\"\n        (dataPointsSelect)=\"widget.dataPointsSelect?.($event)\"\n      />\n    </div>\n   * ```\n   *\n   * ```ts\n    // Component behavior in example.component.ts\n    import { Component } from '@angular/core';\n    import { BehaviorSubject } from 'rxjs';\n    import { DashboardService, type DashboardProps } from '@sisense/sdk-ui-angular';\n\n    @Component({\n      selector: 'example',\n      templateUrl: './example.component.html',\n      styleUrls: ['./example.component.scss'],\n    })\n    export class ExampleComponent {\n      dashboard$: BehaviorSubject<DashboardProps> | undefined;\n\n      constructor(private dashboardService: DashboardService) {}\n\n      ngOnInit() {\n        const initialDashboard: DashboardProps = { ... };\n        const composedDashboard = this.dashboardService.createComposedDashboard(initialDashboard);\n        this.dashboard$ = composedDashboard.dashboard$;\n      }\n\n      trackByIndex = (index: number) => index;\n\n      getDashboardFilters = ({ filters }: DashboardProps) => Array.isArray(filters) ? filters : [];\n    }\n   * ```\n   * @param initialDashboard - Initial dashboard\n   * @param options - Configuration options\n   * @returns Reactive composed dashboard object and API methods for interacting with it\n   */\n  createComposedDashboard<D extends ComposableDashboardProps | DashboardProps>(\n    initialDashboard: D,\n    options: UseComposedDashboardOptions = {},\n  ): {\n    dashboard$: BehaviorSubject<D>;\n    setFilters: (filters: Filter[] | FilterRelations) => Promise<void>;\n    setWidgetsLayout: (newLayout: WidgetsPanelLayout) => Promise<void>;\n  } {\n    const hookAdapter = new HookAdapter(\n      useComposedDashboardInternal<ComposableDashboardPropsPreact | DashboardPropsPreact>,\n      [createSisenseContextConnector(this.sisenseContextService)],\n    );\n    const dashboard$ = new BehaviorSubject<D>(initialDashboard);\n\n    hookAdapter.subscribe(({ dashboard }) => {\n      dashboard$.next(translateFromPreactDashboardProps(dashboard) as D);\n    });\n\n    hookAdapter.run(\n      translateToPreactDashboardProps(initialDashboard) as\n        | ComposableDashboardPropsPreact\n        | DashboardPropsPreact,\n      options,\n    );\n\n    const setFilters = createHookApiFacade(hookAdapter, 'setFilters', true);\n    const setWidgetsLayout = createHookApiFacade(hookAdapter, 'setWidgetsLayout', true);\n\n    return {\n      dashboard$,\n      setFilters,\n      setWidgetsLayout,\n    };\n  }\n}\n"]}

package/dist/esm2020/lib/services/hierarchy.service.mjs

@@ -37,4 +37,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i1.SisenseContextService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/services/index.mjs

@@ -1,8 +1,8 @@
+export * from './dashboard.service';
+export * from './hierarchy.service';
+export * from './plugins.service';
 export * from './query.service';
 export * from './sisense-context.service';
 export * from './theme.service';
-export * from './plugins.service';
-export * from './dashboard.service';
 export * from './widget.service';
-export * from './hierarchy.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3F1ZXJ5LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zaXNlbnNlLWNvbnRleHQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3RoZW1lLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9wbHVnaW5zLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXNoYm9hcmQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3dpZGdldC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaGllcmFyY2h5LnNlcnZpY2UnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Rhc2hib2FyZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaGllcmFyY2h5LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9wbHVnaW5zLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyeS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc2lzZW5zZS1jb250ZXh0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90aGVtZS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0LnNlcnZpY2UnO1xuIl19

package/dist/esm2020/lib/services/plugins.service.mjs

@@ -52,4 +52,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/services/query.service.mjs

@@ -1,8 +1,9 @@
 import { __decorate } from "tslib";
 import { Injectable } from '@angular/core';
-import { executeQuery, executeQueryByWidgetId, executePivotQuery, } from '@sisense/sdk-ui-preact';
-import { TrackableService } from '../decorators/trackable.decorator';
 import { getFilterListAndRelationsJaql } from '@sisense/sdk-data';
+import { executePivotQuery, executeQuery, executeQueryByWidgetId, HookAdapter, useExecuteCsvQueryInternal, } from '@sisense/sdk-ui-preact';
+import { createSisenseContextConnector } from '../component-wrapper-helpers';
+import { TrackableService } from '../decorators/trackable.decorator';
 import * as i0 from "@angular/core";
 import * as i1 from "./sisense-context.service";
 /**
@@ -25,7 +26,7 @@ let QueryService = class QueryService {
      * @return Query result
      */
     async executeQuery(params) {
-        const { dataSource, dimensions, measures, filters, highlights, count, offset, beforeQuery, onBeforeQuery, } = params;
+        const { dataSource, dimensions, measures, filters, highlights, count, offset, ungroup, beforeQuery, } = params;
         const app = await this.sisenseContextService.getApp();
         const { filters: filterList, relations: filterRelations } = getFilterListAndRelationsJaql(filters);
         const data = await executeQuery({
@@ -37,7 +38,8 @@ let QueryService = class QueryService {
             highlights,
             count,
             offset,
-        }, app, { onBeforeQuery: beforeQuery ?? onBeforeQuery });
+            ungroup,
+        }, app, { onBeforeQuery: beforeQuery });
         return { data };
     }
     /**
@@ -51,7 +53,7 @@ let QueryService = class QueryService {
         return executeQueryByWidgetId({
             ...params,
             app,
-            onBeforeQuery: params.beforeQuery ?? params.onBeforeQuery,
+            onBeforeQuery: params.beforeQuery,
         });
     }
     /**
@@ -79,6 +81,33 @@ let QueryService = class QueryService {
         }, app, { onBeforeQuery: beforeQuery });
         return { data };
     }
+    /**
+     * Executes a CSV data query.
+     * Similar to {@link QueryService.executeQuery}, but returns the data in CSV format as text or as a stream.
+     *
+     * @param params - CSV query parameters
+     * @return CSV query result
+     */
+    async executeCsvQuery(params) {
+        const hookAdapter = new HookAdapter(useExecuteCsvQueryInternal, [
+            createSisenseContextConnector(this.sisenseContextService),
+        ]);
+        const resultPromise = new Promise((resolve, reject) => {
+            hookAdapter.subscribe((res) => {
+                const { data, isSuccess, isError, error } = res;
+                if (isSuccess) {
+                    resolve({ data });
+                }
+                else if (isError) {
+                    reject(error);
+                }
+            });
+        });
+        hookAdapter.run(params);
+        return resultPromise.finally(() => {
+            hookAdapter.destroy();
+        });
+    }
 };
 QueryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: QueryService, deps: [{ token: i1.SisenseContextService }], target: i0.ɵɵFactoryTarget.Injectable });
 QueryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: QueryService, providedIn: 'root' });
@@ -92,4 +121,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i1.SisenseContextService }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.service.js","sourceRoot":"","sources":["../../../../src/lib/services/query.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EACL,YAAY,EACZ,sBAAsB,EACtB,iBAAiB,GAIlB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;;;AAkClE;;;;GAIG;AAKI,IAAM,YAAY,GAAlB,MAAM,YAAY;IACvB,YAAoB,qBAA4C;QAA5C,0BAAqB,GAArB,qBAAqB,CAAuB;IAAG,CAAC;IAEpE;;;;;;;;;OASG;IACH,KAAK,CAAC,YAAY,CAAC,MAA0B;QAC3C,MAAM,EACJ,UAAU,EACV,UAAU,EACV,QAAQ,EACR,OAAO,EACP,UAAU,EACV,KAAK,EACL,MAAM,EACN,WAAW,EACX,aAAa,GACd,GAAG,MAAM,CAAC;QACX,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,CAAC;QACtD,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,EAAE,GACvD,6BAA6B,CAAC,OAAO,CAAC,CAAC;QACzC,MAAM,IAAI,GAAG,MAAM,YAAY,CAC7B;YACE,UAAU;YACV,UAAU;YACV,QAAQ;YACR,OAAO,EAAE,UAAU;YACnB,eAAe;YACf,UAAU;YACV,KAAK;YACL,MAAM;SACP,EACD,GAAG,EACH,EAAE,aAAa,EAAE,WAAW,IAAI,aAAa,EAAE,CAChD,CAAC;QAEF,OAAO,EAAE,IAAI,EAAE,CAAC;IAClB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,sBAAsB,CAAC,MAAoC;QAC/D,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,CAAC;QAEtD,OAAO,sBAAsB,CAAC;YAC5B,GAAG,MAAM;YACT,GAAG;YACH,aAAa,EAAE,MAAM,CAAC,WAAW,IAAI,MAAM,CAAC,aAAa;SAC1D,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,iBAAiB,CAAC,MAA+B;QACrD,MAAM,EACJ,UAAU,EACV,IAAI,EACJ,OAAO,EACP,MAAM,EACN,WAAW,EACX,OAAO,EACP,UAAU,EACV,KAAK,EACL,MAAM,EACN,WAAW,GACZ,GAAG,MAAM,CAAC;QACX,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,EAAE,GACvD,6BAA6B,CAAC,OAAO,CAAC,CAAC;QAEzC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,CAAC;QACtD,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAClC;YACE,UAAU;YACV,IAAI;YACJ,OAAO;YACP,MAAM;YACN,WAAW;YACX,OAAO,EAAE,UAAU;YACnB,eAAe;YACf,UAAU;YACV,KAAK;YACL,MAAM;SACP,EACD,GAAG,EACH,EAAE,aAAa,EAAE,WAAW,EAAE,CAC/B,CAAC;QAEF,OAAO,EAAE,IAAI,EAAE,CAAC;IAClB,CAAC;;0GAxGU,YAAY;8GAAZ,YAAY,cAHX,MAAM;AAGP,YAAY;IADxB,gBAAgB,CAAe,CAAC,cAAc,EAAE,wBAAwB,EAAE,mBAAmB,CAAC,CAAC;GACnF,YAAY,CAyGxB;SAzGY,YAAY;4FAAZ,YAAY;kBAJxB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  executeQuery,\n  executeQueryByWidgetId,\n  executePivotQuery,\n  type ExecuteQueryParams as ExecuteQueryParamsPreact,\n  type ExecuteQueryByWidgetIdParams as ExecuteQueryByWidgetIdParamsPreact,\n  type ExecutePivotQueryParams as ExecutePivotQueryParamsPreact,\n} from '@sisense/sdk-ui-preact';\nimport { SisenseContextService } from './sisense-context.service';\nimport { TrackableService } from '../decorators/trackable.decorator';\nimport { getFilterListAndRelationsJaql } from '@sisense/sdk-data';\n\ninterface ExecuteQueryHandlers {\n  /** Sync or async callback that allows to modify the JAQL payload before it is sent to the server. */\n  beforeQuery?: ExecuteQueryParamsPreact['onBeforeQuery'];\n  /**\n   * Sync or async callback that allows to modify the JAQL payload before it is sent to the server.\n   *\n   * @deprecated Use `beforeQuery` instead.\n   */\n  onBeforeQuery?: ExecuteQueryParamsPreact['onBeforeQuery'];\n}\n\n/**\n * Parameters for data query execution.\n */\nexport interface ExecuteQueryParams\n  extends Omit<ExecuteQueryParamsPreact, 'enabled' | 'onBeforeQuery'>,\n    ExecuteQueryHandlers {}\n\n/**\n * Parameters for data query by widget id execution.\n */\nexport interface ExecuteQueryByWidgetIdParams\n  extends Omit<ExecuteQueryByWidgetIdParamsPreact, 'enabled' | 'onBeforeQuery'>,\n    ExecuteQueryHandlers {}\n\n/**\n * Parameters for pivot data query execution.\n */\nexport interface ExecutePivotQueryParams\n  extends Omit<ExecutePivotQueryParamsPreact, 'enabled' | 'onBeforeQuery'>,\n    Omit<ExecuteQueryHandlers, 'onBeforeQuery'> {}\n\n/**\n * Service for executing data queries.\n *\n * @group Queries\n */\n@Injectable({\n  providedIn: 'root',\n})\n@TrackableService<QueryService>(['executeQuery', 'executeQueryByWidgetId', 'executePivotQuery'])\nexport class QueryService {\n  constructor(private sisenseContextService: SisenseContextService) {}\n\n  /**\n   * Executes a data query. If you want to display the query results, you can use\n   * them to populate Compose SDK UI elements or third party UI elements.\n   *\n   * To learn how to populate third party UI elements with query results, see the\n   * [External Charts Guide](/guides/sdk/guides/charts/guide-external-charts.html#query)\n   *\n   * @param params - Query parameters\n   * @return Query result\n   */\n  async executeQuery(params: ExecuteQueryParams) {\n    const {\n      dataSource,\n      dimensions,\n      measures,\n      filters,\n      highlights,\n      count,\n      offset,\n      beforeQuery,\n      onBeforeQuery,\n    } = params;\n    const app = await this.sisenseContextService.getApp();\n    const { filters: filterList, relations: filterRelations } =\n      getFilterListAndRelationsJaql(filters);\n    const data = await executeQuery(\n      {\n        dataSource,\n        dimensions,\n        measures,\n        filters: filterList,\n        filterRelations,\n        highlights,\n        count,\n        offset,\n      },\n      app,\n      { onBeforeQuery: beforeQuery ?? onBeforeQuery },\n    );\n\n    return { data };\n  }\n\n  /**\n   * Executes a data query extracted from an existing widget in the Sisense instance.\n   *\n   * @param params - Parameters to identify the target widget\n   * @returns Query result\n   */\n  async executeQueryByWidgetId(params: ExecuteQueryByWidgetIdParams) {\n    const app = await this.sisenseContextService.getApp();\n\n    return executeQueryByWidgetId({\n      ...params,\n      app,\n      onBeforeQuery: params.beforeQuery ?? params.onBeforeQuery,\n    });\n  }\n\n  /**\n   * Executes a data query for a pivot table.\n   *\n   * @param params - Pivot query parameters\n   * @return Pivot query result\n   * @beta\n   */\n  async executePivotQuery(params: ExecutePivotQueryParams) {\n    const {\n      dataSource,\n      rows,\n      columns,\n      values,\n      grandTotals,\n      filters,\n      highlights,\n      count,\n      offset,\n      beforeQuery,\n    } = params;\n    const { filters: filterList, relations: filterRelations } =\n      getFilterListAndRelationsJaql(filters);\n\n    const app = await this.sisenseContextService.getApp();\n    const data = await executePivotQuery(\n      {\n        dataSource,\n        rows,\n        columns,\n        values,\n        grandTotals,\n        filters: filterList,\n        filterRelations,\n        highlights,\n        count,\n        offset,\n      },\n      app,\n      { onBeforeQuery: beforeQuery },\n    );\n\n    return { data };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.service.js","sourceRoot":"","sources":["../../../../src/lib/services/query.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAEL,iBAAiB,EAEjB,YAAY,EACZ,sBAAsB,EAGtB,WAAW,EACX,0BAA0B,GAC3B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,6BAA6B,EAAE,MAAM,8BAA8B,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;;;AAoCrE;;;;GAIG;AAKI,IAAM,YAAY,GAAlB,MAAM,YAAY;IACvB,YAAoB,qBAA4C;QAA5C,0BAAqB,GAArB,qBAAqB,CAAuB;IAAG,CAAC;IAEpE;;;;;;;;;OASG;IACH,KAAK,CAAC,YAAY,CAAC,MAA0B;QAC3C,MAAM,EACJ,UAAU,EACV,UAAU,EACV,QAAQ,EACR,OAAO,EACP,UAAU,EACV,KAAK,EACL,MAAM,EACN,OAAO,EACP,WAAW,GACZ,GAAG,MAAM,CAAC;QACX,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,CAAC;QACtD,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,EAAE,GACvD,6BAA6B,CAAC,OAAO,CAAC,CAAC;QACzC,MAAM,IAAI,GAAG,MAAM,YAAY,CAC7B;YACE,UAAU;YACV,UAAU;YACV,QAAQ;YACR,OAAO,EAAE,UAAU;YACnB,eAAe;YACf,UAAU;YACV,KAAK;YACL,MAAM;YACN,OAAO;SACR,EACD,GAAG,EACH,EAAE,aAAa,EAAE,WAAW,EAAE,CAC/B,CAAC;QAEF,OAAO,EAAE,IAAI,EAAE,CAAC;IAClB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,sBAAsB,CAAC,MAAoC;QAC/D,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,CAAC;QAEtD,OAAO,sBAAsB,CAAC;YAC5B,GAAG,MAAM;YACT,GAAG;YACH,aAAa,EAAE,MAAM,CAAC,WAAW;SAClC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,iBAAiB,CAAC,MAA+B;QACrD,MAAM,EACJ,UAAU,EACV,IAAI,EACJ,OAAO,EACP,MAAM,EACN,WAAW,EACX,OAAO,EACP,UAAU,EACV,KAAK,EACL,MAAM,EACN,WAAW,GACZ,GAAG,MAAM,CAAC;QACX,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,EAAE,GACvD,6BAA6B,CAAC,OAAO,CAAC,CAAC;QAEzC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,CAAC;QACtD,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAClC;YACE,UAAU;YACV,IAAI;YACJ,OAAO;YACP,MAAM;YACN,WAAW;YACX,OAAO,EAAE,UAAU;YACnB,eAAe;YACf,UAAU;YACV,KAAK;YACL,MAAM;SACP,EACD,GAAG,EACH,EAAE,aAAa,EAAE,WAAW,EAAE,CAC/B,CAAC;QAEF,OAAO,EAAE,IAAI,EAAE,CAAC;IAClB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,eAAe,CAAC,MAA6B;QACjD,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,0BAA0B,EAAE;YAC9D,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC;SAC1D,CAAC,CAAC;QAEH,MAAM,aAAa,GAAG,IAAI,OAAO,CAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC7E,WAAW,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE;gBAC5B,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC;gBAChD,IAAI,SAAS,EAAE;oBACb,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;iBACnB;qBAAM,IAAI,OAAO,EAAE;oBAClB,MAAM,CAAC,KAAK,CAAC,CAAC;iBACf;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAExB,OAAO,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE;YAChC,WAAW,CAAC,OAAO,EAAE,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;;0GAvIU,YAAY;8GAAZ,YAAY,cAHX,MAAM;AAGP,YAAY;IADxB,gBAAgB,CAAe,CAAC,cAAc,EAAE,wBAAwB,EAAE,mBAAmB,CAAC,CAAC;GACnF,YAAY,CAwIxB;SAxIY,YAAY;4FAAZ,YAAY;kBAJxB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { getFilterListAndRelationsJaql } from '@sisense/sdk-data';\nimport {\n  type ExecuteCsvQueryParams as ExecuteCsvQueryParamsPreact,\n  executePivotQuery,\n  type ExecutePivotQueryParams as ExecutePivotQueryParamsPreact,\n  executeQuery,\n  executeQueryByWidgetId,\n  type ExecuteQueryByWidgetIdParams as ExecuteQueryByWidgetIdParamsPreact,\n  type ExecuteQueryParams as ExecuteQueryParamsPreact,\n  HookAdapter,\n  useExecuteCsvQueryInternal,\n} from '@sisense/sdk-ui-preact';\n\nimport { createSisenseContextConnector } from '../component-wrapper-helpers';\nimport { TrackableService } from '../decorators/trackable.decorator';\nimport { SisenseContextService } from './sisense-context.service';\n\ninterface ExecuteQueryHandlers {\n  /** Sync or async callback that allows to modify the JAQL payload before it is sent to the server. */\n  beforeQuery?: ExecuteQueryParamsPreact['onBeforeQuery'];\n}\n\n/**\n * Parameters for data query execution.\n */\nexport interface ExecuteQueryParams\n  extends Omit<ExecuteQueryParamsPreact, 'enabled' | 'onBeforeQuery'>,\n    ExecuteQueryHandlers {}\n\n/**\n * Parameters for data query by widget id execution.\n */\nexport interface ExecuteQueryByWidgetIdParams\n  extends Omit<ExecuteQueryByWidgetIdParamsPreact, 'enabled' | 'onBeforeQuery'>,\n    ExecuteQueryHandlers {}\n\n/**\n * Parameters for pivot data query execution.\n */\nexport interface ExecutePivotQueryParams\n  extends Omit<ExecutePivotQueryParamsPreact, 'enabled' | 'onBeforeQuery'>,\n    ExecuteQueryHandlers {}\n\n/**\n * Parameters for CSV data query execution.\n */\nexport interface ExecuteCsvQueryParams\n  extends Omit<ExecuteCsvQueryParamsPreact, 'enabled' | 'onBeforeQuery'>,\n    ExecuteQueryHandlers {}\n\n/**\n * Service for executing data queries.\n *\n * @group Queries\n */\n@Injectable({\n  providedIn: 'root',\n})\n@TrackableService<QueryService>(['executeQuery', 'executeQueryByWidgetId', 'executePivotQuery'])\nexport class QueryService {\n  constructor(private sisenseContextService: SisenseContextService) {}\n\n  /**\n   * Executes a data query. If you want to display the query results, you can use\n   * them to populate Compose SDK UI elements or third party UI elements.\n   *\n   * To learn how to populate third party UI elements with query results, see the\n   * [External Charts Guide](/guides/sdk/guides/charts/guide-external-charts.html#query)\n   *\n   * @param params - Query parameters\n   * @return Query result\n   */\n  async executeQuery(params: ExecuteQueryParams) {\n    const {\n      dataSource,\n      dimensions,\n      measures,\n      filters,\n      highlights,\n      count,\n      offset,\n      ungroup,\n      beforeQuery,\n    } = params;\n    const app = await this.sisenseContextService.getApp();\n    const { filters: filterList, relations: filterRelations } =\n      getFilterListAndRelationsJaql(filters);\n    const data = await executeQuery(\n      {\n        dataSource,\n        dimensions,\n        measures,\n        filters: filterList,\n        filterRelations,\n        highlights,\n        count,\n        offset,\n        ungroup,\n      },\n      app,\n      { onBeforeQuery: beforeQuery },\n    );\n\n    return { data };\n  }\n\n  /**\n   * Executes a data query extracted from an existing widget in the Sisense instance.\n   *\n   * @param params - Parameters to identify the target widget\n   * @returns Query result\n   */\n  async executeQueryByWidgetId(params: ExecuteQueryByWidgetIdParams) {\n    const app = await this.sisenseContextService.getApp();\n\n    return executeQueryByWidgetId({\n      ...params,\n      app,\n      onBeforeQuery: params.beforeQuery,\n    });\n  }\n\n  /**\n   * Executes a data query for a pivot table.\n   *\n   * @param params - Pivot query parameters\n   * @return Pivot query result\n   * @beta\n   */\n  async executePivotQuery(params: ExecutePivotQueryParams) {\n    const {\n      dataSource,\n      rows,\n      columns,\n      values,\n      grandTotals,\n      filters,\n      highlights,\n      count,\n      offset,\n      beforeQuery,\n    } = params;\n    const { filters: filterList, relations: filterRelations } =\n      getFilterListAndRelationsJaql(filters);\n\n    const app = await this.sisenseContextService.getApp();\n    const data = await executePivotQuery(\n      {\n        dataSource,\n        rows,\n        columns,\n        values,\n        grandTotals,\n        filters: filterList,\n        filterRelations,\n        highlights,\n        count,\n        offset,\n      },\n      app,\n      { onBeforeQuery: beforeQuery },\n    );\n\n    return { data };\n  }\n\n  /**\n   * Executes a CSV data query.\n   * Similar to {@link QueryService.executeQuery}, but returns the data in CSV format as text or as a stream.\n   *\n   * @param params - CSV query parameters\n   * @return CSV query result\n   */\n  async executeCsvQuery(params: ExecuteCsvQueryParams) {\n    const hookAdapter = new HookAdapter(useExecuteCsvQueryInternal, [\n      createSisenseContextConnector(this.sisenseContextService),\n    ]);\n\n    const resultPromise = new Promise<{ data: Blob | string }>((resolve, reject) => {\n      hookAdapter.subscribe((res) => {\n        const { data, isSuccess, isError, error } = res;\n        if (isSuccess) {\n          resolve({ data });\n        } else if (isError) {\n          reject(error);\n        }\n      });\n    });\n\n    hookAdapter.run(params);\n\n    return resultPromise.finally(() => {\n      hookAdapter.destroy();\n    });\n  }\n}\n"]}

package/dist/esm2020/lib/services/sisense-context.service.mjs

@@ -62,4 +62,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     type: Inject,
                     args: [SISENSE_CONTEXT_CONFIG_TOKEN]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/services/theme.service.mjs

@@ -1,8 +1,8 @@
 import { __decorate } from "tslib";
 import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { getDefaultThemeSettings, getThemeSettingsByOid, } from '@sisense/sdk-ui-preact';
 import { BehaviorSubject } from 'rxjs';
 import merge from 'ts-deepmerge';
-import { getDefaultThemeSettings, getThemeSettingsByOid, } from '@sisense/sdk-ui-preact';
 import { TrackableService } from '../decorators/trackable.decorator';
 import * as i0 from "@angular/core";
 import * as i1 from "./sisense-context.service";
@@ -102,4 +102,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     type: Inject,
                     args: [THEME_CONFIG_TOKEN]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/services/widget.service.mjs

@@ -38,4 +38,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: function () { return [{ type: i1.SisenseContextService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/types/chart-event-props.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/types/dashboard-config.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGFzaGJvYXJkLWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdHlwZXMvZGFzaGJvYXJkLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUge1xuICBEYXNoYm9hcmRDb25maWcgYXMgRGFzaGJvYXJkQ29uZmlnUHJlYWN0LFxuICBEYXNoYm9hcmRCeUlkQ29uZmlnIGFzIERhc2hib2FyZEJ5SWRDb25maWdQcmVhY3QsXG4gIERhc2hib2FyZEZpbHRlcnNQYW5lbENvbmZpZyBhcyBEYXNoYm9hcmRGaWx0ZXJzUGFuZWxDb25maWdQcmVhY3QsXG59IGZyb20gJ0BzaXNlbnNlL3Nkay11aS1wcmVhY3QnO1xuXG4vKipcbiAqIHtAaW5oZXJpdERvYyBAc2lzZW5zZS9zZGstdWkhRGFzaGJvYXJkRmlsdGVyc1BhbmVsQ29uZmlnfVxuICovXG5leHBvcnQgaW50ZXJmYWNlIERhc2hib2FyZEZpbHRlcnNQYW5lbENvbmZpZ1xuICBleHRlbmRzIE9taXQ8RGFzaGJvYXJkRmlsdGVyc1BhbmVsQ29uZmlnUHJlYWN0LCAnYWN0aW9ucyc+IHt9XG5cbi8qKlxuICoge0Bpbmhlcml0RG9jIEBzaXNlbnNlL3Nkay11aSFEYXNoYm9hcmRDb25maWd9XG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRGFzaGJvYXJkQ29uZmlnIGV4dGVuZHMgT21pdDxEYXNoYm9hcmRDb25maWdQcmVhY3QsICdmaWx0ZXJzUGFuZWwnPiB7XG4gIC8qKlxuICAgKiB7QGluaGVyaXREb2MgQHNpc2Vuc2Uvc2RrLXVpIURhc2hib2FyZENvbmZpZy5maWx0ZXJzUGFuZWx9XG4gICAqL1xuICBmaWx0ZXJzUGFuZWw/OiBEYXNoYm9hcmRGaWx0ZXJzUGFuZWxDb25maWc7XG59XG5cbi8qKlxuICoge0Bpbmhlcml0RG9jIEBzaXNlbnNlL3Nkay11aSFEYXNoYm9hcmRCeUlkQ29uZmlnfVxuICovXG5leHBvcnQgaW50ZXJmYWNlIERhc2hib2FyZEJ5SWRDb25maWcgZXh0ZW5kcyBPbWl0PERhc2hib2FyZEJ5SWRDb25maWdQcmVhY3QsICdmaWx0ZXJzUGFuZWwnPiB7XG4gIC8qKlxuICAgKiB7QGluaGVyaXREb2MgQHNpc2Vuc2Uvc2RrLXVpIURhc2hib2FyZEJ5SWRDb25maWcuZmlsdGVyc1BhbmVsfVxuICAgKi9cbiAgZmlsdGVyc1BhbmVsPzogRGFzaGJvYXJkRmlsdGVyc1BhbmVsQ29uZmlnO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGFzaGJvYXJkLWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvdHlwZXMvZGFzaGJvYXJkLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUge1xuICBEYXNoYm9hcmRCeUlkQ29uZmlnIGFzIERhc2hib2FyZEJ5SWRDb25maWdQcmVhY3QsXG4gIERhc2hib2FyZENvbmZpZyBhcyBEYXNoYm9hcmRDb25maWdQcmVhY3QsXG4gIERhc2hib2FyZEZpbHRlcnNQYW5lbENvbmZpZyBhcyBEYXNoYm9hcmRGaWx0ZXJzUGFuZWxDb25maWdQcmVhY3QsXG59IGZyb20gJ0BzaXNlbnNlL3Nkay11aS1wcmVhY3QnO1xuXG4vKipcbiAqIHtAaW5oZXJpdERvYyBAc2lzZW5zZS9zZGstdWkhRGFzaGJvYXJkRmlsdGVyc1BhbmVsQ29uZmlnfVxuICovXG5leHBvcnQgaW50ZXJmYWNlIERhc2hib2FyZEZpbHRlcnNQYW5lbENvbmZpZ1xuICBleHRlbmRzIE9taXQ8RGFzaGJvYXJkRmlsdGVyc1BhbmVsQ29uZmlnUHJlYWN0LCAnYWN0aW9ucyc+IHt9XG5cbi8qKlxuICoge0Bpbmhlcml0RG9jIEBzaXNlbnNlL3Nkay11aSFEYXNoYm9hcmRDb25maWd9XG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRGFzaGJvYXJkQ29uZmlnIGV4dGVuZHMgT21pdDxEYXNoYm9hcmRDb25maWdQcmVhY3QsICdmaWx0ZXJzUGFuZWwnPiB7XG4gIC8qKlxuICAgKiB7QGluaGVyaXREb2MgQHNpc2Vuc2Uvc2RrLXVpIURhc2hib2FyZENvbmZpZy5maWx0ZXJzUGFuZWx9XG4gICAqL1xuICBmaWx0ZXJzUGFuZWw/OiBEYXNoYm9hcmRGaWx0ZXJzUGFuZWxDb25maWc7XG59XG5cbi8qKlxuICoge0Bpbmhlcml0RG9jIEBzaXNlbnNlL3Nkay11aSFEYXNoYm9hcmRCeUlkQ29uZmlnfVxuICovXG5leHBvcnQgaW50ZXJmYWNlIERhc2hib2FyZEJ5SWRDb25maWcgZXh0ZW5kcyBPbWl0PERhc2hib2FyZEJ5SWRDb25maWdQcmVhY3QsICdmaWx0ZXJzUGFuZWwnPiB7XG4gIC8qKlxuICAgKiB7QGluaGVyaXREb2MgQHNpc2Vuc2Uvc2RrLXVpIURhc2hib2FyZEJ5SWRDb25maWcuZmlsdGVyc1BhbmVsfVxuICAgKi9cbiAgZmlsdGVyc1BhbmVsPzogRGFzaGJvYXJkRmlsdGVyc1BhbmVsQ29uZmlnO1xufVxuIl19

package/dist/esm2020/lib/types/data-point.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/types/filter-event-props.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLWV2ZW50LXByb3BzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi90eXBlcy9maWx0ZXItZXZlbnQtcHJvcHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZpbHRlciB9IGZyb20gJ0BzaXNlbnNlL3Nkay1kYXRhJztcblxuZXhwb3J0IHR5cGUgRmlsdGVyQ2hhbmdlRXZlbnQgPSB7XG4gIC8qKiBGaWx0ZXIgdGhhdCB3YXMgY2hhbmdlZCAqL1xuICBmaWx0ZXI6IEZpbHRlciB8IG51bGw7XG59O1xuXG5leHBvcnQgdHlwZSBGaWx0ZXJFZGl0RXZlbnQgPSB7XG4gIC8qKiBJbmRleCBvZiB0aGUgZmlsdGVyIGxldmVsIHRoYXQgdHJpZ2dlcnMgdGhlIGVkaXQgZXZlbnQgKGluIHRoZSBjYXNlIG9mIGEgY2FzY2FkaW5nIGZpbHRlcikgKi9cbiAgbGV2ZWxJbmRleD86IG51bWJlcjtcbn07XG5cbi8qKlxuICogRmlsdGVyIGNoYW5nZSBldmVudCBoYW5kbGVyLlxuICovXG5leHBvcnQgdHlwZSBGaWx0ZXJDaGFuZ2VFdmVudEhhbmRsZXIgPSAoZXZlbnQ6IEZpbHRlckNoYW5nZUV2ZW50KSA9PiB2b2lkO1xuXG4vKipcbiAqIEZpbHRlciBlZGl0IGV2ZW50IGhhbmRsZXIuXG4gKi9cbmV4cG9ydCB0eXBlIEZpbHRlckVkaXRFdmVudEhhbmRsZXIgPSAoZXZlbnQ6IEZpbHRlckVkaXRFdmVudCkgPT4gdm9pZDtcblxuLyoqXG4gKiBGaWx0ZXIgZGVsZXRlIGV2ZW50IGhhbmRsZXIuXG4gKi9cbmV4cG9ydCB0eXBlIEZpbHRlckRlbGV0ZUV2ZW50SGFuZGxlciA9ICgpID0+IHZvaWQ7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQmFzZUZpbHRlclRpbGVFdmVudFByb3BzIHtcbiAgLyoqXG4gICAqIHtAaW5oZXJpdERvYyBGaWx0ZXJDaGFuZ2VFdmVudEhhbmRsZXJ9XG4gICAqL1xuICBmaWx0ZXJDaGFuZ2U/OiBGaWx0ZXJDaGFuZ2VFdmVudEhhbmRsZXI7XG4gIC8qKlxuICAgKiB7QGluaGVyaXREb2MgRmlsdGVyRWRpdEV2ZW50SGFuZGxlcn1cbiAgICovXG4gIGZpbHRlckVkaXQ/OiBGaWx0ZXJFZGl0RXZlbnRIYW5kbGVyO1xuICAvKipcbiAgICoge0Bpbmhlcml0RG9jIEZpbHRlckRlbGV0ZUV2ZW50SGFuZGxlcn1cbiAgICovXG4gIGZpbHRlckRlbGV0ZT86IEZpbHRlckRlbGV0ZUV2ZW50SGFuZGxlcjtcbn1cbiJdfQ==

package/dist/esm2020/lib/types/index.mjs

@@ -1,5 +1,6 @@
-export * from './utility-types';
-export * from './data-point';
 export * from './chart-event-props';
 export * from './dashboard-config';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3R5cGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi91dGlsaXR5LXR5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YS1wb2ludCc7XG5leHBvcnQgKiBmcm9tICcuL2NoYXJ0LWV2ZW50LXByb3BzJztcbmV4cG9ydCAqIGZyb20gJy4vZGFzaGJvYXJkLWNvbmZpZyc7XG4iXX0=
+export * from './data-point';
+export * from './filter-event-props';
+export * from './utility-types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3R5cGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NoYXJ0LWV2ZW50LXByb3BzJztcbmV4cG9ydCAqIGZyb20gJy4vZGFzaGJvYXJkLWNvbmZpZyc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGEtcG9pbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9maWx0ZXItZXZlbnQtcHJvcHMnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlsaXR5LXR5cGVzJztcbiJdfQ==

package/dist/esm2020/lib/utilities/dashboard-helpers.mjs

@@ -1,4 +1,4 @@
-import { dashboardHelpers as dashboardHelpersPreact } from '@sisense/sdk-ui-preact';
+import { dashboardHelpers as dashboardHelpersPreact, } from '@sisense/sdk-ui-preact';
 /**
  * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilters}
  *
@@ -69,19 +69,6 @@ export const addFilters = (dashboard, newFilters) => {
 export const replaceFilter = (dashboard, filterToReplace, newFilter) => {
     return dashboardHelpersPreact.replaceFilter(dashboard, filterToReplace, newFilter);
 };
-/**
- * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.modifyFilter}
- *
- * @deprecated Use {@link replaceFilter} instead
- *
- * @param dashboard - The original dashboard (`DashboardProps`) containing the filter to modify.
- * @param filterToModify - The existing filter to be modified.
- * @param newFilter - The new filter to replace the existing one.
- * @returns A new dashboard instance with the specified filter modified.
- */
-export const modifyFilter = (dashboard, filterToModify, newFilter) => {
-    return dashboardHelpersPreact.modifyFilter(dashboard, filterToModify, newFilter);
-};
 /**
  * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilter}
  *
@@ -116,4 +103,4 @@ export const removeFilter = (dashboard, filterToRemove) => {
 export const removeFilters = (dashboard, filtersToRemove) => {
     return dashboardHelpersPreact.removeFilters(dashboard, filtersToRemove);
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard-helpers.js","sourceRoot":"","sources":["../../../../src/lib/utilities/dashboard-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,IAAI,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAIpF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,SAAyB,EACzB,UAAsC,EACtB,EAAE;IAClB,OAAO,sBAAsB,CAAC,cAAc,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;AACtE,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,SAAyB,EAAE,SAAiB,EAAkB,EAAE;IACxF,OAAO,sBAAsB,CAAC,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;AAChE,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,SAAyB,EAAE,UAAoB,EAAkB,EAAE;IAC5F,OAAO,sBAAsB,CAAC,UAAU,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;AAClE,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,SAAyB,EACzB,eAAuB,EACvB,SAAiB,EACD,EAAE;IAClB,OAAO,sBAAsB,CAAC,aAAa,CAAC,SAAS,EAAE,eAAe,EAAE,SAAS,CAAC,CAAC;AACrF,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,SAAyB,EACzB,cAAsB,EACtB,SAAiB,EACD,EAAE;IAClB,OAAO,sBAAsB,CAAC,YAAY,CAAC,SAAS,EAAE,cAAc,EAAE,SAAS,CAAC,CAAC;AACnF,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,SAAyB,EAAE,cAAsB,EAAkB,EAAE;IAChG,OAAO,sBAAsB,CAAC,YAAY,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;AACxE,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,SAAyB,EACzB,eAAyB,EACT,EAAE;IAClB,OAAO,sBAAsB,CAAC,aAAa,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;AAC1E,CAAC,CAAC","sourcesContent":["import { dashboardHelpers as dashboardHelpersPreact } from '@sisense/sdk-ui-preact';\nimport { DashboardProps } from '../components';\nimport { Filter, FilterRelations } from '@sisense/sdk-data';\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilters}\n *\n * @example\n * Replace all filters on a dashboard with a new set of filters.\n * ```ts\n * const existingDashboard: DashboardProps = {...}\n * const newFilters: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.replaceFilters(existingDashboard, newFilters);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) whose filters are to be replaced.\n * @param newFilters - An array of new filters or filter relations to set on the dashboard.\n * @returns A new dashboard instance with the updated filters.\n */\nexport const replaceFilters = (\n  dashboard: DashboardProps,\n  newFilters: Filter[] | FilterRelations,\n): DashboardProps => {\n  return dashboardHelpersPreact.replaceFilters(dashboard, newFilters);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.addFilter}\n *\n * @example\n * Add a new filter to a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const newFilter: Filter = {...};\n * const updatedDashboard = dashboardHelpers.addFilter(existingDashboard, newFilter);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) to which the filter will be added.\n * @param newFilter - The filter to add to the dashboard.\n * @returns A new dashboard instance with the new filter added.\n */\nexport const addFilter = (dashboard: DashboardProps, newFilter: Filter): DashboardProps => {\n  return dashboardHelpersPreact.addFilter(dashboard, newFilter);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.addFilters}\n *\n * @example\n * Add multiple new filters to a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const newFilters: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.addFilters(existingDashboard, newFilters);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) to which the filters will be added.\n * @param newFilters - An array of filters to add to the dashboard.\n * @returns A new dashboard instance with the new filters added.\n */\nexport const addFilters = (dashboard: DashboardProps, newFilters: Filter[]): DashboardProps => {\n  return dashboardHelpersPreact.addFilters(dashboard, newFilters);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilter}\n *\n * @example\n * Replace a filter in a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filterToReplace: Filter = {...};\n * const newFilter: Filter = {...};\n * const updatedDashboard = dashboardHelpers.replaceFilter(existingDashboard, filterToReplace, newFilter);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) containing the filter to be replaced.\n * @param filterToReplace - The existing filter to be replaced.\n * @param newFilter - The new filter to replace the existing one.\n * @returns A new dashboard instance with the specified filter replaced.\n */\nexport const replaceFilter = (\n  dashboard: DashboardProps,\n  filterToReplace: Filter,\n  newFilter: Filter,\n): DashboardProps => {\n  return dashboardHelpersPreact.replaceFilter(dashboard, filterToReplace, newFilter);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.modifyFilter}\n *\n * @deprecated Use {@link replaceFilter} instead\n *\n * @param dashboard - The original dashboard (`DashboardProps`) containing the filter to modify.\n * @param filterToModify - The existing filter to be modified.\n * @param newFilter - The new filter to replace the existing one.\n * @returns A new dashboard instance with the specified filter modified.\n */\nexport const modifyFilter = (\n  dashboard: DashboardProps,\n  filterToModify: Filter,\n  newFilter: Filter,\n): DashboardProps => {\n  return dashboardHelpersPreact.modifyFilter(dashboard, filterToModify, newFilter);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilter}\n *\n * @example\n * Remove a filter from a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filterToRemove: Filter = {...};\n * const updatedDashboard = dashboardHelpers.removeFilter(existingDashboard, filterToRemove);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) from which to remove the filter.\n * @param filterToRemove - The filter to be removed.\n * @returns A new dashboard instance with the specified filter removed.\n */\nexport const removeFilter = (dashboard: DashboardProps, filterToRemove: Filter): DashboardProps => {\n  return dashboardHelpersPreact.removeFilter(dashboard, filterToRemove);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilters}\n *\n * @example\n * Remove multiple filters from a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filtersToRemove: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.removeFilters(existingDashboard, filtersToRemove);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) from which the specified filters are removed.\n * @param filtersToRemove - An array of filters to remove.\n * @returns A new dashboard instance with the specified filters removed.\n */\nexport const removeFilters = (\n  dashboard: DashboardProps,\n  filtersToRemove: Filter[],\n): DashboardProps => {\n  return dashboardHelpersPreact.removeFilters(dashboard, filtersToRemove);\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard-helpers.js","sourceRoot":"","sources":["../../../../src/lib/utilities/dashboard-helpers.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,IAAI,sBAAsB,GAE3C,MAAM,wBAAwB,CAAC;AAIhC;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,SAAyB,EACzB,UAAsC,EACtB,EAAE;IAClB,OAAO,sBAAsB,CAAC,cAAc,CAAC,SAAiC,EAAE,UAAU,CAAC,CAAC;AAC9F,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,SAAyB,EAAE,SAAiB,EAAkB,EAAE;IACxF,OAAO,sBAAsB,CAAC,SAAS,CAAC,SAAiC,EAAE,SAAS,CAAC,CAAC;AACxF,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,SAAyB,EAAE,UAAoB,EAAkB,EAAE;IAC5F,OAAO,sBAAsB,CAAC,UAAU,CAAC,SAAiC,EAAE,UAAU,CAAC,CAAC;AAC1F,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,SAAyB,EACzB,eAAuB,EACvB,SAAiB,EACD,EAAE;IAClB,OAAO,sBAAsB,CAAC,aAAa,CACzC,SAAiC,EACjC,eAAe,EACf,SAAS,CACV,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,SAAyB,EAAE,cAAsB,EAAkB,EAAE;IAChG,OAAO,sBAAsB,CAAC,YAAY,CAAC,SAAiC,EAAE,cAAc,CAAC,CAAC;AAChG,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,SAAyB,EACzB,eAAyB,EACT,EAAE;IAClB,OAAO,sBAAsB,CAAC,aAAa,CAAC,SAAiC,EAAE,eAAe,CAAC,CAAC;AAClG,CAAC,CAAC","sourcesContent":["import { Filter, FilterRelations } from '@sisense/sdk-data';\nimport {\n  dashboardHelpers as dashboardHelpersPreact,\n  type DashboardProps as DashboardPropsPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport { DashboardProps } from '../components';\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilters}\n *\n * @example\n * Replace all filters on a dashboard with a new set of filters.\n * ```ts\n * const existingDashboard: DashboardProps = {...}\n * const newFilters: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.replaceFilters(existingDashboard, newFilters);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) whose filters are to be replaced.\n * @param newFilters - An array of new filters or filter relations to set on the dashboard.\n * @returns A new dashboard instance with the updated filters.\n */\nexport const replaceFilters = (\n  dashboard: DashboardProps,\n  newFilters: Filter[] | FilterRelations,\n): DashboardProps => {\n  return dashboardHelpersPreact.replaceFilters(dashboard as DashboardPropsPreact, newFilters);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.addFilter}\n *\n * @example\n * Add a new filter to a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const newFilter: Filter = {...};\n * const updatedDashboard = dashboardHelpers.addFilter(existingDashboard, newFilter);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) to which the filter will be added.\n * @param newFilter - The filter to add to the dashboard.\n * @returns A new dashboard instance with the new filter added.\n */\nexport const addFilter = (dashboard: DashboardProps, newFilter: Filter): DashboardProps => {\n  return dashboardHelpersPreact.addFilter(dashboard as DashboardPropsPreact, newFilter);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.addFilters}\n *\n * @example\n * Add multiple new filters to a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const newFilters: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.addFilters(existingDashboard, newFilters);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) to which the filters will be added.\n * @param newFilters - An array of filters to add to the dashboard.\n * @returns A new dashboard instance with the new filters added.\n */\nexport const addFilters = (dashboard: DashboardProps, newFilters: Filter[]): DashboardProps => {\n  return dashboardHelpersPreact.addFilters(dashboard as DashboardPropsPreact, newFilters);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilter}\n *\n * @example\n * Replace a filter in a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filterToReplace: Filter = {...};\n * const newFilter: Filter = {...};\n * const updatedDashboard = dashboardHelpers.replaceFilter(existingDashboard, filterToReplace, newFilter);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) containing the filter to be replaced.\n * @param filterToReplace - The existing filter to be replaced.\n * @param newFilter - The new filter to replace the existing one.\n * @returns A new dashboard instance with the specified filter replaced.\n */\nexport const replaceFilter = (\n  dashboard: DashboardProps,\n  filterToReplace: Filter,\n  newFilter: Filter,\n): DashboardProps => {\n  return dashboardHelpersPreact.replaceFilter(\n    dashboard as DashboardPropsPreact,\n    filterToReplace,\n    newFilter,\n  );\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilter}\n *\n * @example\n * Remove a filter from a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filterToRemove: Filter = {...};\n * const updatedDashboard = dashboardHelpers.removeFilter(existingDashboard, filterToRemove);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) from which to remove the filter.\n * @param filterToRemove - The filter to be removed.\n * @returns A new dashboard instance with the specified filter removed.\n */\nexport const removeFilter = (dashboard: DashboardProps, filterToRemove: Filter): DashboardProps => {\n  return dashboardHelpersPreact.removeFilter(dashboard as DashboardPropsPreact, filterToRemove);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilters}\n *\n * @example\n * Remove multiple filters from a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filtersToRemove: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.removeFilters(existingDashboard, filtersToRemove);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) from which the specified filters are removed.\n * @param filtersToRemove - An array of filters to remove.\n * @returns A new dashboard instance with the specified filters removed.\n */\nexport const removeFilters = (\n  dashboard: DashboardProps,\n  filtersToRemove: Filter[],\n): DashboardProps => {\n  return dashboardHelpersPreact.removeFilters(dashboard as DashboardPropsPreact, filtersToRemove);\n};\n"]}

package/dist/esm2020/lib/utilities/dashboard-model-translator.mjs

@@ -46,4 +46,4 @@ export class DashboardComponent {
 export function toDashboardProps(dashboardModel) {
     return dashboardModelTranslatorPreact.toDashboardProps(dashboardModel);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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