@sisense/sdk-ui-angular 2.20.0 → 2.22.0

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

@@ -0,0 +1,102 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { HookAdapter, useGetSharedFormulaInternal, } from '@sisense/sdk-ui-preact';
+import { createSisenseContextConnector } from '../component-wrapper-helpers';
+import { TrackableService } from '../decorators/trackable.decorator';
+import * as i0 from "@angular/core";
+import * as i1 from "./sisense-context.service";
+/**
+ * Service for working with shared formulas.
+ *
+ * @group Fusion Assets
+ * @fusionEmbed
+ */
+let FormulaService = class FormulaService {
+    constructor(sisenseContextService) {
+        this.sisenseContextService = sisenseContextService;
+    }
+    /**
+     * Fetch a [shared formula](https://docs.sisense.com/main/SisenseLinux/shared-formulas.htm) from a Fusion instance.
+     *
+     * The formula can be identified either by `oid` or by `name` and `dataSource` pair.
+     *
+     * When the retrieval is successful but the shared formula is not found, the result is `null`. When the retrieval is not successful, the promise is rejected with an error.
+     *
+     * ## Example
+     *
+     * Retrieve a shared formula by oid:
+     *
+     * ```ts
+     * try {
+     *   const formula = await formulaService.getSharedFormula({
+     *     oid: 'd61c337b-fabc-4e9e-b4cc-a30116857153',
+     *   });
+     *
+     *   if (formula) {
+     *     console.log('Formula found:', formula);
+     *   } else {
+     *     console.log('Formula not found');
+     *   }
+     * } catch (error) {
+     *   console.error('Error:', error);
+     * }
+     * ```
+     *
+     * ## Example
+     *
+     * Retrieve a shared formula by name and data source:
+     *
+     * ```ts
+     * try {
+     *   const formula = await formulaService.getSharedFormula({
+     *     name: 'My Shared Formula',
+     *     dataSource: DM.DataSource,
+     *   });
+     *
+     *   if (formula) {
+     *     console.log('Formula found:', formula);
+     *   } else {
+     *     console.log('Formula not found');
+     *   }
+     * } catch (error) {
+     *   console.error('Error:', error);
+     * }
+     * ```
+     *
+     * @param params - Parameters for retrieving the shared formula. Must include either `oid` or both `name` and `dataSource`.
+     * @returns Promise that resolves to the shared formula, or `null` if not found
+     */
+    async getSharedFormula(params) {
+        const hookAdapter = new HookAdapter(useGetSharedFormulaInternal, [
+            createSisenseContextConnector(this.sisenseContextService),
+        ]);
+        const resultPromise = new Promise((resolve, reject) => {
+            hookAdapter.subscribe((res) => {
+                const { formula, isError, isSuccess, error } = res;
+                if (isError) {
+                    reject(error);
+                }
+                else if (isSuccess) {
+                    resolve(formula ?? null);
+                }
+            });
+        });
+        hookAdapter.run(params);
+        return resultPromise.finally(() => {
+            hookAdapter.destroy();
+        });
+    }
+};
+FormulaService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FormulaService, deps: [{ token: i1.SisenseContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+FormulaService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FormulaService, providedIn: 'root' });
+FormulaService = __decorate([
+    TrackableService(['getSharedFormula'])
+], FormulaService);
+export { FormulaService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FormulaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SisenseContextService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,9 +1,10 @@
 export * from './custom-widgets.service';
 export * from './dashboard.service';
 export * from './filter.service';
+export * from './formula.service';
 export * from './hierarchy.service';
 export * from './query.service';
 export * from './sisense-context.service';
 export * from './theme.service';
 export * from './widget.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY3VzdG9tLXdpZGdldHMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2Rhc2hib2FyZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZmlsdGVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9oaWVyYXJjaHkuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3F1ZXJ5LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zaXNlbnNlLWNvbnRleHQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3RoZW1lLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi93aWRnZXQuc2VydmljZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jdXN0b20td2lkZ2V0cy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZGFzaGJvYXJkLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9maWx0ZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm11bGEuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2hpZXJhcmNoeS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcXVlcnkuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3Npc2Vuc2UtY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vdGhlbWUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3dpZGdldC5zZXJ2aWNlJztcbiJdfQ==

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

@@ -4,7 +4,7 @@ import { getWidgetModel, HookAdapter, useJtdWidget as useJtdWidgetPreact, } from
 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 { toPreactWidgetProps, toWidgetProps } 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";
@@ -137,12 +137,12 @@ let WidgetService = class WidgetService {
             createThemeContextConnector(this.themeService),
         ]);
         // Convert Angular props to preact props
