@sisense/sdk-ui 2.29.0 → 2.31.0

package/dist/packages/sdk-ui/src/domains/dashboarding/common-filters/utils.d.ts

@@ -22,5 +22,5 @@ type GetWidgetDataOptionsWithDrilldownParams = {
  * @param params.drilldownOptions - The drilldown options of the widget.
  * @returns The widget data options with drilldown applied.
  */
-export declare function getWidgetDataOptionsWithDrilldown({ widgetType, chartType, dataOptions, drilldownOptions, }: GetWidgetDataOptionsWithDrilldownParams): import('../../../index.js').CategoricalChartDataOptions | import('../../../index.js').ScatterChartDataOptions | import('../../../index.js').IndicatorChartDataOptions | import('../../../index.js').BoxplotChartDataOptions | import('../../../index.js').BoxplotChartCustomDataOptions | import('../../../index.js').AreamapChartDataOptions | import('../../../index.js').ScattermapChartDataOptions | import('../../../index.js').RangeChartDataOptions | import('../../../index.js').CalendarHeatmapChartDataOptions | import('../../../index.js').TableDataOptions | PivotTableDataOptions | GenericDataOptions;
+export declare function getWidgetDataOptionsWithDrilldown({ widgetType, chartType, dataOptions, drilldownOptions, }: GetWidgetDataOptionsWithDrilldownParams): import('../../../index.js').CategoricalChartDataOptions | import('../../../index.js').ScatterChartDataOptions | import('../../../index.js').IndicatorChartDataOptions | import('../../../index.js').BoxplotChartDataOptions | import('../../../index.js').BoxplotChartCustomDataOptions | import('../../../index.js').AreamapChartDataOptions | import('../../../index.js').ScattermapChartDataOptions | import('../../../index.js').RangeChartDataOptions | import('../../../index.js').CalendarHeatmapChartDataOptions | import('../../../index.js').SankeyChartDataOptions | import('../../../index.js').TableDataOptions | PivotTableDataOptions | GenericDataOptions;
 export {};

package/dist/packages/sdk-ui/src/domains/dashboarding/components/dashboard-container.d.ts

@@ -1,2 +1,2 @@
 import { DashboardContainerProps } from '../../../domains/dashboarding/types';
-export declare const DashboardContainer: ({ editMode, onLayoutChange, renderToolbar, title, layoutOptions, config, widgets, filters, onFiltersChange, defaultDataSource, filterPanelCollapsed, onFilterPanelCollapsedChange, }: DashboardContainerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DashboardContainer: ({ editMode, onLayoutChange, headerItems, headerConfig, title, layoutOptions, config, widgets, filters, onFiltersChange, defaultDataSource, filterPanelCollapsed, onFilterPanelCollapsedChange, }: DashboardContainerProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,16 @@
+/**
+ * Layout constants for the dashboard header.
+ */
+/**
+ * Default (and minimum) dashboard header height (px): the default 28px item plus the 10px top/bottom
+ * padding. The header grows beyond this when an item is taller than the default.
+ */
+export declare const DASHBOARD_HEADER_HEIGHT = 48;
+/**
+ * Default size (px) for dashboard header items that don't specify their own size.
+ */
+export declare const DASHBOARD_HEADER_ITEM_SIZE = 28;
+/**
+ * Gap (px) between adjacent dashboard header items (matches Fusion's 10px spacing).
+ */
+export declare const DASHBOARD_HEADER_ITEMS_GAP = 10;

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

@@ -0,0 +1,122 @@
+import { ReactNode } from 'react';
+import { DashboardHeaderTarget } from './dashboard-header-targets';
+/**
+ * Size of a custom dashboard header item, in pixels.
+ */
+export interface DashboardHeaderItemSize {
+    /**
+     * Fixed width of the item, in pixels.
+     *
+     * If omitted, it falls back to the default dashboard header item size of `28px`.
+     *
+     * @default 28
+     */
+    width?: number;
+    /**
+     * Fixed height of the item, in pixels.
+     *
+     * If omitted, it falls back to the default dashboard header item size of `28px`.
+     *
+     * @default 28
+     */
+    height?: number;
+}
+/**
+ * Props passed to a {@link DashboardHeaderItemComponent} when it is rendered.
+ */
+export interface DashboardHeaderItemComponentProps {
+    /** The size resolved for the item by the header layout, with defaults applied. */
+    size: {
+        /**
+         * Fixed width of the item, in pixels.
+         */
+        width: number;
+        /**
+         * Fixed height of the item, in pixels.
+         */
+        height: number;
+    };
+}
+/**
+ * A React component that renders the content of a custom dashboard header item.
+ */
+export type DashboardHeaderItemComponent = (props: DashboardHeaderItemComponentProps) => ReactNode;
+/**
+ * Position of a custom dashboard header item relative to the other items.
+ *
+ * - `auto` (default) — automatic placement.
+ * - `before` / `after` — placed immediately before/after the item with the given `target` id.
+ *   Pass a {@link DashboardHeaderTargets} constant to anchor to a built-in item (works even when
+ *   that built-in is currently hidden), or any custom item id to anchor to another injected item.
+ * - `first` / `last` — placed at the very start/end of the header.
+ */
+export type DashboardHeaderItemPosition = {
+    type: 'auto';
+} | {
+    type: 'before';
+    target: DashboardHeaderTarget | string;
+} | {
+    type: 'after';
+    target: DashboardHeaderTarget | string;
+} | {
+    type: 'first';
+} | {
+    type: 'last';
+};
+/**
+ * A custom item to inject into the dashboard header.
+ */
+export interface DashboardHeaderItem {
+    /**
+     * Unique identifier of the item.
+     *
+     * Must not match a built-in dashboard header item id (see {@link DashboardHeaderTargets}).
+     */
+    id: string;
+    /**
+     * Component that renders the content of the item.
+     */
+    component: DashboardHeaderItemComponent;
+    /**
+     * Placement of the item.
+     *
+     * Defaults to `{ type: 'auto' }` (after the center spacer).
+     */
+    position?: DashboardHeaderItemPosition;
+    /**
+     * Size of the item.
+     */
+    size?: DashboardHeaderItemSize;
+}
+/**
+ * A dashboard header item after the built-in and custom items have been ordered (position applied).
+ *
+ * This is the shape passed to {@link DashboardHeaderConfig.onBeforeRender}.
+ */
+export type DashboardResolvedHeaderItem = Omit<DashboardHeaderItem, 'position'>;
+/**
+ * Transforms the fully ordered list of dashboard header items right before rendering.
+ */
+export type DashboardHeaderItemsTransform = (items: ReadonlyArray<DashboardResolvedHeaderItem>) => DashboardResolvedHeaderItem[];
+/**
+ * Configuration for the dashboard header items.
+ */
+export interface DashboardHeaderConfig {
+    /**
+     * Boolean flag that determines whether the dashboard header is visible.
+     *
+     * If not specified, the default value is `true`.
+     */
+    visible?: boolean;
+    /**
+     * Custom items to inject into the header.
+     *
+     * Each item's `id` must not match a built-in item id (see {@link DashboardHeaderTargets}).
+     */
+    items?: DashboardHeaderItem[];
+    /**
+     * Advanced callback to inspect and rewrite the full, ordered list of header items (built-in +
+     * custom) right before rendering. The only way to modify or remove built-in items.
+     */
+    onBeforeRender?: DashboardHeaderItemsTransform;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Ids of the built-in dashboard header items.
+ *
+ * Use these as `target`s for the `before`/`after` position of a {@link DashboardHeaderItem}.
+ * A target stays valid even when it is not currently shown (e.g. the filter toggle when
+ * its icon is disabled): the position resolves as if the built-in were there, so the custom item lands
+ * in a stable spot regardless of which built-ins happen to be visible.
+ */
+export declare const DashboardHeaderTargets: {
+    /** The dashboard title. */
+    readonly Title: "dashboard-header-title";
+    /** The flexible center spacer that separates the title and trailing groups. */
+    readonly Spacer: "dashboard-header-spacer";
+    /** The edit-mode toolbar (undo/redo/cancel/apply), shown while editing with batch changes. */
+    readonly EditModeToolbar: "dashboard-header-edit-mode-toolbar";
+    /** The edit-mode toggle button. */
+    readonly EditToggle: "dashboard-header-edit-toggle";
+    /** The filters-panel toggle button. */
+    readonly FilterToggle: "dashboard-header-filter-toggle";
+    /** The overflow/context menu button. */
+    readonly Menu: "dashboard-header-menu";
+};
+/**
+ * Union of the built-in dashboard header item ids, usable as `target` for `before`/`after` positions.
+ */
+export type DashboardHeaderTarget = (typeof DashboardHeaderTargets)[keyof typeof DashboardHeaderTargets];

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

@@ -0,0 +1,20 @@
+import { HeaderItem } from '../../../../domains/shared/header';
+/**
+ * Props for {@link DashboardHeaderTitle}.
+ */
+export interface DashboardHeaderTitleProps {
+    /** The dashboard title text. */
+    title: string;
+}
+/**
+ * The dashboard title, rendered as the content of the built-in title header item.
+ */
+export declare const DashboardHeaderTitle: ({ title }: DashboardHeaderTitleProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Builds the built-in title header item.
+ *
+ * The title can be targeted by `before`/`after`. It uses the internal `fill: 'truncate'` so it
+ * takes its natural content width on the leading side and is the only item that shrinks/ellipsizes
+ * under pressure (action buttons keep their size); the center spacer absorbs the free space.
+ */
+export declare const createDashboardTitleItem: (title: string) => HeaderItem;

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

@@ -0,0 +1,9 @@
+import { DashboardHeaderProps } from '../../../../domains/dashboarding/types';
+/**
+ * Dashboard header.
+ *
+ * Pure renderer: it receives the full list of built-in header items (title and center spacer
+ * included), resolves them against the user {@link DashboardHeaderConfig} (ordering then
+ * `onBeforeRender`), and renders the result. Auto-positioned items land after the center spacer.
+ */
+export declare const DashboardHeader: ({ items, config }: DashboardHeaderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/packages/sdk-ui/src/domains/dashboarding/components/toolbar/edit-toggle.d.ts

@@ -17,6 +17,11 @@ export interface EditToggleProps {
      * Color of the edit toggle button
      */
     color?: string;
+    /**
+     * Size (px) of the square button box, provided by the header layout. Defaults to the dashboard
+     * header item size.
+     */
+    size?: number;
     /**
      * Callback function called when the edit toggle button is clicked
      */

package/dist/packages/sdk-ui/src/domains/dashboarding/components/toolbar/filter-toggle.d.ts

@@ -8,6 +8,11 @@ export interface FilterToggleProps {
      * Color of the filter toggle button
      */
     color?: string;
+    /**
+     * Size (px) of the square button box, provided by the header layout. Defaults to the dashboard
+     * header item size.
+     */
+    size?: number;
     /**
      * Callback function called when the filter toggle button is clicked
      */

package/dist/packages/sdk-ui/src/domains/dashboarding/constants.d.ts

@@ -1,11 +1,11 @@
 import type { DeepRequired } from 'ts-essentials';
 import { DashboardByIdConfig, DashboardConfig, EditModeConfig, WidgetsPanelConfig } from './types.js';
-export declare const DEFAULT_DASHBOARD_CONFIG: DeepRequired<Omit<DashboardConfig, 'widgetsPanel' | 'tabbers'> & {
+export declare const DEFAULT_DASHBOARD_CONFIG: DeepRequired<Omit<DashboardConfig, 'widgetsPanel' | 'tabbers' | 'header'> & {
     widgetsPanel: Omit<WidgetsPanelConfig, 'editMode'> & {
         editMode: Omit<EditModeConfig, 'isEditing'>;
     };
 }>;
-export declare const DEFAULT_DASHBOARD_BY_ID_CONFIG: DeepRequired<Omit<DashboardByIdConfig, 'widgetsPanel' | 'tabbers'> & {
+export declare const DEFAULT_DASHBOARD_BY_ID_CONFIG: DeepRequired<Omit<DashboardByIdConfig, 'widgetsPanel' | 'tabbers' | 'header'> & {
     widgetsPanel: Omit<WidgetsPanelConfig, 'editMode'> & {
         editMode: Omit<EditModeConfig, 'isEditing'>;
     };

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

@@ -1,4 +1,5 @@
 import { Filter, FilterRelations } from '@sisense/sdk-data';
+import { DashboardHeaderItem } from './components/dashboard-header/dashboard-header-config.js';
 import type { JumpToDashboardConfig } from './hooks/jtd/jtd-types.js';
 import { DashboardProps } from './types.js';
 /**
@@ -216,3 +217,23 @@ export declare const applyJtdConfig: (dashboard: DashboardProps, widgetOid: stri
  * @group Dashboard Utilities
  */
 export declare const applyJtdConfigs: (dashboard: DashboardProps, jtdConfigs: Record<string, JumpToDashboardConfig>) => DashboardProps;
+/**
+ * Creates a transformer that appends the given item to `config.header.items` of a dashboard.
+ *
+ * This is the canonical way for a dashboard customization (see `DashboardCustomization`) to add a
+ * header toolbar item. The returned transformer is pure — it does not modify the original dashboard;
+ * instead, it returns a new dashboard with the header item added.
+ *
+ * @example
+ * Add a custom header item to a dashboard.
+ * ```ts
+ * const updatedDashboard = withHeaderItem({
+ *   id: 'my-button',
+ *   component: () => <MyButton />,
+ * })(dashboard);
+ * ```
+ * @param item - The header item to add.
+ * @returns A transformer `(dashboard: DashboardProps) => DashboardProps` with the item appended.
+ * @sisenseInternal
+ */
+export declare const withHeaderItem: (item: DashboardHeaderItem) => (dashboard: Readonly<DashboardProps>) => DashboardProps;

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-model/translate-dashboard-utils.d.ts

@@ -1,6 +1,6 @@
 import { Dimension, Filter, FilterRelations, Measure } from '@sisense/sdk-data';
 import { JtdTarget, JumpToDashboardConfig, JumpToDashboardConfigForPivot, TriggerMethod } from '../../../domains/dashboarding/hooks/jtd/jtd-types';
-import { TabbersConfig } from '../../../domains/dashboarding/hooks/use-tabber';
+import { TabberConfig, TabbersConfig } from '../../../domains/dashboarding/hooks/use-tabber';
 import { Panel, WidgetDto } from '../../../domains/widgets/components/widget-by-id/types';
 import { RestApi } from '../../../infra/api/rest-api';
 import { type CascadingFilterDto, DashboardDto, type FilterDto, type LayoutDto } from '../../../infra/api/types/dashboard-dto';
@@ -39,6 +39,48 @@ export declare function translateWidgetsOptions(widgets?: WidgetDto[]): WidgetsO
  * @internal
  */
 export declare function withSpecificWidgetOptions(widgetOptions?: SpecificWidgetOptions): (widgetDto: WidgetDto) => WidgetDto;
+/**
+ * The dashboard-level context held about a single widget, gathered from the
+ * (separate) containers it can live in: `widgetsOptions[id]`
+ * ({@link SpecificWidgetOptions}: common filters, JTD, partial DTO snapshot) and
+ * `config.tabbers[id]` ({@link TabberConfig}: per-tab show/hide mapping).
+ *
+ * Consumed by {@link withDashboardWidgetContext} to re-project this context onto a
+ * freshly-translated {@link WidgetDto} on add/duplicate, so dashboard-level config
+ * survives the model → DTO write path.
+ *
+ * @internal
+ */
+export type WidgetContext = {
+    /** Per-widget options from `widgetsOptions[id]`. */
+    options?: SpecificWidgetOptions;
+    /** Tabber show/hide mapping from `config.tabbers[id]`. */
+    tabber?: TabberConfig;
+};
+/**
+ * Overlays a {@link TabberConfig} onto a tabber {@link WidgetDto}.
+ *
+ * The widget-level translator (`toTabberWidgetStyle`) rebuilds `style.tabs[]` with
+ * tab names / `activeTab` / styling but empty `displayWidgetIds` — the widget model
+ * does not know about other widgets' ids. This overlays the dashboard-level
+ * show/hide mapping back onto those tabs by index. No-op for non-tabber DTOs or
+ * when there is no tabber config.
+ *
+ * @internal
+ */
+export declare function withTabberWidgetConfig(tabberConfig?: TabberConfig): (widgetDto: WidgetDto) => WidgetDto;
+/**
+ * Projects all dashboard-level {@link WidgetContext} for a widget onto a freshly
+ * translated {@link WidgetDto}. Composes the per-container projections
+ * ({@link withSpecificWidgetOptions} for `widgetsOptions`, {@link withTabberWidgetConfig}
+ * for `config.tabbers`); each is last-write-wins and a no-op when its slice is absent.
+ *
+ * This is the single seam that re-attaches dashboard-level widget config on
+ * add/duplicate; a new per-widget side-channel adds its projection here.
+ *
+ * @internal
+ */
+export declare function withDashboardWidgetContext(context: WidgetContext): (widgetDto: WidgetDto) => WidgetDto;
 export declare function translateTabbersOptions(widgets?: WidgetDto[]): TabbersConfig;
 /**
  * Replace all shared formulas, which defined by id references, in the dashboard with their actual values.

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-model/use-dashboard-model/dashboard-model-reducer/persist-dashboard-model-middleware.d.ts

@@ -4,6 +4,16 @@ import { RestApi } from '../../../../../infra/api/rest-api';
 import { AppSettings } from '../../../../../infra/app/settings/settings';
 import { CompleteThemeSettingsInternal } from '../../../../../types';
 import { UseDashboardModelInternalAction } from './types.js';
+/**
+ * Returns the Fusion `tableState.colResize.tableSize` for persisted column widths.
+ * Fusion renders each column as `(columnPx / sum(columns)) × tableSize`, so
+ * `tableSize` must equal the sum of column pixel widths for absolute px rendering.
+ *
+ * @param columnWidths - Column pixel widths in display order
+ * @returns Total table width in pixels
+ * @internal
+ */
+export declare function toColResizeTableSize(columnWidths: readonly number[]): number;
 export type PersistDashboardModelMiddlewareParams = {
     /** Dashboard OID, or undefined if not initialized */
     dashboardOid: string | undefined;

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-model/use-dashboard-model/dashboard-model-reducer/types.d.ts

@@ -1,5 +1,6 @@
 import { Filter, FilterRelations } from '@sisense/sdk-data';
 import { DashboardModel, SpecificWidgetOptions, WidgetsPanelLayout } from '../../../../../domains/dashboarding/dashboard-model';
+import { TabberConfig } from '../../../../../domains/dashboarding/hooks/use-tabber';
 import type { WidgetPropsUpdate } from '../../../../../domains/dashboarding/persistence/update-types.js';
 import type { WidgetDto } from '../../../../../domains/widgets/components/widget-by-id/types';
 import { WidgetModel } from '../../../../../domains/widgets/widget-model';
@@ -123,6 +124,12 @@ export type UseDashboardModelAddWidgetAction = {
         widget: WidgetModel;
         widgetsPanelLayout?: WidgetsPanelLayout;
         widgetOptions?: SpecificWidgetOptions;
+        /**
+         * Dashboard-level tabber config for the widget (from `config.tabbers[id]`),
+         * carried so the persist middleware can project it back onto the widget DTO
+         * and the reducer can store it under the new widget id on duplication.
+         */
+        tabberConfig?: TabberConfig;
     };
 };
 /**

package/dist/packages/sdk-ui/src/domains/dashboarding/dashboard-model/use-dashboard-model/dashboard-model-reducer/utils.d.ts

@@ -1,5 +1,6 @@
 import { Filter, FilterRelations } from '@sisense/sdk-data';
 import { SpecificWidgetOptions, WidgetsPanelLayout } from '../../../../../domains/dashboarding/dashboard-model';
+import { TabberConfig } from '../../../../../domains/dashboarding/hooks/use-tabber';
 import { WidgetModel } from '../../../../../domains/widgets/widget-model';
 import { AddWidgetPayload } from './types.js';
 /**
@@ -24,6 +25,7 @@ export declare function parseAddWidgetPayload(payload: AddWidgetPayload): {
     widget: WidgetModel;
     widgetsPanelLayout?: WidgetsPanelLayout;
     widgetOptions?: SpecificWidgetOptions;
+    tabberConfig?: TabberConfig;
 };
 /**
  * Appends a widget cell to the first column's first row. Creates row/cells if missing.

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

@@ -0,0 +1,34 @@
+import { ApiContract, ApiField, Module } from '../../../infra/modules/types';
+import { DashboardCustomization } from './types.js';
+/** Name of the `dashboard` module. */
+export declare const DASHBOARD_MODULE_NAME = "dashboard";
+/**
+ * API declaration for the `dashboard` module.
+ */
+export interface DashboardModuleApiDefinition {
+    /**
+     * Registry of dashboard customization middlewares. Each contribution is applied, in registration
+     * order, to the props of every {@link Dashboard}.
+     */
+    customizations: ApiField<DashboardCustomization[], DashboardCustomization[]>;
+}
+/**
+ * The `dashboard` module.
+ *
+ * Owns the `customizations` registry — other modules contribute {@link DashboardCustomization}
+ * middlewares there (via their `integrations`), which `Dashboard` applies to its props. Register it
+ * on `SisenseContextProvider`'s `modules` prop together with the modules that customize dashboards.
+ *
+ * @example
+ * ```ts
+ * <SisenseContextProvider modules={[DashboardModule, ...otherModules]} ... />
+ * ```
+ * @sisenseInternal
+ */
+export declare const DashboardModule: Module<DashboardModuleApiDefinition>;
+/**
+ * API contract for contributing to the `dashboard` module.
+ *
+ * @sisenseInternal
+ */
+export type DashboardModuleApi = ApiContract<DashboardModuleApiDefinition>;

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

@@ -0,0 +1,65 @@
+import { Filter, FilterRelations } from '@sisense/sdk-data';
+import { SpecificWidgetOptions, WidgetsPanelLayout } from '../../../domains/dashboarding/dashboard-model';
+import { DashboardProps } from '../../../domains/dashboarding/types';
+import { WidgetProps } from '../../../domains/widgets/components/widget/types';
+/**
+ * Dashboard state API.
+ *
+ * Passed as the second argument to every {@link DashboardCustomization}. Each method is backed by
+ * the composition layer's own state, so mutations flow through the normal dashboard pipeline and are
+ * persisted automatically when the dashboard has persistence enabled.
+ *
+ * @sisenseInternal
+ */
+export interface DashboardStateApi {
+    /**
+     * Adds a widget to the dashboard. Persists automatically when the dashboard is configured with
+     * persistence enabled; otherwise updates local state only.
+     *
+     * @param widget - The widget to add.
+     * @param options - Optional dashboard-level configuration for the new widget:
+     * - `widgetOptions`: dashboard-level options for the widget (e.g. filtersOptions, jtdConfig).
+     * - `widgetsPanelLayout`: explicit widgets-panel layout describing where the widget is placed;
+     *   When omitted, the widget is appended in a new full-width row at the end of the first column.
+     * @returns void
+     */
+    addWidget: (widget: WidgetProps, options?: {
+        widgetOptions?: SpecificWidgetOptions;
+        widgetsPanelLayout?: WidgetsPanelLayout;
+    }) => void;
+    /**
+     * Replaces the dashboard filters.
+     *
+     * @param filters - The new filters or filter relations to apply.
+     * @returns void
+     */
+    setFilters: (filters: Filter[] | FilterRelations) => void;
+    /**
+     * Replaces the widgets-panel layout.
+     *
+     * @param layout - The new widgets-panel layout.
+     * @returns void
+     */
+    setWidgetsLayout: (layout: WidgetsPanelLayout) => void;
+}
+/**
+ * A dashboard customization middleware.
+ *
+ * Receives the dashboard props and returns a (possibly) modified copy — for example to
+ * inject a header item via `config.header.items`. The second argument is a {@link DashboardStateApi}
+ * for imperatively mutating dashboard state (e.g. adding a widget) in response to later user
+ * interaction. Customizations must be pure with respect to `dashboard` (return new props rather than
+ * mutate the argument) and idempotent, since they are re-applied on every render.
+ *
+ * @sisenseInternal
+ */
+export type DashboardCustomization = (
+/**
+ * The current dashboard props (read-only). Return a new object with your modifications rather
+ * than mutating this value directly.
+ *
+ * @param dashboard - Current dashboard props.
+ * @param stateApi - API for imperatively mutating dashboard state.
+ * @returns Modified dashboard props.
+ */
+dashboard: Readonly<DashboardProps>, stateApi: DashboardStateApi) => DashboardProps;

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

@@ -4,7 +4,6 @@ import { DashboardProps } from '../../domains/dashboarding/types';
  * React component that renders a dashboard whose elements are customizable. It includes internal logic of applying common filters to widgets.
  *
  * **Note:** Dashboard and Widget extensions based on JS scripts and add-ons in Fusion – for example, Blox and Jump To Dashboard – are not supported.
- *
  * @example
  *
  * Example of rendering a Fusion dashboard using the `useGetDashboardModel hook and the `Dashboard` component.

package/dist/packages/sdk-ui/src/domains/dashboarding/hooks/duplicate-widget/use-duplicate-widget-menu-item.d.ts

@@ -1,11 +1,14 @@
 /// <reference types="react" />
 import type { WidgetsOptions, WidgetsPanelLayout } from '../../../../domains/dashboarding/dashboard-model/types.js';
+import type { TabbersConfig } from '../../../../domains/dashboarding/hooks/use-tabber.js';
 import { type WidgetProps } from '../../../../domains/widgets/components/widget/types.js';
 import type { DashboardPersistenceManager } from '../../persistence/types.js';
 /** Setter for widgets array (e.g. React setState or updater function). */
 export type SetWidgets = React.Dispatch<React.SetStateAction<WidgetProps[]>>;
 /** Setter for widgets options array (e.g. React setState or updater function). */
 export type SetWidgetsOptions = React.Dispatch<React.SetStateAction<WidgetsOptions>>;
+/** Setter for the dashboard-level tabbers config (e.g. React setState or updater function). */
+export type SetTabbersConfig = React.Dispatch<React.SetStateAction<TabbersConfig>>;
 /** Setter for widgets panel layout. */
 export type SetWidgetsLayout = (newLayout: WidgetsPanelLayout) => void;
 /** Options for the duplicate widget middleware hook. */
@@ -24,6 +27,10 @@ export type UseDuplicateWidgetMenuItemParams = {
     widgetsOptions?: WidgetsOptions;
     /** Setter to update widgets options (e.g. from parent state). */
     setWidgetsOptions: SetWidgetsOptions;
+    /** Dashboard-level tabbers config (copied to the cloned widget so its tab show/hide mapping survives). */
+    tabbersConfig?: TabbersConfig;
+    /** Setter to update the tabbers config (e.g. from parent state). */
+    setTabbersConfig?: SetTabbersConfig;
     persistence?: Pick<DashboardPersistenceManager, 'addWidget'>;
 };
 /** Output of the duplicate widget middleware. */

package/dist/packages/sdk-ui/src/domains/dashboarding/hooks/use-dashboard-header-menu-item.d.ts

@@ -0,0 +1,9 @@
+import { HeaderItem } from '../../../domains/shared/header';
+import { MenuItemSection } from '../../../props';
+/**
+ * Builds the built-in dashboard header menu item from the given menu sections.
+ *
+ * Always returns the item so it can anchor `before`/`after` positioning; it is marked `hidden`
+ * (anchor-only, not rendered) when there are no menu sections.
+ */
+export declare const useDashboardHeaderMenuItem: (menuItemSections?: MenuItemSection[]) => HeaderItem;

package/dist/packages/sdk-ui/src/domains/dashboarding/hooks/use-edit-mode-with-history.d.ts

@@ -46,7 +46,6 @@ export interface UseEditModeToolbarResult {
 }
 /**
  * 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
  * @internal

package/dist/packages/sdk-ui/src/domains/dashboarding/hooks/use-widget-updates-persistence.d.ts

@@ -5,7 +5,8 @@ type Persistence = Pick<DashboardPersistenceManager, 'updateWidget'> | undefined
  * Composition middleware that adds persistable widget-update plumbing to a
  * widget list. For each widget that exposes a known runtime-state callback
  * (currently only `styleOptions.navigator.onScrollerChange` for charts with
- * a navigator), the hook injects a handler that:
+ * a navigator, and `styleOptions.columns.onColumnsResize` for table charts with
+ * resizable columns), the hook injects a handler that:
  *
  * 1. Applies the update optimistically to local widget state (the parent
  *    `useComposedDashboardInternal` re-renders with the new value).

package/dist/packages/sdk-ui/src/domains/dashboarding/persistence/types.d.ts

@@ -1,4 +1,5 @@
 import type { SpecificWidgetOptions, WidgetPatch, WidgetsPanelLayout } from '../../../domains/dashboarding/dashboard-model';
+import type { TabberConfig } from '../../../domains/dashboarding/hooks/use-tabber';
 import type { WidgetProps } from '../../../domains/widgets/components/widget/types';
 import type { WidgetPropsUpdate } from './update-types.js';
 export type { WidgetPropsUpdate, OnWidgetUpdate } from './update-types.js';
@@ -24,7 +25,12 @@ export type DashboardPersistenceManager = {
     /**
      * The dashboard-level options for the new widget.
      */
-    widgetOptions?: SpecificWidgetOptions) => Promise<{
+    widgetOptions?: SpecificWidgetOptions, 
+    /**
+     * The dashboard-level tabber config for the new widget (from `config.tabbers[id]`).
+     * Projected back onto the widget DTO and stored under the new widget id.
+     */
+    tabberConfig?: TabberConfig) => Promise<{
         /**
          * The persisted widget (possibly modified by the server, e.g. new id).
          */
@@ -37,6 +43,10 @@ export type DashboardPersistenceManager = {
          * The options for the widget (after server modifications).
          */
         widgetOptions?: SpecificWidgetOptions;
+        /**
+         * The tabber config for the widget (after server modifications).
+         */
+        tabberConfig?: TabberConfig;
     }>;
     /**
      * Patch a single field (e.g. title) on an existing widget.

package/dist/packages/sdk-ui/src/domains/dashboarding/persistence/update-types.d.ts

@@ -20,6 +20,9 @@ export type WidgetPropsUpdate = {
                 readonly max: number;
             };
         };
+        readonly columns?: {
+            readonly widths?: ReadonlyArray<number>;
+        };
         /**
          * For custom (plugin) widgets, `styleOptions` is an opaque deeply-partial
          * bag — arbitrary keys are deep-merged into the widget's opaque DTO
@@ -44,7 +47,7 @@ export type WidgetPropsUpdate = {
  * a persistable update for a specific widget. Not part of the public
  * `WidgetProps` surface — composition layer injects handlers into the
  * visualization's existing callback APIs (e.g.
- * `styleOptions.navigator.onScrollerChange`).
+ * `styleOptions.navigator.onScrollerChange`, `styleOptions.columns.onColumnsResize`).
  *
  * @internal
  */