@sisense/sdk-ui 2.4.1 → 2.6.0

package/dist/packages/sdk-ui/src/analytics-composer/common/utils.d.ts

@@ -29,3 +29,21 @@ export declare function isNonEmptyArray<T>(array: T[]): boolean;
  * @returns The modified string with the first empty line removed if the next line contains "import *" or "import {". If no such condition is met, the input remains unchanged.
  */
 export declare function removeEmptyLineBeforeImport(input: string): string;
+/**
+ * Returns a new object where any "unsafe" keys (i.e., keys that contain
+ * characters not allowed in JavaScript dot notation — such as spaces, slashes, dashes, etc.)
+ * are wrapped in double quotes.
+ *
+ * If the object contains a `composeCode` field, it is returned as-is without modification.
+ *
+ * Safe keys (valid JS identifiers) are left unchanged.
+ *
+ * @param obj - The input object with arbitrary string keys
+ * @returns A new object with the same values, but with unsafe keys wrapped in quotes,
+ *          unless the object has a `composeCode` field
+ *
+ * @example
+ * quoteUnsafeKeys({ "user-id": true, normalKey: 42 })
+ * // => { '"user-id"': true, normalKey: 42 }
+ */
+export declare function quoteUnsafeKeys<T extends Record<string, any>>(obj: T): Record<string, any>;

package/dist/packages/sdk-ui/src/api/types/dashboard-dto.d.ts

@@ -11,6 +11,10 @@ export type LayoutDto = {
                 elements: {
                     height: number | string;
                     widgetid: string;
+                    minWidth: number;
+                    maxWidth: number;
+                    minHeight: number;
+                    maxHeight: number;
                 }[];
             }[];
         }[];

package/dist/packages/sdk-ui/src/app/client-application.d.ts

@@ -110,18 +110,37 @@ export type AppConfig = {
         onTrackingEvent?: (payload: TrackingEventDetails) => void;
     };
     /**
-     * Configuration of the jump to dashboard feature
-     * Only the widgets with pre-configured JTD config will support this feature.
-     * You can configure the JTD config in the widget settings in Fusion UI having jump to dashboard plugin enabled.
+     * Configuration of the Jump to Dashboard feature
+     *
+     * This feature is currently in Beta.
+     *
+     * **Note:** Only widgets that are configured using the Fusion UI as documented
+     * [here](https://docs.sisense.com/main/SisenseLinux/jump-to-dashboard.htm?tocpath=Add-ons%7C_____2#ConfiguringJTDPerWidget)
+     * are supported in Compose SDK.
+     *
+     * Widgets that are configured using an older version of Jump To Dashboard, or via scripts, are not supported.
+     *
+     * Known limitations:
+     * - Jump To Dashboard is not currently supported for Pivot widgets.
+     * - Target dashboards are always opened in a popup window, options to open in new tab and new window are not supported.
+     * - Show 'Header' and 'Dashboards panel' options are not supported (only relevant to Fusion).
+     * - 'Reset filters after JTD' is not supported, since changes are never saved to the target dashboard using Compose SDK.
+     *
+     * The following Jump To Dashboard configuration is supported:
+     *   - Target dashboard set by Id, with configurable display title
+     *   - 'Popup window' display type ('Allow Resize' not supported)
+     *   - Display filter panel on the target dashboard (true/false)
+     *   - Navigation setting (Click / Right click)
+     *     - Note: 'Keep changes made by user' is not supported, since changes are never saved to the target dashboard using Compose SDK.
+     *   - Apply filters to the target dashboard (select)
+     *   - Merge target dashboard filters (true/false)
      *
-     * This feature is currently in alpha.
-     * To learn more about the jump to dashboard feature, see the [Jump to Dashboard documentation](https://docs.sisense.com/main/SisenseLinux/jump-to-dashboard.htm?tocpath=Add-ons%7C_____2#ConfiguringJTDPerWidget).
      */
     jumpToDashboardConfig?: {
         /**
          * Whether to enable or disable the jump to dashboard feature
          *
-         * If not specified, the default value is `false`
+         * If not specified, the default value is `true`
          */
         enabled?: boolean;
     };
@@ -162,7 +181,7 @@ export interface ClientApplication {
         clear: () => void;
     };
 }
-type ClientApplicationParams = Pick<SisenseContextProviderProps, 'appConfig' | 'defaultDataSource' | 'url' | 'token' | 'wat' | 'ssoEnabled' | 'enableSilentPreAuth' | 'useFusionAuth'>;
+type ClientApplicationParams = Pick<SisenseContextProviderProps, 'appConfig' | 'defaultDataSource' | 'url' | 'token' | 'wat' | 'ssoEnabled' | 'enableSilentPreAuth' | 'useFusionAuth' | 'alternativeSsoHost'>;
 /** @internal */
-export declare const createClientApplication: ({ defaultDataSource, url: rawUrl, token, wat, ssoEnabled, appConfig, enableSilentPreAuth, useFusionAuth, }: ClientApplicationParams) => Promise<ClientApplication>;
+export declare const createClientApplication: ({ defaultDataSource, url: rawUrl, token, wat, ssoEnabled, appConfig, enableSilentPreAuth, useFusionAuth, alternativeSsoHost, }: ClientApplicationParams) => Promise<ClientApplication>;
 export {};

package/dist/packages/sdk-ui/src/chart/advanced-chart.d.ts

@@ -4,4 +4,4 @@ import { RegularChartProps } from '../props.js';
  * @param props
  * @returns
  */
-export declare const AdvancedChart: (props: RegularChartProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const AdvancedChart: (props: RegularChartProps) => import("react/jsx-runtime").JSX.Element;

package/dist/packages/sdk-ui/src/chart/restructured-charts/highchart-based-charts/highcharts-based-chart-renderer/highcharts-based-chart-renderer.d.ts

@@ -12,6 +12,10 @@ export type HighchartsBasedChartRendererProps<CT extends HighchartBasedChartType
     onDataPointContextMenu?: SisenseChartDataPointEventHandler;
     onDataPointsSelected?: SisenseChartDataPointsEventHandler;
     onBeforeRender?: BeforeRenderHandler;
+    size?: {
+        width?: number;
+        height?: number;
+    };
 };
 /**
  * Creates a specific highcharts based chart renderer component

package/dist/packages/sdk-ui/src/chart-data-options/types.d.ts

@@ -58,6 +58,10 @@ export interface CategoryStyle {
     width?: number;
     /** {@inheritDoc DataColorOptions} */
     color?: DataColorOptions;
+    /**
+     * Name of the column.
+     */
+    name?: string;
 }
 /**
  * Wrapped {@link @sisense/sdk-data!Column | Column} with styles controlling how the column is visualized in a chart.
@@ -157,6 +161,10 @@ export type ValueStyle = {
      * @internal
      */
     width?: number;
+    /**
+     * Name of the measure.
+     */
+    name?: string;
 };
 /**
  * Specific style options to be applied to specific series in Chart.

package/dist/packages/sdk-ui/src/chart-data-options/utils.d.ts

@@ -34,7 +34,14 @@ export declare const splitColumn: <C extends AnyColumn>(targetColumn: C) => {
  * @internal
  */
 export declare function isMeasureColumn(arg: AnyColumn): arg is MeasureColumn | CalculatedMeasureColumn | StyledMeasureColumn;
-export declare const getDataOptionTitle: ({ column }: StyledColumn | StyledMeasureColumn) => string;
+/**
+ * Returns the title of a column (data option).
+ *
+ * @param column - The column to get the title of.
+ * @param name - The name of the column.
+ * @returns The title of the column.
+ */
+export declare const getDataOptionTitle: ({ column, name }: StyledColumn | StyledMeasureColumn) => string;
 export declare const getDataOptionGranularity: ({ column, granularity }: StyledColumn) => string;
 /** @internal */
 export declare const translateColumnToAttribute: (c: Column | StyledColumn) => Attribute;

package/dist/packages/sdk-ui/src/common/components/modal/index.d.ts

@@ -1,2 +1,2 @@
-export { useModal, ModalContext, useModalContext, type ModalOptions, type ModalInstance, } from './modal-context';
+export { ModalContext, useModalContext, type ModalOptions, type ModalInstance, } from './modal-context';
 export { ModalProvider, ModalTreeRootProvider, ModalTreeNodeProvider } from './modal-provider';

package/dist/packages/sdk-ui/src/common/components/modal/modal-context.d.ts

@@ -30,10 +30,4 @@ export declare const ModalContext: import("react").Context<ModalSettings | null>
  * @internal
  */
 export declare const useModalContext: () => ModalSettings | null;
-/**
- * Hook to use modal functionality
- *
- * @returns Modal API functions
- */
-export declare const useModal: () => ModalSettings;
 export {};

package/dist/packages/sdk-ui/src/common/hooks/use-modal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hook to access modal API.
+ *
+ * Throws an error if used outside the modal context.
+ *
+ * @internal
+ */
+export declare const useModal: () => {
+    openModal: import("../components/modal/modal-context").OpenModalFn;
+    closeModal: import("../components/modal/modal-context").CloseModalFn;
+    closeAllModals: () => void;
+    getModalStack: () => import('../../common/components/modal').ModalInstance[];
+    isModalOpen: (modalId: string) => boolean;
+};

package/dist/packages/sdk-ui/src/common/icons/jtd-jumpable-icon.d.ts

@@ -0,0 +1 @@
+export declare const JtdJumpableIcon: () => import("react/jsx-runtime").JSX.Element;

package/dist/packages/sdk-ui/src/dashboard/components/editable-layout/components/resizable-columns.d.ts

@@ -14,9 +14,13 @@ interface ResizableColumnsProps {
      */
     widths: number[];
     /**
-     * The minimum width of the columns (in percentage)
+     * The minimum width of the columns (in pixels)
      */
-    minColWidth: number;
+    minColWidths?: number[];
+    /**
+     * The maximum width of the columns (in pixels)
+     */
+    maxColWidths?: number[];
     /**
      * The callback function to call when the widths change
      */
@@ -27,5 +31,5 @@ interface ResizableColumnsProps {
  *
  * @internal
  */
-export declare const ResizableColumns: ({ children, widths, minColWidth, onWidthsChange, }: ResizableColumnsProps) => import("react/jsx-runtime").JSX.Element;
+export declare const ResizableColumns: ({ children, widths, minColWidths, maxColWidths, onWidthsChange, }: ResizableColumnsProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/packages/sdk-ui/src/dashboard/components/editable-layout/const.d.ts

@@ -1,9 +1,9 @@
 export declare const RESIZE_LINE_SIZE = 4;
-export declare const MIN_COL_WIDTH_PERCENTAGE = 10;
-export declare const MIN_CELL_WIDTH_PERCENTAGE = 5;
 export declare const MIN_ROW_HEIGHT = 60;
 export declare const MAX_ROW_HEIGHT = 1500;
 export declare const WIDGET_HEADER_HEIGHT = 32;
+export declare const MIN_COLUMN_WIDTH = 128;
+export declare const MAX_COLUMN_WIDTH = 2048;
 export declare const Z_INDEX_RESIZE_OVERLAY = 100;
 export declare const Z_INDEX_RESIZE_LINE = 101;
 export declare const Z_INDEX_CELL_DROPZONE = 102;

package/dist/packages/sdk-ui/src/dashboard/components/editable-layout/helpers.d.ts

@@ -1,5 +1,6 @@
 import { WidgetsPanelColumn, WidgetsPanelColumnLayout, WidgetsPanelLayout, WidgetsPanelRow } from '../../../models';
 import { EditableLayoutDropData, EditableLayoutDragData } from './types';
+import { WidgetProps } from '../../../index-typedoc';
 /**
  * Updates the height of all cells in a specific row within a column layout.
  *
@@ -96,3 +97,8 @@ export declare const distributeEqualWidthInRow: (layout: WidgetsPanelLayout, col
  * @internal
  */
 export declare function updateLayoutAfterDragAndDrop(layout: WidgetsPanelLayout, dragData: EditableLayoutDragData, dropData: EditableLayoutDropData): WidgetsPanelColumnLayout;
+export declare function getRowHeight(row: WidgetsPanelRow, widgets: WidgetProps[]): number;
+export declare function getRowMaxHeight(row: WidgetsPanelRow): number;
+export declare function getRowMinHeight(row: WidgetsPanelRow): number;
+export declare function getColumnMinWidths(row: WidgetsPanelRow): number[];
+export declare function getColumnMaxWidths(row: WidgetsPanelRow): number[];

package/dist/packages/sdk-ui/src/dashboard/components/jtd-dashboard.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="react" />
 import { type Filter } from '@sisense/sdk-data';
-interface JTDDashboardProps {
+interface JtdDashboardProps {
     dashboardOid: string;
     filters: Filter[];
     mergeTargetDashboardFilters: boolean;
@@ -11,5 +12,5 @@ interface JTDDashboardProps {
  * This component reuses DashboardById logic but is specifically designed for JTD use cases
  * @internal
  */
-export declare const JTDDashboard: ({ dashboardOid, filters: runtimeFilters, mergeTargetDashboardFilters, displayToolbarRow, displayFilterPane, }: JTDDashboardProps) => import("react/jsx-runtime").JSX.Element;
+export declare const JtdDashboard: import("react").FunctionComponent<JtdDashboardProps>;
 export {};

package/dist/packages/sdk-ui/src/dashboard/hooks/jtd/index.d.ts

@@ -0,0 +1,5 @@
+export { getFiltersFromDataPoint, getFormulaContextFilters, filterByAllowedDimensions, handleFormulaDuplicateFilters, mergeJtdFilters, } from './jtd-filters';
+export { getJtdClickHandler, getJtdClickHandlerForMultiplePoints, handleDataPointClick, handleTextWidgetClick, } from './jtd-handlers';
+export { getJumpToDashboardMenuItem, getJumpToDashboardMenuItemForMultiplePoints, } from './jtd-menu';
+export { addPointerCursorToChart, applyClickNavigationForChart, applyClickNavigationForText, applyRightClickNavigation, addJtdIconToHeader, } from './jtd-widget-transforms';
+export { type JtdCoreData, type JtdContext, type JtdActions, type JtdClickHandlerData, type JtdWidgetTransformConfig, type JtdDataPointClickEvent, type JtdMenuItem, } from './jtd-types';

package/dist/packages/sdk-ui/src/dashboard/hooks/jtd/jtd-filters.d.ts

@@ -0,0 +1,129 @@
+import { type Filter } from '@sisense/sdk-data';
+import { WidgetProps } from '../../../props.js';
+import { DataPoint, ScatterDataPoint } from '../../../types';
+import { JtdConfig } from '../../../widget-by-id/types';
+/**
+ * Jump to Dashboard (JTD) Filter Merging Logic:
+ *
+ * When a user clicks on a datapoint to open a JTD modal, multiple types of filters are merged:
+ *
+ * 1. **Generated Filters**: Created from the clicked datapoint's category and breakBy entries
+ * 2. **Dashboard Filters**: Current dashboard filters (filtered by includeDashFilterDims)
+ * 3. **Widget Filters**: Original widget-specific filters (filtered by includeWidgetFilterDims)
+ * 4. **Formula Context Filters**: NEW - Embedded filters from the clicked widget's datapoint calculations
+ *
+ * ## Formula Context Filters (New Feature)
+ *
+ * Formula context filters are embedded within datapoint calculations and represent intrinsic
+ * filters that are part of the measure/column computation itself. They are extracted only from
+ * the specific widget that was clicked, not from all widgets. For example:
+ *
+ * ```
+ * clickedWidget.dataOptions.value[0].column.context = {
+ *   "13FC1-655": {
+ *     "type": "filter",
+ *     "filterType": "numeric",
+ *     "attribute": { ... },
+ *     "valueA": 10,
+ *     "valueB": 27249.89453125
+ *   }
+ * }
+ * ```
+ *
+ * These filters:
+ * - Represent calculation constraints that are intrinsic to the clicked widget's datapoint
+ * - Are extracted from all dataOption fields of the clicked widget (value, category, breakBy, x, y, etc.)
+ * - Support both object format and string reference format
+ *
+ * ## Duplicate Filter Handling
+ *
+ * Complex formulas like `AVG(cost) - AVG(PREVMONTH(cost))` can contain multiple filters on the same dimension.
+ * The `sendFormulaFiltersDuplicate` parameter controls how duplicates are handled:
+ *
+ * - **"none"**: Exclude all duplicate filters (only include filters that appear once)
+ * - **Number (1+)**: Include only the filter at that position (1-indexed). Invalid numbers treated as "none"
+ * - **Other values**: Include only the first duplicate filter
+ *
+ * Examples:
+ * - Formula has 2 filters on Commerce.Cost dimension
+ * - `sendFormulaFiltersDuplicate = "none"` → No Cost filters included
+ * - `sendFormulaFiltersDuplicate = 1` → Include first Cost filter
+ * - `sendFormulaFiltersDuplicate = 2` → Include second Cost filter
+ * - `sendFormulaFiltersDuplicate = 3` → Invalid (out of range), treat as "none"
+ */
+/**
+ * Extract formula context filters from data point
+ *
+ * @param clickedWidget - The clicked widget
+ * @param jtdConfig - The JTD configuration
+ * @returns Array of formula context filters
+ */
+export declare const getFormulaContextFilters: (clickedWidget: WidgetProps, jtdConfig: JtdConfig) => Filter[];
+/**
+ * Handle duplicate formula filters based on sendFormulaFiltersDuplicate parameter
+ *
+ * @param filters - The filters to handle
+ * @param sendFormulaFiltersDuplicate - The send formula filters duplicate parameter
+ * @returns The filtered filters
+ * @internal
+ */
+export declare const handleFormulaDuplicateFilters: (filters: Filter[], sendFormulaFiltersDuplicate?: number | 'none') => Filter[];
+/**
+ * Type guard to check if a data point is a ScatterDataPoint.
+ * Checks for actual scatter chart structure (x/y coordinates) and scatter-only properties.
+ *
+ * @param point - The data point to check
+ * @returns True if the point is a ScatterDataPoint, false otherwise
+ * @internal
+ */
+export declare const isScatterDataPoint: (point: DataPoint | ScatterDataPoint) => point is ScatterDataPoint;
+/**
+ * Extracts filters from scatter chart data point (breakByColor and breakByPoint).
+ *
+ * @param point - The scatter data point
+ * @returns Array of filters generated from scatter chart breakBy properties
+ * @internal
+ */
+export declare const getFiltersFromScatterDataPoint: (point: ScatterDataPoint) => Filter[];
+/**
+ * Extracts filters from regular chart data point (category and breakBy array).
+ * Also processes any scatter properties (breakByColor/breakByPoint) if present.
+ *
+ * @param point - The regular data point (may have mixed properties)
+ * @returns Array of filters generated from all available entries
+ * @internal
+ */
+export declare const getFiltersFromRegularDataPoint: (point: DataPoint) => Filter[];
+/**
+ * Extracts filters from a data point for Jump To Dashboard functionality.
+ *
+ * This function handles both regular DataPoint and ScatterDataPoint types:
+ * - If data point has scatter properties (breakByColor/breakByPoint), process as scatter chart
+ * - Otherwise, process as regular chart (category/breakBy entries)
+ * - Scatter properties take priority over regular properties when both exist
+ *
+ * @param point - The data point from chart interaction
+ * @returns Array of filters generated from the data point
+ * @internal
+ */
+export declare const getFiltersFromDataPoint: (point: DataPoint | ScatterDataPoint) => Filter[];
+/**
+ * Filter filters based on allowed dimension names, supporting cascading filters
+ *
+ * @param filters - The filters to filter
+ * @param allowedDims - The allowed dimensions
+ * @returns The filtered filters
+ * @internal
+ */
+export declare const filterByAllowedDimensions: (filters: Filter[], allowedDims?: string[]) => Filter[];
+/**
+ * Merge all types of filters for JTD functionality
+ *
+ * @param generatedFilters - Filters generated from data point
+ * @param dashboardFilters - Current dashboard filters
+ * @param widgetFilters - Widget-specific filters
+ * @param formulaContextFilters - Formula context filters
+ * @returns Merged filters array
+ * @internal
+ */
+export declare const mergeJtdFilters: (generatedFilters: Filter[], dashboardFilters: Filter[], widgetFilters: Filter[], formulaContextFilters: Filter[]) => Filter[];

package/dist/packages/sdk-ui/src/dashboard/hooks/jtd/jtd-handlers.d.ts

@@ -0,0 +1,46 @@
+import { type Filter } from '@sisense/sdk-data';
+import { WidgetProps } from '../../../props.js';
+import { JtdConfig } from '../../../widget-by-id/types';
+import { OpenModalFn } from '../../../common/components/modal/modal-context';
+import { JtdCoreData, JtdContext, JtdActions, JtdClickHandlerData, JtdDataPointClickEvent } from './jtd-types';
+/**
+ * Get the JTD click handler for a specific data point of the specific widget
+ *
+ * @param data - Core data with drill target (config, drill target, widget props, point)
+ * @param context - Context data (filters)
+ * @param actions - Action functions
+ * @returns The JTD click handler
+ * @internal
+ */
+export declare const getJtdClickHandler: (data: JtdClickHandlerData, context: JtdContext, actions: Pick<JtdActions, 'openModal'>) => () => Promise<string>;
+/**
+ * Get the JTD click handler for multiple data points
+ *
+ * @param data - Core data with drill target (config, drill target, widget props, points)
+ * @param context - Context data (filters)
+ * @param actions - Action functions
+ * @returns The JTD click handler
+ * @internal
+ */
+export declare const getJtdClickHandlerForMultiplePoints: (data: JtdClickHandlerData, context: JtdContext, actions: Pick<JtdActions, 'openModal'>) => () => void;
+/**
+ * Handle data point click for chart widgets
+ *
+ * @param coreData - Core data (config, widget props, point)
+ * @param context - Context data (filters)
+ * @param actions - Action functions
+ * @param event - Event-related data
+ * @internal
+ */
+export declare const handleDataPointClick: (coreData: JtdCoreData, context: JtdContext, actions: Pick<JtdActions, 'openModal' | 'openMenu' | 'translate'>, event: JtdDataPointClickEvent) => void | Promise<string>;
+/**
+ * Handle text widget click (placeholder for future implementation)
+ *
+ * @param jtdConfig - The JTD config
+ * @param widgetProps - The widget props
+ * @param dashboardFilters - The dashboard filters
+ * @param originalWidgetFilters - The original widget filters
+ * @param openModal - The open modal function
+ * @internal
+ */
+export declare const handleTextWidgetClick: (jtdConfig: JtdConfig, widgetProps: WidgetProps, dashboardFilters: Filter[], originalWidgetFilters: Filter[], openModal: OpenModalFn) => Promise<string>;

package/dist/packages/sdk-ui/src/dashboard/hooks/jtd/jtd-menu.d.ts

@@ -0,0 +1,47 @@
+import { JtdCoreData, JtdContext, JtdActions } from './jtd-types';
+/**
+ * Get the JTD menu item for a specific data point of the specific widget
+ *
+ * @param coreData - Core data (config, widget props, point)
+ * @param context - Context data (filters)
+ * @param actions - Action functions
+ * @returns The JTD menu item
+ * @internal
+ */
+export declare const getJumpToDashboardMenuItem: (coreData: JtdCoreData, context: JtdContext, actions: Pick<JtdActions, 'openModal' | 'translate'>) => {
+    caption: string;
+    subItems: {
+        items: {
+            caption: string;
+            onClick: () => Promise<string>;
+        }[];
+    }[];
+    onClick?: undefined;
+} | {
+    caption: string;
+    onClick: () => Promise<string>;
+    subItems?: undefined;
+} | null;
+/**
+ * Get the JTD menu item for multiple data points of the specific widget
+ *
+ * @param coreData - Core data (config, widget props, points)
+ * @param context - Context data (filters)
+ * @param actions - Action functions
+ * @returns The JTD menu item
+ * @internal
+ */
+export declare const getJumpToDashboardMenuItemForMultiplePoints: (coreData: JtdCoreData, context: JtdContext, actions: Pick<JtdActions, 'openModal' | 'translate'>) => {
+    caption: string;
+    subItems: {
+        items: {
+            caption: string;
+            onClick: () => void;
+        }[];
+    }[];
+    onClick?: undefined;
+} | {
+    caption: string;
+    onClick: () => void;
+    subItems?: undefined;
+} | null;

package/dist/packages/sdk-ui/src/dashboard/hooks/jtd/jtd-types.d.ts

@@ -0,0 +1,93 @@
+import { type Filter } from '@sisense/sdk-data';
+import { WidgetProps } from '../../../props.js';
+import { DataPoint } from '../../../types';
+import { JtdConfig, JtdDrillTarget } from '../../../widget-by-id/types';
+import { OpenModalFn } from '../../../common/components/modal/modal-context';
+import { OpenMenuFn } from '../../../common/components/menu/types.js';
+/**
+ * Menu item structure for JTD navigation
+ *
+ * @internal
+ */
+export type JtdMenuItem = {
+    caption: string;
+    onClick?: () => void;
+    subItems?: Array<{
+        items: Array<{
+            caption: string;
+            onClick: () => void;
+        }>;
+    }>;
+} | null;
+/**
+ * Base interface for core JTD data used across all JTD functions
+ *
+ * @internal
+ */
+export interface JtdCoreData {
+    /** The JTD config */
+    jtdConfig: JtdConfig;
+    /** The widget props */
+    widgetProps: WidgetProps;
+    /** The data point (single point) */
+    point?: DataPoint;
+    /** The data points (multiple points) */
+    points?: DataPoint[];
+}
+/**
+ * Base interface for JTD context data (filters) used across all JTD functions
+ *
+ * @internal
+ */
+export interface JtdContext {
+    /** The dashboard filters */
+    dashboardFilters: Filter[];
+    /** The original widget filters */
+    originalWidgetFilters: Filter[];
+}
+/**
+ * Base interface for JTD action functions
+ *
+ * @internal
+ */
+export interface JtdActions {
+    /** The open modal function */
+    openModal: OpenModalFn;
+    /** The open menu function (optional) */
+    openMenu?: OpenMenuFn;
+    /** The translation function (optional) */
+    translate?: (key: string) => string;
+}
+/**
+ * Extended core data for JTD click handlers that includes drill target
+ *
+ * @internal
+ */
+export interface JtdClickHandlerData extends JtdCoreData {
+    /** The drill target */
+    drillTarget: JtdDrillTarget;
+}
+/**
+ * Configuration for widget transforms, combining config and context
+ *
+ * @internal
+ */
+export interface JtdWidgetTransformConfig {
+    /** The JTD config */
+    jtdConfig: JtdConfig;
+    /** The dashboard filters */
+    dashboardFilters: Filter[];
+    /** The original widget filters */
+    originalWidgetFilters: Filter[];
+}
+/**
+ * Event-related data for handling data point clicks
+ *
+ * @internal
+ */
+export interface JtdDataPointClickEvent {
+    /** The native event */
+    nativeEvent: PointerEvent;
+    /** Function to get menu item */
+    getJumpToDashboardMenuItem: (coreData: JtdCoreData, context: JtdContext, actions: Pick<JtdActions, 'openModal' | 'translate'>) => JtdMenuItem;
+}

package/dist/packages/sdk-ui/src/dashboard/hooks/jtd/jtd-widget-transforms.d.ts

@@ -0,0 +1,48 @@
+import { WidgetProps } from '../../../props.js';
+import { JtdActions, JtdWidgetTransformConfig } from './jtd-types';
+/**
+ * Add pointer cursor to chart widgets that support it
+ *
+ * @param widgetProps - The widget props
+ * @returns Updated widget props with pointer cursor
+ * @internal
+ */
+export declare const addPointerCursorToChart: (widgetProps: WidgetProps) => WidgetProps;
+/**
+ * Apply JTD click navigation for chart widgets
+ *
+ * @param widgetProps - The widget props
+ * @param config - The JTD configuration and context
+ * @param actions - The action functions
+ * @returns Updated widget props with click navigation
+ * @internal
+ */
+export declare const applyClickNavigationForChart: (widgetProps: WidgetProps, config: JtdWidgetTransformConfig, actions: Pick<JtdActions, 'openModal' | 'openMenu' | 'translate'>) => WidgetProps;
+/**
+ * Apply JTD click navigation for text widgets
+ *
+ * @param widgetProps - The widget props
+ * @param config - The JTD configuration and context
+ * @param actions - The action functions for modal operations
+ * @returns Updated widget props with click navigation
+ * @internal
+ */
+export declare const applyClickNavigationForText: (widgetProps: WidgetProps, config: JtdWidgetTransformConfig, actions: Pick<JtdActions, 'openModal'>) => WidgetProps;
+/**
+ * Apply JTD right-click navigation for chart widgets
+ *
+ * @param widgetProps - The widget props
+ * @param config - The JTD configuration and context
+ * @param actions - The action functions
+ * @returns Updated widget props with right-click navigation
+ * @internal
+ */
+export declare const applyRightClickNavigation: (widgetProps: WidgetProps, config: JtdWidgetTransformConfig, actions: Pick<JtdActions, 'openModal' | 'openMenu' | 'translate'>) => WidgetProps;
+/**
+ * Add JTD icon to widget header if configured
+ *
+ * @param widgetProps - The widget props
+ * @returns Updated widget props with JTD icon in header
+ * @internal
+ */
+export declare const addJtdIconToHeader: (widgetProps: WidgetProps) => WidgetProps;