@sisense/sdk-ui 2.7.0 → 2.9.0

package/dist/packages/sdk-ui/src/chart/restructured-charts/highchart-based-charts/cartesians/stackable/bar-chart/highchart-options/axes.d.ts

@@ -0,0 +1,6 @@
+import { AxisSettings } from '../../../../../../../chart-options-processor/translations/axis-section';
+import { BuildContext } from '../../../../types';
+export declare const getAxes: (ctx: BuildContext<'bar'>) => {
+    xAxis: AxisSettings[];
+    yAxis: AxisSettings[];
+};

package/dist/packages/sdk-ui/src/chart/restructured-charts/highchart-based-charts/cartesians/stackable/bar-chart/highchart-options/labels-spacing.d.ts

@@ -0,0 +1,9 @@
+import { StackableChartDesignOptions } from '../../../../../../../chart-options-processor/translations/design-options';
+/**
+ * Calculate spacing for bar chart total labels based on rotation.
+ * Bar charts only use horizontal spacing as they have vertical orientation.
+ */
+export declare function getBarChartSpacingForTotalLabels(chartDesignOptions: StackableChartDesignOptions): {
+    rightSpacing: number;
+    topSpacing: number;
+};

package/dist/packages/sdk-ui/src/chart/restructured-charts/highchart-based-charts/cartesians/stackable/column-chart/highchart-options/axes.d.ts

@@ -0,0 +1,6 @@
+import { AxisSettings } from '../../../../../../../chart-options-processor/translations/axis-section';
+import { BuildContext } from '../../../../types';
+export declare const getAxes: (ctx: BuildContext<'column'>) => {
+    xAxis: AxisSettings[];
+    yAxis: AxisSettings[];
+};

package/dist/packages/sdk-ui/src/chart/restructured-charts/highchart-based-charts/cartesians/stackable/column-chart/highchart-options/labels-spacing.d.ts

@@ -0,0 +1,9 @@
+import { StackableChartDesignOptions } from '../../../../../../../chart-options-processor/translations/design-options';
+/**
+ * Calculate spacing for column chart total labels based on rotation.
+ * Column charts only use top spacing as they have horizontal orientation.
+ */
+export declare function getColumnChartSpacingForTotalLabels(chartDesignOptions: StackableChartDesignOptions): {
+    rightSpacing: number;
+    topSpacing: number;
+};

package/dist/packages/sdk-ui/src/chart/restructured-charts/highchart-based-charts/cartesians/stackable/helpers/highchart-options/stacking.d.ts

@@ -0,0 +1,21 @@
+import { AxisSettings } from '../../../../../../../chart-options-processor/translations/axis-section';
+import { BuildContext } from '../../../../types';
+import { StackableChartTypes } from '../../types';
+/**
+ * Functional transformer that applies stacking-specific Y-axis enhancements.
+ * This transformer adds stacking-related properties (stack labels, total labels, formatting)
+ * to basic Y-axis settings for stackable charts (bar, column, area).
+ *
+ * This version is chart-type independent since all stackable chart types use identical stacking logic.
+ *
+ * @param ctx - Build context containing chart data, options, and configuration
+ * @returns A function that transforms basic Y-axis settings to include stacking support
+ *
+ * @example
+ * ```typescript
+ * // Apply stacking enhancements to basic Y-axis
+ * const basicYAxisSettings = getBasicYAxisSettings(ctx);
+ * const stackedYAxis = withStacking(ctx)(basicYAxisSettings);
+ * ```
+ */
+export declare const withStacking: (ctx: BuildContext<StackableChartTypes>) => (basicYAxisSettings: AxisSettings[]) => AxisSettings[];

package/dist/packages/sdk-ui/src/chart/restructured-charts/highchart-based-charts/cartesians/stackable/types.d.ts

@@ -0,0 +1 @@
+export type StackableChartTypes = 'column' | 'bar' | 'area';

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

@@ -1 +1 @@
-export type CartesianChartTypes = 'column' | 'bar';
+export type CartesianChartTypes = 'column' | 'bar' | 'line' | 'area' | 'polar';

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

@@ -5,7 +5,7 @@ import { BuildContext, HighchartBasedChartTypes, HighchartsOptionsBuilder } from
 import { SisenseChartDataPointsEventHandler } from '../../../../sisense-chart/types';
 import { SisenseChartDataPointEventHandler } from '../../../../sisense-chart/types';
 import { BeforeRenderHandler } from '../../../../props';
-export declare function buildHighchartsOptions<CT extends HighchartBasedChartTypes>({ highchartsOptionsBuilder: builder, chartData, dataOptions, designOptions, extraConfig, dataPointsEventHandlers, onBeforeRender, }: {
+export declare const buildHighchartsOptions: <CT extends HighchartBasedChartTypes>({ highchartsOptionsBuilder: builder, chartData, dataOptions, designOptions, extraConfig, dataPointsEventHandlers, onBeforeRender, }: {
     highchartsOptionsBuilder: HighchartsOptionsBuilder<CT>;
     chartData: TypedChartData<CT>;
     dataOptions: TypedDataOptionsInternal<CT>;
@@ -15,6 +15,11 @@ export declare function buildHighchartsOptions<CT extends HighchartBasedChartTyp
         onDataPointContextMenu?: SisenseChartDataPointEventHandler;
         onDataPointsSelected?: SisenseChartDataPointsEventHandler;
     };
-    extraConfig: BuildContext<CT>['extraConfig'];
-    onBeforeRender?: BeforeRenderHandler;
-}): HighchartsOptionsInternal;
+    extraConfig: {
+        translate: import("i18next").TFunction<"translation", undefined>;
+        themeSettings: import("../../../../types.js").CompleteThemeSettings;
+        dateFormatter: (date: Date, format: string) => string;
+        accessibilityEnabled: boolean;
+    };
+    onBeforeRender?: BeforeRenderHandler | undefined;
+}) => HighchartsOptionsInternal;

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

@@ -1,2 +1,3 @@
 import { ChartType } from '../../../../types';
-export declare const isHighchartsBasedChart: (chartType: ChartType) => boolean;
+import { HighchartBasedChartTypes } from '../types';
+export declare const isHighchartsBasedChart: (chartType: ChartType) => chartType is HighchartBasedChartTypes;

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

@@ -2,7 +2,7 @@ import { HighchartsOptionsInternal } from '../../../chart-options-processor/char
 import { CompleteThemeSettings } from '../../../index-typedoc';
 import { TFunction } from '@sisense/sdk-common';
 import { TypedChartData, TypedDataOptionsInternal, TypedDesignOptions } from '../types';
