@sisense/sdk-ui-angular 1.30.0 → 1.32.0

package/dist/esm2020/ai/lib/components/get-nlg-insights.component.mjs

@@ -0,0 +1,146 @@
+import { Component, Input, ViewChild, } from '@angular/core';
+import { ComponentAdapter, createElement } from '@sisense/sdk-ui-preact';
+import { GetNlgInsights, } from '@sisense/sdk-ui-preact/ai';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { createSisenseContextConnector, createThemeContextConnector, } from '@sisense/sdk-ui-angular';
+import { createAiContextConnector } from '../component-wrapper-helpers';
+import { template, rootId } from '../component-wrapper-helpers/template';
+import * as i0 from "@angular/core";
+import * as i1 from "@sisense/sdk-ui-angular";
+import * as i2 from "../services/ai.service";
+/**
+ * An Angular component that fetches and displays a collapsible analysis of the provided query using natural language generation (NLG).
+ * Specifying NLG parameters is similar to providing parameters to the {@link QueryService.executeQuery} service method, using dimensions, measures, and filters.
+ *
+ * ::: warning Note
+ * This component is currently under beta release for our managed cloud customers on version L2024.2 or above. It is subject to changes as we make fixes and improvements.
+ * :::
+ *
+ * @example
+ * An example of using the `GetNlgInsightsComponent`:
+ *
+ * ```html
+<!--Component HTML template in example.component.html-->
+<csdk-get-nlg-insights
+  [dataSource]="nlgParams.dataSource"
+  [dimensions]="nlgParams.dimensions"
+  [measures]="nlgParams.measures"
+/>
+ * ```
+ *
+ * ```ts
+// Component behavior in example.component.ts
+import { Component } from '@angular/core';
+import { measureFactory } 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 {
+  nlgParams = {
+    dataSource: DM.DataSource.title,
+    dimensions: [DM.Divisions.Divison_name],
+    measures: [measureFactory.sum(DM.Admissions.Cost_of_admission)],
+  };
+}
+ * ```
+ *
+ * <img src="media://angular-get-nlg-insights-example.png" width="800px" />
+ * @shortDescription Angular component that displays NLG insights.
+ *
+ * @group Generative AI
+ * @beta
+ */
+export class GetNlgInsightsComponent {
+    /**
+     * Constructor for the `GetNlgInsightsProps`.
+     *
+     * @param sisenseContextService - Sisense context service
+     * @param themeService - Theme service
+     * @param aiService - AI service
+     */
+    constructor(
+    /**
+     * Sisense context service
+     *
+     * @category Constructor
+     */
+    sisenseContextService, 
+    /**
+     * Theme service
+     *
+     * @category Constructor
+     */
+    themeService, 
+    /**
+     * AI service
+     *
+     * @category Constructor
+     */
+    aiService) {
+        this.sisenseContextService = sisenseContextService;
+        this.themeService = themeService;
+        this.aiService = aiService;
+        this.componentAdapter = new ComponentAdapter(() => this.createPreactComponent(), [
+            createSisenseContextConnector(this.sisenseContextService),
+            createThemeContextConnector(this.themeService),
+            createAiContextConnector(this.aiService),
+        ]);
+    }
+    /**
+     * @internal
+     */
+    ngAfterViewInit() {
+        this.componentAdapter.render(this.preactRef.nativeElement);
+    }
+    /**
+     * @internal
+     */
+    ngOnChanges() {
+        if (this.preactRef) {
+            this.componentAdapter.render(this.preactRef.nativeElement);
+        }
+    }
+    createPreactComponent() {
+        const props = {
+            dataSource: this.dataSource,
+            dimensions: this.dimensions,
+            measures: this.measures,
+            filters: this.filters,
+            verbosity: this.verbosity,
+        };
+        return createElement(GetNlgInsights, props);
+    }
+    /**
+     * @internal
+     */
+    ngOnDestroy() {
+        this.componentAdapter.destroy();
+    }
+}
+GetNlgInsightsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: GetNlgInsightsComponent, deps: [{ token: i1.SisenseContextService }, { token: i1.ThemeService }, { token: i2.AiService }], target: i0.ɵɵFactoryTarget.Component });
+GetNlgInsightsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: GetNlgInsightsComponent, selector: "csdk-get-nlg-insights", inputs: { dataSource: "dataSource", dimensions: "dimensions", measures: "measures", filters: "filters", verbosity: "verbosity" }, 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: GetNlgInsightsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'csdk-get-nlg-insights',
+                    template,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i1.ThemeService }, { type: i2.AiService }]; }, propDecorators: { preactRef: [{
+                type: ViewChild,
+                args: [rootId]
+            }], dataSource: [{
+                type: Input
+            }], dimensions: [{
+                type: Input
+            }], measures: [{
+                type: Input
+            }], filters: [{
+                type: Input
+            }], verbosity: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get-nlg-insights.component.js","sourceRoot":"","sources":["../../../../../src/ai/lib/components/get-nlg-insights.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,KAAK,EAGL,SAAS,GACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EACL,cAAc,GAEf,MAAM,2BAA2B,CAAC;AACnC,6DAA6D;AAC7D,OAAO,EAGL,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,uCAAuC,CAAC;;;;AAOzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAKH,MAAM,OAAO,uBAAuB;IAuClC;;;;;;OAMG;IACH;IACE;;;;OAIG;IACI,qBAA4C;IACnD;;;;OAIG;IACI,YAA0B;IACjC;;;;OAIG;IACI,SAAoB;QAZpB,0BAAqB,GAArB,qBAAqB,CAAuB;QAM5C,iBAAY,GAAZ,YAAY,CAAc;QAM1B,cAAS,GAAT,SAAS,CAAW;QAE3B,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;YAC9C,wBAAwB,CAAC,IAAI,CAAC,SAAS,CAAC;SACzC,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,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC;QAEF,OAAO,aAAa,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,WAAW;QACT,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;qHA7GU,uBAAuB;yGAAvB,uBAAuB;4FAAvB,uBAAuB;kBAJnC,SAAS;mBAAC;oBACT,QAAQ,EAAE,uBAAuB;oBACjC,QAAQ;iBACT;+JAMC,SAAS;sBADR,SAAS;uBAAC,MAAM;gBAOjB,UAAU;sBADT,KAAK;gBAON,UAAU;sBADT,KAAK;gBAON,QAAQ;sBADP,KAAK;gBAON,OAAO;sBADN,KAAK;gBAON,SAAS;sBADR,KAAK","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  Input,\n  OnChanges,\n  OnDestroy,\n  ViewChild,\n} from '@angular/core';\nimport { ComponentAdapter, createElement } from '@sisense/sdk-ui-preact';\nimport {\n  GetNlgInsights,\n  type GetNlgInsightsProps as GetNlgInsightsPropsPreact,\n} from '@sisense/sdk-ui-preact/ai';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  SisenseContextService,\n  ThemeService,\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '@sisense/sdk-ui-angular';\nimport { AiService } from '../services/ai.service';\nimport { createAiContextConnector } from '../component-wrapper-helpers';\nimport { template, rootId } from '../component-wrapper-helpers/template';\n\n/**\n * Props of the {@link GetNlgInsightsComponent}.\n */\nexport interface GetNlgInsightsProps extends GetNlgInsightsPropsPreact {}\n\n/**\n * An Angular component that fetches and displays a collapsible analysis of the provided query using natural language generation (NLG).\n * Specifying NLG parameters is similar to providing parameters to the {@link QueryService.executeQuery} service method, using dimensions, measures, and filters.\n *\n * ::: warning Note\n * This component is currently under beta release for our managed cloud customers on version L2024.2 or above. It is subject to changes as we make fixes and improvements.\n * :::\n *\n * @example\n * An example of using the `GetNlgInsightsComponent`:\n *\n * ```html\n<!--Component HTML template in example.component.html-->\n<csdk-get-nlg-insights\n  [dataSource]=\"nlgParams.dataSource\"\n  [dimensions]=\"nlgParams.dimensions\"\n  [measures]=\"nlgParams.measures\"\n/>\n * ```\n *\n * ```ts\n// Component behavior in example.component.ts\nimport { Component } from '@angular/core';\nimport { measureFactory } 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  nlgParams = {\n    dataSource: DM.DataSource.title,\n    dimensions: [DM.Divisions.Divison_name],\n    measures: [measureFactory.sum(DM.Admissions.Cost_of_admission)],\n  };\n}\n * ```\n *\n * <img src=\"media://angular-get-nlg-insights-example.png\" width=\"800px\" />\n * @shortDescription Angular component that displays NLG insights.\n *\n * @group Generative AI\n * @beta\n */\n@Component({\n  selector: 'csdk-get-nlg-insights',\n  template,\n})\nexport class GetNlgInsightsComponent implements AfterViewInit, OnChanges, OnDestroy {\n  /**\n   * @internal\n   */\n  @ViewChild(rootId)\n  preactRef!: ElementRef<HTMLDivElement>;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!GetNlgInsightsProps.dataSource}\n   */\n  @Input()\n  dataSource!: GetNlgInsightsProps['dataSource'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!GetNlgInsightsProps.dimensions}\n   */\n  @Input()\n  dimensions: GetNlgInsightsProps['dimensions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!GetNlgInsightsProps.measures}\n   */\n  @Input()\n  measures: GetNlgInsightsProps['measures'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!GetNlgInsightsProps.filters}\n   */\n  @Input()\n  filters: GetNlgInsightsProps['filters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!GetNlgInsightsProps.verbosity}\n   */\n  @Input()\n  verbosity: GetNlgInsightsProps['verbosity'];\n\n  private componentAdapter: ComponentAdapter;\n\n  /**\n   * Constructor for the `GetNlgInsightsProps`.\n   *\n   * @param sisenseContextService - Sisense context service\n   * @param themeService - Theme service\n   * @param aiService - AI 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     * AI service\n     *\n     * @category Constructor\n     */\n    public aiService: AiService,\n  ) {\n    this.componentAdapter = new ComponentAdapter(\n      () => this.createPreactComponent(),\n      [\n        createSisenseContextConnector(this.sisenseContextService),\n        createThemeContextConnector(this.themeService),\n        createAiContextConnector(this.aiService),\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      dataSource: this.dataSource,\n      dimensions: this.dimensions,\n      measures: this.measures,\n      filters: this.filters,\n      verbosity: this.verbosity,\n    };\n\n    return createElement(GetNlgInsights, props);\n  }\n\n  /**\n   * @internal\n   */\n  ngOnDestroy() {\n    this.componentAdapter.destroy();\n  }\n}\n"]}

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

