@sisense/sdk-ui 2.1.1 → 2.3.0

package/dist/packages/sdk-ui/src/common/hooks/use-state-with-history.d.ts

@@ -0,0 +1,64 @@
+interface UseStateWithHistoryOptions<T> {
+    /**
+     * Maximum number of history entries to store
+     * @default 10
+     */
+    capacity?: number;
+    /**
+     * Initial history entries
+     * @default []
+     */
+    initialHistory?: T[];
+}
+interface StateWithHistoryResult<T> {
+    /** Current state value */
+    state: T;
+    /** All history entries */
+    history: T[];
+    /** Index of the current state in history */
+    currentIndex: number;
+    /** Set state and add to history */
+    setState: (value: T | ((prev: T) => T)) => void;
+    /** Go back to the previous state in history */
+    undo: () => void;
+    /** Go forward to the next state in history */
+    redo: () => void;
+    /** Whether there's a previous state to go back to */
+    canUndo: boolean;
+    /** Whether there's a next state to go forward to */
+    canRedo: boolean;
+    /** Go to a specific point in history by index */
+    goTo: (index: number) => void;
+    /** Clear all history except current state */
+    clearHistory: () => void;
+}
+/**
+ * A hook that provides state management with history tracking for undo/redo functionality.
+ *
+ * @param initialState - The initial state value
+ * @param options - Configuration options for history management
+ * @returns An object containing the current state, history, and methods to navigate through history
+ *
+ * @example
+ * ```tsx
+ * const {
+ *   state,
+ *   setState,
+ *   undo,
+ *   redo,
+ *   canUndo,
+ *   canRedo
+ * } = useStateWithHistory({ count: 0 });
+ *
+ * // Update state
+ * setState({ count: state.count + 1 });
+ *
+ * // Undo last action if possible
+ * if (canUndo) undo();
+ *
+ * // Redo last undone action if possible
+ * if (canRedo) redo();
+ * ```
+ */
+export declare function useStateWithHistory<T>(initialState: T, options?: UseStateWithHistoryOptions<T>): StateWithHistoryResult<T>;
+export {};

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

@@ -1,3 +1,3 @@
 import { DashboardHeaderProps } from '../../dashboard/types';
 export declare const DASHBOARD_HEADER_HEIGHT = 48;