-        const preactProps = translateToPreactWidgetProps(widgetProps);
+        const preactProps = toPreactWidgetProps(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);
+                const angularProps = toWidgetProps(enhancedPreactProps);
                 enhancedProps$.next(angularProps);
             }
             else {
@@ -178,4 +178,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     providedIn: 'root',
                 }]
         }], 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":"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","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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget.service.js","sourceRoot":"","sources":["../../../../src/lib/services/widget.service.ts"],"names":[],"mappings":"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","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 { toPreactWidgetProps, toWidgetProps } 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 = toPreactWidgetProps(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 = toWidgetProps(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/custom-widget-component-props.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,6 +1,7 @@
 export * from './chart-event-props';
+export * from './custom-widget-component-props';
 export * from './data-point';
 export * from './filter-event-props';
 export * from './utility-types';
 export * from './widget-event-props';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3R5cGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NoYXJ0LWV2ZW50LXByb3BzJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YS1wb2ludCc7XG5leHBvcnQgKiBmcm9tICcuL2ZpbHRlci1ldmVudC1wcm9wcyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxpdHktdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi93aWRnZXQtZXZlbnQtcHJvcHMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3R5cGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxzQkFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2hhcnQtZXZlbnQtcHJvcHMnO1xuZXhwb3J0ICogZnJvbSAnLi9jdXN0b20td2lkZ2V0LWNvbXBvbmVudC1wcm9wcyc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGEtcG9pbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9maWx0ZXItZXZlbnQtcHJvcHMnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlsaXR5LXR5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vd2lkZ2V0LWV2ZW50LXByb3BzJztcbiJdfQ==

package/dist/esm2020/lib/utilities/dashboard-helpers.mjs

@@ -1,4 +1,5 @@
-import { dashboardHelpers as dashboardHelpersPreact, } from '@sisense/sdk-ui-preact';
+import { dashboardHelpers as dashboardHelpersPreact } from '@sisense/sdk-ui-preact';
+import { toDashboardProps, toPreactDashboardProps, } from '../helpers/dashboard-props-preact-translator';
 /**
  * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilters}
  *
@@ -14,7 +15,7 @@ import { dashboardHelpers as dashboardHelpersPreact, } from '@sisense/sdk-ui-pre
  * @returns A new dashboard instance with the updated filters.
  */
 export const replaceFilters = (dashboard, newFilters) => {
-    return dashboardHelpersPreact.replaceFilters(dashboard, newFilters);
+    return toDashboardProps(dashboardHelpersPreact.replaceFilters(toPreactDashboardProps(dashboard), newFilters));
 };
 /**
  * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.addFilter}
@@ -31,7 +32,7 @@ export const replaceFilters = (dashboard, newFilters) => {
  * @returns A new dashboard instance with the new filter added.
  */
 export const addFilter = (dashboard, newFilter) => {
-    return dashboardHelpersPreact.addFilter(dashboard, newFilter);
+    return toDashboardProps(dashboardHelpersPreact.addFilter(toPreactDashboardProps(dashboard), newFilter));
 };
 /**
  * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.addFilters}
@@ -48,7 +49,7 @@ export const addFilter = (dashboard, newFilter) => {
  * @returns A new dashboard instance with the new filters added.
  */
 export const addFilters = (dashboard, newFilters) => {
-    return dashboardHelpersPreact.addFilters(dashboard, newFilters);
+    return toDashboardProps(dashboardHelpersPreact.addFilters(toPreactDashboardProps(dashboard), newFilters));
 };
 /**
  * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilter}
@@ -67,7 +68,7 @@ export const addFilters = (dashboard, newFilters) => {
  * @returns A new dashboard instance with the specified filter replaced.
  */
 export const replaceFilter = (dashboard, filterToReplace, newFilter) => {
-    return dashboardHelpersPreact.replaceFilter(dashboard, filterToReplace, newFilter);
+    return toDashboardProps(dashboardHelpersPreact.replaceFilter(toPreactDashboardProps(dashboard), filterToReplace, newFilter));
 };
 /**
  * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilter}
@@ -84,7 +85,7 @@ export const replaceFilter = (dashboard, filterToReplace, newFilter) => {
  * @returns A new dashboard instance with the specified filter removed.
  */
 export const removeFilter = (dashboard, filterToRemove) => {
-    return dashboardHelpersPreact.removeFilter(dashboard, filterToRemove);
+    return toDashboardProps(dashboardHelpersPreact.removeFilter(toPreactDashboardProps(dashboard), filterToRemove));
 };
 /**
  * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilters}
@@ -101,6 +102,6 @@ export const removeFilter = (dashboard, filterToRemove) => {
  * @returns A new dashboard instance with the specified filters removed.
  */
 export const removeFilters = (dashboard, filtersToRemove) => {
-    return dashboardHelpersPreact.removeFilters(dashboard, filtersToRemove);
+    return toDashboardProps(dashboardHelpersPreact.removeFilters(toPreactDashboardProps(dashboard), filtersToRemove));
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard-helpers.js","sourceRoot":"","sources":["../../../../src/lib/utilities/dashboard-helpers.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,IAAI,sBAAsB,GAE3C,MAAM,wBAAwB,CAAC;AAIhC;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,SAAyB,EACzB,UAAsC,EACtB,EAAE;IAClB,OAAO,sBAAsB,CAAC,cAAc,CAAC,SAAiC,EAAE,UAAU,CAAC,CAAC;AAC9F,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,SAAyB,EAAE,SAAiB,EAAkB,EAAE;IACxF,OAAO,sBAAsB,CAAC,SAAS,CAAC,SAAiC,EAAE,SAAS,CAAC,CAAC;AACxF,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,SAAyB,EAAE,UAAoB,EAAkB,EAAE;IAC5F,OAAO,sBAAsB,CAAC,UAAU,CAAC,SAAiC,EAAE,UAAU,CAAC,CAAC;AAC1F,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,SAAyB,EACzB,eAAuB,EACvB,SAAiB,EACD,EAAE;IAClB,OAAO,sBAAsB,CAAC,aAAa,CACzC,SAAiC,EACjC,eAAe,EACf,SAAS,CACV,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,SAAyB,EAAE,cAAsB,EAAkB,EAAE;IAChG,OAAO,sBAAsB,CAAC,YAAY,CAAC,SAAiC,EAAE,cAAc,CAAC,CAAC;AAChG,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,SAAyB,EACzB,eAAyB,EACT,EAAE;IAClB,OAAO,sBAAsB,CAAC,aAAa,CAAC,SAAiC,EAAE,eAAe,CAAC,CAAC;AAClG,CAAC,CAAC","sourcesContent":["import { Filter, FilterRelations } from '@sisense/sdk-data';\nimport {\n  dashboardHelpers as dashboardHelpersPreact,\n  type DashboardProps as DashboardPropsPreact,\n} from '@sisense/sdk-ui-preact';\n\nimport { DashboardProps } from '../components';\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilters}\n *\n * @example\n * Replace all filters on a dashboard with a new set of filters.\n * ```ts\n * const existingDashboard: DashboardProps = {...}\n * const newFilters: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.replaceFilters(existingDashboard, newFilters);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) whose filters are to be replaced.\n * @param newFilters - An array of new filters or filter relations to set on the dashboard.\n * @returns A new dashboard instance with the updated filters.\n */\nexport const replaceFilters = (\n  dashboard: DashboardProps,\n  newFilters: Filter[] | FilterRelations,\n): DashboardProps => {\n  return dashboardHelpersPreact.replaceFilters(dashboard as DashboardPropsPreact, newFilters);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.addFilter}\n *\n * @example\n * Add a new filter to a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const newFilter: Filter = {...};\n * const updatedDashboard = dashboardHelpers.addFilter(existingDashboard, newFilter);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) to which the filter will be added.\n * @param newFilter - The filter to add to the dashboard.\n * @returns A new dashboard instance with the new filter added.\n */\nexport const addFilter = (dashboard: DashboardProps, newFilter: Filter): DashboardProps => {\n  return dashboardHelpersPreact.addFilter(dashboard as DashboardPropsPreact, newFilter);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.addFilters}\n *\n * @example\n * Add multiple new filters to a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const newFilters: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.addFilters(existingDashboard, newFilters);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) to which the filters will be added.\n * @param newFilters - An array of filters to add to the dashboard.\n * @returns A new dashboard instance with the new filters added.\n */\nexport const addFilters = (dashboard: DashboardProps, newFilters: Filter[]): DashboardProps => {\n  return dashboardHelpersPreact.addFilters(dashboard as DashboardPropsPreact, newFilters);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilter}\n *\n * @example\n * Replace a filter in a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filterToReplace: Filter = {...};\n * const newFilter: Filter = {...};\n * const updatedDashboard = dashboardHelpers.replaceFilter(existingDashboard, filterToReplace, newFilter);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) containing the filter to be replaced.\n * @param filterToReplace - The existing filter to be replaced.\n * @param newFilter - The new filter to replace the existing one.\n * @returns A new dashboard instance with the specified filter replaced.\n */\nexport const replaceFilter = (\n  dashboard: DashboardProps,\n  filterToReplace: Filter,\n  newFilter: Filter,\n): DashboardProps => {\n  return dashboardHelpersPreact.replaceFilter(\n    dashboard as DashboardPropsPreact,\n    filterToReplace,\n    newFilter,\n  );\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilter}\n *\n * @example\n * Remove a filter from a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filterToRemove: Filter = {...};\n * const updatedDashboard = dashboardHelpers.removeFilter(existingDashboard, filterToRemove);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) from which to remove the filter.\n * @param filterToRemove - The filter to be removed.\n * @returns A new dashboard instance with the specified filter removed.\n */\nexport const removeFilter = (dashboard: DashboardProps, filterToRemove: Filter): DashboardProps => {\n  return dashboardHelpersPreact.removeFilter(dashboard as DashboardPropsPreact, filterToRemove);\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilters}\n *\n * @example\n * Remove multiple filters from a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filtersToRemove: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.removeFilters(existingDashboard, filtersToRemove);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) from which the specified filters are removed.\n * @param filtersToRemove - An array of filters to remove.\n * @returns A new dashboard instance with the specified filters removed.\n */\nexport const removeFilters = (\n  dashboard: DashboardProps,\n  filtersToRemove: Filter[],\n): DashboardProps => {\n  return dashboardHelpersPreact.removeFilters(dashboard as DashboardPropsPreact, filtersToRemove);\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard-helpers.js","sourceRoot":"","sources":["../../../../src/lib/utilities/dashboard-helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,IAAI,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAGpF,OAAO,EACL,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,8CAA8C,CAAC;AAEtD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,SAAyB,EACzB,UAAsC,EACtB,EAAE;IAClB,OAAO,gBAAgB,CACrB,sBAAsB,CAAC,cAAc,CAAC,sBAAsB,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,CACrF,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,SAAyB,EAAE,SAAiB,EAAkB,EAAE;IACxF,OAAO,gBAAgB,CACrB,sBAAsB,CAAC,SAAS,CAAC,sBAAsB,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC,CAC/E,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,SAAyB,EAAE,UAAoB,EAAkB,EAAE;IAC5F,OAAO,gBAAgB,CACrB,sBAAsB,CAAC,UAAU,CAAC,sBAAsB,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,CACjF,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,SAAyB,EACzB,eAAuB,EACvB,SAAiB,EACD,EAAE;IAClB,OAAO,gBAAgB,CACrB,sBAAsB,CAAC,aAAa,CAClC,sBAAsB,CAAC,SAAS,CAAC,EACjC,eAAe,EACf,SAAS,CACV,CACF,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,SAAyB,EAAE,cAAsB,EAAkB,EAAE;IAChG,OAAO,gBAAgB,CACrB,sBAAsB,CAAC,YAAY,CAAC,sBAAsB,CAAC,SAAS,CAAC,EAAE,cAAc,CAAC,CACvF,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAC3B,SAAyB,EACzB,eAAyB,EACT,EAAE;IAClB,OAAO,gBAAgB,CACrB,sBAAsB,CAAC,aAAa,CAAC,sBAAsB,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC,CACzF,CAAC;AACJ,CAAC,CAAC","sourcesContent":["import { Filter, FilterRelations } from '@sisense/sdk-data';\nimport { dashboardHelpers as dashboardHelpersPreact } from '@sisense/sdk-ui-preact';\n\nimport { DashboardProps } from '../components';\nimport {\n  toDashboardProps,\n  toPreactDashboardProps,\n} from '../helpers/dashboard-props-preact-translator';\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilters}\n *\n * @example\n * Replace all filters on a dashboard with a new set of filters.\n * ```ts\n * const existingDashboard: DashboardProps = {...}\n * const newFilters: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.replaceFilters(existingDashboard, newFilters);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) whose filters are to be replaced.\n * @param newFilters - An array of new filters or filter relations to set on the dashboard.\n * @returns A new dashboard instance with the updated filters.\n */\nexport const replaceFilters = (\n  dashboard: DashboardProps,\n  newFilters: Filter[] | FilterRelations,\n): DashboardProps => {\n  return toDashboardProps(\n    dashboardHelpersPreact.replaceFilters(toPreactDashboardProps(dashboard), newFilters),\n  );\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.addFilter}\n *\n * @example\n * Add a new filter to a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const newFilter: Filter = {...};\n * const updatedDashboard = dashboardHelpers.addFilter(existingDashboard, newFilter);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) to which the filter will be added.\n * @param newFilter - The filter to add to the dashboard.\n * @returns A new dashboard instance with the new filter added.\n */\nexport const addFilter = (dashboard: DashboardProps, newFilter: Filter): DashboardProps => {\n  return toDashboardProps(\n    dashboardHelpersPreact.addFilter(toPreactDashboardProps(dashboard), newFilter),\n  );\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.addFilters}\n *\n * @example\n * Add multiple new filters to a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const newFilters: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.addFilters(existingDashboard, newFilters);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) to which the filters will be added.\n * @param newFilters - An array of filters to add to the dashboard.\n * @returns A new dashboard instance with the new filters added.\n */\nexport const addFilters = (dashboard: DashboardProps, newFilters: Filter[]): DashboardProps => {\n  return toDashboardProps(\n    dashboardHelpersPreact.addFilters(toPreactDashboardProps(dashboard), newFilters),\n  );\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.replaceFilter}\n *\n * @example\n * Replace a filter in a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filterToReplace: Filter = {...};\n * const newFilter: Filter = {...};\n * const updatedDashboard = dashboardHelpers.replaceFilter(existingDashboard, filterToReplace, newFilter);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) containing the filter to be replaced.\n * @param filterToReplace - The existing filter to be replaced.\n * @param newFilter - The new filter to replace the existing one.\n * @returns A new dashboard instance with the specified filter replaced.\n */\nexport const replaceFilter = (\n  dashboard: DashboardProps,\n  filterToReplace: Filter,\n  newFilter: Filter,\n): DashboardProps => {\n  return toDashboardProps(\n    dashboardHelpersPreact.replaceFilter(\n      toPreactDashboardProps(dashboard),\n      filterToReplace,\n      newFilter,\n    ),\n  );\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilter}\n *\n * @example\n * Remove a filter from a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filterToRemove: Filter = {...};\n * const updatedDashboard = dashboardHelpers.removeFilter(existingDashboard, filterToRemove);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) from which to remove the filter.\n * @param filterToRemove - The filter to be removed.\n * @returns A new dashboard instance with the specified filter removed.\n */\nexport const removeFilter = (dashboard: DashboardProps, filterToRemove: Filter): DashboardProps => {\n  return toDashboardProps(\n    dashboardHelpersPreact.removeFilter(toPreactDashboardProps(dashboard), filterToRemove),\n  );\n};\n\n/**\n * {@inheritDoc @sisense/sdk-ui!dashboardHelpers.removeFilters}\n *\n * @example\n * Remove multiple filters from a dashboard.\n * ```ts\n * const existingDashboard: DashboardProps = {...};\n * const filtersToRemove: Filter[] = [{...}, {...}, ...];\n * const updatedDashboard = dashboardHelpers.removeFilters(existingDashboard, filtersToRemove);\n * ```\n * @param dashboard - The original dashboard (`DashboardProps`) from which the specified filters are removed.\n * @param filtersToRemove - An array of filters to remove.\n * @returns A new dashboard instance with the specified filters removed.\n */\nexport const removeFilters = (\n  dashboard: DashboardProps,\n  filtersToRemove: Filter[],\n): DashboardProps => {\n  return toDashboardProps(\n    dashboardHelpersPreact.removeFilters(toPreactDashboardProps(dashboard), filtersToRemove),\n  );\n};\n"]}

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