@@ -0,0 +1,3 @@
+export * from './chatbot.component';
+export * from './get-nlg-insights.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYWkvbGliL2NvbXBvbmVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jaGF0Ym90LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2dldC1ubGctaW5zaWdodHMuY29tcG9uZW50JztcbiJdfQ==

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

@@ -2,11 +2,45 @@
 import { NgModule } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { SdkUiModule } from '@sisense/sdk-ui-angular';
+import { ChatbotComponent, GetNlgInsightsComponent } from './components';
 import * as i0 from "@angular/core";
 /**
- * SDK AI Module
+ * SDK AI Module, which is a container for generative AI components and services.
  *
- * @internal
+ * @example
+ * Example of importing {@link SdkAiModule} and injecting {@link AiContextConfig} into your application,
+ * along with importing dependency {@link SdkUiModule} and injecting {@link SisenseContextConfig} to connect to a Sisense instance:
+ *
+ * ```ts
+ * import { SdkUiModule, SisenseContextConfig } from '@sisense/sdk-ui-angular';
+ * import { SdkAiModule, AI_CONTEXT_CONFIG_TOKEN, AiContextConfig } from '@sisense/sdk-ui-angular/ai';
+ *
+ * const AI_CONTEXT_CONFIG: AiContextConfig = {
+ *   volatile: true,
+ * };
+ * const SISENSE_CONTEXT_CONFIG: SisenseContextConfig = {
+ *   url: "<instance url>", // replace with the URL of your Sisense instance
+ *   token: "<api token>", // replace with the API token of your user account
+ *   defaultDataSource: DM.DataSource,
+ * };
+ *
+ * @NgModule({
+ *   imports: [
+ *     BrowserModule,
+ *     SdkUiModule,
+ *     SdkAiModule,
+ *   ],
+ *   declarations: [AppComponent],
+ *   providers: [
+ *     { provide: AI_CONTEXT_CONFIG_TOKEN, useValue: AI_CONTEXT_CONFIG },
+ *     { provide: SISENSE_CONTEXT_CONFIG_TOKEN, useValue: SISENSE_CONTEXT_CONFIG },
+ *   ],
+ *   bootstrap: [AppComponent],
+ * })
+ * ```
+ *
+ * @group Generative AI
+ * @beta
  */
 export class SdkAiModule {
     constructor() {
@@ -14,15 +48,15 @@ export class SdkAiModule {
     }
 }
 SdkAiModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SdkAiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SdkAiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: SdkAiModule, imports: [CommonModule, SdkUiModule] });
+SdkAiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: SdkAiModule, declarations: [ChatbotComponent, GetNlgInsightsComponent], imports: [CommonModule, SdkUiModule], exports: [ChatbotComponent, GetNlgInsightsComponent] });
 SdkAiModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SdkAiModule, imports: [CommonModule, SdkUiModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: SdkAiModule, decorators: [{
             type: NgModule,
             args: [{
-                    declarations: [],
+                    declarations: [ChatbotComponent, GetNlgInsightsComponent],
                     imports: [CommonModule, SdkUiModule],
-                    exports: [],
+                    exports: [ChatbotComponent, GetNlgInsightsComponent],
                     providers: [],
                 }]
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2RrLWFpLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9haS9saWIvc2RrLWFpLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxzREFBc0Q7QUFDdEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHlCQUF5QixDQUFDOztBQUV0RDs7OztHQUlHO0FBT0gsTUFBTSxPQUFPLFdBQVc7SUFDdEI7UUFDRSxPQUFPLENBQUMsR0FBRyxDQUFDLG9CQUFvQixDQUFDLENBQUM7SUFDcEMsQ0FBQzs7eUdBSFUsV0FBVzswR0FBWCxXQUFXLFlBSlosWUFBWSxFQUFFLFdBQVc7MEdBSXhCLFdBQVcsWUFKWixZQUFZLEVBQUUsV0FBVzs0RkFJeEIsV0FBVztrQkFOdkIsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsRUFBRTtvQkFDaEIsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLFdBQVcsQ0FBQztvQkFDcEMsT0FBTyxFQUFFLEVBQUU7b0JBQ1gsU0FBUyxFQUFFLEVBQUU7aUJBQ2QiLCJzb3VyY2VzQ29udGVudCI6WyIvKiBlc2xpbnQtZGlzYWJsZSBpbXBvcnQvbm8tZXh0cmFuZW91cy1kZXBlbmRlbmNpZXMgKi9cbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgU2RrVWlNb2R1bGUgfSBmcm9tICdAc2lzZW5zZS9zZGstdWktYW5ndWxhcic7XG5cbi8qKlxuICogU0RLIEFJIE1vZHVsZVxuICpcbiAqIEBpbnRlcm5hbFxuICovXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtdLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBTZGtVaU1vZHVsZV0sXG4gIGV4cG9ydHM6IFtdLFxuICBwcm92aWRlcnM6IFtdLFxufSlcbmV4cG9ydCBjbGFzcyBTZGtBaU1vZHVsZSB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIGNvbnNvbGUubG9nKCdTZGtBaU1vZHVsZSBsb2FkZWQnKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+// This file re-exports common types/utils from @sisense/sdk-ui-preact/ai
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2RrLXVpLWNvcmUtZXhwb3J0cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9haS9saWIvc2RrLXVpLWNvcmUtZXhwb3J0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx5RUFBeUUiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBUaGlzIGZpbGUgcmUtZXhwb3J0cyBjb21tb24gdHlwZXMvdXRpbHMgZnJvbSBAc2lzZW5zZS9zZGstdWktcHJlYWN0L2FpXG5cbi8vIFJlLWV4cG9ydHMgdHlwZXMgZnJvbSBAc2lzZW5zZS9zZGstdWktcHJlYWN0L2FpXG5leHBvcnQgdHlwZSB7XG4gIENoYXRDb25maWcsXG4gIEdldFF1ZXJ5UmVjb21tZW5kYXRpb25zUGFyYW1zLFxuICBRdWVyeVJlY29tbWVuZGF0aW9uLFxuICBHZXRObHFSZXN1bHRQYXJhbXMsXG59IGZyb20gJ0BzaXNlbnNlL3Nkay11aS1wcmVhY3QvYWknO1xuIl19

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

@@ -0,0 +1,137 @@
+import { __decorate } from "tslib";
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { ChatRestApi, prepareGetNlgInsightsPayload, DEFAULT_RECOMMENDATIONS_COUNT, widgetComposer, prepareGetNlqResultPayload, } from '@sisense/sdk-ui-preact/ai';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { TrackableService } from '@sisense/sdk-ui-angular';
+import * as i0 from "@angular/core";
+import * as i1 from "@sisense/sdk-ui-angular";
+/**
+ * Token used to inject {@link AiContextConfig} into your application.
+ *
+ * @example
+ * Example of importing {@link SdkAiModule} and injecting {@link AiContextConfig} into your application,
+ * along with importing dependency {@link SdkUiModule} and injecting {@link SisenseContextConfig} to connect to a Sisense instance:
+ *
+ * ```ts
+ * import { SdkUiModule, SisenseContextConfig } from '@sisense/sdk-ui-angular';
+ * import { SdkAiModule, AI_CONTEXT_CONFIG_TOKEN, AiContextConfig } from '@sisense/sdk-ui-angular/ai';
+ *
+ * const AI_CONTEXT_CONFIG: AiContextConfig = {
+ *   volatile: true,
+ * };
+ * const SISENSE_CONTEXT_CONFIG: SisenseContextConfig = {
+ *   url: "<instance url>", // replace with the URL of your Sisense instance
+ *   token: "<api token>", // replace with the API token of your user account
+ *   defaultDataSource: DM.DataSource,
+ * };
+ *
+ * @NgModule({
+ *   imports: [
+ *     BrowserModule,
+ *     SdkUiModule,
+ *     SdkAiModule,
+ *   ],
+ *   declarations: [AppComponent],
+ *   providers: [
+ *     { provide: AI_CONTEXT_CONFIG_TOKEN, useValue: AI_CONTEXT_CONFIG },
+ *     { provide: SISENSE_CONTEXT_CONFIG_TOKEN, useValue: SISENSE_CONTEXT_CONFIG },
+ *   ],
+ *   bootstrap: [AppComponent],
+ * })
+ * ```
+ *
+ * @group Generative AI
+ * @beta
+ */
+export const AI_CONTEXT_CONFIG_TOKEN = new InjectionToken('AI Context Config');
+/**
+ * Service for working with Sisense Fusion Generative AI.
+ *
+ * ::: warning Note
+ * This service is currently under beta release for our managed cloud customers on version L2024.2 or above. It is subject to changes as we make fixes and improvements.
+ * :::
+ *
+ * @group Generative AI
+ * @beta
+ */
+let AiService = class AiService {
+    constructor(sisenseContextService, aiContextConfig) {
+        this.sisenseContextService = sisenseContextService;
+        this.apiPromise = this.sisenseContextService
+            .getApp()
+            .then((app) => new ChatRestApi(app.httpClient, aiContextConfig?.volatile));
+    }
+    /** @internal */
+    getApi() {
+        return this.apiPromise;
+    }
+    /**
+     * Fetches an analysis of the provided query using natural language generation (NLG).
+     * Specifying NLG parameters is similar to providing parameters to the {@link QueryService.executeQuery} service method, using dimensions, measures, and filters.
+     *
+     * @param params - Parameters for getting NLG insights
+     * @returns NLG insights text summary
+     */
+    async getNlgInsights(params) {
+        const api = await this.getApi();
+        const payload = prepareGetNlgInsightsPayload(params);
+        return api.ai
+            .getNlgInsights(payload)
+            .then((response) => response?.data?.answer);
+    }
+    /**
+     * Fetches recommended questions for a data model or perspective.
+     *
+     * @param params - Parameters for recommendations
+     * @returns An array of objects, each containing recommended question text and its corresponding `widgetProps`
+     */
+    async getQueryRecommendations(params) {
+        const api = await this.getApi();
+        const { contextTitle, count, enableAxisTitlesInWidgetProps } = params;
+        const recCount = count ?? DEFAULT_RECOMMENDATIONS_COUNT;
+        const rawRecommendations = (await api.ai.getQueryRecommendations(contextTitle, { numOfRecommendations: recCount })) ||
+            [];
+        return rawRecommendations.map((recommendation) => ({
+            ...recommendation,
+            widgetProps: recommendation.jaql
+                ? widgetComposer.toWidgetProps(recommendation, {
+                    useCustomizedStyleOptions: enableAxisTitlesInWidgetProps,
+                })
+                : undefined,
+        }));
+    }
+    /**
+     * Executes a natural language query (NLQ) against a data model or perspective
+     *
+     * @param params - NLQ query parameters
+     * @returns The result as WidgetProps
+     */
+    async getNlqResult(params) {
+        const { contextTitle, request } = prepareGetNlqResultPayload(params);
+        const api = await this.getApi();
+        const data = await api?.ai.getNlqResult(contextTitle, request);
+        return data
+            ? widgetComposer.toWidgetProps(data, {
+                useCustomizedStyleOptions: params.enableAxisTitlesInWidgetProps || false,
+            })
+            : undefined;
+    }
+};
+AiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AiService, deps: [{ token: i1.SisenseContextService }, { token: AI_CONTEXT_CONFIG_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+AiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AiService, providedIn: 'root' });
+AiService = __decorate([
+    TrackableService(['getNlgInsights', 'getQueryRecommendations'])
+], AiService);
+export { AiService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AI_CONTEXT_CONFIG_TOKEN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai.service.js","sourceRoot":"","sources":["../../../../../src/ai/lib/services/ai.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EACL,WAAW,EAEX,4BAA4B,EAM5B,6BAA6B,EAC7B,cAAc,EACd,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AACnC,6DAA6D;AAC7D,OAAO,EAAyB,gBAAgB,EAAe,MAAM,yBAAyB,CAAC;;;AAK/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,IAAI,cAAc,CAAkB,mBAAmB,CAAC,CAAC;AAEhG;;;;;;;;;GASG;AAKI,IAAM,SAAS,GAAf,MAAM,SAAS;IAGpB,YACU,qBAA4C,EACP,eAAiC;QADtE,0BAAqB,GAArB,qBAAqB,CAAuB;QAGpD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,qBAAqB;aACzC,MAAM,EAAE;aACR,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,WAAW,CAAC,GAAG,CAAC,UAAU,EAAE,eAAe,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC/E,CAAC;IAED,gBAAgB;IAChB,MAAM;QACJ,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,cAAc,CAAC,MAA4B;QAC/C,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,MAAM,OAAO,GAAG,4BAA4B,CAAC,MAAM,CAAC,CAAC;QACrD,OAAO,GAAG,CAAC,EAAE;aACV,cAAc,CAAC,OAAO,CAAC;aACvB,IAAI,CAAC,CAAC,QAAiC,EAAE,EAAE,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IACzE,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,uBAAuB,CAC3B,MAAqC;QAErC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAChC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,6BAA6B,EAAE,GAAG,MAAM,CAAC;QACtE,MAAM,QAAQ,GAAG,KAAK,IAAI,6BAA6B,CAAC;QAExD,MAAM,kBAAkB,GACtB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,uBAAuB,CAAC,YAAY,EAAE,EAAE,oBAAoB,EAAE,QAAQ,EAAE,CAAC,CAAC;YACxF,EAAE,CAAC;QAEL,OAAO,kBAAkB,CAAC,GAAG,CAC3B,CAAC,cAAmC,EAAE,EAAE,CACtC,CAAC;YACC,GAAG,cAAc;YACjB,WAAW,EAAE,cAAc,CAAC,IAAI;gBAC9B,CAAC,CAAC,cAAc,CAAC,aAAa,CAAC,cAAc,EAAE;oBAC3C,yBAAyB,EAAE,6BAA6B;iBACzD,CAAC;gBACJ,CAAC,CAAC,SAAS;SACU,CAAA,CAC5B,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY,CAAC,MAA0B;QAC3C,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,0BAA0B,CAAC,MAAM,CAAC,CAAC;QACrE,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,CAAC;QAEhC,MAAM,IAAI,GAAG,MAAM,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;QAE/D,OAAO,IAAI;YACT,CAAC,CAAC,cAAc,CAAC,aAAa,CAAC,IAAI,EAAE;gBACjC,yBAAyB,EAAE,MAAM,CAAC,6BAA6B,IAAI,KAAK;aACzE,CAAC;YACJ,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;;uGA/EU,SAAS,uDAKE,uBAAuB;2GALlC,SAAS,cAHR,MAAM;AAGP,SAAS;IADrB,gBAAgB,CAAY,CAAC,gBAAgB,EAAE,yBAAyB,CAAC,CAAC;GAC9D,SAAS,CAgFrB;SAhFY,SAAS;4FAAT,SAAS;kBAJrB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAOI,QAAQ;;0BAAI,MAAM;2BAAC,uBAAuB","sourcesContent":["import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';\nimport {\n  ChatRestApi,\n  UseGetNlgInsightsParams,\n  prepareGetNlgInsightsPayload,\n  GetQueryRecommendationsParams,\n  AiContextProviderProps,\n  GetNlgInsightsResponse,\n  QueryRecommendation,\n  GetNlqResultParams,\n  DEFAULT_RECOMMENDATIONS_COUNT,\n  widgetComposer,\n  prepareGetNlqResultPayload,\n} from '@sisense/sdk-ui-preact/ai';\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport { SisenseContextService, TrackableService, WidgetProps } from '@sisense/sdk-ui-angular';\n\nexport interface AiContextConfig extends Omit<AiContextProviderProps, 'children'> {}\nexport interface GetNlgInsightsParams extends Omit<UseGetNlgInsightsParams, 'enabled'> {}\n\n/**\n * Token used to inject {@link AiContextConfig} into your application.\n *\n * @example\n * Example of importing {@link SdkAiModule} and injecting {@link AiContextConfig} into your application,\n * along with importing dependency {@link SdkUiModule} and injecting {@link SisenseContextConfig} to connect to a Sisense instance:\n *\n * ```ts\n * import { SdkUiModule, SisenseContextConfig } from '@sisense/sdk-ui-angular';\n * import { SdkAiModule, AI_CONTEXT_CONFIG_TOKEN, AiContextConfig } from '@sisense/sdk-ui-angular/ai';\n *\n * const AI_CONTEXT_CONFIG: AiContextConfig = {\n *   volatile: true,\n * };\n * const SISENSE_CONTEXT_CONFIG: SisenseContextConfig = {\n *   url: \"<instance url>\", // replace with the URL of your Sisense instance\n *   token: \"<api token>\", // replace with the API token of your user account\n *   defaultDataSource: DM.DataSource,\n * };\n *\n * @NgModule({\n *   imports: [\n *     BrowserModule,\n *     SdkUiModule,\n *     SdkAiModule,\n *   ],\n *   declarations: [AppComponent],\n *   providers: [\n *     { provide: AI_CONTEXT_CONFIG_TOKEN, useValue: AI_CONTEXT_CONFIG },\n *     { provide: SISENSE_CONTEXT_CONFIG_TOKEN, useValue: SISENSE_CONTEXT_CONFIG },\n *   ],\n *   bootstrap: [AppComponent],\n * })\n * ```\n *\n * @group Generative AI\n * @beta\n */\nexport const AI_CONTEXT_CONFIG_TOKEN = new InjectionToken<AiContextConfig>('AI Context Config');\n\n/**\n * Service for working with Sisense Fusion Generative AI.\n *\n * ::: warning Note\n * This service is currently under beta release for our managed cloud customers on version L2024.2 or above. It is subject to changes as we make fixes and improvements.\n * :::\n *\n * @group Generative AI\n * @beta\n */\n@Injectable({\n  providedIn: 'root',\n})\n@TrackableService<AiService>(['getNlgInsights', 'getQueryRecommendations'])\nexport class AiService {\n  private apiPromise: Promise<ChatRestApi>;\n\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    @Optional() @Inject(AI_CONTEXT_CONFIG_TOKEN) aiContextConfig?: AiContextConfig,\n  ) {\n    this.apiPromise = this.sisenseContextService\n      .getApp()\n      .then((app) => new ChatRestApi(app.httpClient, aiContextConfig?.volatile));\n  }\n\n  /** @internal */\n  getApi(): Promise<ChatRestApi> {\n    return this.apiPromise;\n  }\n\n  /**\n   * Fetches an analysis of the provided query using natural language generation (NLG).\n   * Specifying NLG parameters is similar to providing parameters to the {@link QueryService.executeQuery} service method, using dimensions, measures, and filters.\n   *\n   * @param params - Parameters for getting NLG insights\n   * @returns NLG insights text summary\n   */\n  async getNlgInsights(params: GetNlgInsightsParams): Promise<string | undefined> {\n    const api = await this.getApi();\n    const payload = prepareGetNlgInsightsPayload(params);\n    return api.ai\n      .getNlgInsights(payload)\n      .then((response?: GetNlgInsightsResponse) => response?.data?.answer);\n  }\n\n  /**\n   * Fetches recommended questions for a data model or perspective.\n   *\n   * @param params - Parameters for recommendations\n   * @returns An array of objects, each containing recommended question text and its corresponding `widgetProps`\n   */\n  async getQueryRecommendations(\n    params: GetQueryRecommendationsParams,\n  ): Promise<QueryRecommendation[]> {\n    const api = await this.getApi();\n    const { contextTitle, count, enableAxisTitlesInWidgetProps } = params;\n    const recCount = count ?? DEFAULT_RECOMMENDATIONS_COUNT;\n\n    const rawRecommendations =\n      (await api.ai.getQueryRecommendations(contextTitle, { numOfRecommendations: recCount })) ||\n      [];\n\n    return rawRecommendations.map(\n      (recommendation: QueryRecommendation) =>\n        ({\n          ...recommendation,\n          widgetProps: recommendation.jaql\n            ? widgetComposer.toWidgetProps(recommendation, {\n                useCustomizedStyleOptions: enableAxisTitlesInWidgetProps,\n              })\n            : undefined,\n        } as QueryRecommendation),\n    );\n  }\n\n  /**\n   * Executes a natural language query (NLQ) against a data model or perspective\n   *\n   * @param params - NLQ query parameters\n   * @returns The result as WidgetProps\n   */\n  async getNlqResult(params: GetNlqResultParams): Promise<WidgetProps | undefined> {\n    const { contextTitle, request } = prepareGetNlqResultPayload(params);\n    const api = await this.getApi();\n\n    const data = await api?.ai.getNlqResult(contextTitle, request);\n\n    return data\n      ? widgetComposer.toWidgetProps(data, {\n          useCustomizedStyleOptions: params.enableAxisTitlesInWidgetProps || false,\n        })\n      : undefined;\n  }\n}\n"]}

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

@@ -0,0 +1,2 @@
+export * from './ai.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYWkvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9haS5zZXJ2aWNlJztcbiJdfQ==

package/dist/esm2020/ai/public-api.mjs

@@ -1,2 +1,8 @@
+/**
+ * Public API Surface of @sisense/sdk-ui-angular/ai
+ */
 export * from './lib/sdk-ai.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9haS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9zZGstYWkubW9kdWxlJztcbiJdfQ==
+export * from './lib/components';
+export * from './lib/services';
+export * from './lib/sdk-ui-core-exports';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9haS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIEBzaXNlbnNlL3Nkay11aS1hbmd1bGFyL2FpXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvc2RrLWFpLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Nkay11aS1jb3JlLWV4cG9ydHMnO1xuIl19

package/dist/esm2020/lib/component-wrapper-helpers/index.mjs

@@ -1,2 +1,3 @@
 export * from './context-connectors';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudC13cmFwcGVyLWhlbHBlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGV4dC1jb25uZWN0b3JzJztcbiJdfQ==
+export * from './template';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudC13cmFwcGVyLWhlbHBlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGV4dC1jb25uZWN0b3JzJztcbmV4cG9ydCAqIGZyb20gJy4vdGVtcGxhdGUnO1xuIl19

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

@@ -137,4 +137,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], dataPointsSelect: [{
                 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/charts/area-range-chart.component.mjs

@@ -151,4 +151,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], dataPointsSelect: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"area-range-chart.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/charts/area-range-chart.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;;;AAavE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AAmBH,MAAM,OAAO,uBAAuB;IAlBpC;QA4EE;;;;WAIG;QAEH,mBAAc,GAAG,IAAI,YAAY,EAAkB,CAAC;QAEpD;;;;WAIG;QAEH,yBAAoB,GAAG,IAAI,YAAY,EAAkB,CAAC;QAE1D;;;;WAIG;QAEH,qBAAgB,GAAG,IAAI,YAAY,EAAmB,CAAC;QAEvD,gBAAgB;QACT,cAAS,GAAc,WAAW,CAAC;KAC3C;;qHApFY,uBAAuB;yGAAvB,uBAAuB,8XAhBxB;;;;;;;;;;;;;;GAcT;4FAEU,uBAAuB;kBAlBnC,SAAS;mBAAC;oBACT,QAAQ,EAAE,uBAAuB;oBACjC,QAAQ,EAAE;;;;;;;;;;;;;;GAcT;iBACF;8BAQC,OAAO;sBADN,KAAK;gBASN,WAAW;sBADV,KAAK;gBASN,OAAO;sBADN,KAAK;gBASN,UAAU;sBADT,KAAK;gBASN,YAAY;sBADX,KAAK;gBASN,YAAY;sBADX,KAAK;gBAUN,SAAS;sBADR,KAAK;gBASN,cAAc;sBADb,MAAM;gBASP,oBAAoB;sBADnB,MAAM;gBASP,gBAAgB;sBADf,MAAM","sourcesContent":["import { Component, EventEmitter, Input, Output } from '@angular/core';\nimport { type ChartType } from '../../sdk-ui-core-exports';\nimport { type AreaRangeChartProps as AreaRangeChartPropsPreact } from '@sisense/sdk-ui-preact';\nimport {\n  RegularChartEventProps,\n  WithoutPreactChartEventProps,\n} from '../../types/chart-event-props';\nimport { DataPointEvent, DataPointsEvent } from '../../types/data-point';\n\nexport interface AreaRangeChartProps\n  extends WithoutPreactChartEventProps<AreaRangeChartPropsPreact>,\n    RegularChartEventProps {}\n\n/**\n * A component that displays a range of data over a given time period or across multiple categories.\n * It is particularly useful for visualizing the minimum and maximum values in a dataset, along with\n * the area between these values.\n *\n * @example\n * ```html\n *    <csdk-area-range-chart\n *      [dataSet]=\"chart.dataSet\"\n *      [dataOptions]=\"chart.dataOptions\"\n *      [highlights]=\"filters\"\n *      [beforeRender]=\"onBeforeRender\"\n *      (dataPointClick)=\"logArguments($event)\"\n *      (dataPointContextMenu)=\"logArguments($event)\"\n *      (dataPointsSelect)=\"logArguments($event)\"\n *    />\n * ```\n * ```ts\nimport { Component } from '@angular/core';\nimport { measureFactory, filterFactory, Filter } from '@sisense/sdk-data';\nimport * as DM from '../../assets/sample-healthcare-model';\nimport type { ChartType, RangeChartDataOptions } from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-analytics',\n  templateUrl: './analytics.component.html',\n  styleUrls: ['./analytics.component.scss'],\n})\nexport class AnalyticsComponent {\n  DM = DM;\n  filters = [filterFactory.members(DM.Divisions.Divison_name, ['Cardiology', 'Neurology'])];\n  chart = {\n    chartType: 'arearange' as ChartType,\n    dataSet: DM.DataSource,\n    dataOptions: {\n      category: [DM.Admissions.Admission_Time.Years],\n      value: [\n        {\n            title: 'Admission Cost Range',\n            upperBound: measureFactory.multiply(\n              measureFactory.sum(DM.Admissions.Cost_of_admission, 'Lower Admission'),\n              0.6,\n            ),\n            lowerBound: measureFactory.multiply(\n              measureFactory.sum(DM.Admissions.Cost_of_admission, 'Upper Admission'),\n              1.4,\n             ),\n        }\n      ],\n      breakBy: [],\n    } as RangeChartDataOptions,\n  };\n\n  onBeforeRender(options: any) {\n    console.log('beforeRender');\n    console.log(options);\n    return options;\n  }\n\n  logArguments(...args: any[]) {\n    console.log(args);\n  }\n}\n * ```\n * <img src=\"media://angular-area-range-chart-example.png\" width=\"800px\" />\n *\n * @group Charts\n * @beta\n */\n@Component({\n  selector: 'csdk-area-range-chart',\n  template: `\n    <csdk-chart\n      [chartType]=\"chartType\"\n      [dataSet]=\"dataSet\"\n      [dataOptions]=\"dataOptions\"\n      [filters]=\"filters\"\n      [highlights]=\"highlights\"\n      [styleOptions]=\"styleOptions\"\n      [beforeRender]=\"beforeRender\"\n      [dataReady]=\"dataReady\"\n      (dataPointClick)=\"dataPointClick.emit($any($event))\"\n      (dataPointContextMenu)=\"dataPointContextMenu.emit($any($event))\"\n      (dataPointsSelect)=\"dataPointsSelect.emit($any($event))\"\n    />\n  `,\n})\nexport class AreaRangeChartComponent {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.dataSet}\n   *\n   * @category Data\n   */\n  @Input()\n  dataSet: AreaRangeChartProps['dataSet'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.dataOptions}\n   *\n   * @category Chart\n   */\n  @Input()\n  dataOptions!: AreaRangeChartProps['dataOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.filters}\n   *\n   * @category Data\n   */\n  @Input()\n  filters: AreaRangeChartProps['filters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.highlights}\n   *\n   * @category Data\n   */\n  @Input()\n  highlights: AreaRangeChartProps['highlights'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.styleOptions}\n   *\n   * @category Chart\n   */\n  @Input()\n  styleOptions: AreaRangeChartProps['styleOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  @Input()\n  beforeRender: AreaRangeChartProps['beforeRender'];\n\n  /**\n   * {@inheritDoc  @sisense/sdk-ui!AreaRangeChartProps.onDataReady}\n   *\n   * @category Callbacks\n   * @internal\n   */\n  @Input()\n  dataReady: AreaRangeChartProps['dataReady'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointClick = new EventEmitter<DataPointEvent>();\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointContextMenu = new EventEmitter<DataPointEvent>();\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointsSelect = new EventEmitter<DataPointsEvent>();\n\n  /** @internal */\n  public chartType: ChartType = 'arearange';\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"area-range-chart.component.js","sourceRoot":"","sources":["../../../../../src/lib/components/charts/area-range-chart.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;;;AAgBvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AAmBH,MAAM,OAAO,uBAAuB;IAlBpC;QA4EE;;;;WAIG;QAEH,mBAAc,GAAG,IAAI,YAAY,EAAkB,CAAC;QAEpD;;;;WAIG;QAEH,yBAAoB,GAAG,IAAI,YAAY,EAAkB,CAAC;QAE1D;;;;WAIG;QAEH,qBAAgB,GAAG,IAAI,YAAY,EAAmB,CAAC;QAEvD,gBAAgB;QACT,cAAS,GAAc,WAAW,CAAC;KAC3C;;qHApFY,uBAAuB;yGAAvB,uBAAuB,8XAhBxB;;;;;;;;;;;;;;GAcT;4FAEU,uBAAuB;kBAlBnC,SAAS;mBAAC;oBACT,QAAQ,EAAE,uBAAuB;oBACjC,QAAQ,EAAE;;;;;;;;;;;;;;GAcT;iBACF;8BAQC,OAAO;sBADN,KAAK;gBASN,WAAW;sBADV,KAAK;gBASN,OAAO;sBADN,KAAK;gBASN,UAAU;sBADT,KAAK;gBASN,YAAY;sBADX,KAAK;gBASN,YAAY;sBADX,KAAK;gBAUN,SAAS;sBADR,KAAK;gBASN,cAAc;sBADb,MAAM;gBASP,oBAAoB;sBADnB,MAAM;gBASP,gBAAgB;sBADf,MAAM","sourcesContent":["import { Component, EventEmitter, Input, Output } from '@angular/core';\nimport { type ChartType } from '../../sdk-ui-core-exports';\nimport { type AreaRangeChartProps as AreaRangeChartPropsPreact } from '@sisense/sdk-ui-preact';\nimport {\n  RegularChartEventProps,\n  WithoutPreactChartEventProps,\n} from '../../types/chart-event-props';\nimport { DataPointEvent, DataPointsEvent } from '../../types/data-point';\n\n/**\n * Props of the {@link AreaRangeChartComponent}.\n */\nexport interface AreaRangeChartProps\n  extends WithoutPreactChartEventProps<AreaRangeChartPropsPreact>,\n    RegularChartEventProps {}\n\n/**\n * A component that displays a range of data over a given time period or across multiple categories.\n * It is particularly useful for visualizing the minimum and maximum values in a dataset, along with\n * the area between these values.\n *\n * @example\n * ```html\n *    <csdk-area-range-chart\n *      [dataSet]=\"chart.dataSet\"\n *      [dataOptions]=\"chart.dataOptions\"\n *      [highlights]=\"filters\"\n *      [beforeRender]=\"onBeforeRender\"\n *      (dataPointClick)=\"logArguments($event)\"\n *      (dataPointContextMenu)=\"logArguments($event)\"\n *      (dataPointsSelect)=\"logArguments($event)\"\n *    />\n * ```\n * ```ts\nimport { Component } from '@angular/core';\nimport { measureFactory, filterFactory, Filter } from '@sisense/sdk-data';\nimport * as DM from '../../assets/sample-healthcare-model';\nimport type { ChartType, RangeChartDataOptions } from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-analytics',\n  templateUrl: './analytics.component.html',\n  styleUrls: ['./analytics.component.scss'],\n})\nexport class AnalyticsComponent {\n  DM = DM;\n  filters = [filterFactory.members(DM.Divisions.Divison_name, ['Cardiology', 'Neurology'])];\n  chart = {\n    chartType: 'arearange' as ChartType,\n    dataSet: DM.DataSource,\n    dataOptions: {\n      category: [DM.Admissions.Admission_Time.Years],\n      value: [\n        {\n            title: 'Admission Cost Range',\n            upperBound: measureFactory.multiply(\n              measureFactory.sum(DM.Admissions.Cost_of_admission, 'Lower Admission'),\n              0.6,\n            ),\n            lowerBound: measureFactory.multiply(\n              measureFactory.sum(DM.Admissions.Cost_of_admission, 'Upper Admission'),\n              1.4,\n             ),\n        }\n      ],\n      breakBy: [],\n    } as RangeChartDataOptions,\n  };\n\n  onBeforeRender(options: any) {\n    console.log('beforeRender');\n    console.log(options);\n    return options;\n  }\n\n  logArguments(...args: any[]) {\n    console.log(args);\n  }\n}\n * ```\n * <img src=\"media://angular-area-range-chart-example.png\" width=\"800px\" />\n *\n * @group Charts\n * @beta\n */\n@Component({\n  selector: 'csdk-area-range-chart',\n  template: `\n    <csdk-chart\n      [chartType]=\"chartType\"\n      [dataSet]=\"dataSet\"\n      [dataOptions]=\"dataOptions\"\n      [filters]=\"filters\"\n      [highlights]=\"highlights\"\n      [styleOptions]=\"styleOptions\"\n      [beforeRender]=\"beforeRender\"\n      [dataReady]=\"dataReady\"\n      (dataPointClick)=\"dataPointClick.emit($any($event))\"\n      (dataPointContextMenu)=\"dataPointContextMenu.emit($any($event))\"\n      (dataPointsSelect)=\"dataPointsSelect.emit($any($event))\"\n    />\n  `,\n})\nexport class AreaRangeChartComponent {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.dataSet}\n   *\n   * @category Data\n   */\n  @Input()\n  dataSet: AreaRangeChartProps['dataSet'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.dataOptions}\n   *\n   * @category Chart\n   */\n  @Input()\n  dataOptions!: AreaRangeChartProps['dataOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.filters}\n   *\n   * @category Data\n   */\n  @Input()\n  filters: AreaRangeChartProps['filters'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.highlights}\n   *\n   * @category Data\n   */\n  @Input()\n  highlights: AreaRangeChartProps['highlights'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.styleOptions}\n   *\n   * @category Chart\n   */\n  @Input()\n  styleOptions: AreaRangeChartProps['styleOptions'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  @Input()\n  beforeRender: AreaRangeChartProps['beforeRender'];\n\n  /**\n   * {@inheritDoc  @sisense/sdk-ui!AreaRangeChartProps.onDataReady}\n   *\n   * @category Callbacks\n   * @internal\n   */\n  @Input()\n  dataReady: AreaRangeChartProps['dataReady'];\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointClick = new EventEmitter<DataPointEvent>();\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointContextMenu = new EventEmitter<DataPointEvent>();\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreaRangeChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  @Output()\n  dataPointsSelect = new EventEmitter<DataPointsEvent>();\n\n  /** @internal */\n  public chartType: ChartType = 'arearange';\n}\n"]}

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

@@ -102,4 +102,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], dataPointClick: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJlYW1hcC1jaGFydC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvbXBvbmVudHMvY2hhcnRzL2FyZWFtYXAtY2hhcnQuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQWN2RTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTJDRztBQWdCSCxNQUFNLE9BQU8scUJBQXFCO0lBZmxDO1FBaUVFOzs7O1dBSUc7UUFFSCxtQkFBYyxHQUFHLElBQUksWUFBWSxFQUFrQixDQUFDO1FBRXBELGdCQUFnQjtRQUNULGNBQVMsR0FBYyxTQUFTLENBQUM7S0FDekM7O21IQTVEWSxxQkFBcUI7dUdBQXJCLHFCQUFxQix5UUFidEI7Ozs7Ozs7Ozs7O0dBV1Q7NEZBRVUscUJBQXFCO2tCQWZqQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxvQkFBb0I7b0JBQzlCLFFBQVEsRUFBRTs7Ozs7Ozs7Ozs7R0FXVDtpQkFDRjs4QkFRQyxPQUFPO3NCQUROLEtBQUs7Z0JBU04sV0FBVztzQkFEVixLQUFLO2dCQVNOLE9BQU87c0JBRE4sS0FBSztnQkFTTixVQUFVO3NCQURULEtBQUs7Z0JBU04sWUFBWTtzQkFEWCxLQUFLO2dCQVVOLFNBQVM7c0JBRFIsS0FBSztnQkFTTixjQUFjO3NCQURiLE1BQU0iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIEV2ZW50RW1pdHRlciwgSW5wdXQsIE91dHB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtcbiAgdHlwZSBDaGFydFR5cGUsXG4gIHR5cGUgQXJlYW1hcENoYXJ0UHJvcHMgYXMgQXJlYW1hcENoYXJ0UHJvcHNQcmVhY3QsXG59IGZyb20gJ0BzaXNlbnNlL3Nkay11aS1wcmVhY3QnO1xuaW1wb3J0IHsgQmFzZUNoYXJ0RXZlbnRQcm9wcywgV2l0aG91dFByZWFjdENoYXJ0RXZlbnRQcm9wcyB9IGZyb20gJy4uLy4uL3R5cGVzL2NoYXJ0LWV2ZW50LXByb3BzJztcbmltcG9ydCB7IERhdGFQb2ludEV2ZW50LCBEYXRhUG9pbnRFdmVudEhhbmRsZXIgfSBmcm9tICcuLi8uLi90eXBlcy9kYXRhLXBvaW50JztcblxuZXhwb3J0IGludGVyZmFjZSBBcmVhbWFwQ2hhcnRQcm9wc1xuICBleHRlbmRzIFdpdGhvdXRQcmVhY3RDaGFydEV2ZW50UHJvcHM8QXJlYW1hcENoYXJ0UHJvcHNQcmVhY3Q+LFxuICAgIEJhc2VDaGFydEV2ZW50UHJvcHMge1xuICBkYXRhUG9pbnRDbGljaz86IERhdGFQb2ludEV2ZW50SGFuZGxlcjtcbn1cblxuLyoqXG4gKiBBbiBBbmd1bGFyIGNvbXBvbmVudCB0aGF0IGFsbG93cyB0byB2aXN1YWxpemUgZ2VvZ3JhcGhpY2FsIGRhdGEgYXMgcG9seWdvbnMgb24gYSBtYXAuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYGh0bWxcbiAqICAgIDxjc2RrLWFyZWFtYXAtY2hhcnRcbiAqICAgICAgW2RhdGFTZXRdPVwiYXJlYW1hcENoYXJ0LmRhdGFTZXRcIlxuICogICAgICBbZGF0YU9wdGlvbnNdPVwiYXJlYW1hcENoYXJ0LmRhdGFPcHRpb25zXCJcbiAqICAgICAgW3N0eWxlT3B0aW9uc109XCJhcmVhbWFwQ2hhcnQuc3R5bGVPcHRpb25zXCJcbiAqICAgICAgKGRhdGFQb2ludENsaWNrKT1cImxvZ0FyZ3VtZW50cygkZXZlbnQpXCJcbiAqICAgIC8+XG4gKiBgYGBcbiAqXG4gKiBgYGB0c1xuaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBtZWFzdXJlRmFjdG9yeSB9IGZyb20gJ0BzaXNlbnNlL3Nkay1kYXRhJztcbmltcG9ydCAqIGFzIERNIGZyb20gJy4uLy4uL2Fzc2V0cy9zYW1wbGUtZWNvbW1lcmNlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYXBwLWFuYWx5dGljcycsXG4gIHRlbXBsYXRlVXJsOiAnLi9hbmFseXRpY3MuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9hbmFseXRpY3MuY29tcG9uZW50LnNjc3MnXSxcbn0pXG5leHBvcnQgY2xhc3MgQW5hbHl0aWNzQ29tcG9uZW50IHtcbiAgYXJlYW1hcENoYXJ0ID0ge1xuICAgIGRhdGFTZXQ6IERNLkRhdGFTb3VyY2UsXG4gICAgZGF0YU9wdGlvbnM6IHtcbiAgICAgIGdlbzogW0RNLkNvdW50cnkuQ291bnRyeV0sXG4gICAgICBjb2xvcjogW21lYXN1cmVGYWN0b3J5LnN1bShETS5Db21tZXJjZS5SZXZlbnVlLCAnQ29sb3IgYnkgUmV2ZW51ZScpXSxcbiAgICB9IGFzIEFyZWFtYXBDaGFydERhdGFPcHRpb25zLFxuICAgIHN0eWxlT3B0aW9uczoge1xuICAgICAgbWFwVHlwZTogJ3dvcmxkJyxcbiAgICB9IGFzIEFyZWFtYXBTdHlsZU9wdGlvbnMsXG4gIH07XG5cbiAgbG9nQXJndW1lbnRzKC4uLmFyZ3M6IGFueVtdKSB7XG4gICAgY29uc29sZS5sb2coYXJncyk7XG4gIH1cbn1cbiAqIGBgYFxuICogPGltZyBzcmM9XCJtZWRpYTovL2FuZ3VsYXItYXJlYW1hcC1jaGFydC1leGFtcGxlLnBuZ1wiIHdpZHRoPVwiODAwcHhcIiAvPlxuICpcbiAqIEBncm91cCBDaGFydHNcbiAqL1xuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnY3Nkay1hcmVhbWFwLWNoYXJ0JyxcbiAgdGVtcGxhdGU6IGBcbiAgICA8Y3Nkay1jaGFydFxuICAgICAgW2NoYXJ0VHlwZV09XCJjaGFydFR5cGVcIlxuICAgICAgW2RhdGFTZXRdPVwiZGF0YVNldFwiXG4gICAgICBbZGF0YU9wdGlvbnNdPVwiZGF0YU9wdGlvbnNcIlxuICAgICAgW2ZpbHRlcnNdPVwiZmlsdGVyc1wiXG4gICAgICBbaGlnaGxpZ2h0c109XCJoaWdobGlnaHRzXCJcbiAgICAgIFtzdHlsZU9wdGlvbnNdPVwic3R5bGVPcHRpb25zXCJcbiAgICAgIFtkYXRhUmVhZHldPVwiZGF0YVJlYWR5XCJcbiAgICAgIChkYXRhUG9pbnRDbGljayk9XCJkYXRhUG9pbnRDbGljay5lbWl0KCRhbnkoJGV2ZW50KSlcIlxuICAgIC8+XG4gIGAsXG59KVxuZXhwb3J0IGNsYXNzIEFyZWFtYXBDaGFydENvbXBvbmVudCB7XG4gIC8qKlxuICAgKiB7QGluaGVyaXREb2MgQHNpc2Vuc2Uvc2RrLXVpIUFyZWFtYXBDaGFydFByb3BzLmRhdGFTZXR9XG4gICAqXG4gICAqIEBjYXRlZ29yeSBEYXRhXG4gICAqL1xuICBASW5wdXQoKVxuICBkYXRhU2V0OiBBcmVhbWFwQ2hhcnRQcm9wc1snZGF0YVNldCddO1xuXG4gIC8qKlxuICAgKiB7QGluaGVyaXREb2MgQHNpc2Vuc2Uvc2RrLXVpIUFyZWFtYXBDaGFydFByb3BzLmRhdGFPcHRpb25zfVxuICAgKlxuICAgKiBAY2F0ZWdvcnkgQ2hhcnRcbiAgICovXG4gIEBJbnB1dCgpXG4gIGRhdGFPcHRpb25zITogQXJlYW1hcENoYXJ0UHJvcHNbJ2RhdGFPcHRpb25zJ107XG5cbiAgLyoqXG4gICAqIHtAaW5oZXJpdERvYyBAc2lzZW5zZS9zZGstdWkhQXJlYW1hcENoYXJ0UHJvcHMuZmlsdGVyc31cbiAgICpcbiAgICogQGNhdGVnb3J5IERhdGFcbiAgICovXG4gIEBJbnB1dCgpXG4gIGZpbHRlcnM6IEFyZWFtYXBDaGFydFByb3BzWydmaWx0ZXJzJ107XG5cbiAgLyoqXG4gICAqIHtAaW5oZXJpdERvYyBAc2lzZW5zZS9zZGstdWkhQXJlYW1hcENoYXJ0UHJvcHMuaGlnaGxpZ2h0c31cbiAgICpcbiAgICogQGNhdGVnb3J5IERhdGFcbiAgICovXG4gIEBJbnB1dCgpXG4gIGhpZ2hsaWdodHM6IEFyZWFtYXBDaGFydFByb3BzWydoaWdobGlnaHRzJ107XG5cbiAgLyoqXG4gICAqIHtAaW5oZXJpdERvYyBAc2lzZW5zZS9zZGstdWkhQXJlYW1hcENoYXJ0UHJvcHMuc3R5bGVPcHRpb25zfVxuICAgKlxuICAgKiBAY2F0ZWdvcnkgQ2hhcnRcbiAgICovXG4gIEBJbnB1dCgpXG4gIHN0eWxlT3B0aW9uczogQXJlYW1hcENoYXJ0UHJvcHNbJ3N0eWxlT3B0aW9ucyddO1xuXG4gIC8qKlxuICAgKiB7QGluaGVyaXREb2MgIEBzaXNlbnNlL3Nkay11aSFBcmVhbWFwQ2hhcnRQcm9wcy5vbkRhdGFSZWFkeX1cbiAgICpcbiAgICogQGNhdGVnb3J5IENhbGxiYWNrc1xuICAgKiBAaW50ZXJuYWxcbiAgICovXG4gIEBJbnB1dCgpXG4gIGRhdGFSZWFkeTogQXJlYW1hcENoYXJ0UHJvcHNbJ2RhdGFSZWFkeSddO1xuXG4gIC8qKlxuICAgKiB7QGluaGVyaXREb2MgQHNpc2Vuc2Uvc2RrLXVpIUFyZWFtYXBDaGFydFByb3BzLm9uRGF0YVBvaW50Q2xpY2t9XG4gICAqXG4gICAqIEBjYXRlZ29yeSBDYWxsYmFja3NcbiAgICovXG4gIEBPdXRwdXQoKVxuICBkYXRhUG9pbnRDbGljayA9IG5ldyBFdmVudEVtaXR0ZXI8RGF0YVBvaW50RXZlbnQ+KCk7XG5cbiAgLyoqIEBpbnRlcm5hbCAqL1xuICBwdWJsaWMgY2hhcnRUeXBlOiBDaGFydFR5cGUgPSAnYXJlYW1hcCc7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -138,4 +138,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             }], dataPointsSelect: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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