-export declare const DashboardHeader: ({ title }: DashboardHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DashboardHeader: ({ title, toolbar }: DashboardHeaderProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,15 @@
+import { type Filter } from '@sisense/sdk-data';
+interface JTDDashboardProps {
+    dashboardOid: string;
+    filters: Filter[];
+    mergeTargetDashboardFilters: boolean;
+    displayToolbarRow: boolean;
+    displayFilterPane: boolean;
+}
+/**
+ * JTD-specific Dashboard component that handles runtime filters
+ * 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 {};

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

@@ -1,11 +1,14 @@
 /// <reference types="react" />
 import { DashboardProps } from '../dashboard/types';
 import { Filter, FilterRelations } from '@sisense/sdk-data';
+import { WidgetsPanelLayout } from '../models';
 export declare enum DashboardChangeType {
     /** Dashboard filters have been updated */
     FILTERS_UPDATE = "FILTERS.UPDATE",
     /** Filters panel collapsed state changed */
-    UI_FILTERS_PANEL_COLLAPSE = "UI.FILTERS.PANEL.COLLAPSE"
+    UI_FILTERS_PANEL_COLLAPSE = "UI.FILTERS.PANEL.COLLAPSE",
+    /** Widgets panel layout updated */
+    WIDGETS_PANEL_LAYOUT_UPDATE = "WIDGETS_PANEL_LAYOUT.UPDATE"
 }
 export type DashboardChangeAction = {
     type: DashboardChangeType.FILTERS_UPDATE;
@@ -13,6 +16,9 @@ export type DashboardChangeAction = {
 } | {
     type: DashboardChangeType.UI_FILTERS_PANEL_COLLAPSE;
     payload: boolean;
+} | {
+    type: DashboardChangeType.WIDGETS_PANEL_LAYOUT_UPDATE;
+    payload: WidgetsPanelLayout;
 };
 /**
  * React component that renders a dashboard whose elements are customizable. It includes internal logic of applying common filters to widgets.

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

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

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

@@ -0,0 +1,52 @@
+/// <reference types="react" />
+import { WidgetsPanelLayout } from '../../models';
+/**
+ * Props for the useEditModeToolbar hook
+ */
+export interface UseEditModeToolbarProps {
+    /**
+     * Initial layout to track history for
+     */
+    initialLayout: WidgetsPanelLayout;
+    /**
+     * Optional callback when layout is applied
+     */
+    onApply?: (layout: WidgetsPanelLayout) => void;
+    /**
+     * Optional callback when edit is canceled
+     */
+    onCancel?: () => void;
+    /**
+     * Maximum number of history entries to store
+     * @default 20
+     */
+    historyCapacity?: number;
+}
+/**
+ * Return type for the useEditModeToolbar hook
+ */
+export interface UseEditModeToolbarResult {
+    /**
+     * Current layout state
+     */
+    layout: WidgetsPanelLayout;
+    /**
+     * Function to update layout state and track in history
+     */
+    setLayout: (layout: WidgetsPanelLayout | ((prev: WidgetsPanelLayout) => WidgetsPanelLayout)) => void;
+    /**
+     * Whether there are unsaved changes
+     */
+    hasChanges: boolean;
+    /**
+     * Toolbar component with undo, redo, cancel, apply buttons
+     */
+    toolbar: () => JSX.Element;
+}
+/**
+ * Hook that provides layout state management with history tracking and a toolbar with undo/redo/cancel/apply buttons
+ *
+ * @param props Configuration options for the toolbar
+ * @returns Layout state and toolbar component
+ */
+export declare function useEditModeToolbar({ initialLayout, onApply, onCancel, historyCapacity, }: UseEditModeToolbarProps): UseEditModeToolbarResult;

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

@@ -0,0 +1,113 @@
+import { type Filter } from '@sisense/sdk-data';
+import { WidgetProps } from '../../props.js';
+import { OpenMenuFn } from '../../common/components/menu/types.js';
+import { DataPoint } from '../../types';
+import { WidgetsOptions } from '../../index-typedoc';
+import { JTDConfig, JTDDrillTarget } from '../../widget-by-id/types';
+import React from 'react';
+import { SizeMeasurement } from '../../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"
+ */
+export declare const getFormulaContextFilters: (point: DataPoint, clickedWidget: WidgetProps, jtdConfig: JTDConfig) => Filter[];
+/**
+ * @internal
+ * 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
+ */
+export declare const handleFormulaDuplicateFilters: (filters: Filter[], sendFormulaFiltersDuplicate?: number | 'none') => Filter[];
+export declare const getFiltersFromDataPoint: (point: DataPoint) => 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
+ */
+export declare const filterByAllowedDimensions: (filters: Filter[], allowedDims?: string[]) => Filter[];
+/**
+ * @internal
+ * Get the JTD click handler for a specific data point of the specific widget
+ * @param jtdConfig - The JTD config
+ * @param drillTarget - The drill target
+ * @param widgetProps - The widget props
+ * @param point - The data point
+ * @param dashboardFilters - The dashboard filters
+ * @param originalWidgetFilters - The original widget filters
+ * @param openModal - The open modal function
+ * @returns The JTD click handler
+ */
+export declare const getJtdClickHandler: (jtdConfig: JTDConfig, drillTarget: JTDDrillTarget, widgetProps: WidgetProps, point: DataPoint, dashboardFilters: Filter[], originalWidgetFilters: Filter[], openModal: (options: {
+    title: string;
+    width?: number;
+    height?: number;
+    measurement?: SizeMeasurement;
+    allowResize?: boolean;
+    content: React.ReactNode;
+}) => Promise<string>) => () => Promise<void>;
+/**
+ * @internal
+ * Jump to Dashboard (JTD) hook.
+ * Implements the JTD functionality for each widget with JTD config.
+ * @param widgetOptions - The widget options of the dashboard
+ * @param dashboardFilters - The dashboard filters to use
+ * @param widgetFilters - The widget filters to use
+ * @param openMenu - The open menu function to use
+ * @returns The connect to widget props function
+ */
+export declare const useJtd: ({ widgetOptions, dashboardFilters, widgetFilters, openMenu, }: {
+    widgetOptions: WidgetsOptions;
+    dashboardFilters?: Filter[] | undefined;
+    widgetFilters?: Map<string, Filter[]> | undefined;
+    openMenu: OpenMenuFn;
+}) => {
+    connectToWidgetProps: (widgetProps: WidgetProps) => WidgetProps;
+};

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

@@ -3,6 +3,7 @@ import { WidgetProps } from '../props';
 import { DashboardChangeAction } from '../dashboard/dashboard';
 import { DataSource, Filter, FilterRelations } from '@sisense/sdk-data';
 import { FiltersPanelConfig } from '../filters/components/filters-panel/types';
+import { ReactNode } from 'react';
 export type { DashboardStyleOptions, WidgetsPanelColumnLayout, WidgetsPanelLayout, WidgetsPanelCell, WidgetsPanelRow, WidgetsPanelColumn, } from '../models';
 /**
  * Props of the {@link DashboardById} component.
@@ -88,9 +89,16 @@ export interface DashboardConfig {
          */
         responsive?: boolean;
         /**
-         * If true will render editable layout.
+         * If true, an 'Edit Layout' action is visible to users on the dashboard toolbar.
+         * Clicking 'Edit Layout' opens the dashboard in editing mode, where the user can resize or reposition widgets using drag and drop.
+         * Layout changes are temporarily stored during editing, with undo/redo buttons available on the toolbar.
+         * Finally, changes are confirmed or discarded with 'Apply' or 'Cancel' buttons.
          *
-         * @internal
+         * If persistence is enabled for the dashboard, changes to the layout will be saved to Fusion on clicking the 'Apply' button.
+         *
+         * This feature is in alpha.
+         *
+         * @alpha
          */
         editMode?: boolean;
     };
@@ -170,4 +178,5 @@ export interface DashboardProps {
  */
 export interface DashboardHeaderProps {
     title: string;
+    toolbar?: () => ReactNode;
 }

package/dist/packages/sdk-ui/src/data-browser/data-schema-browser/data-schema-browser.d.ts

@@ -0,0 +1,14 @@
+import { Dimension } from '@sisense/sdk-data';
+type DataSchemaBrowserProps = {
+    dimensions: Dimension[];
+    collapseAll?: boolean;
+};
+/**
+ * A component that displays a list of dimensions and attributes for a given data source.
+ *
+ * @param params DataSchemaBrowserProps
+ * @returns ReactElement
+ * @internal
+ */
+export declare const DataSchemaBrowser: ({ dimensions, collapseAll }: DataSchemaBrowserProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/packages/sdk-ui/src/data-browser/data-schema-browser/data-schema-browser.styles.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { Themable } from '../../theme-provider/types.js';
+export declare const DimensionsBrowserContainer: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+} & Themable, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/packages/sdk-ui/src/data-browser/dimensions-browser/types.d.ts

@@ -37,6 +37,11 @@ export type DimensionsBrowserProps = {
         disabledAttributes: AttributiveElement[];
         getTooltip: (attribute: AttributiveElement) => string;
     };
+    /**
+     * Whether to collapse all dimensions by default.
+     * @internal
+     */
+    collapseAll?: boolean;
 };
 /**
  * Attribute-like element.

package/dist/packages/sdk-ui/src/decorators/component-decorators/as-sisense-component.d.ts

@@ -17,6 +17,8 @@ export type SisenseComponentConfig = {
     customContextErrorMessageKey?: string;
     /** If set, the component will have a standalone menu root, allowing the menu to be opened even when the component is used outside of the SisenseContextProvider */
     shouldHaveOwnMenuRoot?: boolean;
+    /** If set, the component will have a standalone modal root, allowing modals to be opened even when the component is used outside of a ModalProvider */
+    shouldHaveOwnModalRoot?: boolean;
 };
 export type ComponentDecorator<DecoratorConfig> = (decoratorConfig: DecoratorConfig) => <ComponentProps extends Record<string, any>>(Component: FunctionComponent<ComponentProps>) => FunctionComponent<ComponentProps>;
 /**

package/dist/packages/sdk-ui/src/decorators/component-decorators/with-modal.d.ts

@@ -0,0 +1,6 @@
+import { ComponentDecorator } from './as-sisense-component';
+type ModalConfig = {
+    shouldHaveOwnModalRoot?: boolean;
+};
+export declare const withModal: ComponentDecorator<ModalConfig>;
+export {};

package/dist/packages/sdk-ui/src/error-boundary/error-boundary.d.ts

@@ -8,11 +8,14 @@ interface ErrorBoundaryProps {
     error?: AbstractTranslatableError | Error | string;
     children: ReactNode;
     resetKeys?: any[];
-    onError?: (error: Error) => void;
+    onError?: (error: Error) => void | ReactNode;
     isContainerComponent?: boolean;
+    /** If set to true, children will be rendered when an error is provided via props, but not when caught during rendering */
+    shouldRenderChildrenWithProvidedError?: boolean;
 }
 type ErrorBoundaryState = {
     error: AbstractTranslatableError | Error | string | null;
+    customErrorUI: ReactNode | null;
 };
 /**
  * This component is used to catch errors thrown by the UI component and display an error message
@@ -24,11 +27,12 @@ type ErrorBoundaryState = {
  */
 export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
     showErrorBox: boolean;
-    onError?: (error: Error) => void;
+    onError?: (error: Error) => void | ReactNode;
     isContainerComponent: boolean;
     constructor(props: ErrorBoundaryProps);
     static getDerivedStateFromError(error: Error): {
         error: Error;
+        customErrorUI: null;
     };
     componentDidCatch(error: Error): void;
     componentDidUpdate(prevProps: ErrorBoundaryProps, prevState: ErrorBoundaryState): void;

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

@@ -44,7 +44,7 @@ export { usePlugins } from './plugins-provider/plugins-provider';
 export { extractDimensionsAndMeasures, useExecutePluginQuery, } from './plugins-provider/use-execute-plugin-query';
 export { getThemeSettingsByOid } from './themes/theme-loader';
 export { getDefaultThemeSettings } from './theme-provider/default-theme-settings';
-export { useGetDashboardModel, useGetDashboardModels, useDashboardModel, getDashboardModel, getDashboardModels, useGetWidgetModel, getWidgetModel, translateToDashboardResponse, translateToDashboardsResponse, useGetHierarchyModels, getHierarchyModels, translateFiltersAndRelationsToDto, type DashboardModel, type GetDashboardModelParams, type GetDashboardModelsParams, type DashboardModelState, type DashboardModelLoadingState, type DashboardModelSuccessState, type DashboardModelErrorState, type DashboardModelsState, type DashboardModelsLoadingState, type DashboardModelsSuccessState, type DashboardModelsErrorState, type WidgetModel, type WidgetDataOptions, type WidgetModelState, type WidgetModelLoadingState, type WidgetModelErrorState, type WidgetModelSuccessState, type GetWidgetModelParams, type GetDashboardModelOptions, type GetDashboardModelsOptions, type WidgetsPanelColumnLayout, type WidgetsPanelLayout, type WidgetsPanelColumn, type WidgetsPanelRow, type WidgetsPanelCell, type WidgetId, type WidgetsOptions, type CommonFiltersOptions, type CommonFiltersApplyMode, type FiltersIgnoringRules, type HierarchyModel, type Hierarchy, type HierarchyId, type GetHierarchyModelsParams, type HierarchyModelsState, type HierarchyModelsLoadingState, type HierarchyModelsErrorState, type HierarchyModelsSuccessState, UseDashboardModelActionType, } from './models';
+export { useGetDashboardModel, useGetDashboardModels, useDashboardModel, useDashboardPersistence, getDashboardModel, getDashboardModels, useGetWidgetModel, getWidgetModel, translateToDashboardResponse, translateToDashboardsResponse, useGetHierarchyModels, getHierarchyModels, translateFiltersAndRelationsToDto, type DashboardModel, type GetDashboardModelParams, type GetDashboardModelsParams, type DashboardModelState, type DashboardModelLoadingState, type DashboardModelSuccessState, type DashboardModelErrorState, type DashboardModelsState, type DashboardModelsLoadingState, type DashboardModelsSuccessState, type DashboardModelsErrorState, type WidgetModel, type WidgetDataOptions, type WidgetModelState, type WidgetModelLoadingState, type WidgetModelErrorState, type WidgetModelSuccessState, type GetWidgetModelParams, type GetDashboardModelOptions, type GetDashboardModelsOptions, type WidgetsPanelColumnLayout, type WidgetsPanelLayout, type WidgetsPanelColumn, type WidgetsPanelRow, type WidgetsPanelCell, type WidgetId, type WidgetsOptions, type CommonFiltersOptions, type CommonFiltersApplyMode, type FiltersIgnoringRules, type HierarchyModel, type Hierarchy, type HierarchyId, type GetHierarchyModelsParams, type HierarchyModelsState, type HierarchyModelsLoadingState, type HierarchyModelsErrorState, type HierarchyModelsSuccessState, UseDashboardModelActionType, } from './models';
 /**
  * Utility functions to translate a Fusion widget model from and to other widget data structures
  *
@@ -93,4 +93,5 @@ export { translateColumnToAttribute } from './chart-data-options/utils';
 export { isSameAttribute } from './utils/filters';
 export { updateDrilldownSelections } from './widgets/common/use-drilldown-core';
 export { getSelectionTitleMenuItem, getDrilldownMenuItems } from './widgets/hooks/use-drilldown';
+export { DataSchemaBrowser } from './data-browser/data-schema-browser/data-schema-browser';
 export { type TranslationDictionary, PACKAGE_NAMESPACE as translationNamespace, } from './translation/resources';

package/dist/packages/sdk-ui/src/models/dashboard/dashboard-model.d.ts

@@ -2,6 +2,7 @@ import { DataSource, Filter, FilterRelations } from '@sisense/sdk-data';
 import { DashboardStyleOptions, TabbersOptions, WidgetModel } from '../../models';
 import { type WidgetsOptions } from './types';
 import { DashboardLayoutOptions } from '../../dashboard';
+import { DashboardSettings } from '../../api/types/dashboard-dto';
 /**
  * Model of Sisense Fusion dashboard defined in the abstractions of Compose SDK.
  *
@@ -55,4 +56,10 @@ export interface DashboardModel {
      * @internal
      */
     tabbersOptions?: TabbersOptions;
