@sisense/sdk-ui-angular 1.5.0 → 1.7.0

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

@@ -0,0 +1,167 @@
+import { Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { ChartWidget, 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";
+/**
+ * The Chart Widget component extending {@link ChartComponent} to support widget style options.
+ *
+ * @example
+ * ```html
+ * <csdk-chart-widget
+ *   [chartType]="chartWidget.chartType"
+ *   [dataSource]="chartWidget.dataSource"
+ *   [dataOptions]="chartWidget.dataOptions"
+ *   [highlights]="filters"
+ *   [title]="chartWidget.title"
+ *   [description]="chartWidget.description"
+ *   [beforeRender]="onBeforeRender"
+ *   (dataPointClick)="logArguments($event)"
+ *   (dataPointContextMenu)="logArguments($event)"
+ *   (dataPointsSelect)="logArguments($event)"
+ * />
+ * ```
+ * ```ts
+ * import { Component } from '@angular/core';
+ * import { ChartType } from '@sisense/sdk-ui-angular';
+ * import { filterFactory } from '@sisense/sdk-data';
+ * import * as DM from '../../assets/sample-healthcare-model';
+ *
+ * @Component({
+ *   selector: 'app-widgets',
+ *   templateUrl: './widgets.component.html',
+ *   styleUrls: ['./widgets.component.scss'],
+ * })
+ * export class WidgetsComponent {
+ *   filters = [filterFactory.members(DM.Divisions.Divison_name, ['Cardiology', 'Neurology'])];
+ *   chartWidget = {
+ *     chartType: 'column' as ChartType,
+ *     dataSource: DM.DataSource,
+ *     dataOptions: {
+ *       category: [DM.Divisions.Divison_name],
+ *       value: [measureFactory.sum(DM.Admissions.Cost_of_admission)],
+ *       breakBy: [],
+ *     },
+ *     title: 'Chart Title',
+ *     description: 'Chart Description',
+ *   };
+ *  logArguments(...args: any[]) {
+ *   console.log(args);
+ * }
+ *
+ * onBeforeRender(options: any) {
+ *   console.log('beforeRender');
+ *   console.log(options);
+ *   return options;
+ * }
+ *
+ * }
+ * ```
+ * <img src="media://angular-chart-widget-example.png" width="800px" />
+ *
+ * @group Chart Utilities
+ */
+export class ChartWidgetComponent {
+    constructor(sisenseContextService, themeService) {
+        this.sisenseContextService = sisenseContextService;
+        this.themeService = themeService;
+        /**
+         * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointClick}
+         *
+         * @category Callbacks
+         */
+        this.dataPointClick = new EventEmitter();
+        /**
+         * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointContextMenu}
+         *
+         * @category Callbacks
+         */
+        this.dataPointContextMenu = new EventEmitter();
+        /**
+         * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointsSelected}
+         *
+         * @category Callbacks
+         */
+        this.dataPointsSelect = new EventEmitter();
+        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 = {
+            chartType: this.chartType,
+            dataSource: this.dataSource,
+            dataOptions: this.dataOptions,
+            filters: this.filters,
+            highlights: this.highlights,
+            styleOptions: this.styleOptions,
+            drilldownOptions: this.drilldownOptions,
+            title: this.title,
+            description: this.description,
+            highlightSelectionDisabled: this.highlightSelectionDisabled,
+            onBeforeRender: this.beforeRender?.bind(this),
+            onDataPointClick: (...[point, nativeEvent]) => this.dataPointClick.emit({ point, nativeEvent }),
+            onDataPointContextMenu: (...[point, nativeEvent]) => this.dataPointContextMenu.emit({ point, nativeEvent }),
+            onDataPointsSelected: (...[points, nativeEvent]) => this.dataPointsSelect.emit({ points, nativeEvent }),
+        };
+        return createElement(ChartWidget, props);
+    }
+    /** @internal */
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+}
+ChartWidgetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ChartWidgetComponent, deps: [{ token: i1.SisenseContextService }, { token: i2.ThemeService }], target: i0.ɵɵFactoryTarget.Component });
+ChartWidgetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: ChartWidgetComponent, selector: "csdk-chart-widget", inputs: { chartType: "chartType", dataSource: "dataSource", dataOptions: "dataOptions", filters: "filters", highlights: "highlights", styleOptions: "styleOptions", drilldownOptions: "drilldownOptions", title: "title", description: "description", highlightSelectionDisabled: "highlightSelectionDisabled", beforeRender: "beforeRender" }, outputs: { dataPointClick: "dataPointClick", dataPointContextMenu: "dataPointContextMenu", dataPointsSelect: "dataPointsSelect" }, 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: ChartWidgetComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-chart-widget',
+                    template,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i2.ThemeService }]; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], chartType: [{
+                type: Input
+            }], dataSource: [{
+                type: Input
+            }], dataOptions: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }], highlights: [{
+                type: Input
+            }], styleOptions: [{
+                type: Input
+            }], drilldownOptions: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], highlightSelectionDisabled: [{
+                type: Input
+            }], beforeRender: [{
+                type: Input
+            }], dataPointClick: [{
+                type: Output
+            }], dataPointContextMenu: [{
+                type: Output
+            }], dataPointsSelect: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-widget.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/widgets/chart-widget.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  ViewChild,\n} from '@angular/core';\nimport {\n  ChartWidget,\n  type ChartWidgetProps,\n  ComponentAdapter,\n  createElement,\n} from '@sisense/sdk-ui-preact';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport type { Arguments, ArgumentsAsObject } from '../../types/utility-types';\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../../component-wrapper-helpers';\nimport { template, rootId } from '../../component-wrapper-helpers/template';\n\n/**\n * The Chart Widget component extending {@link ChartComponent} to support widget style options.\n *\n * @example\n * ```html\n * <csdk-chart-widget\n *   [chartType]=\"chartWidget.chartType\"\n *   [dataSource]=\"chartWidget.dataSource\"\n *   [dataOptions]=\"chartWidget.dataOptions\"\n *   [highlights]=\"filters\"\n *   [title]=\"chartWidget.title\"\n *   [description]=\"chartWidget.description\"\n *   [beforeRender]=\"onBeforeRender\"\n *   (dataPointClick)=\"logArguments($event)\"\n *   (dataPointContextMenu)=\"logArguments($event)\"\n *   (dataPointsSelect)=\"logArguments($event)\"\n * />\n * ```\n * ```ts\n * import { Component } from '@angular/core';\n * import { ChartType } from '@sisense/sdk-ui-angular';\n * import { filterFactory } from '@sisense/sdk-data';\n * import * as DM from '../../assets/sample-healthcare-model';\n *\n * @Component({\n *   selector: 'app-widgets',\n *   templateUrl: './widgets.component.html',\n *   styleUrls: ['./widgets.component.scss'],\n * })\n * export class WidgetsComponent {\n *   filters = [filterFactory.members(DM.Divisions.Divison_name, ['Cardiology', 'Neurology'])];\n *   chartWidget = {\n *     chartType: 'column' as ChartType,\n *     dataSource: DM.DataSource,\n *     dataOptions: {\n *       category: [DM.Divisions.Divison_name],\n *       value: [measureFactory.sum(DM.Admissions.Cost_of_admission)],\n *       breakBy: [],\n *     },\n *     title: 'Chart Title',\n *     description: 'Chart Description',\n *   };\n *  logArguments(...args: any[]) {\n *   console.log(args);\n * }\n *\n * onBeforeRender(options: any) {\n *   console.log('beforeRender');\n *   console.log(options);\n *   return options;\n * }\n *\n * }\n * ```\n * <img src=\"media://angular-chart-widget-example.png\" width=\"800px\" />\n *\n * @group Chart Utilities\n */\n@Component({\n  selector: 'csdk-chart-widget',\n  template,\n})\nexport class ChartWidgetComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /** @internal */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.chartType}\n   *\n   * @category Chart\n   */\n  @Input()\n  chartType!: ChartWidgetProps['chartType'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.dataSource}\n   *\n   * @category Data\n   */\n  @Input()\n  dataSource: ChartWidgetProps['dataSource'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.dataOptions}\n   *\n   * @category Chart\n   */\n  @Input()\n  dataOptions!: ChartWidgetProps['dataOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.filters}\n   *\n   * @category Data\n   */\n  @Input()\n  filters: ChartWidgetProps['filters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.highlights}\n   *\n   * @category Data\n   */\n  @Input()\n  highlights: ChartWidgetProps['highlights'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.styleOptions}\n   *\n   * @category Widget\n   */\n  @Input()\n  styleOptions: ChartWidgetProps['styleOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.drilldownOptions}\n   *\n   * @category Widget\n   * @internal\n   */\n  @Input()\n  drilldownOptions: ChartWidgetProps['drilldownOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.title}\n   *\n   * @category Widget\n   */\n  @Input()\n  title: ChartWidgetProps['title'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.description}\n   *\n   * @category Widget\n   */\n  @Input()\n  description: ChartWidgetProps['description'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.highlightSelectionDisabled}\n   *\n   * @category Widget\n   */\n  @Input()\n  highlightSelectionDisabled: ChartWidgetProps['highlightSelectionDisabled'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  @Input()\n  beforeRender: ChartWidgetProps['onBeforeRender'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointClick = new EventEmitter<\n    ArgumentsAsObject<ChartWidgetProps['onDataPointClick'], ['point', 'nativeEvent']>\n  >();\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointContextMenu = new EventEmitter<\n    ArgumentsAsObject<ChartWidgetProps['onDataPointContextMenu'], ['point', 'nativeEvent']>\n  >();\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointsSelect = new EventEmitter<\n    ArgumentsAsObject<ChartWidgetProps['onDataPointsSelected'], ['points', 'nativeEvent']>\n  >();\n\n  private componentAdapter: ComponentAdapter;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    private themeService: ThemeService,\n  ) {\n    this.componentAdapter = new ComponentAdapter(\n      () => this.createPreactComponent(),\n      [\n        createSisenseContextConnector(this.sisenseContextService),\n        createThemeContextConnector(this.themeService),\n      ],\n    );\n  }\n\n  /** @internal */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement);\n  }\n\n  /** @internal */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement);\n    }\n  }\n\n  private createPreactComponent() {\n    const props = {\n      chartType: this.chartType,\n      dataSource: this.dataSource,\n      dataOptions: this.dataOptions,\n      filters: this.filters,\n      highlights: this.highlights,\n      styleOptions: this.styleOptions,\n      drilldownOptions: this.drilldownOptions,\n      title: this.title,\n      description: this.description,\n      highlightSelectionDisabled: this.highlightSelectionDisabled,\n      onBeforeRender: this.beforeRender?.bind(this),\n      onDataPointClick: (\n        ...[point, nativeEvent]: Arguments<ChartWidgetProps['onDataPointClick']>\n      ) => this.dataPointClick.emit({ point, nativeEvent }),\n      onDataPointContextMenu: (\n        ...[point, nativeEvent]: Arguments<ChartWidgetProps['onDataPointContextMenu']>\n      ) => this.dataPointContextMenu.emit({ point, nativeEvent }),\n      onDataPointsSelected: (\n        ...[points, nativeEvent]: Arguments<ChartWidgetProps['onDataPointsSelected']>\n      ) => this.dataPointsSelect.emit({ points, nativeEvent }),\n    };\n\n    return createElement(ChartWidget, props);\n  }\n\n  /** @internal */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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

@@ -0,0 +1,116 @@
+import { Component, Input, ViewChild, } from '@angular/core';
+import { DashboardWidget, 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";
+/**
+ * The Dashboard Widget component, which is a thin wrapper on {@link ChartWidgetComponent},
+ * 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).
+ *
+ * @example
+ * ```html
+ * <csdk-dashboard-widget
+ *    [widgetOid]="widgetOid"
+ *    [dashboardOid]="dashboardOid"
+ *    [includeDashboardFilters]="true"
+ * />
+ * ```
+ * ```ts
+ * import { Component } from '@angular/core';
+ * import { ChartType } from '@sisense/sdk-ui-angular';
+ * import { filterFactory, measureFactory } from '@sisense/sdk-data';
+ * import * as DM from '../../assets/sample-healthcare-model';
+ *
+ * @Component({
+ *  selector: 'app-widgets',
+ * templateUrl: './widgets.component.html',
+ * styleUrls: ['./widgets.component.scss'],
+ * })
+ * export class WidgetsComponent {
+ *  widgetOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';
+ *  dashboardOid: string = '60f3e3e3e4b0e3e3e4b0e3e3';
+ * ```
+ * @group Fusion Embed
+ * @fusionEmbed
+ */
+export class DashboardWidgetComponent {
+    constructor(sisenseContextService, 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);
+        }
+    }
+    /** @internal */
+    createPreactComponent() {
+        const props = {
+            widgetOid: this.widgetOid,
+            dashboardOid: this.dashboardOid,
+            filters: this.filters,
+            highlights: this.highlights,
+            filtersMergeStrategy: this.filtersMergeStrategy,
+            includeDashboardFilters: this.includeDashboardFilters,
+            title: this.title,
+            description: this.description,
+            styleOptions: this.styleOptions,
+            highlightSelectionDisabled: this.highlightSelectionDisabled,
+            drilldownOptions: this.drilldownOptions,
+        };
+        return createElement(DashboardWidget, props);
+    }
+    /** @internal */
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+}
+DashboardWidgetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DashboardWidgetComponent, deps: [{ token: i1.SisenseContextService }, { token: i2.ThemeService }], target: i0.ɵɵFactoryTarget.Component });
+DashboardWidgetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: DashboardWidgetComponent, selector: "csdk-dashboard-widget", inputs: { widgetOid: "widgetOid", dashboardOid: "dashboardOid", filters: "filters", highlights: "highlights", filtersMergeStrategy: "filtersMergeStrategy", includeDashboardFilters: "includeDashboardFilters", title: "title", description: "description", styleOptions: "styleOptions", highlightSelectionDisabled: "highlightSelectionDisabled", drilldownOptions: "drilldownOptions" }, 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: DashboardWidgetComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-dashboard-widget',
+                    template,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i2.ThemeService }]; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], widgetOid: [{
+                type: Input
+            }], dashboardOid: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }], highlights: [{
+                type: Input
+            }], filtersMergeStrategy: [{
+                type: Input
+            }], includeDashboardFilters: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], styleOptions: [{
+                type: Input
+            }], highlightSelectionDisabled: [{
+                type: Input
+            }], drilldownOptions: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard-widget.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/widgets/dashboard-widget.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,KAAK,EAGL,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,eAAe,EAEf,gBAAgB,EAChB,aAAa,GACd,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;;;;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAKH,MAAM,OAAO,wBAAwB;IAmDnC,YACU,qBAA4C,EAC5C,YAA0B;QAD1B,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,iBAAY,GAAZ,YAAY,CAAc;QAElC,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAC1C,GAAG,EAAE,CAAC,IAAI,CAAC,qBAAqB,EAAE,EAClC;YACE,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC;YACzD,2BAA2B,CAAC,IAAI,CAAC,YAAY,CAAC;SAC/C,CACF,CAAC;IACJ,CAAC;IAED,gBAAgB;IAChB,eAAe;QACb,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IAC7D,CAAC;IAED,gBAAgB;IAChB,WAAW;QACT,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;SAC5D;IACH,CAAC;IAED,gBAAgB;IACR,qBAAqB;QAC3B,MAAM,KAAK,GAAG;YACZ,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;SACxC,CAAC;QAEF,OAAO,aAAa,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;IAC/C,CAAC;IAED,gBAAgB;IAChB,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;sHAlGU,wBAAwB;0GAAxB,wBAAwB;4FAAxB,wBAAwB;kBAJpC,SAAS;mBAAC;oBACT,QAAQ,EAAE,uBAAuB;oBACjC,QAAQ;iBACT;uIAIC,SAAS;sBADR,SAAS;uBAAC,MAAM;gBAIjB,SAAS;sBADR,KAAK;gBAIN,YAAY;sBADX,KAAK;gBASN,OAAO;sBADN,KAAK;gBAIN,UAAU;sBADT,KAAK;gBAIN,oBAAoB;sBADnB,KAAK;gBAIN,uBAAuB;sBADtB,KAAK;gBAIN,KAAK;sBADJ,KAAK;gBAIN,WAAW;sBADV,KAAK;gBASN,YAAY;sBADX,KAAK;gBAIN,0BAA0B;sBADzB,KAAK;gBAKN,gBAAgB;sBADf,KAAK","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  Input,\n  OnChanges,\n  OnDestroy,\n  ViewChild,\n} from '@angular/core';\nimport {\n  DashboardWidget,\n  type DashboardWidgetProps,\n  ComponentAdapter,\n  createElement,\n} from '@sisense/sdk-ui-preact';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../../component-wrapper-helpers';\nimport { template, rootId } from '../../component-wrapper-helpers/template';\n\n/**\n * The Dashboard Widget 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-dashboard-widget\n *    [widgetOid]=\"widgetOid\"\n *    [dashboardOid]=\"dashboardOid\"\n *    [includeDashboardFilters]=\"true\"\n * />\n * ```\n * ```ts\n * import { Component } from '@angular/core';\n * import { ChartType } from '@sisense/sdk-ui-angular';\n * import { filterFactory, measureFactory } from '@sisense/sdk-data';\n * import * as DM from '../../assets/sample-healthcare-model';\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 * @group Fusion Embed\n * @fusionEmbed\n */\n@Component({\n  selector: 'csdk-dashboard-widget',\n  template,\n})\nexport class DashboardWidgetComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /** @internal */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  @Input()\n  widgetOid!: DashboardWidgetProps['widgetOid'];\n\n  @Input()\n  dashboardOid!: DashboardWidgetProps['dashboardOid'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.filters}\n   *\n   * @category Data\n   */\n  @Input()\n  filters: DashboardWidgetProps['filters'];\n\n  @Input()\n  highlights: DashboardWidgetProps['highlights'];\n\n  @Input()\n  filtersMergeStrategy: DashboardWidgetProps['filtersMergeStrategy'];\n\n  @Input()\n  includeDashboardFilters: DashboardWidgetProps['includeDashboardFilters'];\n\n  @Input()\n  title: DashboardWidgetProps['title'];\n\n  @Input()\n  description: DashboardWidgetProps['description'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DashboardWidgetProps.styleOptions}\n   *\n   * @category Widget\n   */\n  @Input()\n  styleOptions: DashboardWidgetProps['styleOptions'];\n\n  @Input()\n  highlightSelectionDisabled: DashboardWidgetProps['highlightSelectionDisabled'];\n\n  /** @internal */\n  @Input()\n  drilldownOptions: DashboardWidgetProps['drilldownOptions'];\n\n  private componentAdapter: ComponentAdapter;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    private themeService: ThemeService,\n  ) {\n    this.componentAdapter = new ComponentAdapter(\n      () => this.createPreactComponent(),\n      [\n        createSisenseContextConnector(this.sisenseContextService),\n        createThemeContextConnector(this.themeService),\n      ],\n    );\n  }\n\n  /** @internal */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement);\n  }\n\n  /** @internal */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement);\n    }\n  }\n\n  /** @internal */\n  private createPreactComponent() {\n    const props = {\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    };\n\n    return createElement(DashboardWidget, props);\n  }\n\n  /** @internal */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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