-export type HighchartBasedChartTypes = 'column' | 'bar';
+export type HighchartBasedChartTypes = 'column' | 'bar' | 'line' | 'area' | 'polar';
 export type HighchartsOptionsBuilder<CT extends HighchartBasedChartTypes> = {
     getChart: (ctx: BuildContext<CT>) => HighchartsOptionsInternal['chart'];
     getSeries: (ctx: BuildContext<CT>) => HighchartsOptionsInternal['series'];

package/dist/packages/sdk-ui/src/chart/restructured-charts/types.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="react" />
 import { Attribute, Measure, QueryResultData } from '@sisense/sdk-data';
 import { QueryDescription, QueryExecutionConfig } from '@sisense/sdk-query-client';
-import type { AreamapStyleOptions, ChartDataOptions, ChartStyleOptions, ScattermapStyleOptions, StackableStyleOptions } from '../../types';
+import type { AreaStyleOptions, AreamapStyleOptions, ChartDataOptions, ChartStyleOptions, LineStyleOptions, PolarStyleOptions, ScattermapStyleOptions, StackableStyleOptions } from '../../types';
 import type { ChartRendererProps } from '../../chart';
 import type { CartesianChartData, ScattermapChartData } from '../../chart-data/types';
 import { AreamapChartDataOptions, AreamapChartDataOptionsInternal, CartesianChartDataOptions, CartesianChartDataOptionsInternal, ChartDataOptionsInternal, ScattermapChartDataOptions, ScattermapChartDataOptionsInternal } from '../../chart-data-options/types';
@@ -12,19 +12,19 @@ import { AreamapProps } from '../../chart/restructured-charts/areamap-chart/rend
 import { ScattermapProps } from '../../charts/map-charts/scattermap/scattermap';
 import { AreamapData } from './areamap-chart/types';
 import { HighchartsBasedChartRendererProps } from './highchart-based-charts/highcharts-based-chart-renderer/highcharts-based-chart-renderer';
-export type SupportedChartType = 'areamap' | 'column' | 'bar';
-export type TypedChartDataOptions<CT extends SupportedChartType> = CT extends 'areamap' ? AreamapChartDataOptions : CT extends 'scattermap' ? ScattermapChartDataOptions : CT extends 'column' | 'bar' ? CartesianChartDataOptions : never;
-export type TypedDataOptionsInternal<CT extends SupportedChartType> = CT extends 'areamap' ? AreamapChartDataOptionsInternal : CT extends 'scattermap' ? ScattermapChartDataOptionsInternal : CT extends 'column' | 'bar' ? CartesianChartDataOptionsInternal : never;
-export type TypedChartStyleOptions<CT extends SupportedChartType> = CT extends 'areamap' ? AreamapStyleOptions : CT extends 'scattermap' ? ScattermapStyleOptions : CT extends 'column' | 'bar' ? StackableStyleOptions : never;
+export type SupportedChartType = 'areamap' | 'column' | 'bar' | 'line' | 'area' | 'polar';
+export type TypedChartDataOptions<CT extends SupportedChartType> = CT extends 'areamap' ? AreamapChartDataOptions : CT extends 'scattermap' ? ScattermapChartDataOptions : CT extends 'column' | 'bar' | 'line' | 'area' | 'polar' ? CartesianChartDataOptions : never;
+export type TypedDataOptionsInternal<CT extends SupportedChartType> = CT extends 'areamap' ? AreamapChartDataOptionsInternal : CT extends 'scattermap' ? ScattermapChartDataOptionsInternal : CT extends 'column' | 'bar' | 'line' | 'area' | 'polar' ? CartesianChartDataOptionsInternal : never;
+export type TypedChartStyleOptions<CT extends SupportedChartType> = CT extends 'areamap' ? AreamapStyleOptions : CT extends 'scattermap' ? ScattermapStyleOptions : CT extends 'column' | 'bar' ? StackableStyleOptions : CT extends 'line' ? LineStyleOptions : CT extends 'area' ? AreaStyleOptions : CT extends 'polar' ? PolarStyleOptions : never;
 export type TypedDesignOptions<CT extends SupportedChartType> = DesignOptions<CT>;
-export type TypedChartData<CT extends SupportedChartType> = CT extends 'areamap' ? AreamapData : CT extends 'scattermap' ? ScattermapChartData : CT extends 'column' | 'bar' ? CartesianChartData : never;
+export type TypedChartData<CT extends SupportedChartType> = CT extends 'areamap' ? AreamapData : CT extends 'scattermap' ? ScattermapChartData : CT extends 'column' | 'bar' | 'line' | 'area' | 'polar' ? CartesianChartData : never;
 export type TypedLoadDataFunction<CT extends SupportedChartType> = (options: {
     app: ClientApplication;
     chartDataOptionsInternal: TypedDataOptionsInternal<CT>;
     queryDescription: QueryDescription;
     executionConfig?: QueryExecutionConfig;
 }) => Promise<QueryResultData>;
-export type TypedChartRendererProps<CT extends SupportedChartType> = CT extends 'areamap' ? AreamapProps : CT extends 'scattermap' ? ScattermapProps : CT extends 'column' | 'bar' ? HighchartsBasedChartRendererProps<CT> : never;
+export type TypedChartRendererProps<CT extends SupportedChartType> = CT extends 'areamap' ? AreamapProps : CT extends 'scattermap' ? ScattermapProps : CT extends 'column' | 'bar' | 'line' | 'area' | 'polar' ? HighchartsBasedChartRendererProps<CT> : never;
 /**
  * Chart builder interface.
  */

package/dist/packages/sdk-ui/src/chart/restructured-charts/utils.d.ts

@@ -1,3 +1,8 @@
 import { ChartType } from '../../index';
 import { SupportedChartType } from './types.js';
+import { ChartDataOptions } from '../../chart-data-options/types';
+/**
+ * Helper function to detect if chart data options contain forecast or trend analytics
+ */
+export declare function hasForecastOrTrend(dataOptions: ChartDataOptions, chartType: ChartType): boolean;
 export declare function isRestructuredChartType(chartType: ChartType): chartType is SupportedChartType;

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

@@ -24,6 +24,12 @@ export type UniformDataColorOptions = {
      * Color name, e.g., `red`, or a hexadecimal value, e.g., `#ff0000`.
      */
     color: string;
+    /**
+     * Color index in the palette colors array
+     *
+     * @internal
+     */
+    colorIndex?: number;
 };
 /**
  * Range color options for data similar to the Range option in the Sisense UI.

package/dist/packages/sdk-ui/src/chart-options-processor/cartesian/utils/axis/axis-builders.d.ts

@@ -0,0 +1,155 @@
+import { ChartType, CompleteThemeSettings } from '../../../../types';
+import { CartesianChartData } from '../../../../chart-data/types';
+import { CartesianChartDataOptionsInternal } from '../../../../chart-data-options/types';
+import { StackableChartDesignOptions, PolarChartDesignOptions } from '../../../translations/design-options';
+import { ChartDesignOptions } from '../../../translations/types';
+import { Axis, AxisSettings, AxisMinMax, PlotBand } from '../../../translations/axis-section';
+import { withChartSpecificAxisSettings, withPolarSpecificAxisSettings, withStacking } from './axis-utils';
+export { withChartSpecificAxisSettings, withPolarSpecificAxisSettings, withStacking };
+import { AxisClipped } from '../../../translations/translations-to-highcharts';
+import { Stacking } from '../../../chart-options-service';
+/**
+ * X-axis orientation type
+ */
+export type XAxisOrientation = 'horizontal' | 'vertical';
+/**
+ * Y-axis metadata containing all Y-axis related configuration
+ */
+export interface YAxisMeta {
+    side: number[];
+    chartType: (string | undefined)[];
+    treatNullAsZero: boolean[];
+    connectNulls: boolean[];
+}
+/**
+ * Categories metadata containing categories, index mapping, and plot bands
+ */
+export interface CategoriesMeta {
+    categories: string[];
+    indexMap: number[];
+    plotBands: PlotBand[];
+}
+/**
+ * Parameters for building X-axis settings
+ */
+export interface BuildXAxisSettingsParams {
+    designOptions: ChartDesignOptions;
+    dataOptions: CartesianChartDataOptionsInternal;
+    chartData: CartesianChartData;
+    categoriesMeta: CategoriesMeta;
+    orientation: XAxisOrientation;
+    isContinuous: boolean;
+    dateFormatter?: (date: Date, format: string) => string;
+}
+/**
+ * Stacking configuration metadata
+ */
+export interface StackingMeta {
+    stacking?: Stacking;
+    showTotal?: boolean;
+}
+/**
+ * Y-axis settings result containing both settings and clipping information
+ */
+export interface YAxisSettingsResult {
+    settings: AxisSettings[];
+    clipped: AxisClipped[];
+}
+/**
+ * Determines if the X-axis should use continuous datetime scale
+ *
+ * @param xDataOptions - X-axis data options
+ * @returns true if continuous datetime X-axis should be used
+ */
+export declare const isContinuousDatetimeXAxis: (xDataOptions: CartesianChartDataOptionsInternal['x']) => boolean;
+/**
+ * Builds Y-axis metadata from chart data and options
+ *
+ * @param chartData - Cartesian chart data
+ * @param dataOptions - Chart data options
+ * @returns Y-axis metadata object
+ */
+export declare const buildYAxisMeta: (chartData: CartesianChartData, dataOptions: CartesianChartDataOptionsInternal) => YAxisMeta;
+/**
+ * Determines X-axis orientation based on chart type and Y-axis chart types
+ *
+ * @param chartType - Main chart type
+ * @param yAxisChartTypes - Array of Y-axis chart types
+ * @returns X-axis orientation
+ */
+export declare const getXAxisOrientation: (chartType: ChartType, yAxisChartTypes: (string | undefined)[]) => XAxisOrientation;
+/**
+ * Builds categories metadata including categories, index map, and plot bands
+ *
+ * @param chartData - Chart data
+ * @param dataOptions - Chart data options
+ * @param designOptions - Chart design options
+ * @param isContinuous - Whether X-axis is continuous
+ * @returns Categories metadata object
+ */
+export declare const buildCategoriesMeta: (chartData: CartesianChartData, dataOptions: CartesianChartDataOptionsInternal, designOptions: ChartDesignOptions, isContinuous: boolean) => CategoriesMeta;
+/**
+ * Builds X-axis settings based on whether it's continuous datetime or categorical
+ *
+ * @param params - Parameters object containing all required data
+ * @param params.designOptions - Chart design options
+ * @param params.dataOptions - Chart data options
+ * @param params.chartData - Chart data
+ * @param params.categoriesMeta - Categories metadata
+ * @param params.orientation - X-axis orientation
+ * @param params.isContinuous - Whether X-axis is continuous
+ * @param params.dateFormatter - Optional date formatter function
+ * @returns X-axis settings array
+ */
+export declare const buildXAxisSettings: ({ designOptions, dataOptions, chartData, categoriesMeta, orientation, isContinuous, dateFormatter, }: BuildXAxisSettingsParams) => AxisSettings[];
+/**
+ * Calculates Y-axis min/max values for a specific axis side
+ *
+ * @param axisIndex - Axis index (0 for left/primary, 1 for right/secondary)
+ * @param chartType - Chart type
+ * @param chartData - Chart data
+ * @param designOptions - Chart design options
+ * @param yAxisSide - Array indicating which side each series belongs to
+ * @param treatNullAsZero - Array indicating null treatment for each series
+ * @returns Axis min/max values
+ */
+export declare const buildYAxisMinMax: (axisIndex: 0 | 1, chartType: ChartType, chartData: CartesianChartData, designOptions: ChartDesignOptions, yAxisSide: number[], treatNullAsZero: boolean[]) => AxisMinMax;
+/**
+ * Builds stacking configuration metadata
+ *
+ * @param chartType - Chart type
+ * @param designOptions - Stackable chart design options
+ * @returns Stacking metadata
+ */
+export declare const buildStackingMeta: (chartType: ChartType, designOptions: StackableChartDesignOptions) => StackingMeta;
+/**
+ * Contextless transformer that normalizes Y-axis configuration for polar charts.
+ * Disables Y-axis titles which are not meaningful in polar coordinate system.
+ *
+ * @param designOptions - Polar chart design options to normalize
+ * @returns Normalized polar chart design options with Y-axis title disabled
+ * @example
+ * const normalizedOptions = withYAxisNormalizationForPolar(polarDesignOptions);
+ */
+export declare const withYAxisNormalizationForPolar: (designOptions: Readonly<PolarChartDesignOptions>) => PolarChartDesignOptions;
+/**
+ * Builds Y-axis settings and clipping information
+ *
+ * @param yAxis - Primary Y-axis configuration
+ * @param y2Axis - Secondary Y-axis configuration
+ * @param primaryMinMax - Primary axis min/max values
+ * @param secondaryMinMax - Secondary axis min/max values (optional)
+ * @param stackingMeta - Stacking configuration
+ * @param totalLabelRotation - Total label rotation angle
+ * @param dataOptions - Chart data options
+ * @param themeSettings - Theme settings (optional)
+ * @returns Y-axis settings and clipping information
+ */
+export declare const buildYAxisSettings: (yAxis: Axis, y2Axis: Axis | undefined, primaryMinMax: AxisMinMax, secondaryMinMax: AxisMinMax | undefined, stackingMeta: StackingMeta, totalLabelRotation: number, dataOptions: CartesianChartDataOptionsInternal, themeSettings?: CompleteThemeSettings) => YAxisSettingsResult;
+/**
+ * Determines if a secondary Y-axis is needed based on Y-axis side configuration
+ *
+ * @param yAxisSide - Array indicating which side each series belongs to
+ * @returns true if secondary Y-axis is needed
+ */
+export declare const hasSecondaryYAxis: (yAxisSide: number[]) => boolean;

package/dist/packages/sdk-ui/src/chart-options-processor/cartesian/utils/axis/axis-settings.d.ts

@@ -0,0 +1,39 @@
+import { ChartDataOptionsInternal } from '../../../../chart-data-options/types';
+import { CompleteThemeSettings } from '../../../../types';
+import { AxisClipped } from '../../../translations/translations-to-highcharts';
+import { Axis, AxisMinMax, AxisOrientation, AxisSettings, PlotBand } from '../../../translations/axis-section';
+/**
+ * Builds X-axis settings for categorical axes
+ *
+ * @param axis - Primary X-axis configuration
+ * @param axis2 - Secondary X-axis configuration (optional)
+ * @param categories - Array of category labels
+ * @param plotBands - Array of plot band configurations
+ * @param xAxisOrientation - X-axis orientation ('horizontal' or 'vertical')
+ * @param dataOptions - Chart data options
+ * @returns Array of X-axis settings
+ */
+export declare const getXAxisSettings: (axis: Axis, axis2: Axis | undefined, categories: string[], plotBands: PlotBand[], xAxisOrientation: AxisOrientation, dataOptions: ChartDataOptionsInternal) => AxisSettings[];
+/**
+ * Creates Y-axis clipping information for cartesian charts.
+ *
+ * @param axis - Primary Y-axis configuration
+ * @param axis2 - Secondary Y-axis configuration (optional)
+ * @param axis2MinMax - Min/max values for secondary axis (optional)
+ * @returns Array of axis clipping information
+ */
+export declare const getYClippings: (axis: Axis, axis2: Axis | undefined, axis2MinMax: AxisMinMax | undefined) => AxisClipped[];
+/**
+ * Creates basic Y-axis settings configuration for cartesian charts.
+ * This function provides core Y-axis functionality without stacking-specific features.
+ * Use the withStacking transformer to add stacking capabilities when needed.
+ *
+ * @param axis - Primary Y-axis configuration
+ * @param axis2 - Secondary Y-axis configuration (optional)
+ * @param axisMinMax - Min/max values for primary axis
+ * @param axis2MinMax - Min/max values for secondary axis (optional)
+ * @param dataOptions - Chart data options
+ * @param themeSettings - Theme settings for styling (optional)
+ * @returns Array of basic axis settings
+ */
+export declare const getYAxisSettings: (axis: Axis, axis2: Axis | undefined, axisMinMax: AxisMinMax, axis2MinMax: AxisMinMax | undefined, dataOptions: ChartDataOptionsInternal, themeSettings?: CompleteThemeSettings) => AxisSettings[];

package/dist/packages/sdk-ui/src/chart-options-processor/cartesian/utils/axis/axis-transformers.d.ts

@@ -0,0 +1,45 @@
+import { Stacking } from '../../../chart-options-service';
+import { ChartDataOptionsInternal } from '../../../../chart-data-options/types';
+import { ChartType, CompleteThemeSettings } from '../../../../types';
+import { AxisSettings } from '../../../translations/axis-section';
+/**
+ * Configuration interface for stacking transformer
+ */
+export interface StackingConfig {
+    stacking?: Stacking;
+    showTotal?: boolean;
+    totalLabelRotation?: number;
+    dataOptions: ChartDataOptionsInternal;
+    themeSettings?: CompleteThemeSettings;
+}
+/**
+ * Transformer that combines polar-specific axis transformations
+ * Applies both top title positioning and removes label rotation
+ */
+export declare const withPolarSpecificAxisSettings: (axisSettings: AxisSettings[]) => AxisSettings[];
+/**
+ * Transformer that applies stacking-specific enhancements to Y-axis settings.
+ * This transformer adds stacking-related properties (stack labels, total labels, formatting)
+ * to basic Y-axis settings for stackable charts.
+ *
+ * @param config - Stacking configuration containing stacking type, showTotal, rotation, and formatting options
+ * @returns A function that transforms basic Y-axis settings to include stacking support
+ *
+ * @example
+ * ```typescript
+ * // Apply stacking enhancements to basic Y-axis
+ * const stackedYAxis = flow(
+ *   getYAxisSettings,
+ *   withStacking({ stacking: 'normal', showTotal: true, totalLabelRotation: 0, dataOptions, themeSettings }),
+ * )(axis, axis2, axisMinMax, axis2MinMax, dataOptions, themeSettings);
+ * ```
+ */
+export declare const withStacking: (config: StackingConfig) => (axisSettings: AxisSettings[]) => AxisSettings[];
+/**
+ * Applies chart-specific axis settings to the axis settings array
+ *
+ * @param chartType - Chart type
+ * @param axisSettings - Array of axis settings
+ * @returns Array of axis settings with chart-specific settings applied
+ */
+export declare const withChartSpecificAxisSettings: (chartType: ChartType) => (axisSettings: AxisSettings[]) => AxisSettings[];

package/dist/packages/sdk-ui/src/chart-options-processor/cartesian/utils/axis/axis-utils.d.ts

@@ -0,0 +1 @@
+export * from './index';

package/dist/packages/sdk-ui/src/chart-options-processor/cartesian/utils/axis/date-utils.d.ts

@@ -0,0 +1,27 @@
+import { StyledColumn } from '../../../../chart-data-options/types';
+import { Axis, AxisSettings } from '../../../translations/axis-section';
+/**
+ * Maps date granularity levels to their corresponding intervals in milliseconds
+ *
+ * @param granularity - The date granularity level
+ * @returns Interval in milliseconds for the given granularity
+ */
+export declare const getInterval: (granularity: string) => number;
+/**
+ * Creates a date formatter function for chart axis labels
+ *
+ * @param category - The styled column containing date formatting information
+ * @param dateFormatter - Optional external date formatter function
+ * @returns A function that formats timestamps as strings
+ */
+export declare const getDateFormatter: (category: StyledColumn, dateFormatter?: ((date: Date, format: string) => string) | undefined) => (time: number) => string;
+/**
+ * Builds X-axis settings for datetime axes with continuous data
+ *
+ * @param axis - Primary axis configuration
+ * @param category - The styled column for date formatting
+ * @param values - Array of numeric timestamp values
+ * @param dateFormatter - Optional date formatter function
+ * @returns Array of axis settings for datetime X-axis
+ */
+export declare const getXAxisDatetimeSettings: (axis: Axis, category: StyledColumn, values: number[], dateFormatter?: ((date: Date, format: string) => string) | undefined) => AxisSettings[];

package/dist/packages/sdk-ui/src/chart-options-processor/cartesian/utils/axis/index.d.ts

@@ -0,0 +1,3 @@
+export { getInterval, getDateFormatter, getXAxisDatetimeSettings } from './date-utils';
+export { getXAxisSettings, getYAxisSettings, getYClippings } from './axis-settings';
+export { withStacking, withPolarSpecificAxisSettings, withChartSpecificAxisSettings, type StackingConfig, } from './axis-transformers';

package/dist/packages/sdk-ui/src/chart-options-processor/cartesian/utils/chart-configuration.d.ts

@@ -1,13 +1,43 @@
+import { ChartDesignOptions } from '../../../chart-options-processor/translations/types';
 import { AxisSettings } from '../../translations/axis-section';
 /**
- * Apply label positioning adjustments based on spacing calculations
+ * Configuration for Y-axis label positioning adjustments
  */
-export declare function applyLabelPositioning(xAxisSettings: AxisSettings[], yAxisSettings: AxisSettings[], rightShift: number, topShift: number, totalLabelRightSpacing: number, totalLabelTopSpacing: number): void;
+type YAxisLabelPositioningConfig = {
+    readonly rightShift: number;
+    readonly topShift: number;
+};
+/**
+ * Configuration for X-axis label positioning adjustments
+ */
+type XAxisLabelPositioningConfig = {
+    readonly totalLabelRightSpacing: number;
+    readonly totalLabelTopSpacing: number;
+};
+/**
+ * Higher-order function for Y-axis label positioning adjustments.
+ * Returns a function that transforms Y-axis settings without mutating the input parameters.
+ *
+ * @example
+ * const positionYAxisLabels = withYAxisLabelPositioning({ rightShift: 10, topShift: 20 });
+ * const updatedSettings = positionYAxisLabels(yAxisSettings);
+ */
+export declare function withYAxisLabelPositioning(config: YAxisLabelPositioningConfig): (yAxisSettings: AxisSettings[]) => AxisSettings[];
+/**
+ * Higher-order function for X-axis label positioning adjustments.
+ * Returns a function that transforms X-axis settings without mutating the input parameters.
+ *
+ * @example
+ * const positionXAxisLabels = withXAxisLabelPositioning({ totalLabelRightSpacing: 15, totalLabelTopSpacing: 25 });
+ * const updatedSettings = positionXAxisLabels(xAxisSettings);
+ */
+export declare function withXAxisLabelPositioning(config: XAxisLabelPositioningConfig): (xAxisSettings: AxisSettings[]) => AxisSettings[];
 /**
  * Determine chart state information
  */
-export declare function determineChartState(chartType: string, chartDesignOptions: any, stacking?: string): {
+export declare function determineChartState(chartType: string, chartDesignOptions: ChartDesignOptions, stacking?: string): {
     treatNullDataAsZeros: boolean;
     isPolarChart: boolean;
     polarType?: any;
 };
+export {};

package/dist/packages/sdk-ui/src/chart-options-processor/chart-options-service.d.ts

@@ -177,16 +177,6 @@ export type HighchartsOptionsInternal = {
     };
     drilldown?: DrilldownOptions;
 };
-export type Style = {
-    fontFamily?: string;
-    fontSize?: string;
-    fontWeight?: string;
-    color?: string;
-    textOutline?: string;
-    pointerEvents?: string;
-    textOverflow?: string;
-    width?: string;
-};
 type Navigator = {
     series: {
         type: HighchartsType;

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

@@ -2,6 +2,7 @@ import { Measure } from '@sisense/sdk-data';
 import { HighchartsPoint } from '../types';
 import { SisenseChartDataPoint } from '../sisense-chart/types';
 import { ChartDataOptionsInternal, StyledColumn, StyledMeasureColumn } from '..';
+export declare function createFormatter(dataOption: StyledColumn | StyledMeasureColumn): (value?: number | string | Date) => string;
 export declare function getDataPointMetadata(dataOptionPath: string, dataOption: StyledColumn | StyledMeasureColumn): {
     measure?: Measure | undefined;
     attribute?: import("@sisense/sdk-data").Attribute | undefined;

package/dist/packages/sdk-ui/src/chart-options-processor/defaults/cartesian.d.ts

@@ -1,10 +1,11 @@
 import { AxisSettings } from '../translations/axis-section';
-import { Style, HighchartsOptionsInternal, Stacking } from '../chart-options-service';
+import { HighchartsOptionsInternal, Stacking } from '../chart-options-service';
+import { TextStyle } from '../translations/types';
 import { ChartType } from '../../types';
 import { PolarType } from '../translations/design-options';
 export declare const lineColorDefault = "#d1d1d7";
-export declare const fontStyleDefault: Style;
-export declare const stackTotalFontStyleDefault: Style;
+export declare const fontStyleDefault: TextStyle;
+export declare const stackTotalFontStyleDefault: TextStyle;
 export declare const xAxisDefaults: AxisSettings;
 export declare const yAxisDefaults: AxisSettings;
 export declare const chartOptionsDefaults: (chartType: ChartType, polarType?: PolarType, stacking?: Stacking) => HighchartsOptionsInternal;

package/dist/packages/sdk-ui/src/chart-options-processor/translations/axis-section.d.ts

@@ -1,8 +1,5 @@
-import { Stacking, Style } from '../chart-options-service';
-import { ChartDataOptionsInternal, StyledColumn } from '../../chart-data-options/types';
-import { ChartType, CompleteThemeSettings } from '../../types';
+import { TextStyle } from './types';
 import { CategoricalXValues } from '../../chart-data/types';
-import { AxisClipped } from './translations-to-highcharts';
 export type Axis = {
     enabled?: boolean;
     titleEnabled?: boolean;
@@ -31,7 +28,7 @@ export type AxisSettings = {
         text?: string | null;
         enabled?: boolean;
         margin?: number;
-        style?: Style;
+        style?: TextStyle;
     };
     gridLineDashStyle?: 'Dot';
     gridLineWidth?: number;
@@ -43,7 +40,7 @@ export type AxisSettings = {
         overflow?: 'none' | 'justify';
         enabled?: boolean;
         autoRotation?: number[];
-        style?: Style;
+        style?: TextStyle;
         rotation?: number;
         formatter?: (this: AxisLabelsFormatterContextObject) => string;
     };
@@ -72,7 +69,7 @@ export type AxisSettings = {
     visible?: boolean;
 };
 export type StackLabel = {
-    style: Style;
+    style: TextStyle;
     crop: boolean;
     allowOverlap: boolean;
     enabled: boolean;
@@ -100,12 +97,8 @@ export type AxisPlotBand = {
         text: string;
         x: number;
         y: number;
-        style?: Style;
+        style?: TextStyle;
     };
 };
 export declare const getCategoricalCompareValue: (value: CategoricalXValues) => number;
 export declare const getDefaultDateFormat: (granularity?: string) => "HH:mm:ss" | "yyyy" | "yyyy Q" | "MM/yyyy" | "ww yyyy" | "M/d/yy" | "HH" | "M/d/yy HH" | "HH:mm" | undefined;
-export declare const getDateFormatter: (category: StyledColumn, dateFormatter?: ((date: Date, format: string) => string) | undefined) => (time: number) => string;
-export declare const getXAxisDatetimeSettings: (axis: Axis, category: StyledColumn, values: number[], dateFormatter?: ((date: Date, format: string) => string) | undefined) => AxisSettings[];
-export declare const getXAxisSettings: (axis: Axis, axis2: Axis | undefined, categories: string[], plotBands: PlotBand[], xAxisOrientation: AxisOrientation, dataOptions: ChartDataOptionsInternal, chartType: ChartType) => AxisSettings[];
-export declare const getYAxisSettings: (axis: Axis, axis2: Axis | undefined, axisMinMax: AxisMinMax, axis2MinMax: AxisMinMax | undefined, showTotal: boolean, totalLabelRotation: number, dataOptions: ChartDataOptionsInternal, stacking: Stacking | undefined, themeSettings?: CompleteThemeSettings) => [AxisSettings[], AxisClipped[]];

package/dist/packages/sdk-ui/src/chart-options-processor/translations/design-options.d.ts

@@ -36,7 +36,7 @@ export type StackableChartDesignOptions = CartesianChartDesignOptions & {
     stackType: StackType;
     showTotal?: boolean;
     totalLabelRotation?: number;
-} & DesignPerSeries;
+};
 export type LineChartDesignOptions = CartesianChartDesignOptions & {
     /** Step type for step line charts: left, center, or right */
     step?: 'left' | 'center' | 'right';

package/dist/packages/sdk-ui/src/chart-options-processor/translations/legend-section.d.ts

@@ -1,11 +1,11 @@
-import { Style } from '../chart-options-service';
+import { TextStyle } from './types';
 export type LegendPosition = 'top' | 'left' | 'right' | 'bottom' | null;
 export type LegendSettings = {
     enabled: boolean;
     align?: 'center' | 'left' | 'right';
     verticalAlign?: 'top' | 'middle' | 'bottom';
     layout?: 'horizontal' | 'vertical';
-    itemStyle?: Style & {
+    itemStyle?: TextStyle & {
         cursor?: string;
     };
     symbolRadius?: number;

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

@@ -1,6 +1,19 @@
 import { AreamapChartDesignOptions } from '../../chart/restructured-charts/areamap-chart/types';
 import { ChartType } from '../../types';
 import { LineChartDesignOptions, AreaChartDesignOptions, BarChartDesignOptions, ColumnChartDesignOptions, PieChartDesignOptions, FunnelChartDesignOptions, IndicatorChartDesignOptions, PolarChartDesignOptions, ScatterChartDesignOptions, TreemapChartDesignOptions, BoxplotChartDesignOptions, ScattermapChartDesignOptions, AreaRangeChartDesignOptions, BaseDesignOptionsType } from './design-options';
+/**
+ * Style configuration for text elements
+ */
+export type TextStyle = {
+    fontFamily?: string;
+    fontSize?: string;
+    fontWeight?: string;
+    color?: string;
+    textOutline?: string;
+    pointerEvents?: string;
+    textOverflow?: string;
+    width?: string;
+};
 export declare const POLAR_CHART_TYPES: readonly ["polar"];
 export type PolarChartType = (typeof POLAR_CHART_TYPES)[number];
 export declare const CARTESIAN_CHART_TYPES: readonly ["line", "area", "bar", "column", "polar"];