@sisense/sdk-ui 1.19.0 → 1.21.0

package/dist/{charts → packages/sdk-ui/src/charts}/indicator/indicator-legacy-chart-data-options.d.ts

@@ -3,7 +3,7 @@ import { IndicatorChartDesignOptions } from '../../chart-options-processor/trans
 import { IndicatorChartData } from '../../chart-data/types';
 import { LegacyIndicatorChartTypes } from './types';
 export type IndicatorLegacyChartDataOptions = ReturnType<typeof createLegacyChartDataOptions>;
-export declare const createLegacyChartDataOptions: (chartData: IndicatorChartData, chartDesignOptions: IndicatorChartDesignOptions, chartDataOptions: IndicatorChartDataOptions) => {
+export declare const createLegacyChartDataOptions: (chartData: IndicatorChartData, chartDesignOptions: IndicatorChartDesignOptions, dataOptions: IndicatorChartDataOptions) => {
     type: LegacyIndicatorChartTypes;
     skin: 1 | 2 | "vertical" | "horizontal";
     title: {

package/dist/{charts → packages/sdk-ui/src/charts}/map-charts/areamap/areamap.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
 import { AreamapChartDataOptionsInternal } from '../../../chart-data-options/types.js';
-import { AreamapData } from '../../../chart-data/types.js';
+import { AreamapData, ChartData } from '../../../chart-data/types.js';
 import { AreamapChartDesignOptions } from '../../../chart-options-processor/translations/design-options.js';
 import { AreamapDataPointEventHandler } from '../../../props';
 import { ChartRendererProps } from '../../../chart/types.js';
@@ -11,4 +11,5 @@ export type AreamapProps = {
     onDataPointClick?: AreamapDataPointEventHandler;
 };
 export declare const Areamap: React.FC<AreamapProps>;
+export declare const isAreamapData: (chartData: ChartData) => chartData is AreamapData;
 export declare const isAreamapProps: (props: ChartRendererProps) => props is AreamapProps;

package/dist/{charts → packages/sdk-ui/src/charts}/map-charts/scattermap/scattermap.d.ts

@@ -1,4 +1,4 @@
-import { ScattermapChartData } from '../../../chart-data/types.js';
+import { ChartData, ScattermapChartData } from '../../../chart-data/types.js';
 import { ScattermapDataPointEventHandler } from '../../../props.js';
 import { ScattermapChartDataOptionsInternal } from '../../../chart-data-options/types.js';
 import { ScattermapChartDesignOptions } from '../../../chart-options-processor/translations/design-options.js';
@@ -13,4 +13,5 @@ export type ScattermapProps = {
     onDataPointClick?: ScattermapDataPointEventHandler;
 };
 export declare const Scattermap: ({ chartData, dataOptions, dataSource, filters, designOptions, onDataPointClick, }: ScattermapProps) => import("react/jsx-runtime").JSX.Element;
+export declare const isScattermapData: (chartData: ChartData) => chartData is ScattermapChartData;
 export declare const isScattermapProps: (props: ChartRendererProps) => props is ScattermapProps;

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

@@ -0,0 +1,7 @@
+import { ContextMenuProps } from '../../../../props';
+/**
+ * Context menu
+ *
+ * @group Drilldown
+ */
+export declare const ContextMenu: ({ position, itemSections, children, closeContextMenu, }: ContextMenuProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { ContextMenu } from './context-menu';

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

@@ -0,0 +1,10 @@
+import { CSSProperties, ReactNode } from 'react';
+type MenuItemProps = {
+    children: ReactNode;
+    disabled?: boolean;
+    style?: CSSProperties;
+    className?: string;
+    onClick?: () => void;
+};
+export declare const MenuItem: ({ children, disabled, style, className, onClick }: MenuItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+type MenuSectionProps = {
+    children: ReactNode;
+};
+export declare const MenuSection: ({ children }: MenuSectionProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { MenuPosition } from '../../../../index';
+type MenuProps = {
+    children: ReactNode;
+    open: boolean;
+    position: MenuPosition | null;
+    onClose: () => void;
+};
+export declare const Menu: ({ children, open, position, onClose }: MenuProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/packages/sdk-ui/src/common/components/menu/context-menu/nested-menu-item.d.ts

@@ -0,0 +1,11 @@
+import { CSSProperties, ReactNode } from 'react';
+type NestedMenuItemProps = {
+    children: ReactNode;
+    label: string | ReactNode;
+    allowOpen: boolean;
+    disabled?: boolean;
+    style?: CSSProperties;
+    className?: string;
+};
+export declare const NestedMenuItem: ({ children, label, allowOpen, disabled, style, className, }: NestedMenuItemProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/packages/sdk-ui/src/common/components/menu/context-menu/right-arrow-icon.d.ts

@@ -0,0 +1,3 @@
+export default function RightArrowIcon({ color }: {
+    color?: string;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { OpenMenuFn } from './types';
+type MenuSettings = {
+    openMenu: OpenMenuFn;
+    closeMenu: () => void;
+};
+export declare const MenuContext: import("react").Context<MenuSettings | null>;
+/**
+ * Hook to get the menu context (menu API)
+ *
+ * @returns The menu context
+ * @internal
+ */
+export declare const useMenuContext: () => MenuSettings | null;
+export {};

package/dist/packages/sdk-ui/src/common/components/menu/menu-ids.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A collection of unique menu IDs for all menu sections from all components.
+ *
+ * Each default menu section in the CSDK should have an unique 'id' to distinguish it.
+ *
+ * @internal
+ */
+export declare enum MenuIds {
+    DRILLDOWN_CHART_POINTS_SELECTION = "drilldown-chart-points-selection",
+    DRILLDOWN_DRILL_DIRECTIONS = "drilldown-drill-directions",
+    CROSSFILTERING_CHART_POINTS_SELECTION = "crossfiltering-chart-points-selection"
+}

package/dist/packages/sdk-ui/src/common/components/menu/menu-provider.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { BeforeMenuOpenHandler } from './types';
+export interface MenuProviderProps {
+    /** Optional handler function to process menu options before opening the menu. */
+    onBeforeMenuOpen?: BeforeMenuOpenHandler;
+    children?: React.ReactNode;
+}
+/**
+ * The general menu provider component that decides whether to use the root or node-level menu provider.
+ */
+export declare const MenuProvider: ({ children, onBeforeMenuOpen }: MenuProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/packages/sdk-ui/src/common/components/menu/types.d.ts

@@ -0,0 +1,7 @@
+import { MenuPosition, MenuItemSection } from '../../../types';
+export type MenuOptions = {
+    position: MenuPosition;
+    itemSections: MenuItemSection[];
+};
+export type BeforeMenuOpenHandler = (options: MenuOptions) => MenuOptions | null;
+export type OpenMenuFn = (options: MenuOptions) => void;

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

@@ -0,0 +1,20 @@
+import { MenuOptions } from '../components/menu/types.js';
+type IsTargetMenuFn = (menuOptions: MenuOptions) => boolean;
+type CombineMenusFn = (currentMenuOptions: MenuOptions, capturedMenuOptions: MenuOptions) => MenuOptions;
+interface CombinedMenuParams {
+    /** Function to determine if the captured menu is the target menu */
+    isTargetMenu: IsTargetMenuFn;
+    /** Function to combine the current menu options with the captured menu options */
+    combineMenus: CombineMenusFn;
+}
+/**
+ * Custom hook to manage a combined menu, allowing you to capture
+ * other menu before openning and combine it with the current one.
+ *
+ * @internal
+ */
+export declare const useCombinedMenu: ({ isTargetMenu, combineMenus }: CombinedMenuParams) => {
+    openMenu: (options: MenuOptions) => void;
+    onBeforeMenuOpen: (options: MenuOptions) => MenuOptions | null;
+};
+export {};

package/dist/{common → packages/sdk-ui/src/common}/hooks/use-fetch.d.ts

@@ -16,7 +16,7 @@ export type RequestConfig = {
  * The result of the `useFetch` hook.
  * Return value of the `useQuery` hook from `@tanstack/react-query`.
  *
- * @link https://tanstack.com/query/v4/docs/framework/react/reference/useQuery
+ * @see https://tanstack.com/query/v4/docs/framework/react/reference/useQuery
  * @template TData - The type of the data returned by the fetch request
  * @template TError - The type of the error returned by the fetch request
  */
@@ -30,9 +30,6 @@ export type UseQueryResult<TData, TError> = TanstackUseQueryResult<TData, TError
     method: 'POST',
   });
  ```
- * @param path - The endpoint path to fetch data from. This should be a relative path like '/api/v1/endpoint'.
- * @param init - The request init object
- * @param options - The additional request options
  * @returns Query state that contains the status of the query execution, the result data, or the error if any occurred
  * @group Fusion Embed
  */

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

@@ -0,0 +1,11 @@
+/**
+ * Hook to access menu API.
+ *
+ * Throws an error if used outside the menu context.
+ *
+ * @internal
+ */
+export declare const useMenu: () => {
+    openMenu: import("../components/menu/types.js").OpenMenuFn;
+    closeMenu: () => void;
+};

package/dist/packages/sdk-ui/src/common/hooks/use-with-change-detection.d.ts

@@ -0,0 +1,20 @@
+import { AnyObject } from '../../utils/utility-types';
+export declare const defaultMerger: <P extends AnyObject>(existingValue: P, delta: Partial<P>) => P & Partial<P>;
+type UseWithChangeDetectionParams<P extends AnyObject> = {
+    target: P | P[];
+    onChange: (delta: Partial<P>, index?: number) => void;
+};
+/**
+ * A hook that extends a target object (or array of objects) with change detection functionality.
+ * It monitors changes and triggers the provided `onChange` callback whenever a change occurs.
+ *
+ * This hook can handle both single object and array of objects.
+ *
+ * @internal
+ */
+export declare function useWithChangeDetection<P extends AnyObject>(params: UseWithChangeDetectionParams<P>): (P & {
+    onChange: (delta: Partial<P>) => void;
+}) | (P & {
+    onChange: (delta: Partial<P>) => void;
+})[];
+export {};

package/dist/{common-filters → packages/sdk-ui/src/common-filters}/common-filters-connector.d.ts

@@ -2,7 +2,9 @@ import { type Filter } from '@sisense/sdk-data';
 import { ChartDataOptions, ChartWidgetProps, PivotTableDataOptions, RenderToolbarHandler } from '../index.js';
 import { CommonFiltersOptions } from './types.js';
 import { WidgetTypeInternal } from '../models/widget/types';
-type CommonFiltersToWidgetConnectProps = Pick<ChartWidgetProps, 'filters' | 'highlights' | 'onDataPointClick' | 'onDataPointsSelected'> & {
+import { OpenMenuFn } from '../common/components/menu/types';
+import { TFunction } from '@sisense/sdk-common';
+type CommonFiltersToWidgetConnectProps = Pick<ChartWidgetProps, 'filters' | 'highlights' | 'onDataPointClick' | 'onDataPointsSelected' | 'onDataPointContextMenu'> & {
     renderToolbar: RenderToolbarHandler;
 };
 /**
@@ -11,5 +13,5 @@ type CommonFiltersToWidgetConnectProps = Pick<ChartWidgetProps, 'filters' | 'hig
  * @param filters - Pure filters (non-cascading)
  * @param setFilters - Function to set updated pure filters (non-cascading)
  */
-export declare function prepareCommonFiltersToWidgetConnectProps(commonFilters: Filter[], updateCommonFilters: (filters: Filter[]) => void, widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions, options: CommonFiltersOptions): CommonFiltersToWidgetConnectProps;
+export declare function prepareCommonFiltersToWidgetConnectProps(commonFilters: Filter[], updateCommonFilters: (filters: Filter[]) => void, widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions, options: CommonFiltersOptions, translate: TFunction, openMenu?: OpenMenuFn): CommonFiltersToWidgetConnectProps;
 export {};

package/dist/{common-filters → packages/sdk-ui/src/common-filters}/selection-utils.d.ts

@@ -1,11 +1,15 @@
 import { Attribute, Filter } from '@sisense/sdk-data';
-import { AreamapDataPoint, ChartDataOptions, DataPoint, PivotTableDataOptions, ScatterDataPoint, ScattermapDataPoint } from '../index.js';
+import { ChartDataOptions, ChartDataPoint, PivotTableDataOptions, MenuItemSection } from '../index.js';
 import { WidgetTypeInternal } from '../models/widget/types.js';
+export declare const SELECTION_TITLE_MAXIMUM_ITEMS = 2;
 type DataSelection = {
     attribute: Attribute;
     values: (string | number)[];
+    displayValues: string[];
 };
-export declare function getWidgetSelections(widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions, points: Array<DataPoint | ScatterDataPoint | ScattermapDataPoint | AreamapDataPoint>): DataSelection[];
+export declare function getWidgetSelections(widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions, points: Array<ChartDataPoint>): DataSelection[];
 export declare function getSelectableWidgetAttributes(widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions): Attribute[];
 export declare function createCommonFiltersOverSelections(selections: DataSelection[], existingCommonFilters: Filter[]): Filter[];
+export declare function getWidgetSelectionsTitleMenuItem(widgetType: WidgetTypeInternal, dataOptions: ChartDataOptions | PivotTableDataOptions, points: Array<ChartDataPoint>): MenuItemSection | null;
+export declare function getSelectMenuItem(title: string, selectHandler: () => void): MenuItemSection;
 export {};

package/dist/{common-filters → packages/sdk-ui/src/common-filters}/use-common-filters.d.ts

@@ -1,13 +1,15 @@
 /// <reference types="react" />
 import { type Filter } from '@sisense/sdk-data';
-import { WidgetModel } from '../index.js';
 import { CommonFiltersOptions } from './types.js';
+import { WidgetProps } from '../props.js';
+import { OpenMenuFn } from '../common/components/menu/types.js';
 /** @internal */
-export declare const useCommonFilters: ({ initialFilters, }?: {
+export declare const useCommonFilters: ({ initialFilters, openMenu, }?: {
     initialFilters?: Filter[] | undefined;
+    openMenu?: OpenMenuFn | undefined;
 }) => {
     filters: Filter[];
     setFilters: import("react").Dispatch<import("react").SetStateAction<Filter[]>>;
     addFilter: (newFilter: Filter) => void;
-    connectToWidgetModel: (widget: WidgetModel, options?: CommonFiltersOptions) => WidgetModel;
+    connectToWidgetProps: (widget: WidgetProps, options?: CommonFiltersOptions) => WidgetProps;
 };

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

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare const HorizontalCollapse: ({ collapsedOnInit, children, }: {
+    collapsedOnInit?: boolean | undefined;
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,24 @@
+import { WidgetsPanelLayout } from '../../models';
+import { WidgetProps } from '../../props';
+/**
+ * Props for the {@link ContentPanel} component.
+ *
+ * @internal
+ */
+export interface ContentPanelProps {
+    /**
+     * An object defining how the widgets should be laid out.
+     */
+    layout?: WidgetsPanelLayout;
+    /**
+     * A list of widget props to render.
+     */
+    widgets: WidgetProps[];
+}
+/**
+ * A React component used for rendering a layout of widgets.
+ *
+ * @param props - {@link ContentPanelProps}
+ * @internal
+ */
+export declare const ContentPanel: ({ layout, widgets }: ContentPanelProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,2 @@
+import { DashboardContainerProps } from '../../dashboard/types';
+export declare const DashboardContainer: ({ title, layoutOptions, config, widgets, filters, onFiltersChange, defaultDataSource, }: DashboardContainerProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,2 +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;

package/dist/{dashboard → packages/sdk-ui/src/dashboard}/dashboard-by-id.d.ts

@@ -23,8 +23,11 @@ import { DashboardByIdProps } from './types';
   export default CodeExample;
  * ```
  *
+ * To learn more about this and related dashboard components,
+ * see [Embedded Dashboards](/guides/sdk/guides/dashboards/index.html).
+ *
  * @group Fusion Embed
  * @fusionEmbed
- * @alpha
+ * @beta
  */
 export declare const DashboardById: import("react").FunctionComponent<DashboardByIdProps>;

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

@@ -0,0 +1,14 @@
+import { Filter } from '@sisense/sdk-data';
+import { DashboardProps } from './types';
+/**
+ * Utility functions to manipulate DashboardProps.
+ *
+ * @group Dashboards
+ */
+export declare const DashboardHelpers: {
+    replaceFilters: (dashboard: DashboardProps, newFilters: Filter[]) => DashboardProps;
+    modifyFilter: (dashboard: DashboardProps, filterToModify: Filter, newFilter: Filter) => DashboardProps;
+    removeFilter: (dashboard: DashboardProps, filter: Filter) => DashboardProps;
+    addFilter: (dashboard: DashboardProps, newFilter: Filter) => DashboardProps;
+    addFilters: (dashboard: DashboardProps, newFilters: Filter[]) => DashboardProps;
+};

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

@@ -7,8 +7,10 @@ import { DashboardProps } from '../dashboard/types';
  *
  * @example
  *
+ * Example of rendering a Fusion dashboard using the `useGetDashboardModel hook and the `Dashboard` component.
+ *
  * ```ts
- * import { Dashboard, useGetDashboardModel } from '@sisense/sdk-ui';
+ * import { Dashboard, useGetDashboardModel, dashboardModelTranslator } from '@sisense/sdk-ui';
 
 const CodeExample = () => {
   const { dashboard } = useGetDashboardModel({
@@ -20,17 +22,7 @@ const CodeExample = () => {
   return (
     <>
       {dashboard && (
-        <Dashboard
-        defaultDataSource={dashboard.dataSource}
-        title={dashboard.title}
-        layout={dashboard.layout}
-        styleOptions={dashboard.styleOptions}
-        widgets={dashboard.widgets}
-        filters={dashboard.filters}
-        widgetFilterOptions={
-          dashboard.widgetFilterOptions
-        }
-        />
+        <Dashboard {...dashboardModelTranslator.toDashboardProps(dashboard)} />
       )}
     </>
   );
@@ -39,8 +31,10 @@ const CodeExample = () => {
 export default CodeExample;
  * ```
  *
- * @group Fusion Embed
- * @fusionEmbed
- * @alpha
+ * To learn more about this and related dashboard components,
+ * see [Embedded Dashboards](/guides/sdk/guides/dashboards/index.html).
+ *
+ * @group Dashboards
+ * @beta
  */
 export declare const Dashboard: import("react").FunctionComponent<DashboardProps>;

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

@@ -0,0 +1,4 @@
+export { DashboardById } from './dashboard-by-id';
+export { Dashboard } from './dashboard';
+export type { DashboardByIdProps, DashboardProps, DashboardLayoutOptions, DashboardStyleOptions, DashboardConfig, } from './types';
+export { DashboardHelpers } from './dashboard-helpers';

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

@@ -0,0 +1,83 @@
+import { DashboardStyleOptions, WidgetsOptions, WidgetsPanelLayout } from '../models';
+import { WidgetProps } from '../props';
+import { DataSource, Filter } from '@sisense/sdk-data';
+export type { DashboardStyleOptions, WidgetsPanelColumnLayout } from '../models';
+/**
+ * Props for the DashboardById component
+ */
+export interface DashboardByIdProps {
+    /**
+     * The OID of the dashboard to render.
+     */
+    dashboardOid: string;
+}
+/**
+ * Props for the DashboardContainer component
+ */
+export interface DashboardContainerProps {
+    title: string;
+    layoutOptions?: DashboardLayoutOptions;
+    config?: DashboardConfig;
+    widgets: WidgetProps[];
+    filters: Filter[];
+    onFiltersChange: (filters: Filter[]) => void;
+    defaultDataSource?: DataSource;
+}
+/**
+ * Dashboard configuration
+ *
+ * @internal
+ */
+export interface DashboardConfig {
+    filtersPanel?: {
+        isVisible: boolean;
+    };
+    toolbar?: {
+        isVisible: boolean;
+    };
+}
+/**
+ * Dashboard layout options
+ */
+export interface DashboardLayoutOptions {
+    /**
+     * The layout of the dashboard widgets panel
+     * If not provided, the widgets will be laid out in one column vertically by default
+     */
+    widgetsPanel?: WidgetsPanelLayout;
+}
+/**
+ * Props for the Dashboard component
+ */
+export interface DashboardProps {
+    /** The title of the dashboard */
+    title?: string;
+    /**
+     * Dashboard layout options
+     */
+    layoutOptions?: DashboardLayoutOptions;
+    /**
+     * The configuration for the dashboard
+     *
+     * @internal
+     */
+    config?: DashboardConfig;
+    /** The widgets to render in the dashboard */
+    widgets: WidgetProps[];
+    /** The dashboard filters to be applied to each of the widgets based on the widget filter options */
+    filters?: Filter[];
+    /** The default data source to use for the dashboard */
+    defaultDataSource?: DataSource;
+    /** The options for each of the widgets */
+    widgetsOptions?: WidgetsOptions;
+    /** The style options for the dashboard */
+    styleOptions?: DashboardStyleOptions;
+}
+/**
+ * Props for the Dashboard Header component
+ *
+ * @internal
+ */
+export interface DashboardHeaderProps {
+    title: string;
+}

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

@@ -0,0 +1,12 @@
+import { WidgetProps } from '../props';
+import { WidgetsPanelColumnLayout } from './types';
+export declare const getDividerStyle: (color: string, width: number) => string;
+/**
+ * Gets the default layout for a set of widgets.
+ *
+ * Widgets are laid out in a single column vertically.
+ *
+ * @param widgets - The widgets to create a layout for.
+ * @returns The default layout for the widgets.
+ */
+export declare const getDefaultWidgetsPanelLayout: (widgets: WidgetProps[]) => WidgetsPanelColumnLayout;

package/dist/{dashboard-widget → packages/sdk-ui/src/dashboard-widget}/translate-dashboard-filters.d.ts

@@ -4777,6 +4777,7 @@ export declare function getDashboardFilters(dashboardFilters: Array<FilterDto |
         dim: string;
         table: string;
         column: string;
+        datasource?: import("@sisense/sdk-data").JaqlDataSource | undefined;
         title: string;
         level?: "years" | "quarters" | "months" | "weeks" | "minutes" | "days" | undefined;
         sort?: "desc" | "asc" | undefined;

package/dist/{dashboard-widget → packages/sdk-ui/src/dashboard-widget}/translate-widget-data-options.d.ts

@@ -1,4 +1,4 @@
-import { DimensionalBaseMeasure, DimensionalAttribute, DimensionalCalculatedMeasure, Jaql } from '@sisense/sdk-data';
+import { DimensionalBaseMeasure, DimensionalAttribute, DimensionalCalculatedMeasure, Jaql, JaqlDataSource } from '@sisense/sdk-data';
 import { StyledMeasureColumn, StyledColumn, Color } from '../types';
 import { Panel, PanelItem, WidgetType, WidgetStyle, BoxplotWidgetStyle } from './types';
 import { WidgetDataOptions } from '../models';
@@ -17,11 +17,16 @@ export declare function applyStatisticalModels(dataOption: StyledMeasureColumn,
         trendType: string;
     };
 }): StyledMeasureColumn;
-export declare function createDataColumn(item: PanelItem, customPaletteColors?: Color[]): StyledMeasureColumn | StyledColumn;
+export declare function createDataColumn(item: PanelItem, customPaletteColors?: Color[]): StyledColumn | StyledMeasureColumn;
 /** @internal */
 export declare const createDataOptionsFromPanels: (panels: Panel[], variantColors: Color[]) => {
     [key: string]: any[];
 };
 export declare function createColumnsFromPanelItems<ColumnType = StyledColumn | StyledMeasureColumn>(panels: Panel[], panelName: string, customPaletteColors?: Color[]): ColumnType[];
 export declare function extractBoxplotBoxType(style: BoxplotWidgetStyle): "iqr" | "extremums" | "standardDeviation";
+/**
+ * Attach a data source to all dimensions in the panels.
+ * This is to support multi-source dashboards.
+ */
+export declare function attachDataSourceToPanels(panels: Panel[], dataSource: JaqlDataSource): Panel[];
 export declare function extractDataOptions(widgetType: WidgetType, panels: Panel[], style: WidgetStyle, customPaletteColors?: Color[]): WidgetDataOptions;

package/dist/{dashboard-widget → packages/sdk-ui/src/dashboard-widget}/types.d.ts

@@ -1,6 +1,7 @@
 import { WidgetContainerStyleOptions } from '../types';
 import { LEGACY_DESIGN_TYPES } from './../themes/legacy-design-settings';
-import { Jaql, JaqlSortDirection } from '@sisense/sdk-data';
+import { BaseJaql, Jaql, JaqlDataSource, JaqlSortDirection } from '@sisense/sdk-data';
+import { HierarchyId } from '../models/hierarchy';
 /**
  * The type of a widget on a dashboard that is a variant of Cartesian widget.
  */
@@ -26,14 +27,6 @@ export declare enum WidgetDashboardFilterMode {
     FILTER = "filter",
     SELECT = "select"
 }
-export type Datasource = {
-    title: string;
-    id: string;
-    fullname?: string;
-    live?: boolean;
-    address?: string;
-    database?: string;
-};
 /**
  * The data transfer object (DTO) containing info of a widget on a dashboard.
  *
@@ -46,7 +39,7 @@ export interface WidgetDto {
     oid: string;
     type: WidgetType | string;
     subtype: WidgetSubtype | string;
-    datasource: Datasource;
+    datasource: JaqlDataSource;
     metadata: {
         ignore?: FiltersIgnoringRules;
         panels: Panel[];
@@ -88,13 +81,29 @@ export interface WidgetDto {
     _id?: string;
 }
 /**
- * @description the scroll location of the navigator scroller / auto zoom feature
+ * The data transfer object (DTO) containing info of a hierarchy.
+ *
+ * This is the (not-comprehensive) structure of the response from the
+ * `/api/elasticubes/hierarchies` endpoint.
+ *
+ * @internal
+ */
+export interface HierarchyDto {
+    _id: string;
+    cubeId: string;
+    title: string;
+    levels: BaseJaql[];
+}
+/**
+ * The scroll location of the navigator scroller / auto zoom feature
  */
 export type AutoZoomNavigatorScrollerLocation = {
     min: number;
     max: number;
 };
-/** @internal sometimes Fusion widgets contain dumb scroller location with both locations empty */
+/**
+ * @internal
+ */
 type EmptyAutoZoomNavigatorScrollerLocation = {
     min: null;
     max: null;
@@ -227,7 +236,7 @@ export type PanelItem = {
         index: number;
     };
     panel?: string;
-    hierarchies?: any;
+    hierarchies?: HierarchyId[];
 };
 export type PanelColorFormat = PanelColorFormatSingle | PanelColorFormatRange | PanelColorFormatConditional;
 export type PanelMembersFormat = Record<string, {