@sisense/sdk-ui-angular 1.34.0 → 2.1.0

package/dist/esm2020/lib/components/filters/filter-tile.component.mjs

@@ -0,0 +1,147 @@
+import { Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { ComponentAdapter, FilterTile as FilterTilePreact, } from '@sisense/sdk-ui-preact';
+import { createSisenseContextConnector, createThemeContextConnector, } from '../../component-wrapper-helpers';
+import { rootId, template } from '../../component-wrapper-helpers/template';
+import { EventEmitterWithHasListeners } from '../../helpers';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/sisense-context.service";
+import * as i2 from "../../services/theme.service";
+/**
+ * UI component that renders a filter tile based on filter type
+ *
+ * @example
+ * Here’s how to render a filter model as a filter tile.
+ *
+ * ```html
+<!--Component HTML template in example.component.html-->
+<csdk-filter-tile
+  [filter]="filterTileProps.filter"
+  (filterChange)="filterTileProps.filterChange($event)"
+/>
+ * ```
+ *
+ * ```ts
+// Component behavior in example.component.ts
+import { Component } from '@angular/core';
+import { type FilterTileProps } from '@sisense/sdk-ui-angular';
+import { filterFactory } from '@sisense/sdk-data';
+import * as DM from '../../assets/sample-healthcare-model';
+
+@Component({
+  selector: 'example',
+  templateUrl: './example.component.html',
+  styleUrls: ['./example.component.scss'],
+})
+export class ExampleComponent {
+  filterTileProps: FilterTileProps = {
+    filter: filterFactory.members(DM.ER.Date.Years, ['2013-01-01T00:00:00']),
+    filterChange({ filter }) {
+      if (filter) {
+        this.filter = filter;
+      }
+    },
+  };
+}
+ * ```
+ * <img src="media://angular-member-filter-tile-example.png" width="225px" />
+ * @group Filter Tiles
+ * @shortDescription Facade component rendering a filter tile based on filter type
+ */
+export class FilterTileComponent {
+    /**
+     * Constructor for the `FilterTileComponent`.
+     *
+     * @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;
+        /**
+         * {@inheritDoc FilterTileProps.filterChange}
+         */
+        this.filterChange = new EventEmitter();
+        /**
+         * {@inheritDoc FilterTileProps.filterEdit}
+         */
+        this.filterEdit = new EventEmitterWithHasListeners();
+        /**
+         * {@inheritDoc FilterTileProps.filterDelete}
+         */
+        this.filterDelete = new EventEmitterWithHasListeners();
+        this.componentAdapter = new ComponentAdapter(FilterTilePreact, [
+            createSisenseContextConnector(this.sisenseContextService),
+            createThemeContextConnector(this.themeService),
+        ]);
+    }
+    /**
+     * @internal
+     */
+    ngAfterViewInit() {
+        this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());
+    }
+    /**
+     * @internal
+     */
+    ngOnChanges() {
+        if (this.preactRef) {
+            this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());
+        }
+    }
+    getPreactComponentProps() {
+        const hasFilterEditListeners = this.filterEdit
+            .hasListeners;
+        const hasFilterDeleteListeners = this.filterDelete
+            .hasListeners;
+        return {
+            filter: this.filter,
+            defaultDataSource: this.defaultDataSource,
+            onChange: (...[filter]) => this.filterChange.emit({ filter }),
+            ...(hasFilterEditListeners && {
+                onEdit: (...[levelIndex]) => this.filterEdit.emit({ levelIndex }),
+            }),
+            ...(hasFilterDeleteListeners && { onDelete: () => this.filterDelete.emit() }),
+        };
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+}
+FilterTileComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FilterTileComponent, deps: [{ token: i1.SisenseContextService }, { token: i2.ThemeService }], target: i0.ɵɵFactoryTarget.Component });
+FilterTileComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: FilterTileComponent, selector: "csdk-filter-tile", inputs: { filter: "filter", defaultDataSource: "defaultDataSource" }, outputs: { filterChange: "filterChange", filterEdit: "filterEdit", filterDelete: "filterDelete" }, 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: FilterTileComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-filter-tile',
+                    template,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i2.ThemeService }]; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], filter: [{
+                type: Input
+            }], defaultDataSource: [{
+                type: Input
+            }], filterChange: [{
+                type: Output
+            }], filterEdit: [{
+                type: Output
+            }], filterDelete: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-tile.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/filters/filter-tile.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  FilterTile as FilterTilePreact,\n  type FilterTileProps as FilterTilePropsPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../../component-wrapper-helpers';\nimport { rootId, template } from '../../component-wrapper-helpers/template';\nimport { EventEmitterWithHasListeners } from '../../helpers';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport type {\n  Arguments,\n  BaseFilterTileEventProps,\n  FilterChangeEvent,\n  FilterEditEvent,\n} from '../../types';\n\n/**\n * Props of the {@link FilterTileComponent}.\n */\nexport interface FilterTileProps\n  extends Omit<FilterTilePropsPreact, 'onChange' | 'onEdit' | 'onDelete'>,\n    BaseFilterTileEventProps {}\n\n/**\n * UI component that renders a filter tile based on filter type\n *\n * @example\n * Here’s how to render a filter model as a filter tile.\n *\n * ```html\n<!--Component HTML template in example.component.html-->\n<csdk-filter-tile\n  [filter]=\"filterTileProps.filter\"\n  (filterChange)=\"filterTileProps.filterChange($event)\"\n/>\n * ```\n *\n * ```ts\n// Component behavior in example.component.ts\nimport { Component } from '@angular/core';\nimport { type FilterTileProps } from '@sisense/sdk-ui-angular';\nimport { filterFactory } from '@sisense/sdk-data';\nimport * as DM from '../../assets/sample-healthcare-model';\n\n@Component({\n  selector: 'example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  filterTileProps: FilterTileProps = {\n    filter: filterFactory.members(DM.ER.Date.Years, ['2013-01-01T00:00:00']),\n    filterChange({ filter }) {\n      if (filter) {\n        this.filter = filter;\n      }\n    },\n  };\n}\n * ```\n * <img src=\"media://angular-member-filter-tile-example.png\" width=\"225px\" />\n * @group Filter Tiles\n * @shortDescription Facade component rendering a filter tile based on filter type\n */\n@Component({\n  selector: 'csdk-filter-tile',\n  template,\n})\nexport class FilterTileComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /**\n   * @internal\n   */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!FilterTileProps.filter}\n   */\n  @Input()\n  filter!: FilterTileProps['filter'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!FilterTileProps.defaultDataSource}\n   */\n  @Input()\n  defaultDataSource: FilterTileProps['defaultDataSource'];\n\n  /**\n   * {@inheritDoc FilterTileProps.filterChange}\n   */\n  @Output()\n  filterChange = new EventEmitter<FilterChangeEvent>();\n\n  /**\n   * {@inheritDoc FilterTileProps.filterEdit}\n   */\n  @Output()\n  filterEdit: EventEmitter<FilterEditEvent> = new EventEmitterWithHasListeners<FilterEditEvent>();\n\n  /**\n   * {@inheritDoc FilterTileProps.filterDelete}\n   */\n  @Output()\n  filterDelete: EventEmitter<void> = new EventEmitterWithHasListeners();\n\n  private componentAdapter: ComponentAdapter<typeof FilterTilePreact>;\n\n  /**\n   * Constructor for the `FilterTileComponent`.\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(FilterTilePreact, [\n      createSisenseContextConnector(this.sisenseContextService),\n      createThemeContextConnector(this.themeService),\n    ]);\n  }\n\n  /**\n   * @internal\n   */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n  }\n\n  /**\n   * @internal\n   */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n    }\n  }\n\n  private getPreactComponentProps(): FilterTilePropsPreact {\n    const hasFilterEditListeners = (this.filterEdit as EventEmitterWithHasListeners<unknown>)\n      .hasListeners;\n    const hasFilterDeleteListeners = (this.filterDelete as EventEmitterWithHasListeners<unknown>)\n      .hasListeners;\n\n    return {\n      filter: this.filter,\n      defaultDataSource: this.defaultDataSource,\n      onChange: (...[filter]: Arguments<FilterTilePropsPreact['onChange']>) =>\n        this.filterChange.emit({ filter }),\n      ...(hasFilterEditListeners && {\n        onEdit: (...[levelIndex]: Arguments<FilterTilePropsPreact['onEdit']>) =>\n          this.filterEdit.emit({ levelIndex }),\n      }),\n      ...(hasFilterDeleteListeners && { onDelete: () => this.filterDelete.emit() }),\n    };\n  }\n\n  /**\n   * @internal\n   */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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

@@ -1,5 +1,6 @@
 export * from './criteria-filter-tile.component';
 export * from './date-range-filter-tile.component';
+export * from './filter-tile.component';
 export * from './member-filter-tile.component';
 export * from './relative-date-filter-tile.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvZmlsdGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jcml0ZXJpYS1maWx0ZXItdGlsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRlLXJhbmdlLWZpbHRlci10aWxlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL21lbWJlci1maWx0ZXItdGlsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9yZWxhdGl2ZS1kYXRlLWZpbHRlci10aWxlLmNvbXBvbmVudCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvZmlsdGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsdUNBQXVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NyaXRlcmlhLWZpbHRlci10aWxlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGUtcmFuZ2UtZmlsdGVyLXRpbGUuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZmlsdGVyLXRpbGUuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbWVtYmVyLWZpbHRlci10aWxlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3JlbGF0aXZlLWRhdGUtZmlsdGVyLXRpbGUuY29tcG9uZW50JztcbiJdfQ==

package/dist/esm2020/lib/components/filters/member-filter-tile.component.mjs

@@ -39,7 +39,7 @@ import * as i2 from "../../services/theme.service";
  *   };
  * }
  * ```
- * <img src="media://angular-member-filter-tile-example.png" width="400px" />
+ * <img src="media://angular-member-filter-tile-example.png" width="225px" />
  * @group Filter Tiles
  */
 export class MemberFilterTileComponent {
@@ -125,4 +125,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], filterChange: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-filter-tile.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/filters/member-filter-tile.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,YAAY,EACZ,KAAK,EAGL,MAAM,EACN,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,IAAI,sBAAsB,GAE3C,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;;;;AAY5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAKH,MAAM,OAAO,yBAAyB;IAyCpC;;;;;OAKG;IACH;IACE;;;;OAIG;IACI,qBAA4C;IACnD;;;;OAIG;IACI,YAA0B;QAN1B,0BAAqB,GAArB,qBAAqB,CAAuB;QAM5C,iBAAY,GAAZ,YAAY,CAAc;QA5BnC;;WAEG;QAEH,iBAAY,GAAG,IAAI,YAAY,EAE5B,CAAC;QAwBF,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,sBAAsB,EAAE;YACnE,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC;YACzD,2BAA2B,CAAC,IAAI,CAAC,YAAY,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,eAAe;QACb,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;IAC7F,CAAC;IAED;;OAEG;IACH,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;IAEO,uBAAuB;QAC7B,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,QAAQ,EAAE,CAAC,GAAG,CAAC,MAAM,CAAqD,EAAE,EAAE,CAC5E,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;SACrC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;uHAnGU,yBAAyB;2GAAzB,yBAAyB;4FAAzB,yBAAyB;kBAJrC,SAAS;mBAAC;oBACT,QAAQ,EAAE,yBAAyB;oBACnC,QAAQ;iBACT;uIAMC,SAAS;sBADR,SAAS;uBAAC,MAAM;gBAOjB,KAAK;sBADJ,KAAK;gBAON,UAAU;sBADT,KAAK;gBAON,SAAS;sBADR,KAAK;gBAON,MAAM;sBADL,KAAK;gBAON,YAAY;sBADX,MAAM","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  MemberFilterTile as MemberFilterTilePreact,\n  type MemberFilterTileProps as MemberFilterTilePropsPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../../component-wrapper-helpers';\nimport { rootId, template } from '../../component-wrapper-helpers/template';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport type { Arguments, ArgumentsAsObject } from '../../types/utility-types';\n\n/**\n * Props of the {@link MemberFilterTileComponent}.\n */\nexport interface MemberFilterTileProps extends Omit<MemberFilterTilePropsPreact, 'onChange'> {\n  filterChange?: (filter: Arguments<MemberFilterTilePropsPreact['onChange']>[0]) => void;\n}\n\n/**\n * Member Filter Tile Component\n *\n * @example\n * ```html\n *     <csdk-member-filter-tile\n *       title=\"Years Filter\"\n *       [attribute]=\"DM.ER.Date.Years\"\n *       [filter]=\"memberFilterTileProps.yearFilter\"\n *       (filterChange)=\"memberFilterTileProps.setYearFilter($event)\"\n *     />\n * ```\n * ```ts\n * import { Component } from '@angular/core';\n * import { Filter, filterFactory } from '@sisense/sdk-data';\n * import * as DM from '../../assets/sample-healthcare-model';\n *\n * @Component({\n *   selector: 'app-filters',\n *   templateUrl: './filters.component.html',\n *   styleUrls: ['./filters.component.scss'],\n * })\n * export class FiltersComponent {\n *   DM = DM;\n *   memberFilterTileProps = {\n *     yearFilter: filterFactory.members(DM.ER.Date.Years, ['2013-01-01T00:00:00']),\n *     setYearFilter({ filter }: { filter: Filter | null }) {\n *       if (filter) {\n *         this.yearFilter = filter;\n *       }\n *     },\n *   };\n * }\n * ```\n * <img src=\"media://angular-member-filter-tile-example.png\" width=\"400px\" />\n * @group Filter Tiles\n */\n@Component({\n  selector: 'csdk-member-filter-tile',\n  template,\n})\nexport class MemberFilterTileComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /**\n   * @internal\n   */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!MemberFilterTileProps.title}\n   */\n  @Input()\n  title!: MemberFilterTileProps['title'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!MemberFilterTileProps.dataSource}\n   */\n  @Input()\n  dataSource: MemberFilterTileProps['dataSource'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!MemberFilterTileProps.attribute}\n   */\n  @Input()\n  attribute!: MemberFilterTileProps['attribute'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!MemberFilterTileProps.filter}\n   */\n  @Input()\n  filter!: MemberFilterTileProps['filter'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!MemberFilterTileProps.onChange}\n   */\n  @Output()\n  filterChange = new EventEmitter<\n    ArgumentsAsObject<MemberFilterTilePropsPreact['onChange'], ['filter']>\n  >();\n\n  private componentAdapter: ComponentAdapter<typeof MemberFilterTilePreact>;\n\n  /**\n   * Constructor for the `MemberFilterTileComponent`.\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(MemberFilterTilePreact, [\n      createSisenseContextConnector(this.sisenseContextService),\n      createThemeContextConnector(this.themeService),\n    ]);\n  }\n\n  /**\n   * @internal\n   */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n  }\n\n  /**\n   * @internal\n   */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n    }\n  }\n\n  private getPreactComponentProps(): MemberFilterTilePropsPreact {\n    return {\n      title: this.title,\n      dataSource: this.dataSource,\n      attribute: this.attribute,\n      filter: this.filter,\n      onChange: (...[filter]: Arguments<MemberFilterTilePropsPreact['onChange']>) =>\n        this.filterChange.emit({ filter }),\n    };\n  }\n\n  /**\n   * @internal\n   */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"member-filter-tile.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/filters/member-filter-tile.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,YAAY,EACZ,KAAK,EAGL,MAAM,EACN,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,IAAI,sBAAsB,GAE3C,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;;;;AAY5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAKH,MAAM,OAAO,yBAAyB;IAyCpC;;;;;OAKG;IACH;IACE;;;;OAIG;IACI,qBAA4C;IACnD;;;;OAIG;IACI,YAA0B;QAN1B,0BAAqB,GAArB,qBAAqB,CAAuB;QAM5C,iBAAY,GAAZ,YAAY,CAAc;QA5BnC;;WAEG;QAEH,iBAAY,GAAG,IAAI,YAAY,EAE5B,CAAC;QAwBF,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,sBAAsB,EAAE;YACnE,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC;YACzD,2BAA2B,CAAC,IAAI,CAAC,YAAY,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,eAAe;QACb,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;IAC7F,CAAC;IAED;;OAEG;IACH,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;IAEO,uBAAuB;QAC7B,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,QAAQ,EAAE,CAAC,GAAG,CAAC,MAAM,CAAqD,EAAE,EAAE,CAC5E,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;SACrC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;uHAnGU,yBAAyB;2GAAzB,yBAAyB;4FAAzB,yBAAyB;kBAJrC,SAAS;mBAAC;oBACT,QAAQ,EAAE,yBAAyB;oBACnC,QAAQ;iBACT;uIAMC,SAAS;sBADR,SAAS;uBAAC,MAAM;gBAOjB,KAAK;sBADJ,KAAK;gBAON,UAAU;sBADT,KAAK;gBAON,SAAS;sBADR,KAAK;gBAON,MAAM;sBADL,KAAK;gBAON,YAAY;sBADX,MAAM","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  MemberFilterTile as MemberFilterTilePreact,\n  type MemberFilterTileProps as MemberFilterTilePropsPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../../component-wrapper-helpers';\nimport { rootId, template } from '../../component-wrapper-helpers/template';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport type { Arguments, ArgumentsAsObject } from '../../types/utility-types';\n\n/**\n * Props of the {@link MemberFilterTileComponent}.\n */\nexport interface MemberFilterTileProps extends Omit<MemberFilterTilePropsPreact, 'onChange'> {\n  filterChange?: (filter: Arguments<MemberFilterTilePropsPreact['onChange']>[0]) => void;\n}\n\n/**\n * Member Filter Tile Component\n *\n * @example\n * ```html\n *     <csdk-member-filter-tile\n *       title=\"Years Filter\"\n *       [attribute]=\"DM.ER.Date.Years\"\n *       [filter]=\"memberFilterTileProps.yearFilter\"\n *       (filterChange)=\"memberFilterTileProps.setYearFilter($event)\"\n *     />\n * ```\n * ```ts\n * import { Component } from '@angular/core';\n * import { Filter, filterFactory } from '@sisense/sdk-data';\n * import * as DM from '../../assets/sample-healthcare-model';\n *\n * @Component({\n *   selector: 'app-filters',\n *   templateUrl: './filters.component.html',\n *   styleUrls: ['./filters.component.scss'],\n * })\n * export class FiltersComponent {\n *   DM = DM;\n *   memberFilterTileProps = {\n *     yearFilter: filterFactory.members(DM.ER.Date.Years, ['2013-01-01T00:00:00']),\n *     setYearFilter({ filter }: { filter: Filter | null }) {\n *       if (filter) {\n *         this.yearFilter = filter;\n *       }\n *     },\n *   };\n * }\n * ```\n * <img src=\"media://angular-member-filter-tile-example.png\" width=\"225px\" />\n * @group Filter Tiles\n */\n@Component({\n  selector: 'csdk-member-filter-tile',\n  template,\n})\nexport class MemberFilterTileComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /**\n   * @internal\n   */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!MemberFilterTileProps.title}\n   */\n  @Input()\n  title!: MemberFilterTileProps['title'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!MemberFilterTileProps.dataSource}\n   */\n  @Input()\n  dataSource: MemberFilterTileProps['dataSource'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!MemberFilterTileProps.attribute}\n   */\n  @Input()\n  attribute!: MemberFilterTileProps['attribute'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!MemberFilterTileProps.filter}\n   */\n  @Input()\n  filter!: MemberFilterTileProps['filter'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!MemberFilterTileProps.onChange}\n   */\n  @Output()\n  filterChange = new EventEmitter<\n    ArgumentsAsObject<MemberFilterTilePropsPreact['onChange'], ['filter']>\n  >();\n\n  private componentAdapter: ComponentAdapter<typeof MemberFilterTilePreact>;\n\n  /**\n   * Constructor for the `MemberFilterTileComponent`.\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(MemberFilterTilePreact, [\n      createSisenseContextConnector(this.sisenseContextService),\n      createThemeContextConnector(this.themeService),\n    ]);\n  }\n\n  /**\n   * @internal\n   */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n  }\n\n  /**\n   * @internal\n   */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n    }\n  }\n\n  private getPreactComponentProps(): MemberFilterTilePropsPreact {\n    return {\n      title: this.title,\n      dataSource: this.dataSource,\n      attribute: this.attribute,\n      filter: this.filter,\n      onChange: (...[filter]: Arguments<MemberFilterTilePropsPreact['onChange']>) =>\n        this.filterChange.emit({ filter }),\n    };\n  }\n\n  /**\n   * @internal\n   */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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

@@ -59,7 +59,7 @@ import * as i2 from "../../services/theme.service";
  *
  * }
  * ```
- * <img src="media://angular-chart-widget-example.png" width="800px" />
+ * <img src="media://angular-chart-widget-example.png" width="500px" />
  * @group Dashboards
  */
 export class ChartWidgetComponent {
@@ -165,4 +165,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], 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 as ChartWidgetPreact,\n  type ChartWidgetProps as ChartWidgetPropsPreact,\n  ComponentAdapter,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../../component-wrapper-helpers';\nimport { rootId, template } from '../../component-wrapper-helpers/template';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport { ChartEventProps, WithoutPreactChartEventProps } from '../../types/chart-event-props';\nimport { ChartDataPointEvent, ChartDataPointsEvent } from '../../types/data-point';\nimport type { Arguments } from '../../types/utility-types';\n\n/**\n * Props of the {@link ChartWidgetComponent}.\n */\nexport interface ChartWidgetProps\n  extends WithoutPreactChartEventProps<ChartWidgetPropsPreact>,\n    ChartEventProps {}\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 * @group Dashboards\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!ChartWidgetProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  @Input()\n  beforeRender: ChartWidgetProps['beforeRender'];\n\n  /**\n   * {@inheritDoc  @sisense/sdk-ui!ChartWidgetProps.onDataReady}\n   *\n   * @category Callbacks\n   * @internal\n   */\n  @Input()\n  dataReady: ChartWidgetProps['dataReady'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointClick = new EventEmitter<ChartDataPointEvent>();\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointContextMenu = new EventEmitter<ChartDataPointEvent>();\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointsSelect = new EventEmitter<ChartDataPointsEvent>();\n\n  private componentAdapter: ComponentAdapter<typeof ChartWidgetPreact>;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    private themeService: ThemeService,\n  ) {\n    this.componentAdapter = new ComponentAdapter(ChartWidgetPreact, [\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  private getPreactComponentProps(): ChartWidgetPropsPreact {\n    return {\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      onDataReady: this.dataReady?.bind(this),\n      onDataPointClick: (\n        ...[point, nativeEvent]: Arguments<ChartWidgetPropsPreact['onDataPointClick']>\n      ) => this.dataPointClick.emit({ point, nativeEvent }),\n      onDataPointContextMenu: (\n        ...[point, nativeEvent]: Arguments<ChartWidgetPropsPreact['onDataPointContextMenu']>\n      ) => this.dataPointContextMenu.emit({ point, nativeEvent }),\n      onDataPointsSelected: (\n        ...[points, nativeEvent]: Arguments<ChartWidgetPropsPreact['onDataPointsSelected']>\n      ) => this.dataPointsSelect.emit({ points, nativeEvent }),\n    };\n  }\n\n  /** @internal */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}
+//# 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 as ChartWidgetPreact,\n  type ChartWidgetProps as ChartWidgetPropsPreact,\n  ComponentAdapter,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../../component-wrapper-helpers';\nimport { rootId, template } from '../../component-wrapper-helpers/template';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport { ChartEventProps, WithoutPreactChartEventProps } from '../../types/chart-event-props';\nimport {\n  ChartDataPointClickEvent,\n  ChartDataPointContextMenuEvent,\n  ChartDataPointsEvent,\n} from '../../types/data-point';\nimport type { Arguments } from '../../types/utility-types';\n\n/**\n * Props of the {@link ChartWidgetComponent}.\n */\nexport interface ChartWidgetProps\n  extends WithoutPreactChartEventProps<ChartWidgetPropsPreact>,\n    ChartEventProps {}\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=\"500px\" />\n * @group Dashboards\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!ChartWidgetProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  @Input()\n  beforeRender: ChartWidgetProps['beforeRender'];\n\n  /**\n   * {@inheritDoc  @sisense/sdk-ui!ChartWidgetProps.onDataReady}\n   *\n   * @category Callbacks\n   */\n  @Input()\n  dataReady: ChartWidgetProps['dataReady'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointClick = new EventEmitter<ChartDataPointClickEvent>();\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointContextMenu = new EventEmitter<ChartDataPointContextMenuEvent>();\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartWidgetProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointsSelect = new EventEmitter<ChartDataPointsEvent>();\n\n  private componentAdapter: ComponentAdapter<typeof ChartWidgetPreact>;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    private themeService: ThemeService,\n  ) {\n    this.componentAdapter = new ComponentAdapter(ChartWidgetPreact, [\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  private getPreactComponentProps(): ChartWidgetPropsPreact {\n    return {\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      onDataReady: this.dataReady?.bind(this),\n      onDataPointClick: (\n        ...[point, nativeEvent]: Arguments<ChartWidgetPropsPreact['onDataPointClick']>\n      ) => this.dataPointClick.emit({ point, nativeEvent } as ChartDataPointClickEvent),\n      onDataPointContextMenu: (\n        ...[point, nativeEvent]: Arguments<ChartWidgetPropsPreact['onDataPointContextMenu']>\n      ) => this.dataPointContextMenu.emit({ point, nativeEvent } as ChartDataPointContextMenuEvent),\n      onDataPointsSelected: (\n        ...[points, nativeEvent]: Arguments<ChartWidgetPropsPreact['onDataPointsSelected']>\n      ) => this.dataPointsSelect.emit({ points, nativeEvent } as ChartDataPointsEvent),\n    };\n  }\n\n  /** @internal */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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

@@ -122,7 +122,6 @@ export class DrilldownWidgetComponent {
     }
     getPreactComponentProps() {
         return {
-            drilldownDimensions: this.drilldownDimensions,
             drilldownPaths: this.drilldownPaths,
             initialDimension: this.initialDimension,
             config: {
@@ -154,7 +153,7 @@ export class DrilldownWidgetComponent {
     }
 }
 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", drilldownPaths: "drilldownPaths", 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 });
+DrilldownWidgetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: DrilldownWidgetComponent, selector: "csdk-drilldown-widget", inputs: { drilldownPaths: "drilldownPaths", 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: [{
@@ -167,8 +166,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], preactContentRef: [{
                 type: ViewChild,
                 args: [rootContentId]
-            }], drilldownDimensions: [{
-                type: Input
             }], drilldownPaths: [{
                 type: Input
             }], initialDimension: [{
@@ -178,4 +175,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], 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":"AAAA,OAAO,EAEL,SAAS,EAET,YAAY,EACZ,KAAK,EAGL,MAAM,EACN,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAGhB,uBAAuB,EACvB,oBAAoB,EACpB,2BAA2B,EAG3B,eAAe,IAAI,qBAAqB,GAEzC,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,aAAa,EACb,MAAM,EACN,mBAAmB,GACpB,MAAM,0CAA0C,CAAC;;;;AAWlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAKH,MAAM,OAAO,wBAAwB;IA2DnC;;;;;OAKG;IACH;IACE;;;;OAIG;IACI,qBAA4C;IACnD;;;;OAIG;IACI,YAA0B;QAN1B,0BAAqB,GAArB,qBAAqB,CAAuB;QAM5C,iBAAY,GAAZ,YAAY,CAAc;QA5BnC;;;;WAIG;QAEH,0BAAqB,GAAG,IAAI,YAAY,EAAyB,CAAC;QAwBhE,IAAI,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,qBAAqB,EAAE;YAClE,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC;YACzD,2BAA2B,CAAC,IAAI,CAAC,YAAY,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,eAAe;QACb,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAC;IAC7F,CAAC;IAED;;OAEG;IACH,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;IAEO,uBAAuB;QAC7B,OAAO;YACL,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;YAC7C,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,MAAM,EAAE;gBACN,GAAG,IAAI,CAAC,MAAM;gBACd,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,oBAAoB,IAAI;oBACvC,oBAAoB,EAAE,2BAA2B,CAAC,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC;iBACpF,CAAC;gBACF,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,oBAAoB,IAAI;oBACvC,oBAAoB,EAAE,CAAC,gBAAkC,EAAE,EAAE,CAC3D,oBAAoB,CAAC,IAAI,CAAC,MAAO,CAAC,oBAAqB,CAAC,gBAAgB,CAAC,CAAC;iBAC7E,CAAC;aACH;YACD,QAAQ,EAAE,CAAC,qBAAqE,EAAE,EAAE;gBAClF,MAAM,EAAE,oBAAoB,EAAE,GAAG,qBAAqB,CAAC;gBACvD,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC;oBAC9B,GAAG,qBAAqB;oBACxB,GAAG,CAAC,oBAAoB,IAAI;wBAC1B,oBAAoB,EAAE,EAAE,MAAM,EAAE,uBAAuB,CAAC,oBAAoB,CAAC,EAAE;qBAChF,CAAC;iBACsB,CAAC,CAAC;gBAC5B,OAAO,oBAAoB,CAAC,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;YACnE,CAAC;SACsB,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;sHAtIU,wBAAwB;0GAAxB,wBAAwB;4FAAxB,wBAAwB;kBAJpC,SAAS;mBAAC;oBACT,QAAQ,EAAE,uBAAuB;oBACjC,QAAQ,EAAE,mBAAmB;iBAC9B;uIAMC,SAAS;sBADR,SAAS;uBAAC,MAAM;gBAOjB,gBAAgB;sBADf,SAAS;uBAAC,aAAa;gBAUxB,mBAAmB;sBADlB,KAAK;gBASN,cAAc;sBADb,KAAK;gBASN,gBAAgB;sBADf,KAAK;gBASN,MAAM;sBADL,KAAK;gBAYN,qBAAqB;sBADpB,MAAM","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  type ComponentRenderer,\n  type ContextMenuProps,\n  createComponentRenderer,\n  createWrapperElement,\n  createWrapperElementHandler,\n  type CustomDrilldownResult as CustomDrilldownResultBase,\n  DrilldownBreadcrumbsProps,\n  DrilldownWidget as DrilldownWidgetPreact,\n  type DrilldownWidgetProps,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../../component-wrapper-helpers';\nimport {\n  rootContentId,\n  rootId,\n  templateWithContent,\n} from '../../component-wrapper-helpers/template';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport type { Arguments } from '../../types/utility-types';\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 *   drilldownPaths: [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 *   [drilldownPaths]=\"drilldown.drilldownPaths\"\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 * @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   * @category Widget\n   * @deprecated Use {@link drilldownPaths} instead\n   */\n  @Input()\n  drilldownDimensions: DrilldownWidgetProps['drilldownDimensions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DrilldownWidgetProps.drilldownPaths}\n   *\n   * @category Widget\n   */\n  @Input()\n  drilldownPaths: DrilldownWidgetProps['drilldownPaths'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DrilldownWidgetProps.initialDimension}\n   *\n   * @category Widget\n   */\n  @Input()\n  initialDimension!: DrilldownWidgetProps['initialDimension'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DrilldownWidgetProps.config}\n   *\n   * @category Widget\n   */\n  @Input()\n  config?: Omit<DrilldownWidgetProps['config'], 'breadcrumbsComponent | contextMenuComponent'> & {\n    breadcrumbsComponent?: (drilldownBreadcrumbsProps: DrilldownBreadcrumbsProps) => HTMLDivElement;\n    contextMenuComponent?: (contextMenuProps: ContextMenuProps) => HTMLDivElement;\n  };\n\n  /**\n   * Drilldown result change handler callback\n   *\n   * @category Callbacks\n   */\n  @Output()\n  drilldownResultChange = new EventEmitter<CustomDrilldownResult>();\n\n  private componentAdapter: ComponentAdapter<typeof DrilldownWidgetPreact>;\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(DrilldownWidgetPreact, [\n      createSisenseContextConnector(this.sisenseContextService),\n      createThemeContextConnector(this.themeService),\n    ]);\n  }\n\n  /**\n   * @internal\n   */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n  }\n\n  /**\n   * @internal\n   */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n    }\n  }\n\n  private getPreactComponentProps(): DrilldownWidgetProps {\n    return {\n      drilldownDimensions: this.drilldownDimensions,\n      drilldownPaths: this.drilldownPaths,\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      children: (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    } as DrilldownWidgetProps;\n  }\n\n  /**\n   * @internal\n   */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}
+//# 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  type ComponentRenderer,\n  type ContextMenuProps,\n  createComponentRenderer,\n  createWrapperElement,\n  createWrapperElementHandler,\n  type CustomDrilldownResult as CustomDrilldownResultBase,\n  DrilldownBreadcrumbsProps,\n  DrilldownWidget as DrilldownWidgetPreact,\n  type DrilldownWidgetProps,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../../component-wrapper-helpers';\nimport {\n  rootContentId,\n  rootId,\n  templateWithContent,\n} from '../../component-wrapper-helpers/template';\nimport { SisenseContextService } from '../../services/sisense-context.service';\nimport { ThemeService } from '../../services/theme.service';\nimport type { Arguments } from '../../types/utility-types';\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 *   drilldownPaths: [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 *   [drilldownPaths]=\"drilldown.drilldownPaths\"\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 * @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.drilldownPaths}\n   *\n   * @category Widget\n   */\n  @Input()\n  drilldownPaths: DrilldownWidgetProps['drilldownPaths'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DrilldownWidgetProps.initialDimension}\n   *\n   * @category Widget\n   */\n  @Input()\n  initialDimension!: DrilldownWidgetProps['initialDimension'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DrilldownWidgetProps.config}\n   *\n   * @category Widget\n   */\n  @Input()\n  config?: Omit<DrilldownWidgetProps['config'], 'breadcrumbsComponent | contextMenuComponent'> & {\n    breadcrumbsComponent?: (drilldownBreadcrumbsProps: DrilldownBreadcrumbsProps) => HTMLDivElement;\n    contextMenuComponent?: (contextMenuProps: ContextMenuProps) => HTMLDivElement;\n  };\n\n  /**\n   * Drilldown result change handler callback\n   *\n   * @category Callbacks\n   */\n  @Output()\n  drilldownResultChange = new EventEmitter<CustomDrilldownResult>();\n\n  private componentAdapter: ComponentAdapter<typeof DrilldownWidgetPreact>;\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(DrilldownWidgetPreact, [\n      createSisenseContextConnector(this.sisenseContextService),\n      createThemeContextConnector(this.themeService),\n    ]);\n  }\n\n  /**\n   * @internal\n   */\n  ngAfterViewInit() {\n    this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n  }\n\n  /**\n   * @internal\n   */\n  ngOnChanges() {\n    if (this.preactRef) {\n      this.componentAdapter.render(this.preactRef.nativeElement, this.getPreactComponentProps());\n    }\n  }\n\n  private getPreactComponentProps(): DrilldownWidgetProps {\n    return {\n      drilldownPaths: this.drilldownPaths,\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      children: (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    } as DrilldownWidgetProps;\n  }\n\n  /**\n   * @internal\n   */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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

@@ -1,7 +1,7 @@
 export * from './chart-widget.component';
-export * from './dashboard-widget.component';
 export * from './drilldown-widget.component';
 export * from './pivot-table-widget.component';
 export * from './table-widget.component';
+export * from './widget.component';
 export * from './widget-by-id.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvd2lkZ2V0cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2hhcnQtd2lkZ2V0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Rhc2hib2FyZC13aWRnZXQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZHJpbGxkb3duLXdpZGdldC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9waXZvdC10YWJsZS13aWRnZXQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vdGFibGUtd2lkZ2V0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3dpZGdldC1ieS1pZC5jb21wb25lbnQnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvd2lkZ2V0cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYywwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2hhcnQtd2lkZ2V0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2RyaWxsZG93bi13aWRnZXQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcGl2b3QtdGFibGUtd2lkZ2V0LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3RhYmxlLXdpZGdldC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi93aWRnZXQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0LWJ5LWlkLmNvbXBvbmVudCc7XG4iXX0=

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

@@ -113,4 +113,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,GAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;;;;AAY5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAKH,MAAM,OAAO,mBAAmB;IAoG9B,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;;iHA/IU,mBAAmB;qGAAnB,mBAAmB;4FAAnB,mBAAmB;kBAJ/B,SAAS;mBAAC;oBACT,QAAQ,EAAE,mBAAmB;oBAC7B,QAAQ;iBACT;uIAIC,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;gBAUN,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} from '../../component-wrapper-helpers';\nimport { rootId, template } from '../../component-wrapper-helpers/template';\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})\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   * @internal\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,GAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,0CAA0C,CAAC;;;;AAY5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAKH,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;kBAJ/B,SAAS;mBAAC;oBACT,QAAQ,EAAE,mBAAmB;oBAC7B,QAAQ;iBACT;uIAIC,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} from '../../component-wrapper-helpers';\nimport { rootId, template } from '../../component-wrapper-helpers/template';\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})\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"]}