@sisense/sdk-ui-angular 2.17.0 → 2.18.0

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

@@ -1,9 +1,13 @@
 import { __decorate } from "tslib";
 import { Injectable } from '@angular/core';
-import { getWidgetModel, } from '@sisense/sdk-ui-preact';
+import { getWidgetModel, HookAdapter, useJtdWidget as useJtdWidgetPreact, } from '@sisense/sdk-ui-preact';
+import { BehaviorSubject } from 'rxjs';
+import { createSisenseContextConnector, createThemeContextConnector, } from '../component-wrapper-helpers';
 import { TrackableService } from '../decorators/trackable.decorator';
+import { translateFromPreactWidgetProps, translateToPreactWidgetProps, } from '../helpers/widget-props-preact-translator';
 import * as i0 from "@angular/core";
 import * as i1 from "./sisense-context.service";
+import * as i2 from "./theme.service";
 /**
  * Service for working with Sisense Fusion widgets.
  *
@@ -11,8 +15,9 @@ import * as i1 from "./sisense-context.service";
  * @fusionEmbed
  */
 let WidgetService = class WidgetService {
-    constructor(sisenseContextService) {
+    constructor(sisenseContextService, themeService) {
         this.sisenseContextService = sisenseContextService;
+        this.themeService = themeService;
     }
     /**
      * Retrieves an existing widget model from the Sisense instance.
@@ -25,11 +30,146 @@ let WidgetService = class WidgetService {
         const app = await this.sisenseContextService.getApp();
         return getWidgetModel(app.httpClient, dashboardOid, widgetOid);
     }
+    /**
+     * Adds Jump To Dashboard (JTD) functionality to widget props.
+     *
+     * Jump To Dashboard (JTD) allows users to navigate from one dashboard to another when interacting with widgets,
+     * such as clicking on chart data points or using context menus. This method is particularly useful when rendering
+     * Widget components directly (not through a Dashboard component), but you still want JTD navigation functionality.
+     *
+     * For widgets that are part of a dashboard, consider using `applyJtdConfig` or `applyJtdConfigs` instead,
+     * as they apply JTD configuration at the dashboard level rather than individual widget level.
+     *
+     * Note: dashboard-only 'includeDashboardFilters' is not supported and would just be ignored, since we do not have a dashboard in the current context.
+     *
+     * This method enhances the provided widget props with JTD navigation capabilities, including:
+     * - Click and right-click event handlers for navigation
+     * - Hyperlink styling for actionable pivot cells (when applicable)
+     * - JTD icon display in widget headers
+     * @example
+     * ```TypeScript
+     * import { Component, OnDestroy } from '@angular/core';
+     * import {
+     *   WidgetService,
+     *   widgetModelTranslator,
+     *   type WidgetProps,
+     * } from '@sisense/sdk-ui-angular';
+     * import { BehaviorSubject } from 'rxjs';
+     *
+     * @Component({
+     *   selector: 'code-example',
+     *   template: `
+     *     <csdk-widget
+     *       *ngIf="widgetProps$ && (widgetProps$ | async) as widgetProps"
+     *       [id]="widgetProps.id"
+     *       [widgetType]="widgetProps.widgetType"
+     *       [chartType]="widgetProps.chartType"
+     *       [title]="widgetProps.title"
+     *       [dataSource]="widgetProps.dataSource"
+     *       [dataOptions]="widgetProps.dataOptions"
+     *       [filters]="widgetProps.filters"
+     *       [highlights]="widgetProps.highlights"
+     *       [styleOptions]="widgetProps.styleOptions"
+     *       [beforeMenuOpen]="widgetProps.beforeMenuOpen"
+     *       (dataPointClick)="widgetProps.dataPointClick?.($event)"
+     *       (dataPointContextMenu)="widgetProps.dataPointContextMenu?.($event)"
+     *       (dataPointsSelect)="widgetProps.dataPointsSelect?.($event)"
+     *     />
+     *   `,
+     * })
+     * export class CodeExample implements OnDestroy {
+     *   constructor(private widgetService: WidgetService) {}
+     *
+     *   widgetProps$: BehaviorSubject<WidgetProps | null> | null = null;
+     *   private jtdDestroy: (() => void) | null = null;
+     *
+     *   async ngOnInit(): Promise<void> {
+     *     const widget = await this.widgetService.getWidgetModel({
+     *       dashboardOid: '65a82171719e7f004018691c',
+     *       widgetOid: '65a82171719e7f004018691f',
+     *     });
+     *
+     *     const baseProps = widget
+     *       ? widgetModelTranslator.toWidgetProps(widget)
+     *       : null;
+     *
+     *     if (baseProps) {
+     *       const jtdConfig = {
+     *         targets: [{ id: 'target-dashboard-id', caption: 'Details' }],
+     *         interaction: { triggerMethod: 'rightclick' },
+     *       };
+     *       const jtdResult = this.widgetService.createJtdWidget(
+     *         baseProps,
+     *         jtdConfig,
+     *       );
+     *       this.widgetProps$ = jtdResult.widget$;
+     *       this.jtdDestroy = jtdResult.destroy;
+     *     }
+     *   }
+     *
+     *   ngOnDestroy(): void {
+     *     this.jtdDestroy?.();
+     *   }
+     * }
+     * ```
+     *
+     * @param widgetProps - Base widget props to enhance with JTD functionality
+     * @param jtdConfig - JTD configuration defining navigation targets and behavior
+     * @returns Object containing:
+     *         - `widget$`: The observable that emits enhanced widget props with JTD handlers.
+     *         - `destroy`: Function to clean up resources. Call this when the component is destroyed.
+     * @group Dashboards
+     */
+    createJtdWidget(widgetProps, jtdConfig) {
+        // Create BehaviorSubject initialized with base props (or null)
+        const enhancedProps$ = new BehaviorSubject(widgetProps);
+        if (!widgetProps) {
+            return {
+                widget$: enhancedProps$,
+                destroy: () => {
+                    enhancedProps$.complete();
+                },
+            };
+        }
+        // Create HookAdapter with useJtdWidget hook and context connectors
+        const hookAdapter = new HookAdapter(useJtdWidgetPreact, [
+            createSisenseContextConnector(this.sisenseContextService),
+            createThemeContextConnector(this.themeService),
+        ]);
+        // Convert Angular props to preact props
+        const preactProps = translateToPreactWidgetProps(widgetProps);
+        // Subscribe to hook adapter results and capture the subscription
+        const hookAdapterSubscription = hookAdapter.subscribe((enhancedPreactProps) => {
+            if (enhancedPreactProps) {
+                // Convert back to Angular props
+                const angularProps = translateFromPreactWidgetProps(enhancedPreactProps);
+                enhancedProps$.next(angularProps);
+            }
+            else {
+                enhancedProps$.next(null);
+            }
+        });
+        // Run the hook with widget props and JTD config
+        // This will trigger the subscription above asynchronously when React contexts are ready
+        hookAdapter.run(preactProps, jtdConfig);
+        // Return the BehaviorSubject and destroy function for cleanup
+        return {
+            widget$: enhancedProps$,
+            destroy: () => {
+                // Unsubscribe from hook adapter
+                hookAdapterSubscription.unsubscribe();
+                // Destroy the hook adapter to clean up React components and contexts
+                hookAdapter.destroy();
+                // Complete the BehaviorSubject to release subscribers and avoid leaks
+                enhancedProps$.complete();
+            },
+        };
+    }
 };
-WidgetService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WidgetService, deps: [{ token: i1.SisenseContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+WidgetService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WidgetService, deps: [{ token: i1.SisenseContextService }, { token: i2.ThemeService }], target: i0.ɵɵFactoryTarget.Injectable });
 WidgetService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WidgetService, providedIn: 'root' });
 WidgetService = __decorate([
-    TrackableService(['getWidgetModel'])
+    TrackableService(['getWidgetModel', 'createJtdWidget'])
 ], WidgetService);
 export { WidgetService };
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WidgetService, decorators: [{
@@ -37,5 +177,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
             args: [{
                     providedIn: 'root',
                 }]
-        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }, { type: i2.ThemeService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget.service.js","sourceRoot":"","sources":["../../../../src/lib/services/widget.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EACL,cAAc,EAEd,WAAW,EAGX,YAAY,IAAI,kBAAkB,GACnC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAEvC,OAAO,EACL,6BAA6B,EAC7B,2BAA2B,GAC5B,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,EACL,8BAA8B,EAC9B,4BAA4B,GAC7B,MAAM,2CAA2C,CAAC;;;;AASnD;;;;;GAKG;AAKI,IAAM,aAAa,GAAnB,MAAM,aAAa;IACxB,YACU,qBAA4C,EAC5C,YAA0B;QAD1B,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,iBAAY,GAAZ,YAAY,CAAc;IACjC,CAAC;IAEJ;;;;;OAKG;IACH,KAAK,CAAC,cAAc,CAAC,MAA4B;QAC/C,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;QAC3C,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,EAAE,CAAC;QACtD,OAAO,cAAc,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;IACjE,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyFG;IACH,eAAe,CACb,WAA+B,EAC/B,SAAgE;QAEhE,+DAA+D;QAC/D,MAAM,cAAc,GAAG,IAAI,eAAe,CAAqB,WAAW,CAAC,CAAC;QAE5E,IAAI,CAAC,WAAW,EAAE;YAChB,OAAO;gBACL,OAAO,EAAE,cAAc;gBACvB,OAAO,EAAE,GAAG,EAAE;oBACZ,cAAc,CAAC,QAAQ,EAAE,CAAC;gBAC5B,CAAC;aACF,CAAC;SACH;QAED,mEAAmE;QACnE,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,kBAAkB,EAAE;YACtD,6BAA6B,CAAC,IAAI,CAAC,qBAAqB,CAAC;YACzD,2BAA2B,CAAC,IAAI,CAAC,YAAY,CAAC;SAC/C,CAAC,CAAC;QAEH,wCAAwC;QACxC,MAAM,WAAW,GAAG,4BAA4B,CAAC,WAAW,CAAC,CAAC;QAE9D,iEAAiE;QACjE,MAAM,uBAAuB,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC,mBAAmB,EAAE,EAAE;YAC5E,IAAI,mBAAmB,EAAE;gBACvB,gCAAgC;gBAChC,MAAM,YAAY,GAAG,8BAA8B,CAAC,mBAAmB,CAAC,CAAC;gBACzE,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;aACnC;iBAAM;gBACL,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAC3B;QACH,CAAC,CAAC,CAAC;QAEH,gDAAgD;QAChD,wFAAwF;QACxF,WAAW,CAAC,GAAG,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;QAExC,8DAA8D;QAC9D,OAAO;YACL,OAAO,EAAE,cAAc;YACvB,OAAO,EAAE,GAAG,EAAE;gBACZ,gCAAgC;gBAChC,uBAAuB,CAAC,WAAW,EAAE,CAAC;gBACtC,qEAAqE;gBACrE,WAAW,CAAC,OAAO,EAAE,CAAC;gBACtB,sEAAsE;gBACtE,cAAc,CAAC,QAAQ,EAAE,CAAC;YAC5B,CAAC;SACF,CAAC;IACJ,CAAC;;2GAhKU,aAAa;+GAAb,aAAa,cAHZ,MAAM;AAGP,aAAa;IADzB,gBAAgB,CAAgB,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;GAC1D,aAAa,CAiKzB;SAjKY,aAAa;4FAAb,aAAa;kBAJzB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  getWidgetModel,\n  type GetWidgetModelParams as GetWidgetModelParamsPreact,\n  HookAdapter,\n  type JumpToDashboardConfig,\n  type JumpToDashboardConfigForPivot,\n  useJtdWidget as useJtdWidgetPreact,\n} from '@sisense/sdk-ui-preact';\nimport { BehaviorSubject } from 'rxjs';\n\nimport {\n  createSisenseContextConnector,\n  createThemeContextConnector,\n} from '../component-wrapper-helpers';\nimport { type WidgetProps } from '../components/widgets/widget.component';\nimport { TrackableService } from '../decorators/trackable.decorator';\nimport {\n  translateFromPreactWidgetProps,\n  translateToPreactWidgetProps,\n} from '../helpers/widget-props-preact-translator';\nimport { SisenseContextService } from './sisense-context.service';\nimport { ThemeService } from './theme.service';\n\n/**\n * Parameters for retrieving an existing widget model from the Sisense instance\n */\nexport interface GetWidgetModelParams extends Omit<GetWidgetModelParamsPreact, 'enabled'> {}\n\n/**\n * Service for working with Sisense Fusion widgets.\n *\n * @group Fusion Assets\n * @fusionEmbed\n */\n@Injectable({\n  providedIn: 'root',\n})\n@TrackableService<WidgetService>(['getWidgetModel', 'createJtdWidget'])\nexport class WidgetService {\n  constructor(\n    private sisenseContextService: SisenseContextService,\n    private themeService: ThemeService,\n  ) {}\n\n  /**\n   * Retrieves an existing widget model from the Sisense instance.\n   *\n   * @param params - Parameters to identify the target widget\n   * @returns Widget model\n   */\n  async getWidgetModel(params: GetWidgetModelParams) {\n    const { dashboardOid, widgetOid } = params;\n    const app = await this.sisenseContextService.getApp();\n    return getWidgetModel(app.httpClient, dashboardOid, widgetOid);\n  }\n\n  /**\n   * Adds Jump To Dashboard (JTD) functionality to widget props.\n   *\n   * Jump To Dashboard (JTD) allows users to navigate from one dashboard to another when interacting with widgets,\n   * such as clicking on chart data points or using context menus. This method is particularly useful when rendering\n   * Widget components directly (not through a Dashboard component), but you still want JTD navigation functionality.\n   *\n   * For widgets that are part of a dashboard, consider using `applyJtdConfig` or `applyJtdConfigs` instead,\n   * as they apply JTD configuration at the dashboard level rather than individual widget level.\n   *\n   * Note: dashboard-only 'includeDashboardFilters' is not supported and would just be ignored, since we do not have a dashboard in the current context.\n   *\n   * This method enhances the provided widget props with JTD navigation capabilities, including:\n   * - Click and right-click event handlers for navigation\n   * - Hyperlink styling for actionable pivot cells (when applicable)\n   * - JTD icon display in widget headers\n   * @example\n   * ```TypeScript\n   * import { Component, OnDestroy } from '@angular/core';\n   * import {\n   *   WidgetService,\n   *   widgetModelTranslator,\n   *   type WidgetProps,\n   * } from '@sisense/sdk-ui-angular';\n   * import { BehaviorSubject } from 'rxjs';\n   *\n   * @Component({\n   *   selector: 'code-example',\n   *   template: `\n   *     <csdk-widget\n   *       *ngIf=\"widgetProps$ && (widgetProps$ | async) as widgetProps\"\n   *       [id]=\"widgetProps.id\"\n   *       [widgetType]=\"widgetProps.widgetType\"\n   *       [chartType]=\"widgetProps.chartType\"\n   *       [title]=\"widgetProps.title\"\n   *       [dataSource]=\"widgetProps.dataSource\"\n   *       [dataOptions]=\"widgetProps.dataOptions\"\n   *       [filters]=\"widgetProps.filters\"\n   *       [highlights]=\"widgetProps.highlights\"\n   *       [styleOptions]=\"widgetProps.styleOptions\"\n   *       [beforeMenuOpen]=\"widgetProps.beforeMenuOpen\"\n   *       (dataPointClick)=\"widgetProps.dataPointClick?.($event)\"\n   *       (dataPointContextMenu)=\"widgetProps.dataPointContextMenu?.($event)\"\n   *       (dataPointsSelect)=\"widgetProps.dataPointsSelect?.($event)\"\n   *     />\n   *   `,\n   * })\n   * export class CodeExample implements OnDestroy {\n   *   constructor(private widgetService: WidgetService) {}\n   *\n   *   widgetProps$: BehaviorSubject<WidgetProps | null> | null = null;\n   *   private jtdDestroy: (() => void) | null = null;\n   *\n   *   async ngOnInit(): Promise<void> {\n   *     const widget = await this.widgetService.getWidgetModel({\n   *       dashboardOid: '65a82171719e7f004018691c',\n   *       widgetOid: '65a82171719e7f004018691f',\n   *     });\n   *\n   *     const baseProps = widget\n   *       ? widgetModelTranslator.toWidgetProps(widget)\n   *       : null;\n   *\n   *     if (baseProps) {\n   *       const jtdConfig = {\n   *         targets: [{ id: 'target-dashboard-id', caption: 'Details' }],\n   *         interaction: { triggerMethod: 'rightclick' },\n   *       };\n   *       const jtdResult = this.widgetService.createJtdWidget(\n   *         baseProps,\n   *         jtdConfig,\n   *       );\n   *       this.widgetProps$ = jtdResult.widget$;\n   *       this.jtdDestroy = jtdResult.destroy;\n   *     }\n   *   }\n   *\n   *   ngOnDestroy(): void {\n   *     this.jtdDestroy?.();\n   *   }\n   * }\n   * ```\n   *\n   * @param widgetProps - Base widget props to enhance with JTD functionality\n   * @param jtdConfig - JTD configuration defining navigation targets and behavior\n   * @returns Object containing:\n   *         - `widget$`: The observable that emits enhanced widget props with JTD handlers.\n   *         - `destroy`: Function to clean up resources. Call this when the component is destroyed.\n   * @group Dashboards\n   */\n  createJtdWidget(\n    widgetProps: WidgetProps | null,\n    jtdConfig: JumpToDashboardConfig | JumpToDashboardConfigForPivot,\n  ): { widget$: BehaviorSubject<WidgetProps | null>; destroy: () => void } {\n    // Create BehaviorSubject initialized with base props (or null)\n    const enhancedProps$ = new BehaviorSubject<WidgetProps | null>(widgetProps);\n\n    if (!widgetProps) {\n      return {\n        widget$: enhancedProps$,\n        destroy: () => {\n          enhancedProps$.complete();\n        },\n      };\n    }\n\n    // Create HookAdapter with useJtdWidget hook and context connectors\n    const hookAdapter = new HookAdapter(useJtdWidgetPreact, [\n      createSisenseContextConnector(this.sisenseContextService),\n      createThemeContextConnector(this.themeService),\n    ]);\n\n    // Convert Angular props to preact props\n    const preactProps = translateToPreactWidgetProps(widgetProps);\n\n    // Subscribe to hook adapter results and capture the subscription\n    const hookAdapterSubscription = hookAdapter.subscribe((enhancedPreactProps) => {\n      if (enhancedPreactProps) {\n        // Convert back to Angular props\n        const angularProps = translateFromPreactWidgetProps(enhancedPreactProps);\n        enhancedProps$.next(angularProps);\n      } else {\n        enhancedProps$.next(null);\n      }\n    });\n\n    // Run the hook with widget props and JTD config\n    // This will trigger the subscription above asynchronously when React contexts are ready\n    hookAdapter.run(preactProps, jtdConfig);\n\n    // Return the BehaviorSubject and destroy function for cleanup\n    return {\n      widget$: enhancedProps$,\n      destroy: () => {\n        // Unsubscribe from hook adapter\n        hookAdapterSubscription.unsubscribe();\n        // Destroy the hook adapter to clean up React components and contexts\n        hookAdapter.destroy();\n        // Complete the BehaviorSubject to release subscribers and avoid leaks\n        enhancedProps$.complete();\n      },\n    };\n  }\n}\n"]}

package/dist/esm2020/lib/types/chart-event-props.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-event-props.js","sourceRoot":"","sources":["../../../../src/lib/types/chart-event-props.ts"],"names":[],"mappings":"","sourcesContent":["import type { Data } from '@sisense/sdk-data';\nimport type { BeforeRenderHandler, IndicatorBeforeRenderHandler } from '@sisense/sdk-ui-preact';\n\nimport type {\n  AreamapDataPointEventHandler,\n  BoxplotDataPointEventHandler,\n  CalendarHeatmapDataPointEventHandler,\n  CalendarHeatmapDataPointsEventHandler,\n  ChartDataPointClickEventHandler,\n  ChartDataPointContextMenuEventHandler,\n  ChartDataPointsEventHandler,\n  DataPointEventHandler,\n  DataPointsEventHandler,\n  IndicatorDataPointEventHandler,\n  ScatterDataPointEventHandler,\n  ScatterDataPointsEventHandler,\n  ScattermapDataPointEventHandler,\n} from './data-point';\n\nexport interface HighchartsBasedChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  beforeRender?: BeforeRenderHandler;\n}\n\nexport interface BaseChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataReady}\n   *\n   * @category Callbacks\n   */\n  dataReady?: (data: Data) => Data;\n}\n\n/**\n * Event props for regular (non-specific) charts which uses DataPoint type\n * to describe data points for events.\n */\nexport interface RegularChartEventProps\n  extends BaseChartEventProps,\n    HighchartsBasedChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: DataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: DataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  dataPointsSelect?: DataPointsEventHandler;\n}\n\n/**\n * Event props for Scatter chart which uses ScatterDataPoint type\n * to describe data points for events.\n */\nexport interface ScatterChartEventProps\n  extends BaseChartEventProps,\n    HighchartsBasedChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: ScatterDataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: ScatterDataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  dataPointsSelect?: ScatterDataPointsEventHandler;\n}\n\n/**\n * Event props for Areamap chart which uses AreamapDataPoint type\n * to describe data points for events.\n */\nexport interface AreamapChartEventProps extends BaseChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreamapChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: AreamapDataPointEventHandler;\n}\n\n/**\n * Event props for Scattermap chart which uses ScattermapDataPoint type\n * to describe data points for events.\n */\nexport interface ScattermapChartEventProps extends BaseChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScattermapChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: ScattermapDataPointEventHandler;\n}\n\n/**\n * Event props for Boxplot chart which uses BoxplotDataPoint type\n * to describe data points for events.\n */\nexport interface BoxplotChartEventProps\n  extends BaseChartEventProps,\n    HighchartsBasedChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!BoxplotChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: BoxplotDataPointEventHandler;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!BoxplotChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: BoxplotDataPointEventHandler;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!BoxplotChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  dataPointsSelect?: DataPointsEventHandler;\n}\n\nexport interface IndicatorChartEventProps extends BaseChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!IndicatorChartProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  beforeRender?: IndicatorBeforeRenderHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!IndicatorChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   * @internal\n   */\n  dataPointClick?: IndicatorDataPointEventHandler;\n}\n\n/**\n * Event props for CalendarHeatmap chart which uses CalendarHeatmapDataPoint type\n * to describe data points for events.\n */\nexport interface CalendarHeatmapChartEventProps\n  extends BaseChartEventProps,\n    HighchartsBasedChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: CalendarHeatmapDataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: CalendarHeatmapDataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  dataPointsSelect?: CalendarHeatmapDataPointsEventHandler;\n}\n\nexport interface ChartEventProps extends BaseChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: ChartDataPointClickEventHandler;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: ChartDataPointContextMenuEventHandler;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  dataPointsSelect?: ChartDataPointsEventHandler;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  beforeRender?:\n    | HighchartsBasedChartEventProps['beforeRender']\n    | IndicatorChartEventProps['beforeRender'];\n}\n\nexport type WithoutPreactChartEventProps<T> = Omit<\n  T,\n  | 'onBeforeRender'\n  | 'onDataReady'\n  | 'onDataPointClick'\n  | 'onDataPointContextMenu'\n  | 'onDataPointsSelected'\n>;\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-event-props.js","sourceRoot":"","sources":["../../../../src/lib/types/chart-event-props.ts"],"names":[],"mappings":"","sourcesContent":["import type { Data } from '@sisense/sdk-data';\nimport type { BeforeRenderHandler, IndicatorBeforeRenderHandler } from '@sisense/sdk-ui-preact';\n\nimport type {\n  AreamapDataPointEventHandler,\n  BoxplotDataPointEventHandler,\n  CalendarHeatmapDataPointEventHandler,\n  CalendarHeatmapDataPointsEventHandler,\n  ChartDataPointClickEventHandler,\n  ChartDataPointContextMenuEventHandler,\n  ChartDataPointsEventHandler,\n  DataPointEventHandler,\n  DataPointsEventHandler,\n  IndicatorDataPointEventHandler,\n  PivotTableDataPointEventHandler,\n  ScatterDataPointEventHandler,\n  ScatterDataPointsEventHandler,\n  ScattermapDataPointEventHandler,\n} from './data-point';\n\nexport interface HighchartsBasedChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  beforeRender?: BeforeRenderHandler;\n}\n\nexport interface BaseChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataReady}\n   *\n   * @category Callbacks\n   */\n  dataReady?: (data: Data) => Data;\n}\n\n/**\n * Event props for regular (non-specific) charts which uses DataPoint type\n * to describe data points for events.\n */\nexport interface RegularChartEventProps\n  extends BaseChartEventProps,\n    HighchartsBasedChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: DataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: DataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  dataPointsSelect?: DataPointsEventHandler;\n}\n\n/**\n * Event props for Scatter chart which uses ScatterDataPoint type\n * to describe data points for events.\n */\nexport interface ScatterChartEventProps\n  extends BaseChartEventProps,\n    HighchartsBasedChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: ScatterDataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: ScatterDataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  dataPointsSelect?: ScatterDataPointsEventHandler;\n}\n\n/**\n * Event props for Areamap chart which uses AreamapDataPoint type\n * to describe data points for events.\n */\nexport interface AreamapChartEventProps extends BaseChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!AreamapChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: AreamapDataPointEventHandler;\n}\n\n/**\n * Event props for Scattermap chart which uses ScattermapDataPoint type\n * to describe data points for events.\n */\nexport interface ScattermapChartEventProps extends BaseChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScattermapChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: ScattermapDataPointEventHandler;\n}\n\n/**\n * Event props for Boxplot chart which uses BoxplotDataPoint type\n * to describe data points for events.\n */\nexport interface BoxplotChartEventProps\n  extends BaseChartEventProps,\n    HighchartsBasedChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!BoxplotChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: BoxplotDataPointEventHandler;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!BoxplotChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: BoxplotDataPointEventHandler;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!BoxplotChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  dataPointsSelect?: DataPointsEventHandler;\n}\n\nexport interface IndicatorChartEventProps extends BaseChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!IndicatorChartProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  beforeRender?: IndicatorBeforeRenderHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!IndicatorChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   * @internal\n   */\n  dataPointClick?: IndicatorDataPointEventHandler;\n}\n\n/**\n * Event props for CalendarHeatmap chart which uses CalendarHeatmapDataPoint type\n * to describe data points for events.\n */\nexport interface CalendarHeatmapChartEventProps\n  extends BaseChartEventProps,\n    HighchartsBasedChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: CalendarHeatmapDataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: CalendarHeatmapDataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ScatterChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  dataPointsSelect?: CalendarHeatmapDataPointsEventHandler;\n}\n\nexport interface PivotTableEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!PivotTableProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: PivotTableDataPointEventHandler;\n  /**\n   * {@inheritDoc @sisense/sdk-ui!PivotTableProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: PivotTableDataPointEventHandler;\n}\n\nexport interface ChartEventProps extends BaseChartEventProps {\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointClick}\n   *\n   * @category Callbacks\n   */\n  dataPointClick?: ChartDataPointClickEventHandler;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointContextMenu}\n   *\n   * @category Callbacks\n   */\n  dataPointContextMenu?: ChartDataPointContextMenuEventHandler;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onDataPointsSelected}\n   *\n   * @category Callbacks\n   */\n  dataPointsSelect?: ChartDataPointsEventHandler;\n\n  /**\n   * {@inheritDoc @sisense/sdk-ui!ChartProps.onBeforeRender}\n   *\n   * @category Callbacks\n   */\n  beforeRender?:\n    | HighchartsBasedChartEventProps['beforeRender']\n    | IndicatorChartEventProps['beforeRender'];\n}\n\nexport type WithoutPreactChartEventProps<T> = Omit<\n  T,\n  | 'onBeforeRender'\n  | 'onDataReady'\n  | 'onDataPointClick'\n  | 'onDataPointContextMenu'\n  | 'onDataPointsSelected'\n>;\n"]}