@@ -1,4 +1,5 @@
 import { dashboardModelTranslator as dashboardModelTranslatorPreact, } from '@sisense/sdk-ui-preact';
+import * as fromPreact from '../helpers/dashboard-props-preact-translator';
 /**
  * Translates {@link DashboardModel} to {@link DashboardProps}.
  *
@@ -44,6 +45,6 @@ export class DashboardComponent {
  * ```
  */
 export function toDashboardProps(dashboardModel) {
-    return dashboardModelTranslatorPreact.toDashboardProps(dashboardModel);
+    return fromPreact.toDashboardProps(dashboardModelTranslatorPreact.toDashboardProps(dashboardModel));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,4 +1,6 @@
 import { widgetModelTranslator as widgetModelTranslatorPreact, } from '@sisense/sdk-ui-preact';
+import * as fromPreactChart from '../helpers/chart-props-preact-translator';
+import * as fromPreactWidget from '../helpers/widget-props-preact-translator';
 /**
  * Translates a {@link WidgetModel} to the parameters for executing a query for the widget.
  *
@@ -85,7 +87,7 @@ export class ExampleComponent {
  * Use {@link toPivotTableProps} instead for getting props for the {@link PivotTableComponent}.
  */
 export function toChartProps(widgetModel) {
-    return widgetModelTranslatorPreact.toChartProps(widgetModel);
+    return fromPreactChart.toChartProps(widgetModelTranslatorPreact.toChartProps(widgetModel));
 }
 /**
  * Translates a {@link WidgetModel} to the props for rendering a table.
@@ -134,7 +136,7 @@ export class ExampleComponent {
  * Use {@link toPivotTableProps} instead for getting props for the {@link PivotTableComponent}.
  */
 export function toTableProps(widgetModel) {
-    return widgetModelTranslatorPreact.toTableProps(widgetModel);
+    return fromPreactChart.toTableProps(widgetModelTranslatorPreact.toTableProps(widgetModel));
 }
 /**
  * Translates a {@link WidgetModel} to the props for rendering a pivot table.
@@ -183,7 +185,7 @@ export class ExampleComponent {
  * Use {@link toTableProps} instead for getting props for the {@link TableComponent}.
  */
 export function toPivotTableProps(widgetModel) {
-    return widgetModelTranslatorPreact.toPivotTableProps(widgetModel);
+    return fromPreactChart.toPivotTableProps(widgetModelTranslatorPreact.toPivotTableProps(widgetModel));
 }
 /**
  * Translates a {@link WidgetModel} to the props for rendering a chart widget.
@@ -232,7 +234,7 @@ export class ExampleComponent {
  * Note: this method is not supported for pivot widgets.
  */
 export function toChartWidgetProps(widgetModel) {
-    return widgetModelTranslatorPreact.toChartWidgetProps(widgetModel);
+    return fromPreactWidget.toChartWidgetProps(widgetModelTranslatorPreact.toChartWidgetProps(widgetModel));
 }
 /**
  * Translates a {@link WidgetModel} to the props for rendering a pivot table widget.
@@ -280,7 +282,7 @@ export class ExampleComponent {
  * Use {@link toChartWidgetProps} instead for getting props for the {@link ChartWidgetComponent}.
  */
 export function toPivotTableWidgetProps(widgetModel) {
-    return widgetModelTranslatorPreact.toPivotTableWidgetProps(widgetModel);
+    return fromPreactWidget.toPivotTableWidgetProps(widgetModelTranslatorPreact.toPivotTableWidgetProps(widgetModel));
 }
 /**
  * Translates a {@link WidgetModel} to the props for rendering a text widget.
@@ -299,7 +301,7 @@ const textWidgetProps = widgetModelTranslator.toTextWidgetProps(widgetModel);
  * Use {@link toPivotTableWidgetProps} instead for getting props for the pivot table widget.
  */
 export function toTextWidgetProps(widgetModel) {
-    return widgetModelTranslatorPreact.toTextWidgetProps(widgetModel);
+    return fromPreactWidget.toTextWidgetProps(widgetModelTranslatorPreact.toTextWidgetProps(widgetModel));
 }
 /**
  * Translates {@link WidgetModel} to {@link WidgetProps}.
@@ -350,6 +352,6 @@ export function toTextWidgetProps(widgetModel) {
  * ```
  */
 export function toWidgetProps(widgetModel) {
-    return widgetModelTranslatorPreact.toWidgetProps(widgetModel);
+    return fromPreactWidget.toWidgetProps(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"]}
+//# 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;AAWhC,OAAO,KAAK,eAAe,MAAM,0CAA0C,CAAC;AAC5E,OAAO,KAAK,gBAAgB,MAAM,2CAA2C,CAAC;AAG9E;;;;;;;;;;;;;;;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,eAAe,CAAC,YAAY,CAAC,2BAA2B,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC;AAC7F,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,YAAY,CAAC,WAAwB;IACnD,OAAO,eAAe,CAAC,YAAY,CAAC,2BAA2B,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC;AAC7F,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAAwB;IACxD,OAAO,eAAe,CAAC,iBAAiB,CACtC,2BAA2B,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAC3D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,kBAAkB,CAAC,WAAwB;IACzD,OAAO,gBAAgB,CAAC,kBAAkB,CACxC,2BAA2B,CAAC,kBAAkB,CAAC,WAAW,CAAC,CAC5D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,UAAU,uBAAuB,CAAC,WAAwB;IAC9D,OAAO,gBAAgB,CAAC,uBAAuB,CAC7C,2BAA2B,CAAC,uBAAuB,CAAC,WAAW,CAAC,CACjE,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAAwB;IACxD,OAAO,gBAAgB,CAAC,iBAAiB,CACvC,2BAA2B,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAC3D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,UAAU,aAAa,CAAC,WAAwB;IACpD,OAAO,gBAAgB,CAAC,aAAa,CAAC,2BAA2B,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC;AAChG,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 * as fromPreactChart from '../helpers/chart-props-preact-translator';\nimport * as fromPreactWidget from '../helpers/widget-props-preact-translator';\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 fromPreactChart.toChartProps(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 fromPreactChart.toTableProps(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 fromPreactChart.toPivotTableProps(\n    widgetModelTranslatorPreact.toPivotTableProps(widgetModel),\n  );\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 fromPreactWidget.toChartWidgetProps(\n    widgetModelTranslatorPreact.toChartWidgetProps(widgetModel),\n  );\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 fromPreactWidget.toPivotTableWidgetProps(\n    widgetModelTranslatorPreact.toPivotTableWidgetProps(widgetModel),\n  );\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 fromPreactWidget.toTextWidgetProps(\n    widgetModelTranslatorPreact.toTextWidgetProps(widgetModel),\n  );\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 fromPreactWidget.toWidgetProps(widgetModelTranslatorPreact.toWidgetProps(widgetModel));\n}\n"]}

package/dist/esm2020/version.mjs

@@ -1,2 +1,2 @@
-export default '2.20.0';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsUUFBUSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgJzIuMjAuMCciXX0=
+export default '2.22.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsUUFBUSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQgJzIuMjIuMCciXX0=