@sisense/sdk-ui-angular 1.5.0 → 1.7.0

package/dist/esm2020/lib/components/context-menu.component.mjs

@@ -7,6 +7,8 @@ import * as i1 from "../services/sisense-context.service";
 import * as i2 from "../services/theme.service";
 /**
  * Context Menu Component
+ *
+ * @group Drilldown
  */
 export class ContextMenuComponent {
     /**
@@ -89,4 +91,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], contextMenuClose: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2020/lib/components/drilldown-breadcrumbs.component.mjs

@@ -7,6 +7,8 @@ import * as i1 from "../services/sisense-context.service";
 import * as i2 from "../services/theme.service";
 /**
  * Drilldown Breadcrumbs Component
+ *
+ * @group Drilldown
  */
 export class DrilldownBreadcrumbsComponent {
     /**
@@ -97,4 +99,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], drilldownSelectionsSlice: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,62 @@
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { BasicMemberFilterTile, ComponentAdapter, createElement, } from '@sisense/sdk-ui-preact';
+import { template, rootId } from '../../component-wrapper-helpers/template';
+import * as i0 from "@angular/core";
+/**
+ * Basic Member Filter Tile Component
+ *
+ * @internal
+ */
+export class BasicMemberFilterTileComponent {
+    constructor() {
+        this.selectedMembersUpdated = new EventEmitter();
+        this.componentAdapter = new ComponentAdapter(() => this.createPreactComponent());
+    }
+    /** @internal */
+    ngAfterViewInit() {
+        this.componentAdapter.render(this.preactRef.nativeElement);
+    }
+    /** @internal */
+    ngOnChanges() {
+        if (this.preactRef) {
+            this.componentAdapter.render(this.preactRef.nativeElement);
+        }
+    }
+    /** @internal */
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+    createPreactComponent() {
+        const props = {
+            allMembers: this.allMembers,
+            initialSelectedMembers: this.initialSelectedMembers,
+            title: this.title,
+            maxAllowedMembers: this.maxAllowedMembers,
+            onUpdateSelectedMembers: (members) => this.selectedMembersUpdated.emit(members),
+        };
+        return createElement(BasicMemberFilterTile, props);
+    }
+}
+BasicMemberFilterTileComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BasicMemberFilterTileComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+BasicMemberFilterTileComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: BasicMemberFilterTileComponent, selector: "csdk-basic-member-filter-tile", inputs: { title: "title", allMembers: "allMembers", initialSelectedMembers: "initialSelectedMembers", maxAllowedMembers: "maxAllowedMembers" }, outputs: { selectedMembersUpdated: "selectedMembersUpdated" }, 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: BasicMemberFilterTileComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-basic-member-filter-tile',
+                    template,
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], title: [{
+                type: Input
+            }], allMembers: [{
+                type: Input
+            }], initialSelectedMembers: [{
+                type: Input
+            }], maxAllowedMembers: [{
+                type: Input
+            }], selectedMembersUpdated: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,141 @@
+import { Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { DateRangeFilterTile, 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";
+/**
+ * Date Range Filter Tile Component
+ *
+ * @example
+ * ```html
+ * <csdk-date-range-filter-tile
+ *       title="dateRangeFilterTileProps.title"
+ *       [attribute]="dateRangeFilterTileProps.attribute"
+ *       [filter]="dateRangeFilterTileProps.filter"
+ *       (filterChange)="dateRangeFilterTileProps.setFilter($event)"
+ *     />
+ * ```
+ * ```ts
+ * import { Component } from '@angular/core';
+ * import { Member } from '@sisense/sdk-ui-angular';
+ * import { Filter, filterFactory } from '@sisense/sdk-data';
+ * import * as DM from '../../assets/sample-healthcare-model';
+ *
+ * @Component({
+ *   selector: 'app-filters',
+ *   templateUrl: './filters.component.html',
+ *   styleUrls: ['./filters.component.scss'],
+ * })
+ * export class FiltersComponent {
+ *   DM = DM;
+
+ *   dateRangeFilterTileProps = {
+ *     title: 'Range Filter',
+ *     attribute: DM.ER.Date.Years,
+ *     filter: filterFactory.dateRange(DM.ER.Date.Years),
+ *     setFilter({ filter }: { filter: Filter | null }) {
+ *       console.log(filter);
+ *       if (filter) {
+ *         this.filter = filter;
+ *       }
+ *     },
+ *   };
+ * }
+ * ```
+ * <img src="media://angular-date-range-filter-tile-example.png" width="800px" />
+ *
+ * @group Filter Tiles
+ */
+export class DateRangeFilterTileComponent {
+    /**
+     * Constructor for the `DateRangeFilterTileComponent`.
+     *
+     * @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 @sisense/sdk-ui!DateRangeFilterTileProps.onChange}
+         */
+        this.filterChange = 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 = {
+            title: this.title,
+            attribute: this.attribute,
+            dataSource: this.dataSource,
+            filter: this.filter,
+            earliestDate: this.earliestDate,
+            lastDate: this.lastDate,
+            onChange: (...[filter]) => this.filterChange.emit({ filter }),
+        };
+        return createElement(DateRangeFilterTile, props);
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+}
+DateRangeFilterTileComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: DateRangeFilterTileComponent, deps: [{ token: i1.SisenseContextService }, { token: i2.ThemeService }], target: i0.ɵɵFactoryTarget.Component });
+DateRangeFilterTileComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: DateRangeFilterTileComponent, selector: "csdk-date-range-filter-tile", inputs: { title: "title", attribute: "attribute", dataSource: "dataSource", filter: "filter", earliestDate: "earliestDate", lastDate: "lastDate" }, outputs: { filterChange: "filterChange" }, 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: DateRangeFilterTileComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-date-range-filter-tile',
+                    template,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i2.ThemeService }]; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], title: [{
+                type: Input
+            }], attribute: [{
+                type: Input
+            }], dataSource: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], earliestDate: [{
+                type: Input
+            }], lastDate: [{
+                type: Input
+            }], filterChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-range-filter-tile.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/filters/date-range-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,mBAAmB,EAEnB,gBAAgB,EAChB,aAAa,GACd,MAAM,wBAAwB,CAAC;AAIhC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;;;;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAKH,MAAM,OAAO,4BAA4B;IAqDvC;;;;;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,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;;OAEG;IACH,eAAe;QACb,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACH,WAAW;QACT,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;SAC5D;IACH,CAAC;IAEO,qBAAqB;QAC3B,MAAM,KAAK,GAAG;YACZ,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,QAAQ,EAAE,CAAC,GAAG,CAAC,MAAM,CAAkD,EAAE,EAAE,CACzE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;SACrC,CAAC;QAEF,OAAO,aAAa,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;0HAtHU,4BAA4B;8GAA5B,4BAA4B;4FAA5B,4BAA4B;kBAJxC,SAAS;mBAAC;oBACT,QAAQ,EAAE,6BAA6B;oBACvC,QAAQ;iBACT;uIAMC,SAAS;sBADR,SAAS;uBAAC,MAAM;gBAOjB,KAAK;sBADJ,KAAK;gBAON,SAAS;sBADR,KAAK;gBAON,UAAU;sBADT,KAAK;gBAON,MAAM;sBADL,KAAK;gBAON,YAAY;sBADX,KAAK;gBAON,QAAQ;sBADP,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  DateRangeFilterTile,\n  type DateRangeFilterTileProps,\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 * Date Range Filter Tile Component\n *\n * @example\n * ```html\n * <csdk-date-range-filter-tile\n *       title=\"dateRangeFilterTileProps.title\"\n *       [attribute]=\"dateRangeFilterTileProps.attribute\"\n *       [filter]=\"dateRangeFilterTileProps.filter\"\n *       (filterChange)=\"dateRangeFilterTileProps.setFilter($event)\"\n *     />\n * ```\n * ```ts\n * import { Component } from '@angular/core';\n * import { Member } from '@sisense/sdk-ui-angular';\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\n *   dateRangeFilterTileProps = {\n *     title: 'Range Filter',\n *     attribute: DM.ER.Date.Years,\n *     filter: filterFactory.dateRange(DM.ER.Date.Years),\n *     setFilter({ filter }: { filter: Filter | null }) {\n *       console.log(filter);\n *       if (filter) {\n *         this.filter = filter;\n *       }\n *     },\n *   };\n * }\n * ```\n * <img src=\"media://angular-date-range-filter-tile-example.png\" width=\"800px\" />\n *\n * @group Filter Tiles\n */\n@Component({\n  selector: 'csdk-date-range-filter-tile',\n  template,\n})\nexport class DateRangeFilterTileComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /**\n   * @internal\n   */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DateRangeFilterTileProps.title}\n   */\n  @Input()\n  title!: DateRangeFilterTileProps['title'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DateRangeFilterTileProps.attribute}\n   */\n  @Input()\n  attribute!: DateRangeFilterTileProps['attribute'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DateRangeFilterTileProps.dataSource}\n   */\n  @Input()\n  dataSource: DateRangeFilterTileProps['dataSource'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DateRangeFilterTileProps.filter}\n   */\n  @Input()\n  filter!: DateRangeFilterTileProps['filter'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DateRangeFilterTileProps.earliestDate}\n   */\n  @Input()\n  earliestDate: DateRangeFilterTileProps['earliestDate'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DateRangeFilterTileProps.lastDate}\n   */\n  @Input()\n  lastDate: DateRangeFilterTileProps['lastDate'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!DateRangeFilterTileProps.onChange}\n   */\n  @Output()\n  filterChange = new EventEmitter<\n    ArgumentsAsObject<DateRangeFilterTileProps['onChange'], ['filter']>\n  >();\n\n  private componentAdapter: ComponentAdapter;\n\n  /**\n   * Constructor for the `DateRangeFilterTileComponent`.\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      title: this.title,\n      attribute: this.attribute,\n      dataSource: this.dataSource,\n      filter: this.filter,\n      earliestDate: this.earliestDate,\n      lastDate: this.lastDate,\n      onChange: (...[filter]: Arguments<DateRangeFilterTileProps['onChange']>) =>\n        this.filterChange.emit({ filter }),\n    };\n\n    return createElement(DateRangeFilterTile, props);\n  }\n\n  /**\n   * @internal\n   */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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

@@ -0,0 +1,4 @@
+export * from './basic-member-filter-tile.component';
+export * from './member-filter-tile.component';
+export * from './date-range-filter-tile.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvZmlsdGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxvQ0FBb0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYmFzaWMtbWVtYmVyLWZpbHRlci10aWxlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL21lbWJlci1maWx0ZXItdGlsZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRlLXJhbmdlLWZpbHRlci10aWxlLmNvbXBvbmVudCc7XG4iXX0=

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

@@ -0,0 +1,131 @@
+import { Component, EventEmitter, Input, Output, ViewChild, } from '@angular/core';
+import { MemberFilterTile, 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";
+/**
+ * Member Filter Tile Component
+ *
+ * @example
+ * ```html
+ *     <csdk-member-filter-tile
+ *       title="Years Filter"
+ *       [attribute]="DM.ER.Date.Years"
+ *       [filter]="memberFilterTileProps.yearFilter"
+ *       (filterChange)="memberFilterTileProps.setYearFilter($event)"
+ *     />
+ * ```
+ * ```ts
+ * import { Component } from '@angular/core';
+ * import { Member } from '@sisense/sdk-ui-angular';
+ * import { Filter, filterFactory } from '@sisense/sdk-data';
+ * import * as DM from '../../assets/sample-healthcare-model';
+ *
+ * @Component({
+ *   selector: 'app-filters',
+ *   templateUrl: './filters.component.html',
+ *   styleUrls: ['./filters.component.scss'],
+ * })
+ * export class FiltersComponent {
+ *   DM = DM;
+ *   memberFilterTileProps = {
+ *     yearFilter: filterFactory.members(DM.ER.Date.Years, ['2013-01-01T00:00:00']),
+ *     setYearFilter({ filter }: { filter: Filter | null }) {
+ *       if (filter) {
+ *         this.yearFilter = filter;
+ *       }
+ *     },
+ *   };
+ * }
+ * ```
+ * <img src="media://angular-member-filter-tile-example.png" width="800px" />
+ *
+ * @group Filter Tiles
+ */
+export class MemberFilterTileComponent {
+    /**
+     * Constructor for the `MemberFilterTileComponent`.
+     *
+     * @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 @sisense/sdk-ui!MemberFilterTileProps.onChange}
+         */
+        this.filterChange = 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 = {
+            title: this.title,
+            dataSource: this.dataSource,
+            attribute: this.attribute,
+            filter: this.filter,
+            onChange: (...[filter]) => this.filterChange.emit({ filter }),
+        };
+        return createElement(MemberFilterTile, props);
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+}
+MemberFilterTileComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MemberFilterTileComponent, deps: [{ token: i1.SisenseContextService }, { token: i2.ThemeService }], target: i0.ɵɵFactoryTarget.Component });
+MemberFilterTileComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: MemberFilterTileComponent, selector: "csdk-member-filter-tile", inputs: { title: "title", dataSource: "dataSource", attribute: "attribute", filter: "filter" }, outputs: { filterChange: "filterChange" }, 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: MemberFilterTileComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-member-filter-tile',
+                    template,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i2.ThemeService }]; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], title: [{
+                type: Input
+            }], dataSource: [{
+                type: Input
+            }], attribute: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], 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,EAEhB,gBAAgB,EAChB,aAAa,GACd,MAAM,wBAAwB,CAAC;AAIhC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,0CAA0C,CAAC;;;;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;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,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;;OAEG;IACH,eAAe;QACb,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACH,WAAW;QACT,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;SAC5D;IACH,CAAC;IAEO,qBAAqB;QAC3B,MAAM,KAAK,GAAG;YACZ,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,CAA+C,EAAE,EAAE,CACtE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;SACrC,CAAC;QAEF,OAAO,aAAa,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;uHAxGU,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  MemberFilterTile,\n  type MemberFilterTileProps,\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 * 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 { Member } from '@sisense/sdk-ui-angular';\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=\"800px\" />\n *\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<MemberFilterTileProps['onChange'], ['filter']>\n  >();\n\n  private componentAdapter: ComponentAdapter;\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(\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      title: this.title,\n      dataSource: this.dataSource,\n      attribute: this.attribute,\n      filter: this.filter,\n      onChange: (...[filter]: Arguments<MemberFilterTileProps['onChange']>) =>\n        this.filterChange.emit({ filter }),\n    };\n\n    return createElement(MemberFilterTile, props);\n  }\n\n  /**\n   * @internal\n   */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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

@@ -1,27 +1,6 @@
-export * from './basic-member-filter-tile.component';
-export * from './chart.component';
-export * from './table.component';
-export * from './chart-widget.component';
-export * from './column-chart.component';
-export * from './bar-chart.component';
-export * from './area-chart.component';
-export * from './line-chart.component';
-export * from './indicator-chart.component';
-export * from './scatter-chart.component';
-export * from './pie-chart.component';
-export * from './funnel-chart.component';
-export * from './polar-chart.component';
-export * from './treemap-chart.component';
-export * from './sunburst-chart.component';
-export * from './table-widget.component';
-export * from './dashboard-widget.component';
-export * from './member-filter-tile.component';
-export * from './drilldown-widget.component';
-export * from './date-range-filter-tile.component';
+export * from './filters';
+export * from './charts';
+export * from './widgets';
 export * from './drilldown-breadcrumbs.component';
 export * from './context-menu.component';
-export * from './boxplot-chart.component';
-export * from './scattermap-chart.component';
-export * from './areamap-chart.component';
-export * from './pivot-table.component';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9maWx0ZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vY2hhcnRzJztcbmV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0cyc7XG5leHBvcnQgKiBmcm9tICcuL2RyaWxsZG93bi1icmVhZGNydW1icy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250ZXh0LW1lbnUuY29tcG9uZW50JztcbiJdfQ==