+    /**
+     * Dashboard settings.
+     *
+     * @internal
+     */
+    settings?: DashboardSettings;
 }

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

@@ -7,3 +7,4 @@ export * from './dashboard-model';
 export * as dashboardModelTranslator from './dashboard-model-translator';
 export * from './use-dashboard-model/use-dashboard-model';
 export * from './use-dashboard-model/use-dashboard-model-reducer';
+export * from './use-dashboard-model/use-dashboard-persistence';

package/dist/packages/sdk-ui/src/models/dashboard/translate-dashboard-dto-utils.d.ts

@@ -1,5 +1,6 @@
 import { Filter } from '@sisense/sdk-data';
-import { CascadingFilterDto, FilterDto } from '../../api/types/dashboard-dto';
+import { CascadingFilterDto, FilterDto, LayoutDto } from '../../api/types/dashboard-dto';
+import { WidgetsPanelLayout } from '../../dashboard/types';
 /**
  * Translates a {@link Filter} to a {@link FilterDto}.
  *
@@ -8,3 +9,4 @@ import { CascadingFilterDto, FilterDto } from '../../api/types/dashboard-dto';
  * @internal
  */
 export declare function filterToFilterDto(filter: Filter): FilterDto | CascadingFilterDto;
+export declare function layoutToLayoutDto(layout: WidgetsPanelLayout): LayoutDto;

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

