@sisense/sdk-ui 2.9.0 → 2.11.0

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

@@ -1,5 +1,20 @@
-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';
+/**
+ * Jump To Dashboard configuration for regular widgets
+ * @group Dashboards
+ */
+export { type JumpToDashboardConfig } from './jtd-types';
+/**
+ * Jump To Dashboard configuration for pivot widgets
+ * @group Dashboards
+ */
+export { type JumpToDashboardConfigForPivot } from './jtd-types';
+/**
+ * Target dashboard configuration for Jump To Dashboard
+ * @group Dashboards
+ */
+export { type JtdTarget } from './jtd-types';
+/**
+ * Trigger method for Jump To Dashboard interactions
+ * @group Dashboards
+ */
+export { type TriggerMethod } from './jtd-types';

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

@@ -0,0 +1,85 @@
+import { WidgetProps } from '../../../props';
+import type { JtdConfig, JtdTarget, JumpToDashboardConfig, JumpToDashboardConfigForPivot, PivotDimId } from './jtd-types';
+import type { Attribute, Dimension, Measure } from '@sisense/sdk-data';
+import { PivotTableDataOptions } from '../../../index-typedoc';
+import type { Panel } from '../../../widget-by-id/types';
+/**
+ * Transform legacy JtdConfig to new JumpToDashboardConfig format
+ *
+ * @param jtdConfig - The legacy JTD configuration
+ * @returns Transformed Jump To Dashboard configuration
+ * @internal
+ */
+export declare const transformJtdConfigToJumpToDashboardConfig: (jtdConfig: JtdConfig) => JumpToDashboardConfig;
+export declare const isPivotJumpToDashboardConfig: (config: JumpToDashboardConfig | JumpToDashboardConfigForPivot) => config is JumpToDashboardConfigForPivot;
+/**
+ * Transform common part of public JumpToDashboardConfig to inner JtdConfig format
+ *
+ * @param jumpConfig - The new Jump To Dashboard configuration
+ * @returns Transformed legacy JTD configuration
+ * @internal
+ */
+export declare const transformJumpToDashboardConfigToJtdConfigCommon: (jumpConfig: JumpToDashboardConfig | JumpToDashboardConfigForPivot) => Omit<JtdConfig, 'jumpTargets'>;
+export declare const transformJumpToDashboardConfigToJtdConfigForPivot: (jumpConfig: JumpToDashboardConfigForPivot, dataOptions: PivotTableDataOptions) => JtdConfig;
+/**
+ * Type guard to check if a config is a JumpToDashboardConfig
+ *
+ * @param config - The configuration to check
+ * @returns True if the config is a JumpToDashboardConfig
+ * @internal
+ */
+export declare const isJumpToDashboardConfig: (config: JtdConfig | JumpToDashboardConfig | JumpToDashboardConfigForPivot) => config is JumpToDashboardConfig | JumpToDashboardConfigForPivot;
+/**
+ * Normalize configuration to JumpToDashboardConfig format
+ * Accepts both legacy JtdConfig and new JumpToDashboardConfig
+ *
+ * @internal
+ * @param config - Either JtdConfig or JumpToDashboardConfig
+ * @returns Normalized JumpToDashboardConfig
+ */
+export declare const normalizeToJumpToDashboardConfig: (config: JtdConfig | JumpToDashboardConfig) => JumpToDashboardConfig;
+/**
+ * Normalize configuration to legacy JtdConfig format
+ * Accepts both legacy JtdConfig and new JumpToDashboardConfig
+ *
+ * @internal
+ * @param config - Either JtdConfig or JumpToDashboardConfig
+ * @returns Normalized JtdConfig
+ */
+export declare const normalizeToJtdConfig: (config: JtdConfig | JumpToDashboardConfig | JumpToDashboardConfigForPivot, widgetProps: WidgetProps) => JtdConfig;
+/**
+ * Enhanced matching strategy that considers location, expression, level, and other properties
+ * @param dimension - The dimension or measure object
+ * @param panels - Constructed panels with PanelItems
+ * @returns PivotDimId like "columns.0", "rows.1", "values.0"
+ * @internal
+ */
+export declare const dimensionToPivotDimId: (dimension: Attribute | Measure | {
+    dimension: Attribute;
+    location: 'row' | 'column' | 'value';
+}, panels: Panel[]) => PivotDimId | null;
+/**
+ * Convert PivotDimId back to Dimension/Measure using widget structure
+ * @param pivotDimId - PivotDimId like "columns.0", "rows.1", "values.0"
+ * @param widgetStructure - Widget structure with rows/columns/values arrays
+ * @returns The dimension or measure object, or null if not found
+ * @internal
+ */
+export declare const pivotDimIdToDimension: (pivotDimId: PivotDimId, widgetStructure: {
+    rows?: Array<Dimension | Measure>;
+    columns?: Array<Dimension | Measure>;
+    values?: Array<Dimension | Measure>;
+}) => Dimension | Measure | null;
+/**
+ * Convert Map-based pivot targets to array-based pivot targets (for internal JtdConfig)
+ * @param targetsMap - Map of dimensions/measures to targets
+ * @param panels - Widget metadata panels (source of truth for dimension positions)
+ * @returns Array of targets with pivotDimensions
+ * @internal
+ */
+export declare const mapTargetsToArrayTargets: (targetsMap: Map<Attribute | {
+    dimension: Attribute;
+    location: 'row' | 'column' | 'value';
+} | Measure, JtdTarget[]>, panels: Panel[]) => Array<JtdTarget & {
+    pivotDimensions?: PivotDimId[];
+}>;

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