@@ -0,0 +1,174 @@
+import { Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { ComponentAdapter, createElement, DrilldownWidget, createWrapperElement, createWrapperElementHandler, createComponentRenderer, } from '@sisense/sdk-ui-preact';
+import { createSisenseContextConnector, createThemeContextConnector, } from '../../component-wrapper-helpers';
+import { templateWithContent, rootId, rootContentId, } 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 designed to add drilldown functionality to any type of chart.
+ *
+ * It acts as a wrapper around a given chart component, enhancing it with drilldown capabilities
+ *
+ * The widget offers several features including:
+ * - A context menu for initiating drilldown actions (can be provided as a custom component)
+ * - Breadcrumbs that not only allow for drilldown selection slicing but also
+ * provide an option to clear the selection (can be provided as a custom component)
+ * - Filters specifically created for drilldown operation
+ * - An option to navigate to the next drilldown dimension
+ *
+ * When an `initialDimension` is specified, the `drilldownDimension` will automatically inherit its value,
+ * even before any points on the chart are selected.
+ * This allows for complete control over the chart's dimensions to be handed over to the DrilldownWidget
+ *
+ * @example
+ * An example of using the `csdk-drilldown-widget` component to plot a `csdk-column-chart`
+ * over the Sample Healthcare data source hosted in a Sisense instance:
+ * ```ts
+ * // Component behavior in .component.ts
+ * chart = {
+ *   dataOptions: {
+ *     category: [DM.Divisions.Divison_name],
+ *     value: [measureFactory.sum(DM.Admissions.Cost_of_admission)],
+ *     breakBy: [],
+ *   },
+ *   dataPointContextMenu: ({ point, nativeEvent }: { point: any; nativeEvent: MouseEvent }) => {
+ *     this.drilldownResult?.onDataPointsSelected?.([point], nativeEvent);
+ *     this.drilldownResult?.onContextMenu({
+ *       left: nativeEvent.clientX,
+ *       top: nativeEvent.clientY,
+ *     });
+ *   }
+ * }
+ *
+ * drilldownResult?: CustomDrilldownResult;
+ *
+ * drilldown = {
+ *   drilldownDimensions: [DM.Patients.Gender, DM.Admissions.Surgical_Procedure],
+ *   initialDimension: DM.Divisions.Divison_name,
+ *   drilldownChange: (drilldownResult: CustomDrilldownResult) => {
+ *     this.drilldownResult = drilldownResult;
+ *     this.chart.dataOptions = {
+ *       ...this.chart.dataOptions,
+ *       category: [drilldownResult.drilldownDimension]
+ *     }
+ *   }
+ * };
+ * ```
+ * ```html
+ * <!--Component HTML template in .component.html-->
+ * <csdk-drilldown-widget
+ *   [drilldownDimensions]="drilldown.drilldownDimensions"
+ *   [initialDimension]="drilldown.initialDimension"
+ *   (drilldownResultChange)="drilldown.drilldownChange($event)"
+ * >
+ *   <csdk-column-chart
+ *     [dataSet]="DM.DataSource"
+ *     [dataOptions]="chart.dataOptions"
+ *     [filters]="drilldownResult?.drilldownFilters || []"
+ *     (dataPointContextMenu)="chart.dataPointContextMenu($event)"
+ *   />
+ * </csdk-drilldown-widget>
+ * ```
+ * <img src="media://angular-drilldown-widget-example.png" width="800px" />
+ *
+ * @group Drilldown
+ */
+export class DrilldownWidgetComponent {
+    /**
+     * Constructor for the `DrilldownWidgetComponent`.
+     *
+     * @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.drilldownResultChange = new EventEmitter();
+        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 = {
+            drilldownDimensions: this.drilldownDimensions,
+            initialDimension: this.initialDimension,
+            config: {
+                ...this.config,
+                ...(this.config?.breadcrumbsComponent && {
+                    breadcrumbsComponent: createWrapperElementHandler(this.config.breadcrumbsComponent),
+                }),
+                ...(this.config?.contextMenuComponent && {
+                    contextMenuComponent: (contextMenuProps) => createWrapperElement(this.config.contextMenuComponent(contextMenuProps)),
+                }),
+            },
+        };
+        return createElement(DrilldownWidget, props, (customDrilldownResult) => {
+            const { breadcrumbsComponent } = customDrilldownResult;
+            this.drilldownResultChange.emit({
+                ...customDrilldownResult,
+                ...(breadcrumbsComponent && {
+                    breadcrumbsComponent: { render: createComponentRenderer(breadcrumbsComponent) },
+                }),
+            });
+            return createWrapperElement(this.preactContentRef.nativeElement);
+        });
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+}
+DrilldownWidgetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DrilldownWidgetComponent, deps: [{ token: i1.SisenseContextService }, { token: i2.ThemeService }], target: i0.ɵɵFactoryTarget.Component });
+DrilldownWidgetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: DrilldownWidgetComponent, selector: "csdk-drilldown-widget", inputs: { drilldownDimensions: "drilldownDimensions", initialDimension: "initialDimension", config: "config" }, outputs: { drilldownResultChange: "drilldownResultChange" }, viewQueries: [{ propertyName: "preactRef", first: true, predicate: ["preact"], descendants: true }, { propertyName: "preactContentRef", first: true, predicate: ["preactContent"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "\n    <div #preact style=\"width: 100%; height: 100%\">\n        <div #preactContent style=\"width: 100%; height: 100%\">\n            <ng-content></ng-content>\n        </div>\n    </div>\n", isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DrilldownWidgetComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-drilldown-widget',
+                    template: templateWithContent,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i2.ThemeService }]; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], preactContentRef: [{
+                type: ViewChild,
+                args: [rootContentId]
+            }], drilldownDimensions: [{
+                type: Input
+            }], initialDimension: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], drilldownResultChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drilldown-widget.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/widgets/drilldown-widget.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  ViewChild,\n} from '@angular/core';\nimport {\n  ComponentAdapter,\n  createElement,\n  DrilldownWidget,\n  type DrilldownWidgetProps,\n  type ContextMenuProps,\n  type CustomDrilldownResult as CustomDrilldownResultBase,\n  type ComponentRenderer,\n  DrilldownBreadcrumbsProps,\n  createWrapperElement,\n  createWrapperElementHandler,\n  createComponentRenderer,\n} from '@sisense/sdk-ui-preact';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport type { Arguments } from '../../types/utility-types';\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../../component-wrapper-helpers';\nimport {\n  templateWithContent,\n  rootId,\n  rootContentId,\n} from '../../component-wrapper-helpers/template';\n\nexport type CustomDrilldownResult = CustomDrilldownResultBase & {\n  breadcrumbsComponent?: {\n    render: ComponentRenderer;\n  };\n};\n\n/**\n * An Angular component designed to add drilldown functionality to any type of chart.\n *\n * It acts as a wrapper around a given chart component, enhancing it with drilldown capabilities\n *\n * The widget offers several features including:\n * - A context menu for initiating drilldown actions (can be provided as a custom component)\n * - Breadcrumbs that not only allow for drilldown selection slicing but also\n * provide an option to clear the selection (can be provided as a custom component)\n * - Filters specifically created for drilldown operation\n * - An option to navigate to the next drilldown dimension\n *\n * When an `initialDimension` is specified, the `drilldownDimension` will automatically inherit its value,\n * even before any points on the chart are selected.\n * This allows for complete control over the chart's dimensions to be handed over to the DrilldownWidget\n *\n * @example\n * An example of using the `csdk-drilldown-widget` component to plot a `csdk-column-chart`\n * over the Sample Healthcare data source hosted in a Sisense instance:\n * ```ts\n * // Component behavior in .component.ts\n * chart = {\n *   dataOptions: {\n *     category: [DM.Divisions.Divison_name],\n *     value: [measureFactory.sum(DM.Admissions.Cost_of_admission)],\n *     breakBy: [],\n *   },\n *   dataPointContextMenu: ({ point, nativeEvent }: { point: any; nativeEvent: MouseEvent }) => {\n *     this.drilldownResult?.onDataPointsSelected?.([point], nativeEvent);\n *     this.drilldownResult?.onContextMenu({\n *       left: nativeEvent.clientX,\n *       top: nativeEvent.clientY,\n *     });\n *   }\n * }\n *\n * drilldownResult?: CustomDrilldownResult;\n *\n * drilldown = {\n *   drilldownDimensions: [DM.Patients.Gender, DM.Admissions.Surgical_Procedure],\n *   initialDimension: DM.Divisions.Divison_name,\n *   drilldownChange: (drilldownResult: CustomDrilldownResult) => {\n *     this.drilldownResult = drilldownResult;\n *     this.chart.dataOptions = {\n *       ...this.chart.dataOptions,\n *       category: [drilldownResult.drilldownDimension]\n *     }\n *   }\n * };\n * ```\n * ```html\n * <!--Component HTML template in .component.html-->\n * <csdk-drilldown-widget\n *   [drilldownDimensions]=\"drilldown.drilldownDimensions\"\n *   [initialDimension]=\"drilldown.initialDimension\"\n *   (drilldownResultChange)=\"drilldown.drilldownChange($event)\"\n * >\n *   <csdk-column-chart\n *     [dataSet]=\"DM.DataSource\"\n *     [dataOptions]=\"chart.dataOptions\"\n *     [filters]=\"drilldownResult?.drilldownFilters || []\"\n *     (dataPointContextMenu)=\"chart.dataPointContextMenu($event)\"\n *   />\n * </csdk-drilldown-widget>\n * ```\n * <img src=\"media://angular-drilldown-widget-example.png\" width=\"800px\" />\n *\n * @group Drilldown\n */\n@Component({\n  selector: 'csdk-drilldown-widget',\n  template: templateWithContent,\n})\nexport class DrilldownWidgetComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /**\n   * @internal\n   */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * @internal\n   */\n  @ViewChild(rootContentId)\n  preactContentRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DrilldownWidgetProps.drilldownDimensions}\n   */\n  @Input()\n  drilldownDimensions!: DrilldownWidgetProps['drilldownDimensions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DrilldownWidgetProps.initialDimension}\n   */\n  @Input()\n  initialDimension!: DrilldownWidgetProps['initialDimension'];\n\n  @Input()\n  config?: Omit<DrilldownWidgetProps['config'], 'breadcrumbsComponent | contextMenuComponent'> & {\n    breadcrumbsComponent?: (drilldownBreadcrumbsProps: DrilldownBreadcrumbsProps) => HTMLDivElement;\n    contextMenuComponent?: (contextMenuProps: ContextMenuProps) => HTMLDivElement;\n  };\n\n  @Output()\n  drilldownResultChange = new EventEmitter<CustomDrilldownResult>();\n\n  private componentAdapter: ComponentAdapter;\n\n  /**\n   * Constructor for the `DrilldownWidgetComponent`.\n   *\n   * @param sisenseContextService - Sisense context service\n   * @param themeService - Theme service\n   */\n  constructor(\n    /**\n     * Sisense context service\n     *\n     * @category Constructor\n     */\n    public sisenseContextService: SisenseContextService,\n    /**\n     * Theme service\n     *\n     * @category Constructor\n     */\n    public themeService: ThemeService,\n  ) {\n    this.componentAdapter = new ComponentAdapter(\n      () => this.createPreactComponent(),\n      [\n        createSisenseContextConnector(this.sisenseContextService),\n        createThemeContextConnector(this.themeService),\n      ],\n    );\n  }\n\n  /**\n   * @internal\n   */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement);\n  }\n\n  /**\n   * @internal\n   */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement);\n    }\n  }\n\n  private createPreactComponent() {\n    const props = {\n      drilldownDimensions: this.drilldownDimensions,\n      initialDimension: this.initialDimension,\n      config: {\n        ...this.config,\n        ...(this.config?.breadcrumbsComponent && {\n          breadcrumbsComponent: createWrapperElementHandler(this.config.breadcrumbsComponent),\n        }),\n        ...(this.config?.contextMenuComponent && {\n          contextMenuComponent: (contextMenuProps: ContextMenuProps) =>\n            createWrapperElement(this.config!.contextMenuComponent!(contextMenuProps)),\n        }),\n      },\n    } as DrilldownWidgetProps;\n\n    return createElement(\n      DrilldownWidget,\n      props,\n      (customDrilldownResult: Arguments<DrilldownWidgetProps['children']>[0]) => {\n        const { breadcrumbsComponent } = customDrilldownResult;\n        this.drilldownResultChange.emit({\n          ...customDrilldownResult,\n          ...(breadcrumbsComponent && {\n            breadcrumbsComponent: { render: createComponentRenderer(breadcrumbsComponent) },\n          }),\n        } as CustomDrilldownResult);\n        return createWrapperElement(this.preactContentRef.nativeElement);\n      },\n    );\n  }\n\n  /**\n   * @internal\n   */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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

@@ -0,0 +1,5 @@
+export * from './table-widget.component';
+export * from './dashboard-widget.component';
+export * from './drilldown-widget.component';
+export * from './chart-widget.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvd2lkZ2V0cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90YWJsZS13aWRnZXQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZGFzaGJvYXJkLXdpZGdldC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmlsbGRvd24td2lkZ2V0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NoYXJ0LXdpZGdldC5jb21wb25lbnQnO1xuIl19

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

@@ -0,0 +1,104 @@
+import { Component, Input, ViewChild, } from '@angular/core';
+import { TableWidget, 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";
+/**
+ * The Table Widget component extending {@link TableComponent} component to support widget style options.
+ *
+ * @example
+ * ```html
+ *  <csdk-table-widget
+ *    [dataSource]="table.dataSet"
+ *    [dataOptions]="table.dataOptions"
+ *    [filters]="filters"
+ *    [title]="table.title"
+ *    [description]="table.description"
+ *  />
+ * ```
+ * ```ts
+ * import { Component } from '@angular/core';
+ * import { ChartType } from '@sisense/sdk-ui-angular';
+ * import { filterFactory, measureFactory } from '@sisense/sdk-data';
+ * import * as DM from '../../assets/sample-healthcare-model';
+ *
+ * @Component({
+ *  selector: 'app-widgets',
+ * templateUrl: './widgets.component.html',
+ * styleUrls: ['./widgets.component.scss'],
+ * })
+ * export class WidgetsComponent {
+ * filters = [filterFactory.members(DM.Divisions.Divison_name, ['Cardiology', 'Neurology'])];
+ *
+ * table = {
+ *    dataSet: DM.DataSource,
+ *    dataOptions: {
+ *      columns: [DM.Admissions.Patient_ID, measureFactory.sum(DM.Admissions.Cost_of_admission)],
+ *    }
+ *    title: 'Widget Title',
+ *    description: 'Widget Description',
+ *  };
+ * }
+ * ```
+ * <img src="media://angular-table-widget-example.png" width="800px" />
+ * @internal
+ */
+export class TableWidgetComponent {
+    constructor(sisenseContextService, themeService) {
+        this.sisenseContextService = sisenseContextService;
+        this.themeService = themeService;
+        this.componentAdapter = new ComponentAdapter(() => this.createPreactComponent(), [
+            createSisenseContextConnector(this.sisenseContextService),
+            createThemeContextConnector(this.themeService),
+        ]);
+    }
+    ngAfterViewInit() {
+        this.componentAdapter.render(this.preactRef.nativeElement);
+    }
+    ngOnChanges() {
+        if (this.preactRef) {
+            this.componentAdapter.render(this.preactRef.nativeElement);
+        }
+    }
+    createPreactComponent() {
+        const props = {
+            dataSource: this.dataSource,
+            dataOptions: this.dataOptions,
+            filters: this.filters,
+            styleOptions: this.styleOptions,
+            title: this.title,
+            description: this.description,
+        };
+        return createElement(TableWidget, props);
+    }
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+}
+TableWidgetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TableWidgetComponent, deps: [{ token: i1.SisenseContextService }, { token: i2.ThemeService }], target: i0.ɵɵFactoryTarget.Component });
+TableWidgetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: TableWidgetComponent, selector: "csdk-table-widget", inputs: { dataSource: "dataSource", dataOptions: "dataOptions", filters: "filters", styleOptions: "styleOptions", title: "title", description: "description" }, 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: TableWidgetComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-table-widget',
+                    template,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i2.ThemeService }]; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], dataSource: [{
+                type: Input
+            }], dataOptions: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }], styleOptions: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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