@@ -1,5 +1,6 @@
 import { CommonFiltersOptions } from '../../common-filters/types';
 import { ColorPaletteTheme, TabberConfig } from '../../types';
+import { JTDConfig } from '../../widget-by-id/types';
 export type { CommonFiltersOptions, CommonFiltersApplyMode, FiltersIgnoringRules, } from '../../common-filters/types';
 /**
  * Part of Dashboard layout, which describes how widgets are arranged in a cell
@@ -49,9 +50,14 @@ export type WidgetId = string;
  */
 export type WidgetsOptions = Record<WidgetId, {
     filtersOptions?: CommonFiltersOptions;
+    /**
+     * Jump to dashboard config for widgets
+      @internal
+     */
+    jtdConfig?: JTDConfig;
 }>;
 /**
- * Options for TabberWidetss in a dashboard
+ * Options for TabberWidets in a dashboard
  *
  * This property actually moves responsibility on the layout management from the tabber widgets to the dashboard,
  * storing all the tabbers configs in the single place

package/dist/packages/sdk-ui/src/models/dashboard/use-dashboard-model/use-dashboard-model-reducer.d.ts

@@ -1,4 +1,4 @@
-import { DashboardModel, WidgetModel } from '../../../models';
+import { DashboardModel, WidgetModel, WidgetsPanelLayout } from '../../../models';
 import { Filter, FilterRelations } from '@sisense/sdk-data';
 import { RestApi } from '../../../api/rest-api';
 export type UseDashboardModelState = DashboardModel | null;
@@ -8,8 +8,7 @@ export type UseDashboardModelState = DashboardModel | null;
  * @internal
  */
 export declare enum UseDashboardModelActionTypeInternal {
-    DASHBOARD_INIT = "DASHBOARD.INIT",
-    DASHBOARD_UPDATE_LAYOUT = "DASHBOARD.UPDATE_LAYOUT"
+    DASHBOARD_INIT = "DASHBOARD.INIT"
 }
 /**
  * Action types for the dashboard model state used in {@link useDashboardModel}.
@@ -18,7 +17,8 @@ export declare enum UseDashboardModelActionTypeInternal {
  */
 export declare enum UseDashboardModelActionType {
     FILTERS_UPDATE = "FILTERS.UPDATE",
-    ADD_WIDGET = "WIDGETS.ADD"
+    ADD_WIDGET = "WIDGETS.ADD",
+    WIDGETS_PANEL_LAYOUT_UPDATE = "WIDGETS_PANEL_LAYOUT.UPDATE"
 }
 /**
  * Internal actions for the dashboard model state used in {@link useDashboardModel}.
@@ -34,7 +34,7 @@ export type UseDashboardModelInternalAction = UseDashboardModelAction | {
  *
  * @internal
  */
-export type UseDashboardModelAction = UseDashboardModelFilterUpdateAction | UseDashboardModelAddWidgetAction;
+export type UseDashboardModelAction = UseDashboardModelFilterUpdateAction | UseDashboardModelAddWidgetAction | UseDashboardModelLayoutUpdateAction;
 /**
  * Filter update actions for the dashboard model state used in {@link useDashboardModel}.
  *
@@ -53,6 +53,15 @@ export type UseDashboardModelAddWidgetAction = {
     type: UseDashboardModelActionType.ADD_WIDGET;
     payload: WidgetModel;
 };
+/**
+ * Layout update action for the dashboard model state used in {@link useDashboardModel}.
+ *
+ * @internal
+ */
+export type UseDashboardModelLayoutUpdateAction = {
+    type: UseDashboardModelActionType.WIDGETS_PANEL_LAYOUT_UPDATE;
+    payload: WidgetsPanelLayout;
+};
 /**
  * Reducer for the dashboard model state used in {@link useDashboardModel}.
  *

package/dist/packages/sdk-ui/src/models/dashboard/use-dashboard-model/use-dashboard-model.d.ts

@@ -1,6 +1,5 @@
-import { GetDashboardModelParams } from '../../../models';
-import { Dispatch } from 'react';
-import { UseDashboardModelAction } from './use-dashboard-model-reducer';
+import { GetDashboardModelParams } from '../use-get-dashboard-model';
+import { UseDashboardPersistenceResult } from './use-dashboard-persistence';
 export interface UseDashboardModelParams extends GetDashboardModelParams {
     /**
      * Boolean flag indicating whether changes to the dashboard state should be saved to the dashboard in Fusion
@@ -10,6 +9,20 @@ export interface UseDashboardModelParams extends GetDashboardModelParams {
      */
     persist?: boolean;
 }
+export interface UseDashboardModelResult extends UseDashboardPersistenceResult {
+    /**
+     * Whether the dashboard model is loading
+     */
+    isLoading: boolean;
+    /**
+     * Whether the dashboard model load has failed
+     */
+    isError: boolean;
+    /**
+     * The error if any occurred during loading
+     */
+    error: Error | undefined;
+}
 /**
  *  This hook allows you to retrieve and manage a dashboard model from a Sisense instance.
  *  It handles fetching the existing dashboard, managing its local state, and saving any changes back to the Sisense server.
@@ -20,22 +33,10 @@ export interface UseDashboardModelParams extends GetDashboardModelParams {
  * @fusionEmbed
  * @internal
  */
-export declare const useDashboardModel: (args_0: UseDashboardModelParams) => {
-    dashboard: import('../../../models').UseDashboardModelState;
-    isLoading: boolean;
-    isError: boolean;
-    error: Error | undefined;
-    dispatchChanges: Dispatch<UseDashboardModelAction>;
-};
+export declare const useDashboardModel: (args_0: UseDashboardModelParams) => UseDashboardModelResult;
 /**
  * {@link useDashboardModel} without tracking to be used inside other hooks or components in Compose SDK.
  *
  * @internal
  */
-export declare function useDashboardModelInternal({ dashboardOid, includeWidgets, includeFilters, persist, }: UseDashboardModelParams): {
-    dashboard: import('../../../models').UseDashboardModelState;
-    isLoading: boolean;
-    isError: boolean;
-    error: Error | undefined;
-    dispatchChanges: Dispatch<UseDashboardModelAction>;
-};
+export declare function useDashboardModelInternal({ dashboardOid, includeWidgets, includeFilters, persist, }: UseDashboardModelParams): UseDashboardModelResult;

package/dist/packages/sdk-ui/src/models/dashboard/use-dashboard-model/use-dashboard-persistence.d.ts

@@ -0,0 +1,34 @@
+import { UseDashboardModelAction } from './use-dashboard-model-reducer';
+import { DashboardModel } from '../../../models';
+export interface UseDashboardPersistenceParams {
+    /**
+     * The dashboard model to manage persistence for
+     */
+    dashboard: DashboardModel | null;
+    /**
+     * Boolean flag indicating whether changes to the dashboard state should be saved to the dashboard in Fusion
+     *
+     * @default true
+     */
+    persist?: boolean;
+}
+export interface UseDashboardPersistenceResult {
+    /**
+     * The current dashboard model with local state
+     */
+    dashboard: DashboardModel | null;
+    /**
+     * Function to dispatch changes to the dashboard model with optional persistence
+     * Returns a promise when persistence is enabled to allow error handling
+     */
+    dispatchChanges: (action: UseDashboardModelAction) => Promise<void> | void;
+}
+/**
+ * Hook that provides persistence capabilities for an already loaded dashboard model.
+ * This hook manages local state changes and optionally persists them to the server.
+ *
+ * @param params - Parameters for dashboard persistence
+ * @returns Dashboard persistence state and dispatch function
+ * @internal
+ */
+export declare function useDashboardPersistence({ dashboard, persist, }: UseDashboardPersistenceParams): UseDashboardPersistenceResult;