@@ -1,16 +1,16 @@
 import { type Filter } from '@sisense/sdk-data';
 import { WidgetProps } from '../../../props.js';
 import { DataPoint, ScatterDataPoint } from '../../../types';
-import { JtdConfig } from '../../../widget-by-id/types';
+import { JtdConfig } from './jtd-types';
 /**
- * Jump to Dashboard (JTD) Filter Merging Logic:
+ * 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
+ * 4. **Formula Context Filters**: Embedded filters from the clicked widget's datapoint calculations
  *
  * ## Formula Context Filters (New Feature)
  *
@@ -57,6 +57,7 @@ import { JtdConfig } from '../../../widget-by-id/types';
  * @param clickedWidget - The clicked widget
  * @param jtdConfig - The JTD configuration
  * @returns Array of formula context filters
+ * @internal
  */
 export declare const getFormulaContextFilters: (clickedWidget: WidgetProps, jtdConfig: JtdConfig) => Filter[];
 /**
@@ -68,6 +69,17 @@ export declare const getFormulaContextFilters: (clickedWidget: WidgetProps, jtdC
  * @internal
  */
 export declare const handleFormulaDuplicateFilters: (filters: Filter[], sendFormulaFiltersDuplicate?: number | 'none') => Filter[];
+/**
+ * Normalizes a date value to the start of the period for the given granularity
+ * This ensures the filter member value matches what the backend query returns
+ * Uses existing date utilities instead of manual parsing to reduce business logic
+ *
+ * @param value - The raw date value (e.g., "2009-11-15T12:30:00.000")
+ * @param granularity - The date granularity (e.g., "Months")
+ * @returns Normalized date string that matches backend member query format
+ * @internal
+ */
+export declare const normalizeDateForGranularity: (value: string, granularity: string) => string;
 /**
  * Type guard to check if a data point is a ScatterDataPoint.
  * Checks for actual scatter chart structure (x/y coordinates) and scatter-only properties.

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

@@ -0,0 +1,80 @@
+import type { CustomDataCellFormatter, CustomHeaderCellFormatter } from '../../../pivot-table/formatters/types';
+import { JtdConfig, JtdTarget } from './jtd-types';
+import { PivotTableDataPoint } from '../../../types';
+/**
+ * Check if a formatter cell ID is actionable for JTD
+ * Used by hyperlink formatters with cell IDs like "rows.0", "columns.1", "values.2"
+ *
+ * @param jtdConfig - The JTD configuration
+ * @param cellId - The cell ID from formatters (e.g., "rows.0")
+ * @returns Object with actionable status and matching target
+ * @internal
+ */
+export declare function getPivotFormatterCellActionability(jtdConfig: JtdConfig, cellId: string): {
+    isActionable: boolean;
+    matchingTarget?: JtdTarget;
+};
+/**
+ * Check if a click handler pivot point is actionable for JTD
+ * Used by click handlers with pivot data points containing custom dimension IDs
+ *
+ * @param jtdConfig - The JTD configuration
+ * @param pivotPoint - The pivot data point from click handlers
+ * @returns Object with actionable status and matching target
+ * @internal
+ */
+export declare function isPivotClickHandlerActionable(jtdConfig: JtdConfig, pivotPoint: PivotTableDataPoint): {
+    isActionable: boolean;
+    matchingTarget?: JtdTarget;
+};
+/**
+ * Find all actionable jump targets for a pivot point (for right-click menus)
+ * Used by right-click handlers that need to show multiple targets
+ *
+ * @param jtdConfig - The JTD configuration
+ * @param pivotPoint - The pivot data point from click handlers
+ * @returns Object with actionable status and all matching targets
+ * @internal
+ *
+ * @example
+ * ```typescript
+ * // Usage in right-click menu handler for pivot tables
+ * const onPivotRightClick = (pivotPoint: PivotTableDataPoint) => {
+ *   const { isActionable, matchingTargets } = findAllActionablePivotTargets(jtdConfig, pivotPoint);
+ *
+ *   if (!isActionable) {
+ *     return; // No menu - headers are not clickable or no valid targets
+ *   }
+ *
+ *   // Only valid targets are returned:
+ *   // - Targets with matching pivot dimensions for this cell
+ *   // - NEVER targets with non-matching pivot dimensions
+ *   const menuItems = matchingTargets.map(target => ({
+ *     caption: target.caption,
+ *     onClick: () => handleJumpToDashboard(target, pivotPoint)
+ *   }));
+ *
+ *   openContextMenu({ items: menuItems });
+ * };
+ * ```
+ */
+export declare function getPivotTargetActionability(jtdConfig: JtdConfig, pivotPoint: PivotTableDataPoint): {
+    isActionable: boolean;
+    matchingTargets: JtdTarget[];
+};
+/**
+ * Creates a data cell formatter that applies hyperlink styling for JTD navigation
+ *
+ * @param hyperlinkColor - The color to use for hyperlink text (uses theme's hyperlinkColor
+ * @returns Data cell formatter function
+ * @internal
+ */
+export declare function createJtdHyperlinkDataCellFormatter(hyperlinkColor: string, jtdConfig: JtdConfig): CustomDataCellFormatter;
+/**
+ * Creates a header cell formatter that applies hyperlink styling for JTD navigation
+ *
+ * @param hyperlinkColor - The color to use for hyperlink text (uses theme's hyperlinkColor or defaults to DEFAULT_HYPERLINK_COLOR)
+ * @param jtdConfig - JTD configuration containing jump targets
+ * @returns A header cell formatter that applies hyperlink styling to matching header cells
+ */
+export declare function createJtdHyperlinkHeaderCellFormatter(hyperlinkColor: string, jtdConfig: JtdConfig): CustomHeaderCellFormatter;

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

@@ -1,12 +1,12 @@
 import { type Filter } from '@sisense/sdk-data';
 import { WidgetProps } from '../../../props.js';
-import { JtdConfig } from '../../../widget-by-id/types';
+import { PivotTableDataPoint, DataPoint } from '../../../types';
+import { JtdActions, JtdClickHandlerData, JtdConfig, JtdContext, JtdCoreData, JtdDataPointClickEvent } from './jtd-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 data - Core data with jump target (config, jump target, widget props, point)
  * @param context - Context data (filters)
  * @param actions - Action functions
  * @returns The JTD click handler
@@ -16,7 +16,7 @@ export declare const getJtdClickHandler: (data: JtdClickHandlerData, context: Jt
 /**
  * Get the JTD click handler for multiple data points
  *
- * @param data - Core data with drill target (config, drill target, widget props, points)
+ * @param data - Core data with jump target (config, jump target, widget props, points)
  * @param context - Context data (filters)
  * @param actions - Action functions
  * @returns The JTD click handler
@@ -33,6 +33,28 @@ export declare const getJtdClickHandlerForMultiplePoints: (data: JtdClickHandler
  * @internal
  */
 export declare const handleDataPointClick: (coreData: JtdCoreData, context: JtdContext, actions: Pick<JtdActions, 'openModal' | 'openMenu' | 'translate'>, event: JtdDataPointClickEvent) => void | Promise<string>;
+/**
+ * Convert PivotTableDataPoint to DataPoint format for JTD processing
+ *
+ * @param pivotPoint - The pivot table data point
+ * @returns Converted data point
+ * @internal
+ */
+export declare const convertPivotToDataPoint: (pivotPoint: PivotTableDataPoint) => DataPoint;
+/**
+ * Handle pivot table data point click
+ *
+ * @param data - Core data with jump target (config, jump target, widget props, pivot point)
+ * @param context - Context data (filters)
+ * @param actions - Action functions
+ * @param eventData - Event-related data
+ * @internal
+ */
+export declare const handlePivotDataPointClick: (data: {
+    jtdConfig: JtdConfig;
+    widgetProps: WidgetProps;
+    point: PivotTableDataPoint;
+}, context: JtdContext, actions: Pick<JtdActions, 'openModal' | 'openMenu' | 'translate'>) => Promise<string> | undefined;
 /**
  * Handle text widget click (placeholder for future implementation)
  *

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

@@ -1,4 +1,5 @@
 import { JtdCoreData, JtdContext, JtdActions } from './jtd-types';
+export declare const jumpToDashboardMenuId = "jump-to-dashboard-menu";
 /**
  * Get the JTD menu item for a specific data point of the specific widget
  *

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

@@ -1,7 +1,7 @@
-import { type Filter } from '@sisense/sdk-data';
+import { Attribute, Measure, type Filter } from '@sisense/sdk-data';
 import { WidgetProps } from '../../../props.js';
 import { DataPoint } from '../../../types';
-import { JtdConfig, JtdDrillTarget } from '../../../widget-by-id/types';
+import { DashboardConfig, DashboardProps } from '../../../dashboard/types';
 import { OpenModalFn } from '../../../common/components/modal/modal-context';
 import { OpenMenuFn } from '../../../common/components/menu/types.js';
 /**
@@ -44,6 +44,8 @@ export interface JtdContext {
     dashboardFilters: Filter[];
     /** The original widget filters */
     originalWidgetFilters: Filter[];
+    /** Extra filters to be applied with highest priority */
+    extraFilters?: Filter[];
 }
 /**
  * Base interface for JTD action functions
@@ -59,13 +61,13 @@ export interface JtdActions {
     translate?: (key: string) => string;
 }
 /**
- * Extended core data for JTD click handlers that includes drill target
+ * Extended core data for JTD click handlers that includes jump target
  *
  * @internal
  */
 export interface JtdClickHandlerData extends JtdCoreData {
-    /** The drill target */
-    drillTarget: JtdDrillTarget;
+    /** The jump target */
+    jumpTarget: JtdTarget;
 }
 /**
  * Configuration for widget transforms, combining config and context
@@ -79,6 +81,8 @@ export interface JtdWidgetTransformConfig {
     dashboardFilters: Filter[];
     /** The original widget filters */
     originalWidgetFilters: Filter[];
+    /** Extra filters to be applied with highest priority */
+    extraFilters?: Filter[];
 }
 /**
  * Event-related data for handling data point clicks
@@ -91,3 +95,254 @@ export interface JtdDataPointClickEvent {
     /** Function to get menu item */
     getJumpToDashboardMenuItem: (coreData: JtdCoreData, context: JtdContext, actions: Pick<JtdActions, 'openModal' | 'translate'>) => JtdMenuItem;
 }
+/**
+ * Configuration for Jump To Dashboard functionality.
+ * Allows users to navigate from a widget to another dashboard with contextual filtering.
+ */
+export interface JumpToDashboardConfig {
+    /**
+     * Whether Jump To Dashboard functionality is enabled
+     * @default true
+     */
+    enabled?: boolean;
+    /** List of target dashboards that can be navigated to */
+    targets: JtdTarget[];
+    /** Configuration for user interaction behavior */
+    interaction?: {
+        /**
+         * How users trigger the jump action
+         * Note that not all widgets support both trigger methods
+         *
+         * @default 'rightclick'
+         **/
+        triggerMethod?: TriggerMethod;
+        /**
+         * Caption prefix for jumping action (i.e in context menu)
+         * @default 'Jump to'
+         */
+        captionPrefix?: string;
+        /**
+         * Whether to show the Jump To Dashboard icon in the toolbar of the source widget
+         * @default true
+         */
+        showIcon?: boolean;
+    };
+    /**
+     * Configuration for the target dashboard display.
+     * This configuration will be merged with target dashboard config, having higher priority
+     * @default {}
+     */
+    targetDashboardConfig?: DashboardConfig;
+    /** Configuration for filter handling between source and target dashboards */
+    filtering?: {
+        /**
+         * Additional filters to apply to the target dashboard
+         *
+         * @example
+         * const extraFilters = [dashboardProps.filters[0], dashboardProps.widgets[0].filters[0]]
+         *
+         * @default []
+         */
+        extraFilters?: Filter[];
+        /**
+         * Dashboard-level filter dimensions to pass through
+         *
+         * undefined - include all
+         * [] - include nothing
+         * [string] - include specific dimensions
+         *
+         * example: ["[ER.Date (Calendar)]", "[Doctors.Specialty]"]
+         * @default undefined
+         */
+        includeDashboardFilters?: string[];
+        /**
+         * Widget-level filter dimensions to pass through
+         *
+         * undefined - include all
+         * [] - include nothing
+         * [string] - include specific dimensions
+         *
+         * example: ["[ER.Date (Calendar)]", "[Doctors.Specialty]"]
+         * @default undefined
+         */
+        includeWidgetFilters?: string[];
+        /**
+         * Whether to merge filters with existing target dashboard filters or replace them
+         * @default false
+         */
+        mergeWithTargetFilters?: boolean;
+    };
+    /** Configuration for the modal window that will display the target dashboard */
+    modal?: {
+        /**
+         * Width of the modal window
+         * @default 85 (when measurementUnit is '%') or 1200 (when measurementUnit is 'px')
+         */
+        width?: number;
+        /**
+         * Height of the modal window
+         * @default 85 (when measurementUnit is '%') or 800 (when measurementUnit is 'px')
+         */
+        height?: number;
+        /**
+         * Unit of measurement for width/height
+         * @default 'px'
+         */
+        measurementUnit?: '%' | 'px';
+    };
+}
+/**
+ * Configuration for Jump To Dashboard functionality for pivot widgets.
+ * Used for pivot widgets, allowing to configure jumping to different dashboard from different dimensions
+ * @see {@link JumpToDashboardConfig}
+ */
+export interface JumpToDashboardConfigForPivot extends Omit<JumpToDashboardConfig, 'targets'> {
+    /**
+     * Map of target dashboards for different dimensions/measures
+     *
+     * @alpha
+     * @example
+     *
+     * const FormulaMeasure = dashboardProps.widgets[0].dataOptions.values[0];
+     * const ageRangeAttribute = dashboardProps.widgets[0].dataOptions.rows[1];
+     *
+     * const targets = new Map([
+     *    [ageRangeAttribute, [target, target2]],
+     *    [FormulaMeasure, [target3]],
+     * ]);
+     *
+     */
+    targets: Map<Attribute | {
+        dimension: Attribute;
+        location: 'row' | 'column' | 'value';
+    } | Measure, JtdTarget[]>;
+}
+/**
+ * Target dashboard for Jump To Dashboard functionality.
+ * Supports both dashboard ID reference and in-code dashboard object.
+ * @see JumpToDashboardConfig
+ * @see DashboardProps
+ */
+export type JtdTarget = {
+    caption: string;
+    id: string;
+} | {
+    caption: string;
+    dashboard: DashboardProps;
+};
+/**
+ * Type guard to check if a jump target contains dashboard props
+ * @internal
+ */
+export declare const isJumpTargetWithDashboardProps: (target: JtdTarget) => target is {
+    caption: string;
+    dashboard: DashboardProps;
+};
+/**
+ * Type guard to check if a jump target contains dashboard ID
+ * @internal
+ */
+export declare const isJumpTargetWithId: (target: JtdTarget) => target is {
+    caption: string;
+    id: string;
+};
+/**
+ * @internal
+ */
+export type PivotDimType = 'columns' | 'rows' | 'values';
+/**
+ * @internal
+ */
+export type NonNegativeIntString = Exclude<`${bigint}`, `-${string}`>;
+/**
+ * Pivot dimension ID
+ * example: "columns.0", "rows.0", "values.0", "columns.1", "rows.1", "values.1", etc.
+ * @internal
+ */
+export type PivotDimId = `${PivotDimType}.${NonNegativeIntString}`;
+export type JtdTargetDto = {
+    caption: string;
+    id?: string;
+    oid?: string;
+};
+export type JtdPivotTargetDto = JtdTargetDto & {
+    pivotDimensions: string[];
+};
+/**
+ * Legacy representation of JTD config from Fusion
+ * @internal
+ */
+export type JtdConfigDto = {
+    drilledDashboardPrefix: string;
+    drilledDashboardsFolderPrefix: string;
+    displayFilterPane: boolean;
+    displayDashboardsPane: boolean;
+    displayToolbarRow: boolean;
+    displayHeaderRow: boolean;
+    volatile: boolean;
+    hideDrilledDashboards: boolean;
+    hideSharedDashboardsForNonOwner: boolean;
+    drillToDashboardRightMenuCaption: string;
+    drillToDashboardNavigateType: number;
+    drillToDashboardNavigateTypePivot: number;
+    drillToDashboardNavigateTypeCharts: number;
+    drillToDashboardNavigateTypeOthers: number;
+    drilledDashboardDisplayType: number;
+    dashboardIds: Array<JtdTargetDto | JtdPivotTargetDto>;
+    modalWindowResize: boolean;
+    modalWindowMeasurement?: 'px' | '%';
+    modalWindowWidth?: number;
+    modalWindowHeight?: number;
+    showFolderNameOnMenuSelection: boolean;
+    resetDashFiltersAfterJTD: boolean;
+    sameCubeRestriction: boolean;
+    showJTDIcon?: boolean;
+    sendPieChartMeasureFiltersOnClick: boolean;
+    forceZeroInsteadNull: boolean;
+    mergeTargetDashboardFilters: boolean;
+    drillToDashboardByName: boolean;
+    sendBreakByValueFilter: boolean;
+    ignoreFiltersSource: boolean;
+    sendFormulaFiltersDuplicate?: number | 'none' | undefined;
+    enabled?: boolean;
+    version?: string;
+    includeDashFilterDims?: string[];
+    includeWidgetFilterDims?: string[];
+};
+/**
+ * Jump To Dashboard action trigger method type
+ * click - when user clicks on the widget
+ * rightclick - when user right clicks on the widget, opening the context menu
+ * @see {@link JumpToDashboardConfig}
+ */
+export type TriggerMethod = 'click' | 'rightclick';
+/**
+ * @internal
+ */
+export type JtdTargetInner = JtdTarget & {
+    pivotDimensions?: PivotDimId[];
+};
+/**
+ * Internal representation of Jump To Dashboard configuration object.
+ * This is the legacy format that includes fields like drilledDashboardPrefix
+ * and modalWindowResize that don't have direct equivalents in JumpToDashboardConfig.
+ * @internal
+ */
+export type JtdConfig = {
+    jumpedDashboardPrefix?: string;
+    dashboardConfig?: DashboardConfig;
+    jumpToDashboardRightMenuCaption?: string;
+    navigateType?: TriggerMethod;
+    includeDashFilterDims?: string[];
+    includeWidgetFilterDims?: string[];
+    jumpTargets: Array<JtdTargetInner>;
+    modalWindowResize?: boolean;
+    modalWindowMeasurement?: 'px' | '%';
+    modalWindowWidth?: number;
+    modalWindowHeight?: number;
+    showJtdIcon?: boolean;
+    mergeTargetDashboardFilters?: boolean;
+    sendFormulaFiltersDuplicate?: number | 'none' | undefined;
+    enabled?: boolean;
+    extraFilters?: Filter[];
+};

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

@@ -18,6 +18,16 @@ export declare const addPointerCursorToChart: (widgetProps: WidgetProps) => Widg
  * @internal
  */
 export declare const applyClickNavigationForChart: (widgetProps: WidgetProps, config: JtdWidgetTransformConfig, actions: Pick<JtdActions, 'openModal' | 'openMenu' | 'translate'>) => WidgetProps;
+/**
+ * Apply JTD click navigation for pivot table 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 applyClickNavigationForPivot: (widgetProps: WidgetProps, config: JtdWidgetTransformConfig, actions: Pick<JtdActions, 'openModal' | 'openMenu' | 'translate'>) => WidgetProps;
 /**
  * Apply JTD click navigation for text widgets
  *
@@ -38,6 +48,25 @@ export declare const applyClickNavigationForText: (widgetProps: WidgetProps, con
  * @internal
  */
 export declare const applyRightClickNavigation: (widgetProps: WidgetProps, config: JtdWidgetTransformConfig, actions: Pick<JtdActions, 'openModal' | 'openMenu' | 'translate'>) => WidgetProps;
+/**
+ * Apply JTD right-click navigation for pivot table 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 applyRightClickNavigationForPivot: (widgetProps: WidgetProps, config: JtdWidgetTransformConfig, actions: Pick<JtdActions, 'openModal' | 'openMenu' | 'translate'>) => WidgetProps;
+/**
+ * Applies hyperlink styling to pivot table cells for PIVOT_LINK navigation
+ * @param widgetProps - Pivot table widget props
+ * @param config - JTD configuration
+ * @param hyperlinkColor
+ * @returns Updated widget props with hyperlink styling
+ * @internal
+ */
+export declare const applyPivotLinkStyling: (widgetProps: WidgetProps, config: JtdWidgetTransformConfig, hyperlinkColor?: string) => WidgetProps;
 /**
  * Add JTD icon to widget header if configured
  *

package/dist/packages/sdk-ui/src/dashboard/hooks/use-dashboard-header-toolbar.d.ts

@@ -1,14 +1,21 @@
+/**
+ * @internal
+ */
 export interface DashboardHeaderToolbarMenuItem {
     title: string;
     icon?: JSX.Element;
     ariaLabel?: string;
     onClick: () => void;
 }
+/**
+ * @internal
+ */
 export interface UseDashboardHeaderToolbarProps {
     menuItems: DashboardHeaderToolbarMenuItem[];
 }
 /**
  * Hook that returns a toolbar element for dashboard header
+ * @internal
  */
 export declare const useDashboardHeaderToolbar: ({ menuItems }: UseDashboardHeaderToolbarProps) => {
     toolbar: () => import("react/jsx-runtime").JSX.Element;