package/dist/esm2020/lib/types/data-point.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-point.js","sourceRoot":"","sources":["../../../../src/lib/types/data-point.ts"],"names":[],"mappings":"","sourcesContent":["import {\n  AreamapDataPoint,\n  BoxplotDataPoint,\n  CalendarHeatmapDataPoint,\n  DataPoint,\n  IndicatorDataPoint,\n  PivotTableDataPoint,\n  ScatterDataPoint,\n  ScattermapDataPoint,\n  TextWidgetDataPoint,\n} from '@sisense/sdk-ui-preact';\n\nexport type DataPointEvent = {\n  /** Data point that was clicked */\n  point: DataPoint;\n  /** Native PointerEvent */\n  nativeEvent: PointerEvent;\n};\n\nexport type ScatterDataPointEvent = {\n  /** Data point that was clicked */\n  point: ScatterDataPoint;\n  /** Native PointerEvent */\n  nativeEvent: PointerEvent;\n};\n\nexport type AreamapDataPointEvent = {\n  /** Data point that was clicked */\n  point: AreamapDataPoint;\n  /** Native MouseEvent */\n  nativeEvent: MouseEvent;\n};\n\nexport type ScattermapDataPointEvent = {\n  /** Data point that was clicked */\n  point: ScattermapDataPoint;\n  /** Native MouseEvent */\n  nativeEvent: MouseEvent;\n};\n\nexport type BoxplotDataPointEvent = {\n  /** Data point that was clicked */\n  point: BoxplotDataPoint;\n  /** Native PointerEvent */\n  nativeEvent: PointerEvent;\n};\n\nexport type IndicatorDataPointEvent = {\n  /** Data point that was clicked */\n  point: IndicatorDataPoint;\n  /** Native MouseEvent */\n  nativeEvent: MouseEvent;\n};\n\nexport type CalendarHeatmapDataPointEvent = {\n  /** Data point that was clicked */\n  point: CalendarHeatmapDataPoint;\n  /** Native PointerEvent */\n  nativeEvent: PointerEvent;\n};\n\nexport type CalendarHeatmapDataPointsEvent = {\n  /** Data points that were selected */\n  points: CalendarHeatmapDataPoint[];\n  /** Native MouseEvent */\n  nativeEvent: MouseEvent;\n};\n\nexport type TextWidgetDataPointEvent = {\n  /** Data point that was clicked */\n  point: TextWidgetDataPoint;\n  /** Native MouseEvent */\n  nativeEvent: MouseEvent;\n};\n\nexport type ChartDataPointClickEvent =\n  | DataPointEvent\n  | ScatterDataPointEvent\n  | BoxplotDataPointEvent\n  | AreamapDataPointEvent\n  | ScattermapDataPointEvent\n  | IndicatorDataPointEvent\n  | CalendarHeatmapDataPointEvent;\n\nexport type WidgetDataPointClickEvent =\n  | ChartDataPointClickEvent\n  | TextWidgetDataPointEvent\n  | PivotTableDataPointEvent;\n\nexport type ChartDataPointContextMenuEvent =\n  | DataPointEvent\n  | ScatterDataPointEvent\n  | BoxplotDataPointEvent\n  | CalendarHeatmapDataPointEvent;\n\nexport type WidgetDataPointContextMenuEvent =\n  | ChartDataPointContextMenuEvent\n  | PivotTableDataPointEvent;\n\nexport type DataPointsEvent = {\n  /** Data points that were selected */\n  points: DataPoint[];\n  /** Native MouseEvent */\n  nativeEvent: MouseEvent;\n};\n\nexport type ScatterDataPointsEvent = {\n  /** Data points that were selected */\n  points: ScatterDataPoint[];\n  /** Native MouseEvent */\n  nativeEvent: MouseEvent;\n};\n\nexport type BoxplotDataPointsEvent = {\n  /** Data point that were selected */\n  points: BoxplotDataPoint[];\n  /** Native MouseEvent */\n  nativeEvent: MouseEvent;\n};\n\nexport type PivotTableDataPointEvent = {\n  /** Data point that was clicked */\n  point: PivotTableDataPoint;\n  /** Native MouseEvent */\n  nativeEvent: MouseEvent;\n};\n\nexport type ChartDataPointsEvent =\n  | DataPointsEvent\n  | ScatterDataPointsEvent\n  | CalendarHeatmapDataPointsEvent;\n\n/**\n * A handler function that allows you to customize what happens when certain events occur to\n * a data point.\n */\nexport type DataPointEventHandler = (event: DataPointEvent) => void;\n\n/** Click handler for when a scatter data point is clicked */\nexport type ScatterDataPointEventHandler = (event: ScatterDataPointEvent) => void;\n\n/**\n * Click handler for when a data point on Areamap is clicked.\n */\nexport type AreamapDataPointEventHandler = (event: AreamapDataPointEvent) => void;\n\n/**\n * Click handler for when a data point on Scattermap is clicked.\n */\nexport type ScattermapDataPointEventHandler = (event: ScattermapDataPointEvent) => void;\n\n/**\n * Click handler for when a data point on Boxplot is clicked.\n */\nexport type BoxplotDataPointEventHandler = (event: BoxplotDataPointEvent) => void;\n\n/** Click handler for when a data point on Indicator is clicked. */\nexport type IndicatorDataPointEventHandler = (event: IndicatorDataPointEvent) => void;\n\n/**\n * Click handler for when a data point on Chart is clicked.\n */\nexport type ChartDataPointClickEventHandler = (event: ChartDataPointClickEvent) => void;\n\n/** Click handler for when a data point on TextWidget is clicked. */\nexport type TextWidgetDataPointEventHandler = (event: TextWidgetDataPointEvent) => void;\n\n/** Click handler for when a data point on Widget is clicked. */\nexport type WidgetDataPointClickEventHandler = (event: WidgetDataPointClickEvent) => void;\n\n/**\n * Context menu handler for when a data point on the Chart is right-clicked.\n */\nexport type ChartDataPointContextMenuEventHandler = (event: ChartDataPointContextMenuEvent) => void;\n\n/** Context menu handler for when a data point on Widget is right-clicked. */\nexport type WidgetDataPointContextMenuEventHandler = (\n  event: WidgetDataPointContextMenuEvent,\n) => void;\n\n/** Click handler for when multiple scatter data points are selected. */\nexport type ScatterDataPointsEventHandler = (event: ScatterDataPointsEvent) => void;\n\n/** Click handler for when multiple data points are selected. */\nexport type DataPointsEventHandler = (event: DataPointsEvent) => void;\n\n/**\n * Click handler for when a calendar-heatmap data point is clicked\n */\nexport type CalendarHeatmapDataPointEventHandler = (event: CalendarHeatmapDataPointEvent) => void;\n\n/**\n * Click handler for when multiple calendar-heatmap data points are selected.\n */\nexport type CalendarHeatmapDataPointsEventHandler = (event: CalendarHeatmapDataPointsEvent) => void;\n\n/** Click handler for when multiple data points on Chart are selected. */\nexport type ChartDataPointsEventHandler = (event: ChartDataPointsEvent) => void;\n\n/** Click handler for when a pivot table data point is clicked. */\nexport type PivotTableDataPointEventHandler = (event: PivotTableDataPointEvent) => void;\n"]}

