@sisense/sdk-ui-angular 2.9.0 → 2.11.0

package/dist/ai/lib/services/ai.service.d.ts

@@ -59,8 +59,8 @@ export declare const AI_CONTEXT_CONFIG_TOKEN: InjectionToken<AiContextConfig>;
  */
 export declare class AiService {
     private sisenseContextService;
-    private apiPromise;
-    constructor(sisenseContextService: SisenseContextService, aiContextConfig?: AiContextConfig);
+    private aiContextConfig?;
+    constructor(sisenseContextService: SisenseContextService, aiContextConfig?: AiContextConfig | undefined);
     /** @internal */
     getApi(): Promise<ChatRestApi>;
     /**

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

@@ -50,13 +50,13 @@ export const AI_CONTEXT_CONFIG_TOKEN = new InjectionToken('AI Context Config');
 let AiService = class AiService {
     constructor(sisenseContextService, aiContextConfig) {
         this.sisenseContextService = sisenseContextService;
-        this.apiPromise = this.sisenseContextService
-            .getApp()
-            .then((app) => new ChatRestApi(app.httpClient, aiContextConfig?.volatile));
+        this.aiContextConfig = aiContextConfig;
     }
     /** @internal */
     getApi() {
-        return this.apiPromise;
+        return this.sisenseContextService
+            .getApp()
+            .then((app) => new ChatRestApi(app.httpClient, this.aiContextConfig?.volatile));
     }
     /**
      * Fetches an analysis of the provided query using natural language generation (NLG).
@@ -131,4 +131,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     type: Inject,
                     args: [AI_CONTEXT_CONFIG_TOKEN]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai.service.js","sourceRoot":"","sources":["../../../../../src/ai/lib/services/ai.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport { SisenseContextService, TrackableService, WidgetProps } from '@sisense/sdk-ui-angular';\nimport {\n  AiContextProviderProps,\n  ChatRestApi,\n  DEFAULT_RECOMMENDATIONS_COUNT,\n  GetNlgInsightsResponse,\n  GetNlqResultParams,\n  GetQueryRecommendationsParams,\n  prepareGetNlgInsightsPayload,\n  prepareGetNlqResultPayload,\n  QueryRecommendation as QueryRecommendationPreact,\n  UseGetNlgInsightsParams,\n  widgetComposer,\n} from '@sisense/sdk-ui-preact/ai';\n\nexport interface AiContextConfig extends Omit<AiContextProviderProps, 'children'> {}\nexport interface GetNlgInsightsParams extends Omit<UseGetNlgInsightsParams, 'enabled'> {}\n\n/**\n * {@inheritDoc @sisense/sdk-ui!QueryRecommendation}\n */\nexport interface QueryRecommendation extends Omit<QueryRecommendationPreact, 'widgetProps'> {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!QueryRecommendation.widgetProps}\n   */\n  widgetProps?: WidgetProps;\n}\n\n/**\n * Token used to inject {@link AiContextConfig} into your application.\n *\n * @example\n * Example of importing {@link SdkAiModule} and injecting {@link AiContextConfig} into your application,\n * along with importing dependency {@link SdkUiModule} and injecting {@link SisenseContextConfig} to connect to a Sisense instance:\n *\n * ```ts\n * import { SdkUiModule, SisenseContextConfig } from '@sisense/sdk-ui-angular';\n * import { SdkAiModule, AI_CONTEXT_CONFIG_TOKEN, AiContextConfig } from '@sisense/sdk-ui-angular/ai';\n *\n * const AI_CONTEXT_CONFIG: AiContextConfig = {\n *   volatile: true,\n * };\n * 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 *     SdkAiModule,\n *   ],\n *   declarations: [AppComponent],\n *   providers: [\n *     { provide: AI_CONTEXT_CONFIG_TOKEN, useValue: AI_CONTEXT_CONFIG },\n *     { provide: SISENSE_CONTEXT_CONFIG_TOKEN, useValue: SISENSE_CONTEXT_CONFIG },\n *   ],\n *   bootstrap: [AppComponent],\n * })\n * ```\n * @group Generative AI\n */\nexport const AI_CONTEXT_CONFIG_TOKEN = new InjectionToken<AiContextConfig>('AI Context Config');\n\n/**\n * Service for working with Sisense Fusion Generative AI.\n *\n * @group Generative AI\n */\n@Injectable({\n  providedIn: 'root',\n})\n@TrackableService<AiService>(['getNlgInsights', 'getQueryRecommendations'])\nexport class AiService {\n  private apiPromise: Promise<ChatRestApi>;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    @Optional() @Inject(AI_CONTEXT_CONFIG_TOKEN) aiContextConfig?: AiContextConfig,\n  ) {\n    this.apiPromise = this.sisenseContextService\n      .getApp()\n      .then((app) => new ChatRestApi(app.httpClient, aiContextConfig?.volatile));\n  }\n\n  /** @internal */\n  getApi(): Promise<ChatRestApi> {\n    return this.apiPromise;\n  }\n\n  /**\n   * Fetches an analysis of the provided query using natural language generation (NLG).\n   * Specifying NLG parameters is similar to providing parameters to the {@link QueryService.executeQuery} service method, using dimensions, measures, and filters.\n   *\n   * @param params - Parameters for getting NLG insights\n   * @returns NLG insights text summary\n   */\n  async getNlgInsights(params: GetNlgInsightsParams): Promise<string | undefined> {\n    const api = await this.getApi();\n    const payload = prepareGetNlgInsightsPayload(params);\n    return api.ai\n      .getNlgInsights(payload)\n      .then((response?: GetNlgInsightsResponse) => response?.data?.answer);\n  }\n\n  /**\n   * Fetches recommended questions for a data model or perspective.\n   *\n   * @param params - Parameters for recommendations\n   * @returns An array of objects, each containing recommended question text and its corresponding `widgetProps`\n   * @beta\n   */\n  async getQueryRecommendations(\n    params: GetQueryRecommendationsParams,\n  ): Promise<QueryRecommendation[]> {\n    const api = await this.getApi();\n    const { contextTitle, count, enableAxisTitlesInWidgetProps, customPrompt } = params;\n    const recCount = count ?? DEFAULT_RECOMMENDATIONS_COUNT;\n\n    const rawRecommendations =\n      (await api.ai.getQueryRecommendations(contextTitle, {\n        numOfRecommendations: recCount,\n        ...(customPrompt ? { userPrompt: customPrompt } : undefined),\n      })) || [];\n\n    return rawRecommendations.map(\n      (recommendation: QueryRecommendationPreact) =>\n        ({\n          ...recommendation,\n          widgetProps: recommendation.jaql\n            ? widgetComposer.toWidgetProps(recommendation, {\n                useCustomizedStyleOptions: enableAxisTitlesInWidgetProps,\n              })\n            : undefined,\n        } as QueryRecommendation),\n    );\n  }\n\n  /**\n   * Executes a natural language query (NLQ) against a data model or perspective\n   *\n   * @param params - NLQ query parameters\n   * @returns The result as WidgetProps\n   * @beta\n   */\n  async getNlqResult(params: GetNlqResultParams): Promise<WidgetProps | undefined> {\n    const { contextTitle, request } = prepareGetNlqResultPayload(params);\n    const api = await this.getApi();\n\n    const data = await api?.ai.getNlqResult(contextTitle, request);\n\n    return data\n      ? (widgetComposer.toWidgetProps(data, {\n          useCustomizedStyleOptions: params.enableAxisTitlesInWidgetProps || false,\n        }) as WidgetProps)\n      : undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai.service.js","sourceRoot":"","sources":["../../../../../src/ai/lib/services/ai.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport { SisenseContextService, TrackableService, WidgetProps } from '@sisense/sdk-ui-angular';\nimport {\n  AiContextProviderProps,\n  ChatRestApi,\n  DEFAULT_RECOMMENDATIONS_COUNT,\n  GetNlgInsightsResponse,\n  GetNlqResultParams,\n  GetQueryRecommendationsParams,\n  prepareGetNlgInsightsPayload,\n  prepareGetNlqResultPayload,\n  QueryRecommendation as QueryRecommendationPreact,\n  UseGetNlgInsightsParams,\n  widgetComposer,\n} from '@sisense/sdk-ui-preact/ai';\n\nexport interface AiContextConfig extends Omit<AiContextProviderProps, 'children'> {}\nexport interface GetNlgInsightsParams extends Omit<UseGetNlgInsightsParams, 'enabled'> {}\n\n/**\n * {@inheritDoc @sisense/sdk-ui!QueryRecommendation}\n */\nexport interface QueryRecommendation extends Omit<QueryRecommendationPreact, 'widgetProps'> {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!QueryRecommendation.widgetProps}\n   */\n  widgetProps?: WidgetProps;\n}\n\n/**\n * Token used to inject {@link AiContextConfig} into your application.\n *\n * @example\n * Example of importing {@link SdkAiModule} and injecting {@link AiContextConfig} into your application,\n * along with importing dependency {@link SdkUiModule} and injecting {@link SisenseContextConfig} to connect to a Sisense instance:\n *\n * ```ts\n * import { SdkUiModule, SisenseContextConfig } from '@sisense/sdk-ui-angular';\n * import { SdkAiModule, AI_CONTEXT_CONFIG_TOKEN, AiContextConfig } from '@sisense/sdk-ui-angular/ai';\n *\n * const AI_CONTEXT_CONFIG: AiContextConfig = {\n *   volatile: true,\n * };\n * 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 *     SdkAiModule,\n *   ],\n *   declarations: [AppComponent],\n *   providers: [\n *     { provide: AI_CONTEXT_CONFIG_TOKEN, useValue: AI_CONTEXT_CONFIG },\n *     { provide: SISENSE_CONTEXT_CONFIG_TOKEN, useValue: SISENSE_CONTEXT_CONFIG },\n *   ],\n *   bootstrap: [AppComponent],\n * })\n * ```\n * @group Generative AI\n */\nexport const AI_CONTEXT_CONFIG_TOKEN = new InjectionToken<AiContextConfig>('AI Context Config');\n\n/**\n * Service for working with Sisense Fusion Generative AI.\n *\n * @group Generative AI\n */\n@Injectable({\n  providedIn: 'root',\n})\n@TrackableService<AiService>(['getNlgInsights', 'getQueryRecommendations'])\nexport class AiService {\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    @Optional() @Inject(AI_CONTEXT_CONFIG_TOKEN) private aiContextConfig?: AiContextConfig,\n  ) {}\n\n  /** @internal */\n  getApi(): Promise<ChatRestApi> {\n    return this.sisenseContextService\n      .getApp()\n      .then((app) => new ChatRestApi(app.httpClient, this.aiContextConfig?.volatile));\n  }\n\n  /**\n   * Fetches an analysis of the provided query using natural language generation (NLG).\n   * Specifying NLG parameters is similar to providing parameters to the {@link QueryService.executeQuery} service method, using dimensions, measures, and filters.\n   *\n   * @param params - Parameters for getting NLG insights\n   * @returns NLG insights text summary\n   */\n  async getNlgInsights(params: GetNlgInsightsParams): Promise<string | undefined> {\n    const api = await this.getApi();\n    const payload = prepareGetNlgInsightsPayload(params);\n    return api.ai\n      .getNlgInsights(payload)\n      .then((response?: GetNlgInsightsResponse) => response?.data?.answer);\n  }\n\n  /**\n   * Fetches recommended questions for a data model or perspective.\n   *\n   * @param params - Parameters for recommendations\n   * @returns An array of objects, each containing recommended question text and its corresponding `widgetProps`\n   * @beta\n   */\n  async getQueryRecommendations(\n    params: GetQueryRecommendationsParams,\n  ): Promise<QueryRecommendation[]> {\n    const api = await this.getApi();\n    const { contextTitle, count, enableAxisTitlesInWidgetProps, customPrompt } = params;\n    const recCount = count ?? DEFAULT_RECOMMENDATIONS_COUNT;\n\n    const rawRecommendations =\n      (await api.ai.getQueryRecommendations(contextTitle, {\n        numOfRecommendations: recCount,\n        ...(customPrompt ? { userPrompt: customPrompt } : undefined),\n      })) || [];\n\n    return rawRecommendations.map(\n      (recommendation: QueryRecommendationPreact) =>\n        ({\n          ...recommendation,\n          widgetProps: recommendation.jaql\n            ? widgetComposer.toWidgetProps(recommendation, {\n                useCustomizedStyleOptions: enableAxisTitlesInWidgetProps,\n              })\n            : undefined,\n        } as QueryRecommendation),\n    );\n  }\n\n  /**\n   * Executes a natural language query (NLQ) against a data model or perspective\n   *\n   * @param params - NLQ query parameters\n   * @returns The result as WidgetProps\n   * @beta\n   */\n  async getNlqResult(params: GetNlqResultParams): Promise<WidgetProps | undefined> {\n    const { contextTitle, request } = prepareGetNlqResultPayload(params);\n    const api = await this.getApi();\n\n    const data = await api?.ai.getNlqResult(contextTitle, request);\n\n    return data\n      ? (widgetComposer.toWidgetProps(data, {\n          useCustomizedStyleOptions: params.enableAxisTitlesInWidgetProps || false,\n        }) as WidgetProps)\n      : undefined;\n  }\n}\n"]}

package/dist/esm2020/lib/component-wrapper-helpers/context-connectors.mjs

@@ -28,16 +28,10 @@ export const createThemeContextConnector = (themeService) => {
         providerComponent: CustomThemeProvider,
     };
 };
-/**
- * Creates Sisense context connector
- *
- * @param sisenseContextService - The Sisense context service
- * @internal
- */
-export const createSisenseContextConnector = (sisenseContextService) => {
-    const { showRuntimeErrors, appConfig } = sisenseContextService.getConfig();
-    const defaultSisenseContext = {
-        isInitialized: true,
+function getBaseSisenseContext(sisenseContextService) {
+    const { showRuntimeErrors, appConfig } = sisenseContextService.getConfig() ?? {};
+    return {
+        isInitialized: sisenseContextService.isInitialized,
         tracking: {
             // if tracking is configured in appConfig, use it
             // if none is set, default to true
@@ -48,20 +42,38 @@ export const createSisenseContextConnector = (sisenseContextService) => {
             showErrorBox: showRuntimeErrors ?? true,
         },
     };
+}
+/**
+ * Creates Sisense context connector
+ *
+ * @param sisenseContextService - The Sisense context service
+ * @internal
+ */
+export const createSisenseContextConnector = (sisenseContextService) => {
     const propsObserver = new DataObserver({
-        context: defaultSisenseContext,
+        context: getBaseSisenseContext(sisenseContextService),
     });
-    sisenseContextService
-        .getApp()
-        .then((app) => propsObserver.setValue({
-        context: {
-            ...defaultSisenseContext,
-            app,
+    sisenseContextService.getApp$().subscribe({
+        next: ({ app, error }) => {
+            if (error) {
+                propsObserver.setValue({
+                    error,
+                });
+                return;
+            }
+            propsObserver.setValue({
+                context: {
+                    ...getBaseSisenseContext(sisenseContextService),
+                    app,
+                },
+            });
         },
-    }))
-        .catch((error) => propsObserver.setValue({
-        error,
-    }));
+        error: (error) => {
+            propsObserver.setValue({
+                error,
+            });
+        },
+    });
     return {
         propsObserver,
         providerComponent: CustomSisenseContextProvider,
@@ -95,4 +107,4 @@ export const createCustomWidgetsContextConnector = (customWidgetsService) => {
         providerComponent: CustomWidgetsProviderAdapter,
     };
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/components/charts/calendar-heatmap-chart.component.mjs

@@ -0,0 +1,133 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./chart.component";
+/**
+ * A component that visualizes values over days in a calendar-like view,
+ * making it easy to identify daily patterns or anomalies
+ *
+ * @example
+ * ```html
+ *    <csdk-calendar-heatmap-chart
+ *      [dataSet]="chart.dataSet"
+ *      [dataOptions]="chart.dataOptions"
+ *      [highlights]="chart.highlights"
+ *      [styleOptions]="chart.styleOptions"
+ *    />
+ * ```
+ * ```ts
+import { Component } from '@angular/core';
+import { measureFactory, filterFactory } from '@sisense/sdk-data';
+import * as DM from '../../assets/sample-ecommerce';
+import type { CalendarHeatmapChartProps } from '@sisense/sdk-ui-angular';
+
+@Component({
+  selector: 'app-analytics',
+  templateUrl: './analytics.component.html',
+  styleUrls: ['./analytics.component.scss'],
+})
+export class AnalyticsComponent {
+  DM = DM;
+  chart = {
+    dataSet: DM.DataSource,
+    dataOptions: {
+      date: DM.Commerce.Date.Days,
+      value: measureFactory.sum(DM.Commerce.Cost),
+    },
+    highlights: [
+      filterFactory.dateRange(
+        DM.Commerce.Date.Days,
+        '2009-11-29',
+        '2009-12-15'
+      ),
+    ],
+    styleOptions: {
+      viewType: 'quarter',
+    },
+  };
+}
+ * ```
+ * <img src="media://angular-calendar-heatmap-chart-example.png" width="800px" />
+ * @group Charts
+ */
+export class CalendarHeatmapChartComponent {
+    constructor() {
+        /**
+         * {@inheritDoc @sisense/sdk-ui!CalendarHeatmapChartProps.onDataPointClick}
+         *
+         * @category Callbacks
+         */
+        this.dataPointClick = new EventEmitter();
+        /**
+         * {@inheritDoc @sisense/sdk-ui!CalendarHeatmapChartProps.onDataPointContextMenu}
+         *
+         * @category Callbacks
+         */
+        this.dataPointContextMenu = new EventEmitter();
+        /**
+         * {@inheritDoc @sisense/sdk-ui!CalendarHeatmapChartProps.onDataPointsSelected}
+         *
+         * @category Callbacks
+         */
+        this.dataPointsSelect = new EventEmitter();
+        /** @internal */
+        this.chartType = 'calendar-heatmap';
+    }
+}
+CalendarHeatmapChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CalendarHeatmapChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CalendarHeatmapChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: CalendarHeatmapChartComponent, selector: "csdk-calendar-heatmap-chart", inputs: { dataSet: "dataSet", dataOptions: "dataOptions", filters: "filters", highlights: "highlights", styleOptions: "styleOptions", beforeRender: "beforeRender", dataReady: "dataReady" }, 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"
+      [dataReady]="dataReady"
+      (dataPointClick)="dataPointClick.emit($any($event))"
+      (dataPointContextMenu)="dataPointContextMenu.emit($any($event))"
+      (dataPointsSelect)="dataPointsSelect.emit($any($event))"
+    />
+  `, isInline: true, dependencies: [{ kind: "component", type: i1.ChartComponent, selector: "csdk-chart", inputs: ["chartType", "dataSet", "dataOptions", "filters", "highlights", "styleOptions", "beforeRender", "dataReady"], outputs: ["dataPointClick", "dataPointContextMenu", "dataPointsSelect"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CalendarHeatmapChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-calendar-heatmap-chart',
+                    template: `
+    <csdk-chart
+      [chartType]="chartType"
+      [dataSet]="dataSet"
+      [dataOptions]="dataOptions"
+      [filters]="filters"
+      [highlights]="highlights"
+      [styleOptions]="styleOptions"
+      [beforeRender]="beforeRender"
+      [dataReady]="dataReady"
+      (dataPointClick)="dataPointClick.emit($any($event))"
+      (dataPointContextMenu)="dataPointContextMenu.emit($any($event))"
+      (dataPointsSelect)="dataPointsSelect.emit($any($event))"
+    />
+  `,
+                }]
+        }], propDecorators: { dataSet: [{
+                type: Input
+            }], dataOptions: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }], highlights: [{
+                type: Input
+            }], styleOptions: [{
+                type: Input
+            }], beforeRender: [{
+                type: Input
+            }], dataReady: [{
+                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

@@ -3,6 +3,7 @@ export * from './area-range-chart.component';
 export * from './areamap-chart.component';
 export * from './bar-chart.component';
 export * from './boxplot-chart.component';
+export * from './calendar-heatmap-chart.component';
 export * from './chart.component';
 export * from './column-chart.component';
 export * from './funnel-chart.component';
@@ -16,4 +17,4 @@ export * from './scattermap-chart.component';
 export * from './sunburst-chart.component';
 export * from './table.component';
 export * from './treemap-chart.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvY2hhcnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLDJCQUEyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hcmVhLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2FyZWEtcmFuZ2UtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYXJlYW1hcC1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9iYXItY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYm94cGxvdC1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb2x1bW4tY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZnVubmVsLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2luZGljYXRvci1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saW5lLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3BpZS1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9waXZvdC10YWJsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9wb2xhci1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zY2F0dGVyLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3NjYXR0ZXJtYXAtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc3VuYnVyc3QtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vdGFibGUuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vdHJlZW1hcC1jaGFydC5jb21wb25lbnQnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvY2hhcnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsMkJBQTJCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FyZWEtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYXJlYS1yYW5nZS1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9hcmVhbWFwLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Jhci1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9ib3hwbG90LWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NhbGVuZGFyLWhlYXRtYXAtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29sdW1uLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Z1bm5lbC1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9pbmRpY2F0b3ItY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGluZS1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9waWUtY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcGl2b3QtdGFibGUuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcG9sYXItY2hhcnQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2NhdHRlci1jaGFydC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zY2F0dGVybWFwLWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3N1bmJ1cnN0LWNoYXJ0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3RhYmxlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3RyZWVtYXAtY2hhcnQuY29tcG9uZW50JztcbiJdfQ==

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

@@ -9,7 +9,7 @@ import * as i2 from "../../services/theme.service";
  * is used to render a widget created in a Sisense Fusion instance.
  *
  * To learn more about using Sisense Fusion Widgets in Compose SDK, see
- * [Sisense Fusion Widgets](https://sisense.dev/guides/sdk/guides/charts/guide-fusion-widgets.html).
+ * [Sisense Fusion Widgets](https://developer.sisense.com/guides/sdk/guides/charts/guide-fusion-widgets.html).
  *
  * @example
  * ```html
@@ -109,4 +109,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], dataReady: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-by-id.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/widgets/widget-by-id.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,KAAK,EAGL,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAChB,UAAU,IAAI,gBAAgB,GAE/B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,EAC3B,MAAM,EACN,MAAM,EACN,QAAQ,GACT,MAAM,iCAAiC,CAAC;;;;AAYzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAMH,MAAM,OAAO,mBAAmB;IAmG9B,YACU,qBAA4C,EAC5C,YAA0B;QAD1B,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,iBAAY,GAAZ,YAAY,CAAc;QAElC,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,gBAAgB,EAAE;YAC7D,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC;YACzD,2BAA2B,CAAC,IAAI,CAAC,YAAY,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;IAChB,eAAe;QACb,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;IAC7F,CAAC;IAED,gBAAgB;IAChB,WAAW;QACT,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;SAC5F;IACH,CAAC;IAED,gBAAgB;IACR,uBAAuB;QAC7B,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;YACrD,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,0BAA0B,EAAE,IAAI,CAAC,0BAA0B;YAC3D,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC;SACxC,CAAC;IACJ,CAAC;IAED,gBAAgB;IAChB,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;iHA9IU,mBAAmB;qGAAnB,mBAAmB;4FAAnB,mBAAmB;kBAL/B,SAAS;+BACE,mBAAmB,YAC7B,QAAQ;uIAMR,SAAS;sBADR,SAAS;uBAAC,MAAM;gBASjB,SAAS;sBADR,KAAK;gBASN,YAAY;sBADX,KAAK;gBASN,OAAO;sBADN,KAAK;gBASN,UAAU;sBADT,KAAK;gBASN,oBAAoB;sBADnB,KAAK;gBASN,uBAAuB;sBADtB,KAAK;gBASN,KAAK;sBADJ,KAAK;gBASN,WAAW;sBADV,KAAK;gBASN,YAAY;sBADX,KAAK;gBASN,0BAA0B;sBADzB,KAAK;gBAKN,gBAAgB;sBADf,KAAK;gBASN,SAAS;sBADR,KAAK","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  Input,\n  OnChanges,\n  OnDestroy,\n  ViewChild,\n} from '@angular/core';\nimport {\n  ComponentAdapter,\n  WidgetById as WidgetByIdPreact,\n  type WidgetByIdProps as WidgetByIdPropsPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n  rootId,\n  styles,\n  template,\n} from '../../component-wrapper-helpers';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport { BaseChartEventProps, WithoutPreactChartEventProps } from '../../types';\n\n/**\n * Props of the {@link WidgetByIdComponent}.\n */\nexport interface WidgetByIdProps\n  extends WithoutPreactChartEventProps<WidgetByIdPropsPreact>,\n    BaseChartEventProps {}\n\n/**\n * The `WidgetById` component, which is a thin wrapper on {@link ChartWidgetComponent},\n * is used to render a widget created in a Sisense Fusion instance.\n *\n * To learn more about using Sisense Fusion Widgets in Compose SDK, see\n * [Sisense Fusion Widgets](https://sisense.dev/guides/sdk/guides/charts/guide-fusion-widgets.html).\n *\n * @example\n * ```html\n * <csdk-widget-by-id\n *    [widgetOid]=\"widgetOid\"\n *    [dashboardOid]=\"dashboardOid\"\n *    [includeDashboardFilters]=\"true\"\n * />\n * ```\n * ```ts\n * import { Component } from '@angular/core';\n *\n * @Component({\n *  selector: 'app-widgets',\n *  templateUrl: './widgets.component.html',\n *  styleUrls: ['./widgets.component.scss'],\n * })\n * export class WidgetsComponent {\n *  widgetOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';\n *  dashboardOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';\n * }\n * ```\n * @group Fusion Assets\n * @fusionEmbed\n */\n@Component({\n  selector: 'csdk-widget-by-id',\n  template,\n  styles,\n})\nexport class WidgetByIdComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /** @internal */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.widgetOid}\n   *\n   * @category Widget\n   */\n  @Input()\n  widgetOid!: WidgetByIdProps['widgetOid'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.dashboardOid}\n   *\n   * @category Widget\n   */\n  @Input()\n  dashboardOid!: WidgetByIdProps['dashboardOid'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.filters}\n   *\n   * @category Data\n   */\n  @Input()\n  filters: WidgetByIdProps['filters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.highlights}\n   *\n   * @category Data\n   */\n  @Input()\n  highlights: WidgetByIdProps['highlights'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.filtersMergeStrategy}\n   *\n   * @category Data\n   */\n  @Input()\n  filtersMergeStrategy: WidgetByIdProps['filtersMergeStrategy'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.includeDashboardFilters}\n   *\n   * @category Data\n   */\n  @Input()\n  includeDashboardFilters: WidgetByIdProps['includeDashboardFilters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.title}\n   *\n   * @category Widget\n   */\n  @Input()\n  title: WidgetByIdProps['title'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.description}\n   *\n   * @category Widget\n   */\n  @Input()\n  description: WidgetByIdProps['description'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.styleOptions}\n   *\n   * @category Widget\n   */\n  @Input()\n  styleOptions: WidgetByIdProps['styleOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.highlightSelectionDisabled}\n   *\n   * @category Widget\n   */\n  @Input()\n  highlightSelectionDisabled: WidgetByIdProps['highlightSelectionDisabled'];\n\n  /** @internal */\n  @Input()\n  drilldownOptions: WidgetByIdProps['drilldownOptions'];\n\n  /**\n   * {@inheritDoc  @sisense/sdk-ui!WidgetByIdProps.onDataReady}\n   *\n   * @category Callbacks\n   */\n  @Input()\n  dataReady: WidgetByIdProps['dataReady'];\n\n  private componentAdapter: ComponentAdapter<typeof WidgetByIdPreact>;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    private themeService: ThemeService,\n  ) {\n    this.componentAdapter = new ComponentAdapter(WidgetByIdPreact, [\n      createSisenseContextConnector(this.sisenseContextService),\n      createThemeContextConnector(this.themeService),\n    ]);\n  }\n\n  /** @internal */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n  }\n\n  /** @internal */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n    }\n  }\n\n  /** @internal */\n  private getPreactComponentProps(): WidgetByIdPropsPreact {\n    return {\n      widgetOid: this.widgetOid,\n      dashboardOid: this.dashboardOid,\n      filters: this.filters,\n      highlights: this.highlights,\n      filtersMergeStrategy: this.filtersMergeStrategy,\n      includeDashboardFilters: this.includeDashboardFilters,\n      title: this.title,\n      description: this.description,\n      styleOptions: this.styleOptions,\n      highlightSelectionDisabled: this.highlightSelectionDisabled,\n      drilldownOptions: this.drilldownOptions,\n      onDataReady: this.dataReady?.bind(this),\n    };\n  }\n\n  /** @internal */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-by-id.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/widgets/widget-by-id.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,KAAK,EAGL,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAChB,UAAU,IAAI,gBAAgB,GAE/B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,EAC3B,MAAM,EACN,MAAM,EACN,QAAQ,GACT,MAAM,iCAAiC,CAAC;;;;AAYzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAMH,MAAM,OAAO,mBAAmB;IAmG9B,YACU,qBAA4C,EAC5C,YAA0B;QAD1B,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,iBAAY,GAAZ,YAAY,CAAc;QAElC,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,gBAAgB,EAAE;YAC7D,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC;YACzD,2BAA2B,CAAC,IAAI,CAAC,YAAY,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;IAChB,eAAe;QACb,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;IAC7F,CAAC;IAED,gBAAgB;IAChB,WAAW;QACT,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;SAC5F;IACH,CAAC;IAED,gBAAgB;IACR,uBAAuB;QAC7B,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;YACrD,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,0BAA0B,EAAE,IAAI,CAAC,0BAA0B;YAC3D,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,IAAI,CAAC;SACxC,CAAC;IACJ,CAAC;IAED,gBAAgB;IAChB,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;iHA9IU,mBAAmB;qGAAnB,mBAAmB;4FAAnB,mBAAmB;kBAL/B,SAAS;+BACE,mBAAmB,YAC7B,QAAQ;uIAMR,SAAS;sBADR,SAAS;uBAAC,MAAM;gBASjB,SAAS;sBADR,KAAK;gBASN,YAAY;sBADX,KAAK;gBASN,OAAO;sBADN,KAAK;gBASN,UAAU;sBADT,KAAK;gBASN,oBAAoB;sBADnB,KAAK;gBASN,uBAAuB;sBADtB,KAAK;gBASN,KAAK;sBADJ,KAAK;gBASN,WAAW;sBADV,KAAK;gBASN,YAAY;sBADX,KAAK;gBASN,0BAA0B;sBADzB,KAAK;gBAKN,gBAAgB;sBADf,KAAK;gBASN,SAAS;sBADR,KAAK","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  Input,\n  OnChanges,\n  OnDestroy,\n  ViewChild,\n} from '@angular/core';\nimport {\n  ComponentAdapter,\n  WidgetById as WidgetByIdPreact,\n  type WidgetByIdProps as WidgetByIdPropsPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n  rootId,\n  styles,\n  template,\n} from '../../component-wrapper-helpers';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport { BaseChartEventProps, WithoutPreactChartEventProps } from '../../types';\n\n/**\n * Props of the {@link WidgetByIdComponent}.\n */\nexport interface WidgetByIdProps\n  extends WithoutPreactChartEventProps<WidgetByIdPropsPreact>,\n    BaseChartEventProps {}\n\n/**\n * The `WidgetById` component, which is a thin wrapper on {@link ChartWidgetComponent},\n * is used to render a widget created in a Sisense Fusion instance.\n *\n * To learn more about using Sisense Fusion Widgets in Compose SDK, see\n * [Sisense Fusion Widgets](https://developer.sisense.com/guides/sdk/guides/charts/guide-fusion-widgets.html).\n *\n * @example\n * ```html\n * <csdk-widget-by-id\n *    [widgetOid]=\"widgetOid\"\n *    [dashboardOid]=\"dashboardOid\"\n *    [includeDashboardFilters]=\"true\"\n * />\n * ```\n * ```ts\n * import { Component } from '@angular/core';\n *\n * @Component({\n *  selector: 'app-widgets',\n *  templateUrl: './widgets.component.html',\n *  styleUrls: ['./widgets.component.scss'],\n * })\n * export class WidgetsComponent {\n *  widgetOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';\n *  dashboardOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';\n * }\n * ```\n * @group Fusion Assets\n * @fusionEmbed\n */\n@Component({\n  selector: 'csdk-widget-by-id',\n  template,\n  styles,\n})\nexport class WidgetByIdComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /** @internal */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.widgetOid}\n   *\n   * @category Widget\n   */\n  @Input()\n  widgetOid!: WidgetByIdProps['widgetOid'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.dashboardOid}\n   *\n   * @category Widget\n   */\n  @Input()\n  dashboardOid!: WidgetByIdProps['dashboardOid'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.filters}\n   *\n   * @category Data\n   */\n  @Input()\n  filters: WidgetByIdProps['filters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.highlights}\n   *\n   * @category Data\n   */\n  @Input()\n  highlights: WidgetByIdProps['highlights'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.filtersMergeStrategy}\n   *\n   * @category Data\n   */\n  @Input()\n  filtersMergeStrategy: WidgetByIdProps['filtersMergeStrategy'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.includeDashboardFilters}\n   *\n   * @category Data\n   */\n  @Input()\n  includeDashboardFilters: WidgetByIdProps['includeDashboardFilters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.title}\n   *\n   * @category Widget\n   */\n  @Input()\n  title: WidgetByIdProps['title'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.description}\n   *\n   * @category Widget\n   */\n  @Input()\n  description: WidgetByIdProps['description'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.styleOptions}\n   *\n   * @category Widget\n   */\n  @Input()\n  styleOptions: WidgetByIdProps['styleOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!WidgetByIdProps.highlightSelectionDisabled}\n   *\n   * @category Widget\n   */\n  @Input()\n  highlightSelectionDisabled: WidgetByIdProps['highlightSelectionDisabled'];\n\n  /** @internal */\n  @Input()\n  drilldownOptions: WidgetByIdProps['drilldownOptions'];\n\n  /**\n   * {@inheritDoc  @sisense/sdk-ui!WidgetByIdProps.onDataReady}\n   *\n   * @category Callbacks\n   */\n  @Input()\n  dataReady: WidgetByIdProps['dataReady'];\n\n  private componentAdapter: ComponentAdapter<typeof WidgetByIdPreact>;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    private themeService: ThemeService,\n  ) {\n    this.componentAdapter = new ComponentAdapter(WidgetByIdPreact, [\n      createSisenseContextConnector(this.sisenseContextService),\n      createThemeContextConnector(this.themeService),\n    ]);\n  }\n\n  /** @internal */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n  }\n\n  /** @internal */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n    }\n  }\n\n  /** @internal */\n  private getPreactComponentProps(): WidgetByIdPropsPreact {\n    return {\n      widgetOid: this.widgetOid,\n      dashboardOid: this.dashboardOid,\n      filters: this.filters,\n      highlights: this.highlights,\n      filtersMergeStrategy: this.filtersMergeStrategy,\n      includeDashboardFilters: this.includeDashboardFilters,\n      title: this.title,\n      description: this.description,\n      styleOptions: this.styleOptions,\n      highlightSelectionDisabled: this.highlightSelectionDisabled,\n      drilldownOptions: this.drilldownOptions,\n      onDataReady: this.dataReady?.bind(this),\n    };\n  }\n\n  /** @internal */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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, extractDimensionsAndMeasures } 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 { CommonModule } from '@angular/common';
 import { NgModule } from '@angular/core';
-import { AreaChartComponent, AreamapChartComponent, AreaRangeChartComponent, BarChartComponent, BoxplotChartComponent, ChartComponent, ChartWidgetComponent, ColumnChartComponent, ContextMenuComponent, CriteriaFilterTileComponent, DashboardByIdComponent, DashboardComponent, DateRangeFilterTileComponent, DrilldownBreadcrumbsComponent, DrilldownWidgetComponent, FiltersPanelComponent, FilterTileComponent, FunnelChartComponent, IndicatorChartComponent, LineChartComponent, MemberFilterTileComponent, PieChartComponent, PivotTableComponent, PivotTableWidgetComponent, PolarChartComponent, RelativeDateFilterTileComponent, ScatterChartComponent, ScattermapChartComponent, SunburstChartComponent, TableComponent, TableWidgetComponent, TreemapChartComponent, WidgetByIdComponent, WidgetComponent, } from './components';
+import { AreaChartComponent, AreamapChartComponent, AreaRangeChartComponent, BarChartComponent, BoxplotChartComponent, CalendarHeatmapChartComponent, ChartComponent, ChartWidgetComponent, ColumnChartComponent, ContextMenuComponent, CriteriaFilterTileComponent, DashboardByIdComponent, DashboardComponent, DateRangeFilterTileComponent, DrilldownBreadcrumbsComponent, DrilldownWidgetComponent, FiltersPanelComponent, FilterTileComponent, FunnelChartComponent, IndicatorChartComponent, LineChartComponent, MemberFilterTileComponent, PieChartComponent, PivotTableComponent, PivotTableWidgetComponent, PolarChartComponent, RelativeDateFilterTileComponent, ScatterChartComponent, ScattermapChartComponent, SunburstChartComponent, TableComponent, TableWidgetComponent, TreemapChartComponent, WidgetByIdComponent, WidgetComponent, } from './components';
 import { DecoratorsModule } from './decorators/decorators.module';
 import * as i0 from "@angular/core";
 /**
@@ -39,6 +39,7 @@ SdkUiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "1
         ColumnChartComponent,
         BarChartComponent,
         AreaChartComponent,
+        CalendarHeatmapChartComponent,
         AreaRangeChartComponent,
         LineChartComponent,
         IndicatorChartComponent,
@@ -72,6 +73,7 @@ SdkUiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "1
         ColumnChartComponent,
         BarChartComponent,
         AreaChartComponent,
+        CalendarHeatmapChartComponent,
         AreaRangeChartComponent,
         LineChartComponent,
         IndicatorChartComponent,
@@ -111,6 +113,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                         ColumnChartComponent,
                         BarChartComponent,
                         AreaChartComponent,
+                        CalendarHeatmapChartComponent,
                         AreaRangeChartComponent,
                         LineChartComponent,
                         IndicatorChartComponent,
@@ -148,6 +151,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                         ColumnChartComponent,
                         BarChartComponent,
                         AreaChartComponent,
+                        CalendarHeatmapChartComponent,
                         AreaRangeChartComponent,
                         LineChartComponent,
                         IndicatorChartComponent,
@@ -180,4 +184,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     providers: [],
                 }]
         }] });
-//# 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,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EACjB,qBAAqB,EACrB,cAAc,EACd,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,2BAA2B,EAC3B,sBAAsB,EACtB,kBAAkB,EAClB,4BAA4B,EAC5B,6BAA6B,EAC7B,wBAAwB,EACxB,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,uBAAuB,EACvB,kBAAkB,EAClB,yBAAyB,EACzB,iBAAiB,EACjB,mBAAmB,EACnB,yBAAyB,EACzB,mBAAmB,EACnB,+BAA+B,EAC/B,qBAAqB,EACrB,wBAAwB,EACxB,sBAAsB,EACtB,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AA6EH,MAAM,OAAO,WAAW;;yGAAX,WAAW;0GAAX,WAAW,iBA1EpB,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,mBAAmB;QACnB,yBAAyB;QACzB,wBAAwB;QACxB,4BAA4B;QAC5B,+BAA+B;QAC/B,2BAA2B;QAC3B,6BAA6B;QAC7B,oBAAoB;QACpB,qBAAqB;QACrB,wBAAwB;QACxB,qBAAqB;QACrB,mBAAmB;QACnB,sBAAsB;QACtB,kBAAkB;QAClB,yBAAyB;QACzB,mBAAmB;QACnB,qBAAqB;QACrB,eAAe,aAEP,YAAY,EAAE,gBAAgB,aAEtC,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,mBAAmB;QACnB,yBAAyB;QACzB,wBAAwB;QACxB,4BAA4B;QAC5B,+BAA+B;QAC/B,2BAA2B;QAC3B,6BAA6B;QAC7B,oBAAoB;QACpB,qBAAqB;QACrB,wBAAwB;QACxB,qBAAqB;QACrB,mBAAmB;QACnB,sBAAsB;QACtB,kBAAkB;QAClB,yBAAyB;QACzB,mBAAmB;QACnB,qBAAqB;QACrB,eAAe;0GAIN,WAAW,YAvCZ,YAAY,EAAE,gBAAgB;4FAuC7B,WAAW;kBA5EvB,QAAQ;mBAAC;oBACR,YAAY,EAAE;wBACZ,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,mBAAmB;wBACnB,yBAAyB;wBACzB,wBAAwB;wBACxB,4BAA4B;wBAC5B,+BAA+B;wBAC/B,2BAA2B;wBAC3B,6BAA6B;wBAC7B,oBAAoB;wBACpB,qBAAqB;wBACrB,wBAAwB;wBACxB,qBAAqB;wBACrB,mBAAmB;wBACnB,sBAAsB;wBACtB,kBAAkB;wBAClB,yBAAyB;wBACzB,mBAAmB;wBACnB,qBAAqB;wBACrB,eAAe;qBAChB;oBACD,OAAO,EAAE,CAAC,YAAY,EAAE,gBAAgB,CAAC;oBACzC,OAAO,EAAE;wBACP,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,mBAAmB;wBACnB,yBAAyB;wBACzB,wBAAwB;wBACxB,4BAA4B;wBAC5B,+BAA+B;wBAC/B,2BAA2B;wBAC3B,6BAA6B;wBAC7B,oBAAoB;wBACpB,qBAAqB;wBACrB,wBAAwB;wBACxB,qBAAqB;wBACrB,mBAAmB;wBACnB,sBAAsB;wBACtB,kBAAkB;wBAClB,yBAAyB;wBACzB,mBAAmB;wBACnB,qBAAqB;wBACrB,eAAe;qBAChB;oBACD,SAAS,EAAE,EAAE;iBACd","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { NgModule } from '@angular/core';\n\nimport {\n  AreaChartComponent,\n  AreamapChartComponent,\n  AreaRangeChartComponent,\n  BarChartComponent,\n  BoxplotChartComponent,\n  ChartComponent,\n  ChartWidgetComponent,\n  ColumnChartComponent,\n  ContextMenuComponent,\n  CriteriaFilterTileComponent,\n  DashboardByIdComponent,\n  DashboardComponent,\n  DateRangeFilterTileComponent,\n  DrilldownBreadcrumbsComponent,\n  DrilldownWidgetComponent,\n  FiltersPanelComponent,\n  FilterTileComponent,\n  FunnelChartComponent,\n  IndicatorChartComponent,\n  LineChartComponent,\n  MemberFilterTileComponent,\n  PieChartComponent,\n  PivotTableComponent,\n  PivotTableWidgetComponent,\n  PolarChartComponent,\n  RelativeDateFilterTileComponent,\n  ScatterChartComponent,\n  ScattermapChartComponent,\n  SunburstChartComponent,\n  TableComponent,\n  TableWidgetComponent,\n  TreemapChartComponent,\n  WidgetByIdComponent,\n  WidgetComponent,\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 * @group Contexts\n */\n@NgModule({\n  declarations: [\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    WidgetByIdComponent,\n    MemberFilterTileComponent,\n    DrilldownWidgetComponent,\n    DateRangeFilterTileComponent,\n    RelativeDateFilterTileComponent,\n    CriteriaFilterTileComponent,\n    DrilldownBreadcrumbsComponent,\n    ContextMenuComponent,\n    BoxplotChartComponent,\n    ScattermapChartComponent,\n    AreamapChartComponent,\n    PivotTableComponent,\n    DashboardByIdComponent,\n    DashboardComponent,\n    PivotTableWidgetComponent,\n    FilterTileComponent,\n    FiltersPanelComponent,\n    WidgetComponent,\n  ],\n  imports: [CommonModule, DecoratorsModule],\n  exports: [\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    WidgetByIdComponent,\n    MemberFilterTileComponent,\n    DrilldownWidgetComponent,\n    DateRangeFilterTileComponent,\n    RelativeDateFilterTileComponent,\n    CriteriaFilterTileComponent,\n    DrilldownBreadcrumbsComponent,\n    ContextMenuComponent,\n    BoxplotChartComponent,\n    ScattermapChartComponent,\n    AreamapChartComponent,\n    PivotTableComponent,\n    DashboardByIdComponent,\n    DashboardComponent,\n    PivotTableWidgetComponent,\n    FilterTileComponent,\n    FiltersPanelComponent,\n    WidgetComponent,\n  ],\n  providers: [],\n})\nexport class SdkUiModule {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk-ui.module.js","sourceRoot":"","sources":["../../../src/lib/sdk-ui.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { NgModule } from '@angular/core';\n\nimport {\n  AreaChartComponent,\n  AreamapChartComponent,\n  AreaRangeChartComponent,\n  BarChartComponent,\n  BoxplotChartComponent,\n  CalendarHeatmapChartComponent,\n  ChartComponent,\n  ChartWidgetComponent,\n  ColumnChartComponent,\n  ContextMenuComponent,\n  CriteriaFilterTileComponent,\n  DashboardByIdComponent,\n  DashboardComponent,\n  DateRangeFilterTileComponent,\n  DrilldownBreadcrumbsComponent,\n  DrilldownWidgetComponent,\n  FiltersPanelComponent,\n  FilterTileComponent,\n  FunnelChartComponent,\n  IndicatorChartComponent,\n  LineChartComponent,\n  MemberFilterTileComponent,\n  PieChartComponent,\n  PivotTableComponent,\n  PivotTableWidgetComponent,\n  PolarChartComponent,\n  RelativeDateFilterTileComponent,\n  ScatterChartComponent,\n  ScattermapChartComponent,\n  SunburstChartComponent,\n  TableComponent,\n  TableWidgetComponent,\n  TreemapChartComponent,\n  WidgetByIdComponent,\n  WidgetComponent,\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 * @group Contexts\n */\n@NgModule({\n  declarations: [\n    ChartComponent,\n    TableComponent,\n    ChartWidgetComponent,\n    ColumnChartComponent,\n    BarChartComponent,\n    AreaChartComponent,\n    CalendarHeatmapChartComponent,\n    AreaRangeChartComponent,\n    LineChartComponent,\n    IndicatorChartComponent,\n    ScatterChartComponent,\n    PieChartComponent,\n    FunnelChartComponent,\n    PolarChartComponent,\n    TreemapChartComponent,\n    SunburstChartComponent,\n    TableWidgetComponent,\n    WidgetByIdComponent,\n    MemberFilterTileComponent,\n    DrilldownWidgetComponent,\n    DateRangeFilterTileComponent,\n    RelativeDateFilterTileComponent,\n    CriteriaFilterTileComponent,\n    DrilldownBreadcrumbsComponent,\n    ContextMenuComponent,\n    BoxplotChartComponent,\n    ScattermapChartComponent,\n    AreamapChartComponent,\n    PivotTableComponent,\n    DashboardByIdComponent,\n    DashboardComponent,\n    PivotTableWidgetComponent,\n    FilterTileComponent,\n    FiltersPanelComponent,\n    WidgetComponent,\n  ],\n  imports: [CommonModule, DecoratorsModule],\n  exports: [\n    ChartComponent,\n    TableComponent,\n    ChartWidgetComponent,\n    ColumnChartComponent,\n    BarChartComponent,\n    AreaChartComponent,\n    CalendarHeatmapChartComponent,\n    AreaRangeChartComponent,\n    LineChartComponent,\n    IndicatorChartComponent,\n    ScatterChartComponent,\n    PieChartComponent,\n    FunnelChartComponent,\n    PolarChartComponent,\n    TreemapChartComponent,\n    SunburstChartComponent,\n    TableWidgetComponent,\n    WidgetByIdComponent,\n    MemberFilterTileComponent,\n    DrilldownWidgetComponent,\n    DateRangeFilterTileComponent,\n    RelativeDateFilterTileComponent,\n    CriteriaFilterTileComponent,\n    DrilldownBreadcrumbsComponent,\n    ContextMenuComponent,\n    BoxplotChartComponent,\n    ScattermapChartComponent,\n    AreamapChartComponent,\n    PivotTableComponent,\n    DashboardByIdComponent,\n    DashboardComponent,\n    PivotTableWidgetComponent,\n    FilterTileComponent,\n    FiltersPanelComponent,\n    WidgetComponent,\n  ],\n  providers: [],\n})\nexport class SdkUiModule {}\n"]}