@sisense/sdk-ui-angular 1.12.0 → 1.14.0

package/dist/esm2020/lib/components/charts/area-range-chart.component.mjs

@@ -0,0 +1,150 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./chart.component";
+/**
+ * A component that displays a range of data over a given time period or across multiple categories.
+ * It is particularly useful for visualizing the minimum and maximum values in a dataset, along with
+ * the area between these values.
+ *
+ * @example
+ * ```html
+ *    <csdk-area-range-chart
+ *      [dataSet]="chart.dataSet"
+ *      [dataOptions]="chart.dataOptions"
+ *      [highlights]="filters"
+ *      [beforeRender]="onBeforeRender"
+ *      (dataPointClick)="logArguments($event)"
+ *      (dataPointContextMenu)="logArguments($event)"
+ *      (dataPointsSelect)="logArguments($event)"
+ *    />
+ * ```
+ * ```ts
+import { Component } from '@angular/core';
+import { measureFactory, filterFactory, Filter } from '@sisense/sdk-data';
+import * as DM from '../../assets/sample-healthcare-model';
+import type { ChartType, RangeChartDataOptions } from '@sisense/sdk-ui-angular';
+
+@Component({
+  selector: 'app-analytics',
+  templateUrl: './analytics.component.html',
+  styleUrls: ['./analytics.component.scss'],
+})
+export class AnalyticsComponent {
+  DM = DM;
+  filters = [filterFactory.members(DM.Divisions.Divison_name, ['Cardiology', 'Neurology'])];
+  chart = {
+    chartType: 'arearange' as ChartType,
+    dataSet: DM.DataSource,
+    dataOptions: {
+      category: [DM.Admissions.Admission_Time.Years],
+      value: [
+        {
+            title: 'Admission Cost Range',
+            upperBound: measureFactory.multiply(
+              measureFactory.sum(DM.Admissions.Cost_of_admission, 'Lower Admission'),
+              0.6,
+            ),
+            lowerBound: measureFactory.multiply(
+              measureFactory.sum(DM.Admissions.Cost_of_admission, 'Upper Admission'),
+              1.4,
+             ),
+        }
+      ],
+      breakBy: [],
+    } as RangeChartDataOptions,
+  };
+
+  onBeforeRender(options: any) {
+    console.log('beforeRender');
+    console.log(options);
+    return options;
+  }
+
+  logArguments(...args: any[]) {
+    console.log(args);
+  }
+}
+ * ```
+ * <img src="media://angular-area-range-chart-example.png" width="800px" />
+ *
+ * @group Charts
+ * @beta
+ */
+export class AreaRangeChartComponent {
+    constructor() {
+        /**
+         * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onDataPointClick}
+         *
+         * @category Callbacks
+         */
+        this.dataPointClick = new EventEmitter();
+        /**
+         * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onDataPointContextMenu}
+         *
+         * @category Callbacks
+         */
+        this.dataPointContextMenu = new EventEmitter();
+        /**
+         * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onDataPointsSelected}
+         *
+         * @category Callbacks
+         */
+        this.dataPointsSelect = new EventEmitter();
+        /** @internal */
+        this.chartType = 'arearange';
+    }
+}
+AreaRangeChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AreaRangeChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+AreaRangeChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: AreaRangeChartComponent, selector: "csdk-area-range-chart", inputs: { dataSet: "dataSet", dataOptions: "dataOptions", filters: "filters", highlights: "highlights", styleOptions: "styleOptions", beforeRender: "beforeRender" }, outputs: { dataPointClick: "dataPointClick", dataPointContextMenu: "dataPointContextMenu", dataPointsSelect: "dataPointsSelect" }, ngImport: i0, template: `
+    <csdk-chart
+      [chartType]="chartType"
+      [dataSet]="dataSet"
+      [dataOptions]="dataOptions"
+      [filters]="filters"
+      [highlights]="highlights"
+      [styleOptions]="styleOptions"
+      [beforeRender]="beforeRender"
+      (dataPointClick)="dataPointClick.emit($event)"
+      (dataPointContextMenu)="dataPointContextMenu.emit($event)"
+      (dataPointsSelect)="dataPointsSelect.emit($event)"
+    />
+  `, isInline: true, dependencies: [{ kind: "component", type: i1.ChartComponent, selector: "csdk-chart", inputs: ["chartType", "dataSet", "dataOptions", "filters", "highlights", "styleOptions", "beforeRender"], outputs: ["dataPointClick", "dataPointContextMenu", "dataPointsSelect"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AreaRangeChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-area-range-chart',
+                    template: `
+    <csdk-chart
+      [chartType]="chartType"
+      [dataSet]="dataSet"
+      [dataOptions]="dataOptions"
+      [filters]="filters"
+      [highlights]="highlights"
+      [styleOptions]="styleOptions"
+      [beforeRender]="beforeRender"
+      (dataPointClick)="dataPointClick.emit($event)"
+      (dataPointContextMenu)="dataPointContextMenu.emit($event)"
+      (dataPointsSelect)="dataPointsSelect.emit($event)"
+    />
+  `,
+                }]
+        }], propDecorators: { dataSet: [{
+                type: Input
+            }], dataOptions: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }], highlights: [{
+                type: Input
+            }], styleOptions: [{
+                type: Input
+            }], beforeRender: [{
+                type: Input
+            }], dataPointClick: [{
+                type: Output
+            }], dataPointContextMenu: [{
+                type: Output
+            }], dataPointsSelect: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/components/charts/index.mjs

@@ -15,4 +15,5 @@ export * from './boxplot-chart.component';
 export * from './scattermap-chart.component';
 export * from './areamap-chart.component';
 export * from './pivot-table.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvY2hhcnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vdGFibGUuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29sdW1uLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Jhci1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9hcmVhLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpbmUtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vaW5kaWNhdG9yLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3NjYXR0ZXItY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcGllLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Z1bm5lbC1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9wb2xhci1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi90cmVlbWFwLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3N1bmJ1cnN0LWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2JveHBsb3QtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2NhdHRlcm1hcC1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9hcmVhbWFwLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3Bpdm90LXRhYmxlLmNvbXBvbmVudCc7XG4iXX0=
+export * from './area-range-chart.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvY2hhcnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb2x1bW4tY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYmFyLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2FyZWEtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGluZS1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9pbmRpY2F0b3ItY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2NhdHRlci1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9waWUtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZnVubmVsLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3BvbGFyLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3RyZWVtYXAtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc3VuYnVyc3QtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYm94cGxvdC1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zY2F0dGVybWFwLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2FyZWFtYXAtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcGl2b3QtdGFibGUuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYXJlYS1yYW5nZS1jaGFydC5jb21wb25lbnQnO1xuIl19

package/dist/esm2020/lib/components/dashboard/dashboard-by-id.component.mjs

@@ -0,0 +1,101 @@
+import { Component, Input, ViewChild, } from '@angular/core';
+import { DashboardById, ComponentAdapter, createElement, } from '@sisense/sdk-ui-preact';
+import { createSisenseContextConnector, createThemeContextConnector, } from '../../component-wrapper-helpers';
+import { template, rootId } from '../../component-wrapper-helpers/template';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/sisense-context.service";
+import * as i2 from "../../services/theme.service";
+/**
+ * An Angular component used for easily rendering a dashboard by its ID created in a Sisense Fusion instance.
+ *
+ * @example
+ * ```html
+ * <csdk-dashboard-by-id
+ *   [dashboardOid]="dashboardOid"
+ * />
+ * ```
+ * ```ts
+ * import { Component } from '@angular/core';
+ *
+ * @Component({
+ *  selector: 'app-dashboard',
+ *  templateUrl: './dashboard.component.html',
+ *  styleUrls: ['./dashboard.component.scss'],
+ * })
+ * export class DashboardComponent {
+ *  dashboardOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';
+ * }
+ * ```
+ * @group Fusion Embed
+ * @fusionEmbed
+ * @internal
+ */
+export class DashboardByIdComponent {
+    /**
+     * Constructor for the `DashboardById` component.
+     *
+     * @param sisenseContextService - Sisense context service
+     * @param themeService - Theme service
+     */
+    constructor(
+    /**
+     * Sisense context service
+     *
+     * @category Constructor
+     */
+    sisenseContextService, 
+    /**
+     * Theme service
+     *
+     * @category Constructor
+     */
+    themeService) {
+        this.sisenseContextService = sisenseContextService;
+        this.themeService = themeService;
+        this.componentAdapter = new ComponentAdapter(() => this.createPreactComponent(), [
+            createSisenseContextConnector(this.sisenseContextService),
+            createThemeContextConnector(this.themeService),
+        ]);
+    }
+    /**
+     * @internal
+     */
+    ngAfterViewInit() {
+        this.componentAdapter.render(this.preactRef.nativeElement);
+    }
+    /**
+     * @internal
+     */
+    ngOnChanges() {
+        if (this.preactRef) {
+            this.componentAdapter.render(this.preactRef.nativeElement);
+        }
+    }
+    createPreactComponent() {
+        const props = {
+            dashboardOid: this.dashboardOid,
+        };
+        return createElement(DashboardById, props);
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+}
+DashboardByIdComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DashboardByIdComponent, deps: [{ token: i1.SisenseContextService }, { token: i2.ThemeService }], target: i0.ɵɵFactoryTarget.Component });
+DashboardByIdComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: DashboardByIdComponent, selector: "csdk-dashboard-by-id", inputs: { dashboardOid: "dashboardOid" }, viewQueries: [{ propertyName: "preactRef", first: true, predicate: ["preact"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "\n    <div #preact style=\"width: 100%; height: 100%\"></div>\n", isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DashboardByIdComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-dashboard-by-id',
+                    template,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i2.ThemeService }]; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], dashboardOid: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/components/dashboard/dashboard.component.mjs

@@ -0,0 +1,129 @@
+import { Component, Input, ViewChild, } from '@angular/core';
+import { Dashboard, ComponentAdapter, createElement, } from '@sisense/sdk-ui-preact';
+import { createSisenseContextConnector, createThemeContextConnector, } from '../../component-wrapper-helpers';
+import { template, rootId } from '../../component-wrapper-helpers/template';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/sisense-context.service";
+import * as i2 from "../../services/theme.service";
+/**
+ * An Angular component used for easily rendering a dashboard.
+ *
+ * @example
+ * ```html
+ * <csdk-dashboard
+ *  *ngIf="dashboard"
+ *  [title]="dashboard!.title"
+ *  [layout]="dashboard!.layout"
+ *  [widgets]="dashboard!.widgets"
+ *  [filters]="dashboard!.filters"
+ *  [defaultDataSource]="dashboard!.dataSource"
+ *  [widgetFilterOptions]="dashboard!.widgetFilterOptions"
+ * />
+ * ```
+ * ```ts
+ * import { Component } from '@angular/core';
+ * import { type DashboardModel, DashboardService } from '@sisense/sdk-ui-angular';
+ *
+ * @Component({
+ *  selector: 'app-dashboard',
+ *  templateUrl: './dashboard.component.html',
+ *  styleUrls: ['./dashboard.component.scss'],
+ * })
+ * export class DashboardComponent {
+ *
+ *  dashboard: DashboardModel | null = null;
+ *
+ *  constructor(private dashboardService: DashboardService) {}
+ *
+ *  async ngOnInit(): Promise<void> {
+ *    this.dashboard = await this.dashboardService.getDashboardModel('60f3e3e3e4b0e3e3e4b0e3e3', { includeWidgets: true, includeFilters: true });
+ *  }
+ * ```
+ * @group Fusion Embed
+ * @fusionEmbed
+ * @internal
+ */
+export class DashboardComponent {
+    /**
+     * Constructor for the `Dashboard` component.
+     *
+     * @param sisenseContextService - Sisense context service
+     * @param themeService - Theme service
+     */
+    constructor(
+    /**
+     * Sisense context service
+     *
+     * @category Constructor
+     */
+    sisenseContextService, 
+    /**
+     * Theme service
+     *
+     * @category Constructor
+     */
+    themeService) {
+        this.sisenseContextService = sisenseContextService;
+        this.themeService = themeService;
+        this.componentAdapter = new ComponentAdapter(() => this.createPreactComponent(), [
+            createSisenseContextConnector(this.sisenseContextService),
+            createThemeContextConnector(this.themeService),
+        ]);
+    }
+    /**
+     * @internal
+     */
+    ngAfterViewInit() {
+        this.componentAdapter.render(this.preactRef.nativeElement);
+    }
+    /**
+     * @internal
+     */
+    ngOnChanges() {
+        if (this.preactRef) {
+            this.componentAdapter.render(this.preactRef.nativeElement);
+        }
+    }
+    createPreactComponent() {
+        const props = {
+            title: this.title,
+            layout: this.layout,
+            widgets: this.widgets,
+            filters: this.filters,
+            defaultDataSource: this.defaultDataSource,
+            widgetFilterOptions: this.widgetFilterOptions,
+        };
+        return createElement(Dashboard, props);
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+}
+DashboardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DashboardComponent, deps: [{ token: i1.SisenseContextService }, { token: i2.ThemeService }], target: i0.ɵɵFactoryTarget.Component });
+DashboardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: DashboardComponent, selector: "csdk-dashboard", inputs: { title: "title", layout: "layout", widgets: "widgets", filters: "filters", defaultDataSource: "defaultDataSource", widgetFilterOptions: "widgetFilterOptions" }, viewQueries: [{ propertyName: "preactRef", first: true, predicate: ["preact"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "\n    <div #preact style=\"width: 100%; height: 100%\"></div>\n", isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DashboardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-dashboard',
+                    template,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i2.ThemeService }]; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], title: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], widgets: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }], defaultDataSource: [{
+                type: Input
+            }], widgetFilterOptions: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/components/dashboard/index.mjs

@@ -0,0 +1,3 @@
+export * from './dashboard-by-id.component';
+export * from './dashboard.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvZGFzaGJvYXJkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGFzaGJvYXJkLWJ5LWlkLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Rhc2hib2FyZC5jb21wb25lbnQnO1xuIl19

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

@@ -1,6 +1,7 @@
 export * from './filters';
 export * from './charts';
 export * from './widgets';
+export * from './dashboard';
 export * from './drilldown-breadcrumbs.component';
 export * from './context-menu.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9maWx0ZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vY2hhcnRzJztcbmV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0cyc7XG5leHBvcnQgKiBmcm9tICcuL2RyaWxsZG93bi1icmVhZGNydW1icy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0LW1lbnUuY29tcG9uZW50JztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9maWx0ZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vY2hhcnRzJztcbmV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0cyc7XG5leHBvcnQgKiBmcm9tICcuL2Rhc2hib2FyZCc7XG5leHBvcnQgKiBmcm9tICcuL2RyaWxsZG93bi1icmVhZGNydW1icy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0LW1lbnUuY29tcG9uZW50JztcbiJdfQ==

package/dist/esm2020/lib/decorators/trackable.decorator.mjs

@@ -32,11 +32,11 @@ async function track(action, methodName) {
                 packageVersion,
                 methodName,
             };
-            void trackProductEvent(action, payload, app.httpClient, !enableTracking).catch((e) => console.warn(`An error occurred when sending the ${action} event`, e));
+            void trackProductEvent(action, payload, app.httpClient, !enableTracking);
         }
     }
     catch (e) {
         console.warn('tracking error', e);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/sdk-ui-core-exports.mjs

@@ -1,4 +1,4 @@
 // This file re-exports common types/utils from @sisense/sdk-ui-preact
 // Re-exports utils from @sisense/sdk-ui-preact
 export { boxWhiskerProcessResult } from '@sisense/sdk-ui-preact';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/sdk-ui.module.mjs

@@ -1,6 +1,6 @@
 import { NgModule } from '@angular/core';
 import { CommonModule } from '@angular/common';
-import { BasicMemberFilterTileComponent, ChartComponent, TableComponent, ChartWidgetComponent, ColumnChartComponent, BarChartComponent, AreaChartComponent, LineChartComponent, IndicatorChartComponent, ScatterChartComponent, PieChartComponent, FunnelChartComponent, PolarChartComponent, TreemapChartComponent, SunburstChartComponent, TableWidgetComponent, DashboardWidgetComponent, MemberFilterTileComponent, DrilldownWidgetComponent, DateRangeFilterTileComponent, DrilldownBreadcrumbsComponent, ContextMenuComponent, BoxplotChartComponent, ScattermapChartComponent, AreamapChartComponent, PivotTableComponent, } from './components';
+import { BasicMemberFilterTileComponent, ChartComponent, TableComponent, ChartWidgetComponent, ColumnChartComponent, BarChartComponent, AreaChartComponent, AreaRangeChartComponent, LineChartComponent, IndicatorChartComponent, ScatterChartComponent, PieChartComponent, FunnelChartComponent, PolarChartComponent, TreemapChartComponent, SunburstChartComponent, TableWidgetComponent, DashboardWidgetComponent, MemberFilterTileComponent, DrilldownWidgetComponent, DateRangeFilterTileComponent, DrilldownBreadcrumbsComponent, ContextMenuComponent, BoxplotChartComponent, ScattermapChartComponent, AreamapChartComponent, PivotTableComponent, DashboardByIdComponent, DashboardComponent, } from './components';
 import { DecoratorsModule } from './decorators/decorators.module';
 import * as i0 from "@angular/core";
 /**
@@ -41,6 +41,7 @@ SdkUiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "1
         ColumnChartComponent,
         BarChartComponent,
         AreaChartComponent,
+        AreaRangeChartComponent,
         LineChartComponent,
         IndicatorChartComponent,
         ScatterChartComponent,
@@ -59,13 +60,16 @@ SdkUiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "1
         BoxplotChartComponent,
         ScattermapChartComponent,
         AreamapChartComponent,
-        PivotTableComponent], imports: [CommonModule, DecoratorsModule], exports: [BasicMemberFilterTileComponent,
+        PivotTableComponent,
+        DashboardByIdComponent,
+        DashboardComponent], imports: [CommonModule, DecoratorsModule], exports: [BasicMemberFilterTileComponent,
         ChartComponent,
         TableComponent,
         ChartWidgetComponent,
         ColumnChartComponent,
         BarChartComponent,
         AreaChartComponent,
+        AreaRangeChartComponent,
         LineChartComponent,
         IndicatorChartComponent,
         ScatterChartComponent,
@@ -84,7 +88,9 @@ SdkUiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "1
         BoxplotChartComponent,
         ScattermapChartComponent,
         AreamapChartComponent,
-        PivotTableComponent] });
+        PivotTableComponent,
+        DashboardByIdComponent,
+        DashboardComponent] });
 SdkUiModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SdkUiModule, imports: [CommonModule, DecoratorsModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SdkUiModule, decorators: [{
             type: NgModule,
@@ -97,6 +103,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                         ColumnChartComponent,
                         BarChartComponent,
                         AreaChartComponent,
+                        AreaRangeChartComponent,
                         LineChartComponent,
                         IndicatorChartComponent,
                         ScatterChartComponent,
@@ -116,6 +123,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                         ScattermapChartComponent,
                         AreamapChartComponent,
                         PivotTableComponent,
+                        DashboardByIdComponent,
+                        DashboardComponent,
                     ],
                     imports: [CommonModule, DecoratorsModule],
                     exports: [
@@ -126,6 +135,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                         ColumnChartComponent,
                         BarChartComponent,
                         AreaChartComponent,
+                        AreaRangeChartComponent,
                         LineChartComponent,
                         IndicatorChartComponent,
                         ScatterChartComponent,
@@ -145,8 +155,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                         ScattermapChartComponent,
                         AreamapChartComponent,
                         PivotTableComponent,
+                        DashboardByIdComponent,
+                        DashboardComponent,
                     ],
                     providers: [],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2RrLXVpLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvc2RrLXVpLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQ0wsOEJBQThCLEVBQzlCLGNBQWMsRUFDZCxjQUFjLEVBQ2Qsb0JBQW9CLEVBQ3BCLG9CQUFvQixFQUNwQixpQkFBaUIsRUFDakIsa0JBQWtCLEVBQ2xCLGtCQUFrQixFQUNsQix1QkFBdUIsRUFDdkIscUJBQXFCLEVBQ3JCLGlCQUFpQixFQUNqQixvQkFBb0IsRUFDcEIsbUJBQW1CLEVBQ25CLHFCQUFxQixFQUNyQixzQkFBc0IsRUFDdEIsb0JBQW9CLEVBQ3BCLHdCQUF3QixFQUN4Qix5QkFBeUIsRUFDekIsd0JBQXdCLEVBQ3hCLDRCQUE0QixFQUM1Qiw2QkFBNkIsRUFDN0Isb0JBQW9CLEVBQ3BCLHFCQUFxQixFQUNyQix3QkFBd0IsRUFDeEIscUJBQXFCLEVBQ3JCLG1CQUFtQixHQUNwQixNQUFNLGNBQWMsQ0FBQztBQUN0QixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQzs7QUFFbEU7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTJCRztBQTZESCxNQUFNLE9BQU8sV0FBVzs7eUdBQVgsV0FBVzswR0FBWCxXQUFXLGlCQTFEcEIsOEJBQThCO1FBQzlCLGNBQWM7UUFDZCxjQUFjO1FBQ2Qsb0JBQW9CO1FBQ3BCLG9CQUFvQjtRQUNwQixpQkFBaUI7UUFDakIsa0JBQWtCO1FBQ2xCLGtCQUFrQjtRQUNsQix1QkFBdUI7UUFDdkIscUJBQXFCO1FBQ3JCLGlCQUFpQjtRQUNqQixvQkFBb0I7UUFDcEIsbUJBQW1CO1FBQ25CLHFCQUFxQjtRQUNyQixzQkFBc0I7UUFDdEIsb0JBQW9CO1FBQ3BCLHdCQUF3QjtRQUN4Qix5QkFBeUI7UUFDekIsd0JBQXdCO1FBQ3hCLDRCQUE0QjtRQUM1Qiw2QkFBNkI7UUFDN0Isb0JBQW9CO1FBQ3BCLHFCQUFxQjtRQUNyQix3QkFBd0I7UUFDeEIscUJBQXFCO1FBQ3JCLG1CQUFtQixhQUVYLFlBQVksRUFBRSxnQkFBZ0IsYUFFdEMsOEJBQThCO1FBQzlCLGNBQWM7UUFDZCxjQUFjO1FBQ2Qsb0JBQW9CO1FBQ3BCLG9CQUFvQjtRQUNwQixpQkFBaUI7UUFDakIsa0JBQWtCO1FBQ2xCLGtCQUFrQjtRQUNsQix1QkFBdUI7UUFDdkIscUJBQXFCO1FBQ3JCLGlCQUFpQjtRQUNqQixvQkFBb0I7UUFDcEIsbUJBQW1CO1FBQ25CLHFCQUFxQjtRQUNyQixzQkFBc0I7UUFDdEIsb0JBQW9CO1FBQ3BCLHdCQUF3QjtRQUN4Qix5QkFBeUI7UUFDekIsd0JBQXdCO1FBQ3hCLDRCQUE0QjtRQUM1Qiw2QkFBNkI7UUFDN0Isb0JBQW9CO1FBQ3BCLHFCQUFxQjtRQUNyQix3QkFBd0I7UUFDeEIscUJBQXFCO1FBQ3JCLG1CQUFtQjswR0FJVixXQUFXLFlBL0JaLFlBQVksRUFBRSxnQkFBZ0I7NEZBK0I3QixXQUFXO2tCQTVEdkIsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUU7d0JBQ1osOEJBQThCO3dCQUM5QixjQUFjO3dCQUNkLGNBQWM7d0JBQ2Qsb0JBQW9CO3dCQUNwQixvQkFBb0I7d0JBQ3BCLGlCQUFpQjt3QkFDakIsa0JBQWtCO3dCQUNsQixrQkFBa0I7d0JBQ2xCLHVCQUF1Qjt3QkFDdkIscUJBQXFCO3dCQUNyQixpQkFBaUI7d0JBQ2pCLG9CQUFvQjt3QkFDcEIsbUJBQW1CO3dCQUNuQixxQkFBcUI7d0JBQ3JCLHNCQUFzQjt3QkFDdEIsb0JBQW9CO3dCQUNwQix3QkFBd0I7d0JBQ3hCLHlCQUF5Qjt3QkFDekIsd0JBQXdCO3dCQUN4Qiw0QkFBNEI7d0JBQzVCLDZCQUE2Qjt3QkFDN0Isb0JBQW9CO3dCQUNwQixxQkFBcUI7d0JBQ3JCLHdCQUF3Qjt3QkFDeEIscUJBQXFCO3dCQUNyQixtQkFBbUI7cUJBQ3BCO29CQUNELE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxnQkFBZ0IsQ0FBQztvQkFDekMsT0FBTyxFQUFFO3dCQUNQLDhCQUE4Qjt3QkFDOUIsY0FBYzt3QkFDZCxjQUFjO3dCQUNkLG9CQUFvQjt3QkFDcEIsb0JBQW9CO3dCQUNwQixpQkFBaUI7d0JBQ2pCLGtCQUFrQjt3QkFDbEIsa0JBQWtCO3dCQUNsQix1QkFBdUI7d0JBQ3ZCLHFCQUFxQjt3QkFDckIsaUJBQWlCO3dCQUNqQixvQkFBb0I7d0JBQ3BCLG1CQUFtQjt3QkFDbkIscUJBQXFCO3dCQUNyQixzQkFBc0I7d0JBQ3RCLG9CQUFvQjt3QkFDcEIsd0JBQXdCO3dCQUN4Qix5QkFBeUI7d0JBQ3pCLHdCQUF3Qjt3QkFDeEIsNEJBQTRCO3dCQUM1Qiw2QkFBNkI7d0JBQzdCLG9CQUFvQjt3QkFDcEIscUJBQXFCO3dCQUNyQix3QkFBd0I7d0JBQ3hCLHFCQUFxQjt3QkFDckIsbUJBQW1CO3FCQUNwQjtvQkFDRCxTQUFTLEVBQUUsRUFBRTtpQkFDZCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHtcbiAgQmFzaWNNZW1iZXJGaWx0ZXJUaWxlQ29tcG9uZW50LFxuICBDaGFydENvbXBvbmVudCxcbiAgVGFibGVDb21wb25lbnQsXG4gIENoYXJ0V2lkZ2V0Q29tcG9uZW50LFxuICBDb2x1bW5DaGFydENvbXBvbmVudCxcbiAgQmFyQ2hhcnRDb21wb25lbnQsXG4gIEFyZWFDaGFydENvbXBvbmVudCxcbiAgTGluZUNoYXJ0Q29tcG9uZW50LFxuICBJbmRpY2F0b3JDaGFydENvbXBvbmVudCxcbiAgU2NhdHRlckNoYXJ0Q29tcG9uZW50LFxuICBQaWVDaGFydENvbXBvbmVudCxcbiAgRnVubmVsQ2hhcnRDb21wb25lbnQsXG4gIFBvbGFyQ2hhcnRDb21wb25lbnQsXG4gIFRyZWVtYXBDaGFydENvbXBvbmVudCxcbiAgU3VuYnVyc3RDaGFydENvbXBvbmVudCxcbiAgVGFibGVXaWRnZXRDb21wb25lbnQsXG4gIERhc2hib2FyZFdpZGdldENvbXBvbmVudCxcbiAgTWVtYmVyRmlsdGVyVGlsZUNvbXBvbmVudCxcbiAgRHJpbGxkb3duV2lkZ2V0Q29tcG9uZW50LFxuICBEYXRlUmFuZ2VGaWx0ZXJUaWxlQ29tcG9uZW50LFxuICBEcmlsbGRvd25CcmVhZGNydW1ic0NvbXBvbmVudCxcbiAgQ29udGV4dE1lbnVDb21wb25lbnQsXG4gIEJveHBsb3RDaGFydENvbXBvbmVudCxcbiAgU2NhdHRlcm1hcENoYXJ0Q29tcG9uZW50LFxuICBBcmVhbWFwQ2hhcnRDb21wb25lbnQsXG4gIFBpdm90VGFibGVDb21wb25lbnQsXG59IGZyb20gJy4vY29tcG9uZW50cyc7XG5pbXBvcnQgeyBEZWNvcmF0b3JzTW9kdWxlIH0gZnJvbSAnLi9kZWNvcmF0b3JzL2RlY29yYXRvcnMubW9kdWxlJztcblxuLyoqXG4gKiBTREsgVUkgTW9kdWxlLCB3aGljaCBpcyBhIGNvbnRhaW5lciBmb3IgY29tcG9uZW50cy5cbiAqXG4gKiBAZXhhbXBsZVxuICogRXhhbXBsZSBvZiBpbXBvcnRpbmcgYFNka1VpTW9kdWxlYCBhbmQgaW5qZWN0aW5nIHtAbGluayBTaXNlbnNlQ29udGV4dENvbmZpZ30gaW50byB5b3VyIGFwcGxpY2F0aW9uOlxuICpcbiAqIGBgYHRzXG4gKiBleHBvcnQgY29uc3QgU0lTRU5TRV9DT05URVhUX0NPTkZJRzogU2lzZW5zZUNvbnRleHRDb25maWcgPSB7XG4gKiAgIHVybD1cIjxpbnN0YW5jZSB1cmw+XCIgLy8gcmVwbGFjZSB3aXRoIHRoZSBVUkwgb2YgeW91ciBTaXNlbnNlIGluc3RhbmNlXG4gKiAgIHRva2VuPVwiPGFwaSB0b2tlbj5cIiAvLyByZXBsYWNlIHdpdGggdGhlIEFQSSB0b2tlbiBvZiB5b3VyIHVzZXIgYWNjb3VudFxuICogICBkZWZhdWx0RGF0YVNvdXJjZTogRE0uRGF0YVNvdXJjZSxcbiAqIH07XG4gKlxuICogQE5nTW9kdWxlKHtcbiAqICAgaW1wb3J0czogW1xuICogICAgIEJyb3dzZXJNb2R1bGUsXG4gKiAgICAgU2RrVWlNb2R1bGUsXG4gKiAgIF0sXG4gKiAgIGRlY2xhcmF0aW9uczogW0FwcENvbXBvbmVudF0sXG4gKiAgIHByb3ZpZGVyczogW1xuICogICAgIHsgcHJvdmlkZTogU0lTRU5TRV9DT05URVhUX0NPTkZJR19UT0tFTiwgdXNlVmFsdWU6IFNJU0VOU0VfQ09OVEVYVF9DT05GSUcgfSxcbiAqICAgXSxcbiAqICAgYm9vdHN0cmFwOiBbQXBwQ29tcG9uZW50XSxcbiAqIH0pXG4gKiBgYGBcbiAqXG4gKiBAZ3JvdXAgQ29udGV4dHNcbiAqL1xuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgQmFzaWNNZW1iZXJGaWx0ZXJUaWxlQ29tcG9uZW50LFxuICAgIENoYXJ0Q29tcG9uZW50LFxuICAgIFRhYmxlQ29tcG9uZW50LFxuICAgIENoYXJ0V2lkZ2V0Q29tcG9uZW50LFxuICAgIENvbHVtbkNoYXJ0Q29tcG9uZW50LFxuICAgIEJhckNoYXJ0Q29tcG9uZW50LFxuICAgIEFyZWFDaGFydENvbXBvbmVudCxcbiAgICBMaW5lQ2hhcnRDb21wb25lbnQsXG4gICAgSW5kaWNhdG9yQ2hhcnRDb21wb25lbnQsXG4gICAgU2NhdHRlckNoYXJ0Q29tcG9uZW50LFxuICAgIFBpZUNoYXJ0Q29tcG9uZW50LFxuICAgIEZ1bm5lbENoYXJ0Q29tcG9uZW50LFxuICAgIFBvbGFyQ2hhcnRDb21wb25lbnQsXG4gICAgVHJlZW1hcENoYXJ0Q29tcG9uZW50LFxuICAgIFN1bmJ1cnN0Q2hhcnRDb21wb25lbnQsXG4gICAgVGFibGVXaWRnZXRDb21wb25lbnQsXG4gICAgRGFzaGJvYXJkV2lkZ2V0Q29tcG9uZW50LFxuICAgIE1lbWJlckZpbHRlclRpbGVDb21wb25lbnQsXG4gICAgRHJpbGxkb3duV2lkZ2V0Q29tcG9uZW50LFxuICAgIERhdGVSYW5nZUZpbHRlclRpbGVDb21wb25lbnQsXG4gICAgRHJpbGxkb3duQnJlYWRjcnVtYnNDb21wb25lbnQsXG4gICAgQ29udGV4dE1lbnVDb21wb25lbnQsXG4gICAgQm94cGxvdENoYXJ0Q29tcG9uZW50LFxuICAgIFNjYXR0ZXJtYXBDaGFydENvbXBvbmVudCxcbiAgICBBcmVhbWFwQ2hhcnRDb21wb25lbnQsXG4gICAgUGl2b3RUYWJsZUNvbXBvbmVudCxcbiAgXSxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgRGVjb3JhdG9yc01vZHVsZV0sXG4gIGV4cG9ydHM6IFtcbiAgICBCYXNpY01lbWJlckZpbHRlclRpbGVDb21wb25lbnQsXG4gICAgQ2hhcnRDb21wb25lbnQsXG4gICAgVGFibGVDb21wb25lbnQsXG4gICAgQ2hhcnRXaWRnZXRDb21wb25lbnQsXG4gICAgQ29sdW1uQ2hhcnRDb21wb25lbnQsXG4gICAgQmFyQ2hhcnRDb21wb25lbnQsXG4gICAgQXJlYUNoYXJ0Q29tcG9uZW50LFxuICAgIExpbmVDaGFydENvbXBvbmVudCxcbiAgICBJbmRpY2F0b3JDaGFydENvbXBvbmVudCxcbiAgICBTY2F0dGVyQ2hhcnRDb21wb25lbnQsXG4gICAgUGllQ2hhcnRDb21wb25lbnQsXG4gICAgRnVubmVsQ2hhcnRDb21wb25lbnQsXG4gICAgUG9sYXJDaGFydENvbXBvbmVudCxcbiAgICBUcmVlbWFwQ2hhcnRDb21wb25lbnQsXG4gICAgU3VuYnVyc3RDaGFydENvbXBvbmVudCxcbiAgICBUYWJsZVdpZGdldENvbXBvbmVudCxcbiAgICBEYXNoYm9hcmRXaWRnZXRDb21wb25lbnQsXG4gICAgTWVtYmVyRmlsdGVyVGlsZUNvbXBvbmVudCxcbiAgICBEcmlsbGRvd25XaWRnZXRDb21wb25lbnQsXG4gICAgRGF0ZVJhbmdlRmlsdGVyVGlsZUNvbXBvbmVudCxcbiAgICBEcmlsbGRvd25CcmVhZGNydW1ic0NvbXBvbmVudCxcbiAgICBDb250ZXh0TWVudUNvbXBvbmVudCxcbiAgICBCb3hwbG90Q2hhcnRDb21wb25lbnQsXG4gICAgU2NhdHRlcm1hcENoYXJ0Q29tcG9uZW50LFxuICAgIEFyZWFtYXBDaGFydENvbXBvbmVudCxcbiAgICBQaXZvdFRhYmxlQ29tcG9uZW50LFxuICBdLFxuICBwcm92aWRlcnM6IFtdLFxufSlcbmV4cG9ydCBjbGFzcyBTZGtVaU1vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk-ui.module.js","sourceRoot":"","sources":["../../../src/lib/sdk-ui.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EACL,8BAA8B,EAC9B,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,uBAAuB,EACvB,kBAAkB,EAClB,uBAAuB,EACvB,qBAAqB,EACrB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,EACxB,4BAA4B,EAC5B,6BAA6B,EAC7B,oBAAoB,EACpB,qBAAqB,EACrB,wBAAwB,EACxB,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAmEH,MAAM,OAAO,WAAW;;yGAAX,WAAW;0GAAX,WAAW,iBAhEpB,8BAA8B;QAC9B,cAAc;QACd,cAAc;QACd,oBAAoB;QACpB,oBAAoB;QACpB,iBAAiB;QACjB,kBAAkB;QAClB,uBAAuB;QACvB,kBAAkB;QAClB,uBAAuB;QACvB,qBAAqB;QACrB,iBAAiB;QACjB,oBAAoB;QACpB,mBAAmB;QACnB,qBAAqB;QACrB,sBAAsB;QACtB,oBAAoB;QACpB,wBAAwB;QACxB,yBAAyB;QACzB,wBAAwB;QACxB,4BAA4B;QAC5B,6BAA6B;QAC7B,oBAAoB;QACpB,qBAAqB;QACrB,wBAAwB;QACxB,qBAAqB;QACrB,mBAAmB;QACnB,sBAAsB;QACtB,kBAAkB,aAEV,YAAY,EAAE,gBAAgB,aAEtC,8BAA8B;QAC9B,cAAc;QACd,cAAc;QACd,oBAAoB;QACpB,oBAAoB;QACpB,iBAAiB;QACjB,kBAAkB;QAClB,uBAAuB;QACvB,kBAAkB;QAClB,uBAAuB;QACvB,qBAAqB;QACrB,iBAAiB;QACjB,oBAAoB;QACpB,mBAAmB;QACnB,qBAAqB;QACrB,sBAAsB;QACtB,oBAAoB;QACpB,wBAAwB;QACxB,yBAAyB;QACzB,wBAAwB;QACxB,4BAA4B;QAC5B,6BAA6B;QAC7B,oBAAoB;QACpB,qBAAqB;QACrB,wBAAwB;QACxB,qBAAqB;QACrB,mBAAmB;QACnB,sBAAsB;QACtB,kBAAkB;0GAIT,WAAW,YAlCZ,YAAY,EAAE,gBAAgB;4FAkC7B,WAAW;kBAlEvB,QAAQ;mBAAC;oBACR,YAAY,EAAE;wBACZ,8BAA8B;wBAC9B,cAAc;wBACd,cAAc;wBACd,oBAAoB;wBACpB,oBAAoB;wBACpB,iBAAiB;wBACjB,kBAAkB;wBAClB,uBAAuB;wBACvB,kBAAkB;wBAClB,uBAAuB;wBACvB,qBAAqB;wBACrB,iBAAiB;wBACjB,oBAAoB;wBACpB,mBAAmB;wBACnB,qBAAqB;wBACrB,sBAAsB;wBACtB,oBAAoB;wBACpB,wBAAwB;wBACxB,yBAAyB;wBACzB,wBAAwB;wBACxB,4BAA4B;wBAC5B,6BAA6B;wBAC7B,oBAAoB;wBACpB,qBAAqB;wBACrB,wBAAwB;wBACxB,qBAAqB;wBACrB,mBAAmB;wBACnB,sBAAsB;wBACtB,kBAAkB;qBACnB;oBACD,OAAO,EAAE,CAAC,YAAY,EAAE,gBAAgB,CAAC;oBACzC,OAAO,EAAE;wBACP,8BAA8B;wBAC9B,cAAc;wBACd,cAAc;wBACd,oBAAoB;wBACpB,oBAAoB;wBACpB,iBAAiB;wBACjB,kBAAkB;wBAClB,uBAAuB;wBACvB,kBAAkB;wBAClB,uBAAuB;wBACvB,qBAAqB;wBACrB,iBAAiB;wBACjB,oBAAoB;wBACpB,mBAAmB;wBACnB,qBAAqB;wBACrB,sBAAsB;wBACtB,oBAAoB;wBACpB,wBAAwB;wBACxB,yBAAyB;wBACzB,wBAAwB;wBACxB,4BAA4B;wBAC5B,6BAA6B;wBAC7B,oBAAoB;wBACpB,qBAAqB;wBACrB,wBAAwB;wBACxB,qBAAqB;wBACrB,mBAAmB;wBACnB,sBAAsB;wBACtB,kBAAkB;qBACnB;oBACD,SAAS,EAAE,EAAE;iBACd","sourcesContent":["import { NgModule } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport {\n  BasicMemberFilterTileComponent,\n  ChartComponent,\n  TableComponent,\n  ChartWidgetComponent,\n  ColumnChartComponent,\n  BarChartComponent,\n  AreaChartComponent,\n  AreaRangeChartComponent,\n  LineChartComponent,\n  IndicatorChartComponent,\n  ScatterChartComponent,\n  PieChartComponent,\n  FunnelChartComponent,\n  PolarChartComponent,\n  TreemapChartComponent,\n  SunburstChartComponent,\n  TableWidgetComponent,\n  DashboardWidgetComponent,\n  MemberFilterTileComponent,\n  DrilldownWidgetComponent,\n  DateRangeFilterTileComponent,\n  DrilldownBreadcrumbsComponent,\n  ContextMenuComponent,\n  BoxplotChartComponent,\n  ScattermapChartComponent,\n  AreamapChartComponent,\n  PivotTableComponent,\n  DashboardByIdComponent,\n  DashboardComponent,\n} from './components';\nimport { DecoratorsModule } from './decorators/decorators.module';\n\n/**\n * SDK UI Module, which is a container for components.\n *\n * @example\n * Example of importing `SdkUiModule` and injecting {@link SisenseContextConfig} into your application:\n *\n * ```ts\n * export const SISENSE_CONTEXT_CONFIG: SisenseContextConfig = {\n *   url=\"<instance url>\" // replace with the URL of your Sisense instance\n *   token=\"<api token>\" // replace with the API token of your user account\n *   defaultDataSource: DM.DataSource,\n * };\n *\n * @NgModule({\n *   imports: [\n *     BrowserModule,\n *     SdkUiModule,\n *   ],\n *   declarations: [AppComponent],\n *   providers: [\n *     { provide: SISENSE_CONTEXT_CONFIG_TOKEN, useValue: SISENSE_CONTEXT_CONFIG },\n *   ],\n *   bootstrap: [AppComponent],\n * })\n * ```\n *\n * @group Contexts\n */\n@NgModule({\n  declarations: [\n    BasicMemberFilterTileComponent,\n    ChartComponent,\n    TableComponent,\n    ChartWidgetComponent,\n    ColumnChartComponent,\n    BarChartComponent,\n    AreaChartComponent,\n    AreaRangeChartComponent,\n    LineChartComponent,\n    IndicatorChartComponent,\n    ScatterChartComponent,\n    PieChartComponent,\n    FunnelChartComponent,\n    PolarChartComponent,\n    TreemapChartComponent,\n    SunburstChartComponent,\n    TableWidgetComponent,\n    DashboardWidgetComponent,\n    MemberFilterTileComponent,\n    DrilldownWidgetComponent,\n    DateRangeFilterTileComponent,\n    DrilldownBreadcrumbsComponent,\n    ContextMenuComponent,\n    BoxplotChartComponent,\n    ScattermapChartComponent,\n    AreamapChartComponent,\n    PivotTableComponent,\n    DashboardByIdComponent,\n    DashboardComponent,\n  ],\n  imports: [CommonModule, DecoratorsModule],\n  exports: [\n    BasicMemberFilterTileComponent,\n    ChartComponent,\n    TableComponent,\n    ChartWidgetComponent,\n    ColumnChartComponent,\n    BarChartComponent,\n    AreaChartComponent,\n    AreaRangeChartComponent,\n    LineChartComponent,\n    IndicatorChartComponent,\n    ScatterChartComponent,\n    PieChartComponent,\n    FunnelChartComponent,\n    PolarChartComponent,\n    TreemapChartComponent,\n    SunburstChartComponent,\n    TableWidgetComponent,\n    DashboardWidgetComponent,\n    MemberFilterTileComponent,\n    DrilldownWidgetComponent,\n    DateRangeFilterTileComponent,\n    DrilldownBreadcrumbsComponent,\n    ContextMenuComponent,\n    BoxplotChartComponent,\n    ScattermapChartComponent,\n    AreamapChartComponent,\n    PivotTableComponent,\n    DashboardByIdComponent,\n    DashboardComponent,\n  ],\n  providers: [],\n})\nexport class SdkUiModule {}\n"]}