package/dist/esm2020/lib/utilities/widget-model-translator.mjs

@@ -301,4 +301,55 @@ const textWidgetProps = widgetModelTranslator.toTextWidgetProps(widgetModel);
 export function toTextWidgetProps(widgetModel) {
     return widgetModelTranslatorPreact.toTextWidgetProps(widgetModel);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-model-translator.js","sourceRoot":"","sources":["../../../../src/lib/utilities/widget-model-translator.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,IAAI,2BAA2B,GACrD,MAAM,wBAAwB,CAAC;AAYhC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,WAAwB,EAAsB,EAAE;IACnF,OAAO,2BAA2B,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;AACvE,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,WAAwB,EAA2B,EAAE;IAC7F,OAAO,2BAA2B,CAAC,yBAAyB,CAAC,WAAW,CAAC,CAAC;AAC5E,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,UAAU,YAAY,CAAC,WAAwB;IACnD,OAAO,2BAA2B,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,YAAY,CAAC,WAAwB;IACnD,OAAO,2BAA2B,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAAwB;IACxD,OAAO,2BAA2B,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;AACpE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,kBAAkB,CAAC,WAAwB;IACzD,OAAO,2BAA2B,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,UAAU,uBAAuB,CAAC,WAAwB;IAC9D,OAAO,2BAA2B,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAAwB;IACxD,OAAO,2BAA2B,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;AACpE,CAAC","sourcesContent":["import {\n  type WidgetModel,\n  widgetModelTranslator as widgetModelTranslatorPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  ChartProps,\n  ChartWidgetProps,\n  PivotTableProps,\n  PivotTableWidgetProps,\n  TableProps,\n  type TextWidgetProps,\n} from '../components';\nimport { ExecutePivotQueryParams, ExecuteQueryParams } from '../services';\n\n/**\n * Translates a {@link WidgetModel} to the parameters for executing a query for the widget.\n *\n * @example\n * ```ts\nconst widgetModel = await widgetService.getWidgetModel({\n  dashboardOid: 'your-dashboard-oid',\n  widgetOid: 'your-widget-oid'\n});\nconst executeQueryParams = widgetModelTranslator.toExecuteQueryParams(widgetModel);\nconst queryResult = await queryService.executeQuery(executeQueryParams);\n * ```\n *\n * Note: this method is not supported for getting pivot query.\n * Use {@link toExecutePivotQueryParams} instead for getting query parameters for the pivot widget.\n */\nexport const toExecuteQueryParams = (widgetModel: WidgetModel): ExecuteQueryParams => {\n  return widgetModelTranslatorPreact.toExecuteQueryParams(widgetModel);\n};\n\n/**\n * Translates a {@link WidgetModel} to the parameters for executing a query for the pivot widget.\n *\n * @example\n * ```ts\nconst widgetModel = await widgetService.getWidgetModel({\n  dashboardOid: 'your-dashboard-oid',\n  widgetOid: 'your-widget-oid'\n});\nconst executePivotQueryParams = widgetModelTranslator.toExecutePivotQueryParams(widgetModel);\nconst queryResult = await queryService.executePivotQuery(executeQueryParams);\n * ```\n *\n * Note: this method is supported only for getting pivot query.\n * Use {@link toExecuteQueryParams} instead for getting query parameters for non-pivot widgets.\n */\nexport const toExecutePivotQueryParams = (widgetModel: WidgetModel): ExecutePivotQueryParams => {\n  return widgetModelTranslatorPreact.toExecutePivotQueryParams(widgetModel);\n};\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a chart.\n *\n * @example\n * ```html\n<csdk-chart\n  *ngIf=\"chartProps\"\n  [chartType]=\"chartProps.chartType\"\n  [dataSet]=\"chartProps.dataSet\"\n  [dataOptions]=\"chartProps.dataOptions\"\n  [filters]=\"chartProps.filters\"\n  [highlights]=\"chartProps.highlights\"\n  [styleOptions]=\"chartProps.styleOptions\"\n/>\n * ```\n *\n * ```ts\nimport { Component } from '@angular/core';\nimport {\n  type ChartProps\n  WidgetService,\n  widgetModelTranslator,\n} from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  chartProps: ChartProps | null = null;\n\n  constructor(private widgetService: WidgetService) {}\n\n  async ngOnInit(): Promise<void> {\n    const widgetModel = await widgetService.getWidgetModel({\n      dashboardOid: 'your-dashboard-oid',\n      widgetOid: 'your-widget-oid'\n    });\n    this.chartProps = widgetModelTranslator.toChartProps(widgetModel);\n  }\n}\n * ```\n *\n * Note: this method is not supported for pivot widgets.\n * Use {@link toPivotTableProps} instead for getting props for the {@link PivotTableComponent}.\n */\nexport function toChartProps(widgetModel: WidgetModel): ChartProps {\n  return widgetModelTranslatorPreact.toChartProps(widgetModel);\n}\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a table.\n *\n * @example\n * ```html\n<csdk-table\n  *ngIf=\"tableProps\"\n  [dataSet]=\"tableProps.dataSet\"\n  [dataOptions]=\"tableProps.dataOptions\"\n  [filters]=\"tableProps.filters\"\n  [styleOptions]=\"tableProps.styleOptions\"\n/>\n * ```\n *\n * ```ts\nimport { Component } from '@angular/core';\nimport {\n  type TableProps\n  WidgetService,\n  widgetModelTranslator,\n} from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  tableProps: TableProps | null = null;\n\n  constructor(private widgetService: WidgetService) {}\n\n  async ngOnInit(): Promise<void> {\n    const widgetModel = await widgetService.getWidgetModel({\n      dashboardOid: 'your-dashboard-oid',\n      widgetOid: 'your-widget-oid'\n    });\n    this.tableProps = widgetModelTranslator.toTableProps(widgetModel);\n  }\n}\n * ```\n *\n * Note: this method is not supported for chart and pivot widgets.\n * Use {@link toChartProps} instead for getting props for the {@link ChartComponent}.\n * Use {@link toPivotTableProps} instead for getting props for the {@link PivotTableComponent}.\n */\nexport function toTableProps(widgetModel: WidgetModel): TableProps {\n  return widgetModelTranslatorPreact.toTableProps(widgetModel);\n}\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a pivot table.\n *\n * @example\n * ```html\n<csdk-pivot-table\n  *ngIf=\"pivotTableProps\"\n  [dataSet]=\"pivotTableProps.dataSet\"\n  [dataOptions]=\"pivotTableProps.dataOptions\"\n  [filters]=\"pivotTableProps.filters\"\n  [styleOptions]=\"pivotTableProps.styleOptions\"\n/>\n * ```\n *\n * ```ts\nimport { Component } from '@angular/core';\nimport {\n  type PivotTableProps\n  WidgetService,\n  widgetModelTranslator,\n} from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  pivotTableProps: PivotTableProps | null = null;\n\n  constructor(private widgetService: WidgetService) {}\n\n  async ngOnInit(): Promise<void> {\n    const widgetModel = await widgetService.getWidgetModel({\n      dashboardOid: 'your-dashboard-oid',\n      widgetOid: 'your-widget-oid'\n    });\n    this.pivotTableProps = widgetModelTranslator.toPivotTableProps(widgetModel);\n  }\n}\n * ```\n *\n * Note: this method is not supported for chart or table widgets.\n * Use {@link toChartProps} instead for getting props for the {@link ChartComponent}.\n * Use {@link toTableProps} instead for getting props for the {@link TableComponent}.\n */\nexport function toPivotTableProps(widgetModel: WidgetModel): PivotTableProps {\n  return widgetModelTranslatorPreact.toPivotTableProps(widgetModel);\n}\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a chart widget.\n *\n * @example\n * ```html\n<csdk-chart-widget\n  *ngIf=\"chartWidgetProps\"\n  [chartType]=\"chartWidgetProps.chartType\"\n  [dataSource]=\"chartWidgetProps.dataSource\"\n  [dataOptions]=\"chartWidgetProps.dataOptions\"\n  [filters]=\"chartWidgetProps.filters\"\n  [highlights]=\"chartWidgetProps.highlights\"\n  [styleOptions]=\"chartWidgetProps.styleOptions\"\n/>\n * ```\n *\n * ```ts\nimport { Component } from '@angular/core';\nimport {\n  type ChartWidgetProps\n  WidgetService,\n  widgetModelTranslator,\n} from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  chartWidgetProps: ChartWidgetProps | null = null;\n\n  constructor(private widgetService: WidgetService) {}\n\n  async ngOnInit(): Promise<void> {\n    const widgetModel = await widgetService.getWidgetModel({\n      dashboardOid: 'your-dashboard-oid',\n      widgetOid: 'your-widget-oid'\n    });\n    this.chartWidgetProps = widgetModelTranslator.toChartWidgetProps(widgetModel);\n  }\n}\n * ```\n *\n * Note: this method is not supported for pivot widgets.\n */\nexport function toChartWidgetProps(widgetModel: WidgetModel): ChartWidgetProps {\n  return widgetModelTranslatorPreact.toChartWidgetProps(widgetModel);\n}\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a pivot table widget.\n *\n * @example\n * ```html\n<csdk-pivot-table-widget\n  *ngIf=\"pivotWidgetProps\"\n  [dataSet]=\"pivotWidgetProps.dataSet\"\n  [dataOptions]=\"pivotWidgetProps.dataOptions\"\n  [filters]=\"pivotWidgetProps.filters\"\n  [styleOptions]=\"pivotWidgetProps.styleOptions\"\n/>\n * ```\n *\n * ```ts\nimport { Component } from '@angular/core';\nimport {\n  type PivotTableWidgetProps\n  WidgetService,\n  widgetModelTranslator,\n} from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  pivotWidgetProps: PivotTableWidgetProps | null = null;\n\n  constructor(private widgetService: WidgetService) {}\n\n  async ngOnInit(): Promise<void> {\n    const widgetModel = await widgetService.getWidgetModel({\n      dashboardOid: 'your-dashboard-oid',\n      widgetOid: 'your-widget-oid'\n    });\n    this.pivotWidgetProps = widgetModelTranslator.toPivotTableWidgetProps(widgetModel);\n  }\n}\n * ```\n *\n * Note: this method is not supported for chart or table widgets.\n * Use {@link toChartWidgetProps} instead for getting props for the {@link ChartWidgetComponent}.\n */\nexport function toPivotTableWidgetProps(widgetModel: WidgetModel): PivotTableWidgetProps {\n  return widgetModelTranslatorPreact.toPivotTableWidgetProps(widgetModel);\n}\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a text widget.\n *\n * @example\n * ```ts\nconst widgetModel = await widgetService.getWidgetModel({\n  dashboardOid: 'your-dashboard-oid',\n  widgetOid: 'your-widget-oid'\n});\nconst textWidgetProps = widgetModelTranslator.toTextWidgetProps(widgetModel);\n * ```\n *\n * Note: this method is not supported for chart or pivot widgets.\n * Use {@link toChartWidgetProps} instead for getting props for the {@link ChartWidgetComponent}.\n * Use {@link toPivotTableWidgetProps} instead for getting props for the pivot table widget.\n */\nexport function toTextWidgetProps(widgetModel: WidgetModel): TextWidgetProps {\n  return widgetModelTranslatorPreact.toTextWidgetProps(widgetModel);\n}\n"]}
+/**
+ * Translates {@link WidgetModel} to {@link WidgetProps}.
+ *
+ * @example
+ * ```html
+ * <csdk-widget
+ *   *ngIf="widgetProps"
+ *   [id]="widgetProps.id"
+ *   [widgetType]="widgetProps.widgetType"
+ *   [chartType]="widgetProps.chartType"
+ *   [dataSource]="widgetProps.dataSource"
+ *   [dataOptions]="widgetProps.dataOptions"
+ *   [filters]="widgetProps.filters"
+ *   [highlights]="widgetProps.highlights"
+ *   [styleOptions]="widgetProps.styleOptions"
+ *   [title]="widgetProps.title"
+ *   [description]="widgetProps.description"
+ * />
+ * ```
+ *
+ * ```ts
+ * import { Component } from '@angular/core';
+ * import {
+ *   type WidgetProps,
+ *   WidgetService,
+ *   widgetModelTranslator,
+ * } from '@sisense/sdk-ui-angular';
+ *
+ * @Component({
+ *   selector: 'app-example',
+ *   templateUrl: './example.component.html',
+ *   styleUrls: ['./example.component.scss'],
+ * })
+ * export class ExampleComponent {
+ *   widgetProps: WidgetProps | null = null;
+ *
+ *   constructor(private widgetService: WidgetService) {}
+ *
+ *   async ngOnInit(): Promise<void> {
+ *     const widgetModel = await widgetService.getWidgetModel({
+ *       dashboardOid: 'your-dashboard-oid',
+ *       widgetOid: 'your-widget-oid'
+ *     });
+ *     this.widgetProps = widgetModelTranslator.toWidgetProps(widgetModel);
+ *   }
+ * }
+ * ```
+ */
+export function toWidgetProps(widgetModel) {
+    return widgetModelTranslatorPreact.toWidgetProps(widgetModel);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-model-translator.js","sourceRoot":"","sources":["../../../../src/lib/utilities/widget-model-translator.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,IAAI,2BAA2B,GACrD,MAAM,wBAAwB,CAAC;AAahC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,WAAwB,EAAsB,EAAE;IACnF,OAAO,2BAA2B,CAAC,oBAAoB,CAAC,WAAW,CAAC,CAAC;AACvE,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,WAAwB,EAA2B,EAAE;IAC7F,OAAO,2BAA2B,CAAC,yBAAyB,CAAC,WAAW,CAAC,CAAC;AAC5E,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,UAAU,YAAY,CAAC,WAAwB;IACnD,OAAO,2BAA2B,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,YAAY,CAAC,WAAwB;IACnD,OAAO,2BAA2B,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAAwB;IACxD,OAAO,2BAA2B,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;AACpE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,kBAAkB,CAAC,WAAwB;IACzD,OAAO,2BAA2B,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,UAAU,uBAAuB,CAAC,WAAwB;IAC9D,OAAO,2BAA2B,CAAC,uBAAuB,CAAC,WAAW,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAAwB;IACxD,OAAO,2BAA2B,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;AACpE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,UAAU,aAAa,CAAC,WAAwB;IACpD,OAAO,2BAA2B,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;AAChE,CAAC","sourcesContent":["import {\n  type WidgetModel,\n  widgetModelTranslator as widgetModelTranslatorPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport {\n  ChartProps,\n  ChartWidgetProps,\n  PivotTableProps,\n  PivotTableWidgetProps,\n  TableProps,\n  type TextWidgetProps,\n  type WidgetProps,\n} from '../components';\nimport { ExecutePivotQueryParams, ExecuteQueryParams } from '../services';\n\n/**\n * Translates a {@link WidgetModel} to the parameters for executing a query for the widget.\n *\n * @example\n * ```ts\nconst widgetModel = await widgetService.getWidgetModel({\n  dashboardOid: 'your-dashboard-oid',\n  widgetOid: 'your-widget-oid'\n});\nconst executeQueryParams = widgetModelTranslator.toExecuteQueryParams(widgetModel);\nconst queryResult = await queryService.executeQuery(executeQueryParams);\n * ```\n *\n * Note: this method is not supported for getting pivot query.\n * Use {@link toExecutePivotQueryParams} instead for getting query parameters for the pivot widget.\n */\nexport const toExecuteQueryParams = (widgetModel: WidgetModel): ExecuteQueryParams => {\n  return widgetModelTranslatorPreact.toExecuteQueryParams(widgetModel);\n};\n\n/**\n * Translates a {@link WidgetModel} to the parameters for executing a query for the pivot widget.\n *\n * @example\n * ```ts\nconst widgetModel = await widgetService.getWidgetModel({\n  dashboardOid: 'your-dashboard-oid',\n  widgetOid: 'your-widget-oid'\n});\nconst executePivotQueryParams = widgetModelTranslator.toExecutePivotQueryParams(widgetModel);\nconst queryResult = await queryService.executePivotQuery(executeQueryParams);\n * ```\n *\n * Note: this method is supported only for getting pivot query.\n * Use {@link toExecuteQueryParams} instead for getting query parameters for non-pivot widgets.\n */\nexport const toExecutePivotQueryParams = (widgetModel: WidgetModel): ExecutePivotQueryParams => {\n  return widgetModelTranslatorPreact.toExecutePivotQueryParams(widgetModel);\n};\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a chart.\n *\n * @example\n * ```html\n<csdk-chart\n  *ngIf=\"chartProps\"\n  [chartType]=\"chartProps.chartType\"\n  [dataSet]=\"chartProps.dataSet\"\n  [dataOptions]=\"chartProps.dataOptions\"\n  [filters]=\"chartProps.filters\"\n  [highlights]=\"chartProps.highlights\"\n  [styleOptions]=\"chartProps.styleOptions\"\n/>\n * ```\n *\n * ```ts\nimport { Component } from '@angular/core';\nimport {\n  type ChartProps\n  WidgetService,\n  widgetModelTranslator,\n} from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  chartProps: ChartProps | null = null;\n\n  constructor(private widgetService: WidgetService) {}\n\n  async ngOnInit(): Promise<void> {\n    const widgetModel = await widgetService.getWidgetModel({\n      dashboardOid: 'your-dashboard-oid',\n      widgetOid: 'your-widget-oid'\n    });\n    this.chartProps = widgetModelTranslator.toChartProps(widgetModel);\n  }\n}\n * ```\n *\n * Note: this method is not supported for pivot widgets.\n * Use {@link toPivotTableProps} instead for getting props for the {@link PivotTableComponent}.\n */\nexport function toChartProps(widgetModel: WidgetModel): ChartProps {\n  return widgetModelTranslatorPreact.toChartProps(widgetModel);\n}\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a table.\n *\n * @example\n * ```html\n<csdk-table\n  *ngIf=\"tableProps\"\n  [dataSet]=\"tableProps.dataSet\"\n  [dataOptions]=\"tableProps.dataOptions\"\n  [filters]=\"tableProps.filters\"\n  [styleOptions]=\"tableProps.styleOptions\"\n/>\n * ```\n *\n * ```ts\nimport { Component } from '@angular/core';\nimport {\n  type TableProps\n  WidgetService,\n  widgetModelTranslator,\n} from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  tableProps: TableProps | null = null;\n\n  constructor(private widgetService: WidgetService) {}\n\n  async ngOnInit(): Promise<void> {\n    const widgetModel = await widgetService.getWidgetModel({\n      dashboardOid: 'your-dashboard-oid',\n      widgetOid: 'your-widget-oid'\n    });\n    this.tableProps = widgetModelTranslator.toTableProps(widgetModel);\n  }\n}\n * ```\n *\n * Note: this method is not supported for chart and pivot widgets.\n * Use {@link toChartProps} instead for getting props for the {@link ChartComponent}.\n * Use {@link toPivotTableProps} instead for getting props for the {@link PivotTableComponent}.\n */\nexport function toTableProps(widgetModel: WidgetModel): TableProps {\n  return widgetModelTranslatorPreact.toTableProps(widgetModel);\n}\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a pivot table.\n *\n * @example\n * ```html\n<csdk-pivot-table\n  *ngIf=\"pivotTableProps\"\n  [dataSet]=\"pivotTableProps.dataSet\"\n  [dataOptions]=\"pivotTableProps.dataOptions\"\n  [filters]=\"pivotTableProps.filters\"\n  [styleOptions]=\"pivotTableProps.styleOptions\"\n/>\n * ```\n *\n * ```ts\nimport { Component } from '@angular/core';\nimport {\n  type PivotTableProps\n  WidgetService,\n  widgetModelTranslator,\n} from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  pivotTableProps: PivotTableProps | null = null;\n\n  constructor(private widgetService: WidgetService) {}\n\n  async ngOnInit(): Promise<void> {\n    const widgetModel = await widgetService.getWidgetModel({\n      dashboardOid: 'your-dashboard-oid',\n      widgetOid: 'your-widget-oid'\n    });\n    this.pivotTableProps = widgetModelTranslator.toPivotTableProps(widgetModel);\n  }\n}\n * ```\n *\n * Note: this method is not supported for chart or table widgets.\n * Use {@link toChartProps} instead for getting props for the {@link ChartComponent}.\n * Use {@link toTableProps} instead for getting props for the {@link TableComponent}.\n */\nexport function toPivotTableProps(widgetModel: WidgetModel): PivotTableProps {\n  return widgetModelTranslatorPreact.toPivotTableProps(widgetModel);\n}\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a chart widget.\n *\n * @example\n * ```html\n<csdk-chart-widget\n  *ngIf=\"chartWidgetProps\"\n  [chartType]=\"chartWidgetProps.chartType\"\n  [dataSource]=\"chartWidgetProps.dataSource\"\n  [dataOptions]=\"chartWidgetProps.dataOptions\"\n  [filters]=\"chartWidgetProps.filters\"\n  [highlights]=\"chartWidgetProps.highlights\"\n  [styleOptions]=\"chartWidgetProps.styleOptions\"\n/>\n * ```\n *\n * ```ts\nimport { Component } from '@angular/core';\nimport {\n  type ChartWidgetProps\n  WidgetService,\n  widgetModelTranslator,\n} from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  chartWidgetProps: ChartWidgetProps | null = null;\n\n  constructor(private widgetService: WidgetService) {}\n\n  async ngOnInit(): Promise<void> {\n    const widgetModel = await widgetService.getWidgetModel({\n      dashboardOid: 'your-dashboard-oid',\n      widgetOid: 'your-widget-oid'\n    });\n    this.chartWidgetProps = widgetModelTranslator.toChartWidgetProps(widgetModel);\n  }\n}\n * ```\n *\n * Note: this method is not supported for pivot widgets.\n */\nexport function toChartWidgetProps(widgetModel: WidgetModel): ChartWidgetProps {\n  return widgetModelTranslatorPreact.toChartWidgetProps(widgetModel);\n}\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a pivot table widget.\n *\n * @example\n * ```html\n<csdk-pivot-table-widget\n  *ngIf=\"pivotWidgetProps\"\n  [dataSet]=\"pivotWidgetProps.dataSet\"\n  [dataOptions]=\"pivotWidgetProps.dataOptions\"\n  [filters]=\"pivotWidgetProps.filters\"\n  [styleOptions]=\"pivotWidgetProps.styleOptions\"\n/>\n * ```\n *\n * ```ts\nimport { Component } from '@angular/core';\nimport {\n  type PivotTableWidgetProps\n  WidgetService,\n  widgetModelTranslator,\n} from '@sisense/sdk-ui-angular';\n\n@Component({\n  selector: 'app-example',\n  templateUrl: './example.component.html',\n  styleUrls: ['./example.component.scss'],\n})\nexport class ExampleComponent {\n  pivotWidgetProps: PivotTableWidgetProps | null = null;\n\n  constructor(private widgetService: WidgetService) {}\n\n  async ngOnInit(): Promise<void> {\n    const widgetModel = await widgetService.getWidgetModel({\n      dashboardOid: 'your-dashboard-oid',\n      widgetOid: 'your-widget-oid'\n    });\n    this.pivotWidgetProps = widgetModelTranslator.toPivotTableWidgetProps(widgetModel);\n  }\n}\n * ```\n *\n * Note: this method is not supported for chart or table widgets.\n * Use {@link toChartWidgetProps} instead for getting props for the {@link ChartWidgetComponent}.\n */\nexport function toPivotTableWidgetProps(widgetModel: WidgetModel): PivotTableWidgetProps {\n  return widgetModelTranslatorPreact.toPivotTableWidgetProps(widgetModel);\n}\n\n/**\n * Translates a {@link WidgetModel} to the props for rendering a text widget.\n *\n * @example\n * ```ts\nconst widgetModel = await widgetService.getWidgetModel({\n  dashboardOid: 'your-dashboard-oid',\n  widgetOid: 'your-widget-oid'\n});\nconst textWidgetProps = widgetModelTranslator.toTextWidgetProps(widgetModel);\n * ```\n *\n * Note: this method is not supported for chart or pivot widgets.\n * Use {@link toChartWidgetProps} instead for getting props for the {@link ChartWidgetComponent}.\n * Use {@link toPivotTableWidgetProps} instead for getting props for the pivot table widget.\n */\nexport function toTextWidgetProps(widgetModel: WidgetModel): TextWidgetProps {\n  return widgetModelTranslatorPreact.toTextWidgetProps(widgetModel);\n}\n\n/**\n * Translates {@link WidgetModel} to {@link WidgetProps}.\n *\n * @example\n * ```html\n * <csdk-widget\n *   *ngIf=\"widgetProps\"\n *   [id]=\"widgetProps.id\"\n *   [widgetType]=\"widgetProps.widgetType\"\n *   [chartType]=\"widgetProps.chartType\"\n *   [dataSource]=\"widgetProps.dataSource\"\n *   [dataOptions]=\"widgetProps.dataOptions\"\n *   [filters]=\"widgetProps.filters\"\n *   [highlights]=\"widgetProps.highlights\"\n *   [styleOptions]=\"widgetProps.styleOptions\"\n *   [title]=\"widgetProps.title\"\n *   [description]=\"widgetProps.description\"\n * />\n * ```\n *\n * ```ts\n * import { Component } from '@angular/core';\n * import {\n *   type WidgetProps,\n *   WidgetService,\n *   widgetModelTranslator,\n * } from '@sisense/sdk-ui-angular';\n *\n * @Component({\n *   selector: 'app-example',\n *   templateUrl: './example.component.html',\n *   styleUrls: ['./example.component.scss'],\n * })\n * export class ExampleComponent {\n *   widgetProps: WidgetProps | null = null;\n *\n *   constructor(private widgetService: WidgetService) {}\n *\n *   async ngOnInit(): Promise<void> {\n *     const widgetModel = await widgetService.getWidgetModel({\n *       dashboardOid: 'your-dashboard-oid',\n *       widgetOid: 'your-widget-oid'\n *     });\n *     this.widgetProps = widgetModelTranslator.toWidgetProps(widgetModel);\n *   }\n * }\n * ```\n */\nexport function toWidgetProps(widgetModel: WidgetModel): WidgetProps {\n  return widgetModelTranslatorPreact.toWidgetProps(widgetModel);\n}\n"]}

package/dist/esm2020/public-api.mjs

@@ -9,4 +9,4 @@ export * from './lib/utilities';
 /* Re-exports internal core functionalities to use in dependant angular modules */
 export { createCustomWidgetsContextConnector, createSisenseContextConnector, createThemeContextConnector, } from './lib/component-wrapper-helpers';
 export { TrackableService } from './lib/decorators';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxnQkFBZ0IsQ0FBQztBQTRDL0IsY0FBYyxpQkFBaUIsQ0FBQztBQUVoQyxrRkFBa0Y7QUFDbEYsT0FBTyxFQUNMLG1DQUFtQyxFQUNuQyw2QkFBNkIsRUFDN0IsMkJBQTJCLEdBQzVCLE1BQU0saUNBQWlDLENBQUM7QUFDekMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBAc2lzZW5zZS9zZGstdWktYW5ndWxhclxuICovXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3Nkay11aS5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2RrLXVpLWNvcmUtZXhwb3J0cyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcyc7XG5leHBvcnQgdHlwZSB7XG4gIEFyZWFtYXBEYXRhUG9pbnRFdmVudCxcbiAgQXJlYW1hcERhdGFQb2ludEV2ZW50SGFuZGxlcixcbiAgQm94cGxvdERhdGFQb2ludEV2ZW50LFxuICBCb3hwbG90RGF0YVBvaW50RXZlbnRIYW5kbGVyLFxuICBCb3hwbG90RGF0YVBvaW50c0V2ZW50LFxuICBDYWxlbmRhckhlYXRtYXBEYXRhUG9pbnRFdmVudCxcbiAgQ2FsZW5kYXJIZWF0bWFwRGF0YVBvaW50RXZlbnRIYW5kbGVyLFxuICBDYWxlbmRhckhlYXRtYXBEYXRhUG9pbnRzRXZlbnQsXG4gIENhbGVuZGFySGVhdG1hcERhdGFQb2ludHNFdmVudEhhbmRsZXIsXG4gIENoYXJ0RGF0YVBvaW50Q2xpY2tFdmVudCxcbiAgQ2hhcnREYXRhUG9pbnRDbGlja0V2ZW50SGFuZGxlcixcbiAgQ2hhcnREYXRhUG9pbnRDb250ZXh0TWVudUV2ZW50LFxuICBDaGFydERhdGFQb2ludENvbnRleHRNZW51RXZlbnRIYW5kbGVyLFxuICBDaGFydERhdGFQb2ludHNFdmVudCxcbiAgQ2hhcnREYXRhUG9pbnRzRXZlbnRIYW5kbGVyLFxuICBEYXRhUG9pbnRFdmVudCxcbiAgRGF0YVBvaW50RXZlbnRIYW5kbGVyLFxuICBEYXRhUG9pbnRzRXZlbnQsXG4gIERhdGFQb2ludHNFdmVudEhhbmRsZXIsXG4gIEZpbHRlckNoYW5nZUV2ZW50LFxuICBGaWx0ZXJDaGFuZ2VFdmVudEhhbmRsZXIsXG4gIEZpbHRlckRlbGV0ZUV2ZW50SGFuZGxlcixcbiAgRmlsdGVyRWRpdEV2ZW50LFxuICBGaWx0ZXJFZGl0RXZlbnRIYW5kbGVyLFxuICBGaWx0ZXJzUGFuZWxDaGFuZ2VFdmVudCxcbiAgRmlsdGVyc1BhbmVsQ2hhbmdlRXZlbnRIYW5kbGVyLFxuICBJbmRpY2F0b3JEYXRhUG9pbnRFdmVudCxcbiAgSW5kaWNhdG9yRGF0YVBvaW50RXZlbnRIYW5kbGVyLFxuICBTY2F0dGVyRGF0YVBvaW50RXZlbnQsXG4gIFNjYXR0ZXJEYXRhUG9pbnRFdmVudEhhbmRsZXIsXG4gIFNjYXR0ZXJEYXRhUG9pbnRzRXZlbnQsXG4gIFNjYXR0ZXJEYXRhUG9pbnRzRXZlbnRIYW5kbGVyLFxuICBXaWRnZXREYXRhUG9pbnRDbGlja0V2ZW50SGFuZGxlcixcbiAgV2lkZ2V0RGF0YVBvaW50Q29udGV4dE1lbnVFdmVudEhhbmRsZXIsXG4gIFNjYXR0ZXJtYXBEYXRhUG9pbnRFdmVudCxcbiAgU2NhdHRlcm1hcERhdGFQb2ludEV2ZW50SGFuZGxlcixcbiAgUGl2b3RUYWJsZURhdGFQb2ludEV2ZW50LFxuICBQaXZvdFRhYmxlRGF0YVBvaW50RXZlbnRIYW5kbGVyLFxuICBXaWRnZXREYXRhUG9pbnRDbGlja0V2ZW50LFxuICBXaWRnZXREYXRhUG9pbnRDb250ZXh0TWVudUV2ZW50LFxuICBUZXh0V2lkZ2V0RGF0YVBvaW50RXZlbnQsXG59IGZyb20gJy4vbGliL3R5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3V0aWxpdGllcyc7XG5cbi8qIFJlLWV4cG9ydHMgaW50ZXJuYWwgY29yZSBmdW5jdGlvbmFsaXRpZXMgdG8gdXNlIGluIGRlcGVuZGFudCBhbmd1bGFyIG1vZHVsZXMgKi9cbmV4cG9ydCB7XG4gIGNyZWF0ZUN1c3RvbVdpZGdldHNDb250ZXh0Q29ubmVjdG9yLFxuICBjcmVhdGVTaXNlbnNlQ29udGV4dENvbm5lY3RvcixcbiAgY3JlYXRlVGhlbWVDb250ZXh0Q29ubmVjdG9yLFxufSBmcm9tICcuL2xpYi9jb21wb25lbnQtd3JhcHBlci1oZWxwZXJzJztcbmV4cG9ydCB7IFRyYWNrYWJsZVNlcnZpY2UgfSBmcm9tICcuL2xpYi9kZWNvcmF0b3JzJztcbiJdfQ==

package/dist/esm2020/version.mjs

@@ -1,2 +1,2 @@
-export default '2.17.0';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsUUFBUSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgJzIuMTcuMCciXX0=
+export default '2.18.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsUUFBUSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgJzIuMTguMCciXX0=