@sisense/sdk-ui 0.11.3

package/dist/chart-options-processor/translations/design-options.d.ts

@@ -0,0 +1,118 @@
+import { ValueLabel } from './value-label-section';
+import { Axis } from './axis-section';
+import { Marker } from './marker-section';
+import { LegendPosition } from './legend-section';
+import { LineType, StackType } from './translations-to-highcharts';
+import { PieType, PieLabels } from './pie-plot-options';
+import { FunnelSize, FunnelType, FunnelDirection, FunnelLabels } from './funnel-plot-options';
+import { Convolution, TreemapStyleOptions } from '../../types';
+import { ScatterMarkerSize } from './scatter-plot-options';
+type DataLimits = {
+    seriesCapacity: number;
+    categoriesCapacity: number;
+};
+export type BaseDesignOptionsType = {
+    legend: LegendPosition;
+    valueLabel: ValueLabel;
+    lineType: LineType;
+    lineWidth: number;
+    marker: Marker;
+    xAxis: Axis;
+    yAxis: Axis;
+    x2Axis?: Axis;
+    y2Axis?: Axis;
+    autoZoom: boolean;
+    dataLimits: DataLimits;
+};
+export type LineChartDesignOptions = BaseDesignOptionsType;
+export type StackableChartDesignOptions = BaseDesignOptionsType & {
+    stackType: StackType;
+    showTotal?: boolean;
+};
+export type AreaChartDesignOptions = StackableChartDesignOptions;
+export type BarChartDesignOptions = StackableChartDesignOptions;
+export type ColumnChartDesignOptions = StackableChartDesignOptions;
+export type PieChartDesignOptions = BaseDesignOptionsType & {
+    pieType?: PieType;
+    pieLabels?: PieLabels;
+    convolution?: Convolution;
+};
+export type FunnelChartDesignOptions = BaseDesignOptionsType & {
+    funnelSize?: FunnelSize;
+    funnelType?: FunnelType;
+    funnelDirection?: FunnelDirection;
+    funnelLabels?: FunnelLabels;
+};
+export type TreemapChartDesignOptions = BaseDesignOptionsType & TreemapStyleOptions;
+export type ScatterChartDesignOptions = BaseDesignOptionsType & {
+    markerSize?: ScatterMarkerSize;
+};
+/**
+ * Configuration for Table design options
+ *
+ */
+export type TableDesignOptions = {
+    /**
+     * Boolean flag responsible for header cells background color fill
+     *
+     */
+    headersColor?: boolean;
+    /**
+     * Boolean flag responsible for alternating rows background color fill
+     *
+     */
+    alternatingRowsColor?: boolean;
+    /**
+     * Boolean flag responsible for alternating columns background color fill
+     *
+     */
+    alternatingColumnsColor?: boolean;
+};
+export type IndicatorStyleType = 'numeric' | 'gauge';
+export type NumericIndicatorSubType = 'numericSimple' | 'numericBar';
+export type IndicatorSkin = 'vertical' | 'horizontal' | 1 | 2;
+/** Configuration options that define components of an indicator chart. */
+export type IndicatorComponents = {
+    /** The main title of the indicator chart */
+    title?: {
+        /** Whether the title should be shown */
+        shouldBeShown: boolean;
+        /** The text of the title */
+        text?: string;
+    };
+    /** The secondary title of the indicator chart to be shown when `secondary` is specified in {@link IndicatorDataOptions} */
+    secondaryTitle?: {
+        /** The text of the secondary title */
+        text?: string;
+    };
+    /** The ticks displayed on the indicator chart */
+    ticks?: {
+        /** Whether the ticks should be shown */
+        shouldBeShown: boolean;
+    };
+    /** The value labels of the indicator chart */
+    labels?: {
+        /** Whether the labels should be shown */
+        shouldBeShown: boolean;
+    };
+};
+/**
+ * Design options for an indicator chart.
+ */
+export type IndicatorChartDesignOptions<IndicatorType extends IndicatorStyleType = IndicatorStyleType> = BaseDesignOptionsType & {
+    indicatorComponents: IndicatorComponents;
+} & (IndicatorType extends 'gauge' ? GaugeSpecificDesignOptions : NumericSpecificDesignOptions);
+export type GaugeSpecificDesignOptions = {
+    indicatorType: 'gauge';
+    skin: 1 | 2;
+};
+export type NumericSpecificDesignOptions<NumericSubtype extends NumericIndicatorSubType = NumericIndicatorSubType> = {
+    indicatorType: 'numeric';
+    numericSubtype: NumericSubtype;
+    skin: NumericSubtype extends 'numericSimple' ? 'vertical' | 'horizontal' : never;
+};
+export type PolarType = 'line' | 'area' | 'column';
+export type PolarChartDesignOptions = BaseDesignOptionsType & {
+    polarType: PolarType;
+};
+export {};

package/dist/chart-options-processor/translations/funnel-plot-options.d.ts

@@ -0,0 +1,53 @@
+import { PlotOptions } from '../chart-options-service';
+import { ValueLabelSettings } from './value-label-section';
+import { FunnelChartDesignOptions } from './design-options';
+import { ChartDataOptionsInternal } from '../../chart-data-options/types';
+export declare const DefaultFunnelLabels: FunnelLabels;
+export type FunnelLabels = {
+    enabled: boolean;
+    showCategories: boolean;
+    showValue: boolean;
+    showPercent: boolean;
+    showDecimals: boolean;
+};
+export declare const DefaultFunnelSize: FunnelSize;
+export declare const funnelSizes: readonly ["wide", "regular", "narrow"];
+/** Visual size of the lowest slice (degree of funnel narrowing from highest to lowest slices)*/
+export type FunnelSize = (typeof funnelSizes)[number];
+export declare const DefaultFunnelType: FunnelType;
+export declare const funnelTypes: readonly ["regular", "pinched"];
+/** Visual type of the lowest slice of Funnel chart */
+export type FunnelType = (typeof funnelTypes)[number];
+export declare const DefaultFunnelDirection: FunnelDirection;
+export declare const funnelDirections: readonly ["regular", "inverted"];
+/** Direction of Funnel chart narrowing */
+export type FunnelDirection = (typeof funnelDirections)[number];
+export type FunnelOptions = {
+    allowPointSelect: boolean;
+    cursor: 'pointer';
+    dataLabels: ValueLabelSettings & {
+        funnelMinimumFontSizeToTextLabel: number;
+        formatter?: () => string;
+    };
+    showInLegend: boolean;
+    reversed: boolean;
+    neckWidth: string | number;
+    neckHeight: string | number;
+    width: string | number;
+};
+export declare const isFunnelReversed: (direction: FunnelDirection) => boolean;
+export declare const seriesDataLabels: (labels: FunnelLabels) => {
+    enabled: boolean;
+};
+export type RenderTo = {
+    clientWidth: number;
+    clientHeight: number;
+};
+export declare const MAX_FUNNEL_WIDTH = 66.6;
+export declare const HEIGHT_TO_WIDTH_COEFFICIENT = 1.5;
+export declare const DEFAULT_NECK_WIDTH = 15;
+export declare const DEFAULT_SHIFT = 50;
+export declare const funnelWidthPercentage: (renderTo: RenderTo | null) => number;
+export declare const funnelNeckWidth: (widthPercentage: number, funnelSize: FunnelSize) => number;
+export declare const funnelNeckHeight: (type: FunnelType) => number;
+export declare const getFunnelPlotOptions: (funnelDesignOptions: FunnelChartDesignOptions, chartDataOptions: ChartDataOptionsInternal) => PlotOptions;

package/dist/chart-options-processor/translations/funnel-series.d.ts

@@ -0,0 +1,15 @@
+import { Color, SeriesWithAlerts, CompleteThemeSettings } from '../../types';
+import { SeriesType } from '../chart-options-service';
+import { FunnelChartDesignOptions } from './design-options';
+import { CategoricalChartData } from '../../chart-data/types';
+import { CategoricalChartDataOptionsInternal } from '../../chart-data-options/types';
+export declare const getAPaletteColor: (colors: Color[] | undefined, index: number) => string;
+/**
+ * Convert categorical chart data into renderable highcharts funnel series. *
+ *
+ * @param chartData
+ * @param dataOptions
+ * @param designOptions
+ * @param themeSettings
+ */
+export declare const formatFunnelChartData: (chartData: CategoricalChartData, dataOptions: CategoricalChartDataOptionsInternal, designOptions: FunnelChartDesignOptions, themeSettings?: CompleteThemeSettings) => SeriesWithAlerts<SeriesType[]>;

package/dist/chart-options-processor/translations/legend-section.d.ts

@@ -0,0 +1,23 @@
+import { Style } from '../chart-options-service';
+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 & {
+        cursor?: string;
+    };
+    symbolRadius?: number;
+    symbolHeight?: number;
+    symbolWidth?: number;
+    borderWidth?: string;
+    borderColor?: string;
+    backgroundColor?: string;
+    title?: {
+        style?: {
+            [key: string]: string | number;
+        };
+    };
+};
+export declare const getLegendSettings: (position: LegendPosition) => LegendSettings;

package/dist/chart-options-processor/translations/marker-section.d.ts

@@ -0,0 +1,26 @@
+export type Marker = {
+    enabled: boolean;
+    size: 'small' | 'large';
+    fill: 'full' | 'hollow';
+};
+export type MarkerSettings = {
+    enabled: boolean;
+    radius?: number;
+    symbol?: string;
+    fillColor?: string | null;
+    lineColor?: string | null;
+    lineWidth?: number;
+    fillOpacity?: number;
+    states?: {
+        hover?: {
+            fillColor: string;
+            radius: number;
+            lineWidth: number;
+        };
+        select?: {
+            fillOpacity: number;
+            lineWidth: number;
+        };
+    };
+};
+export declare const getMarkerSettings: (marker: Marker) => MarkerSettings;

package/dist/chart-options-processor/translations/navigator.d.ts

@@ -0,0 +1,32 @@
+import { AxisSettings } from './axis-section';
+import { HighchartsType } from './translations-to-highcharts';
+type Navigator = {
+    series: {
+        type: HighchartsType;
+        dataGrouping: {
+            enabled: boolean;
+        };
+    };
+    enabled: boolean;
+    margin: number;
+    height: number;
+    xAxis: AxisSettings;
+    handles: {
+        symbols: string[];
+        backgroundColor: string;
+        borderColor: string;
+    };
+    maskInside: boolean;
+    maskFill: string;
+    outlineColor: string;
+    outlineWidth: number;
+    threshold?: number;
+    tooltipFormatter?: (min: number, max: number) => {
+        left: string;
+        right: string;
+    };
+};
+export declare const getNavigator: (type: HighchartsType, enabled: boolean, xAxisCount: number) => Navigator | {
+    enabled: boolean;
+};
+export {};

package/dist/chart-options-processor/translations/number-format-config.d.ts

@@ -0,0 +1,16 @@
+export type DecimalScale = number | 'auto';
+export type NumberFormatConfig = {
+    name: 'Numbers' | 'Currency' | 'Percent';
+    decimalScale: DecimalScale;
+    trillion: boolean;
+    billion: boolean;
+    million: boolean;
+    kilo: boolean;
+    thousandSeparator: boolean;
+    prefix: boolean;
+    symbol: string;
+};
+export declare const defaultConfig: NumberFormatConfig;
+export declare const applyFormatStaticMarkup: (config: NumberFormatConfig, value: number) => string;
+export declare const applyFormat: (config: NumberFormatConfig, value: number) => string;
+export declare const applyFormatPlainText: (config: NumberFormatConfig, value: number) => string;

package/dist/chart-options-processor/translations/pie-plot-options.d.ts

@@ -0,0 +1,29 @@
+import { PlotOptions } from '../chart-options-service';
+import { ValueLabelSettings } from './value-label-section';
+import { ChartDataOptionsInternal } from '../../chart-data-options/types';
+export declare const DefaultPieLabels: PieLabels;
+export type PieLabels = {
+    enabled: boolean;
+    showCategories: boolean;
+    showValue: boolean;
+    showPercent: boolean;
+    showDecimals: boolean;
+};
+export declare const DefaultPieType: PieType;
+export declare const pieTypes: readonly ["classic", "donut", "ring"];
+export type PieType = (typeof pieTypes)[number];
+export type PieOptions = {
+    allowPointSelect: boolean;
+    cursor?: string;
+    dataLabels: ValueLabelSettings & {
+        showPercentLabels: boolean;
+        showDecimals: boolean;
+        pieMinimumFontSizeToTextLabel: number;
+        formatter?: () => string;
+    };
+    showInLegend: boolean;
+    innerSize?: InnerSize;
+};
+type InnerSize = '0%' | '40%' | '80%';
+export declare const getPiePlotOptions: (pieType: "classic" | "donut" | "ring" | undefined, pieLabels: PieLabels | undefined, chartDataOptions: ChartDataOptionsInternal) => PlotOptions;
+export {};

package/dist/chart-options-processor/translations/pie-series.d.ts

@@ -0,0 +1,19 @@
+import { Color, SeriesWithAlerts, CompleteThemeSettings } from '../../types';
+import { CategoricalChartDataOptionsInternal } from '../../chart-data-options/types';
+import { SeriesType } from '../chart-options-service';
+import { PieChartDesignOptions } from './design-options';
+import { CategoricalChartData } from '../../chart-data/types';
+export declare const getAPaletteColor: (colors: Color[] | undefined, index: number) => string;
+type FormattedPieChartData = SeriesWithAlerts<SeriesType[]> & {
+    convolutionSeries: SeriesType[];
+};
+/**
+ * Convert categorical chart data into renderable highcharts pie series.
+ *
+ * @param chartData
+ * @param dataOptions
+ * @param designOptions
+ * @param themeSettings
+ */
+export declare const formatCategoricalChartData: (chartData: CategoricalChartData, dataOptions: CategoricalChartDataOptionsInternal, designOptions: PieChartDesignOptions, themeSettings?: CompleteThemeSettings) => FormattedPieChartData;
+export {};

package/dist/chart-options-processor/translations/scatter-axis.d.ts

@@ -0,0 +1,7 @@
+import { ScatterCategories } from '../../chart-data/types';
+import { ScatterChartDataOptionsInternal, Category, Value } from './../../chart-data-options/types';
+import { Axis, AxisSettings } from './axis-section';
+export declare const commonColor = "#d1d1d7";
+export declare function scatterFormatter(axisAttribute: Category | Value | undefined, value: string | number, categories: (string | number)[] | undefined): string;
+export declare const getScatterXAxisSettings: (xAxis: Axis, categories: ScatterCategories, scatterDataOptions: ScatterChartDataOptionsInternal) => AxisSettings[];
+export declare const getScatterYAxisSettings: (yAxis: Axis, categories: ScatterCategories, scatterDataOptions: ScatterChartDataOptionsInternal) => AxisSettings[];

package/dist/chart-options-processor/translations/scatter-plot-options.d.ts

@@ -0,0 +1,22 @@
+import { ScatterChartDataOptionsInternal } from '../../chart-data-options/types';
+import { PlotOptions } from '../chart-options-service';
+import { ScatterChartDesignOptions } from './design-options';
+import { InternalSeries } from './tooltip-utils';
+import { ScatterCustomPointOptions } from './scatter-tooltip';
+export type ScatterMarkerSize = {
+    scatterDefaultSize: number;
+    scatterBubbleMinSize: number;
+    scatterBubbleMaxSize: number;
+};
+export type ScatterBubbleOptions = {
+    animation: boolean;
+    maxSize: number;
+    minSize: number;
+};
+export declare const defaultScatterMarkerSize: ScatterMarkerSize;
+export type ScatterChartInternalSeries = InternalSeries & {
+    point: {
+        custom?: ScatterCustomPointOptions;
+    };
+};
+export declare const getScatterPlotOptions: (chartDesignOptions: ScatterChartDesignOptions, dataOptions: ScatterChartDataOptionsInternal) => PlotOptions;

package/dist/chart-options-processor/translations/scatter-series.d.ts

@@ -0,0 +1,23 @@
+import { ScatterChartDataOptionsInternal } from '../../chart-data-options/types';
+import { SeriesType } from '../chart-options-service';
+import { ScatterAxisCategoriesMap, ScatterDataTable } from '../../chart-data/types';
+import { ComparableData } from '../../chart-data-processor/table-processor';
+import { SeriesWithAlerts, CompleteThemeSettings } from '../../types';
+export type ScatterSeriesColor = {
+    index: number;
+    color: string;
+};
+export type ScatterSeriesColorsMap = Map<string, ScatterSeriesColor>;
+export interface AxisComputedProperties {
+    x: number | null;
+    y: number | null;
+    z: number | null;
+    maskedX: string;
+    maskedY: string;
+    maskedBreakByPoint?: string;
+    maskedBreakByColor?: string;
+    maskedSize?: string;
+    color?: string;
+}
+export declare const handleNumberValue: (cell: ComparableData) => number | null;
+export declare const buildScatterSeries: (data: ScatterDataTable, categoriesMap: ScatterAxisCategoriesMap, dataOptions?: ScatterChartDataOptionsInternal, themeSettings?: CompleteThemeSettings, seriesCapacity?: number) => SeriesWithAlerts<SeriesType[]>;

package/dist/chart-options-processor/translations/scatter-tooltip.d.ts

@@ -0,0 +1,21 @@
+import { InternalSeries, TooltipSettings } from './tooltip-utils';
+import { ScatterChartDataOptionsInternal } from '../../chart-data-options/types';
+export interface ScatterTooltipElements {
+    x: string;
+    y: string;
+    breakByPoint: string;
+    breakByColor: string;
+    size: string;
+}
+export interface ScatterCustomPointOptions {
+    maskedX: string;
+    maskedY: string;
+    maskedBreakByPoint?: string;
+    maskedBreakByColor?: string;
+    maskedSize?: string;
+}
+export declare const spanSegment: (value: number | string, color?: string) => string;
+export declare const tooltipWrapper: (content: string) => string;
+export declare const tooltipSeparator: () => string;
+export declare const tooltipFormatter: (ctx: InternalSeries, dataOptions: ScatterChartDataOptionsInternal) => string;
+export declare const getScatterTooltipSettings: (dataOptions: ScatterChartDataOptionsInternal) => TooltipSettings;

package/dist/chart-options-processor/translations/tooltip-utils.d.ts

@@ -0,0 +1,39 @@
+import { Category, Value } from '../../chart-data-options/types.js';
+export declare const isXValueNumeric: (dataOptionX: Value | Category | undefined) => boolean | "";
+export declare const formatTooltipValue: (dataOption: Value | Category | undefined, value: number | undefined, displayValue: string) => string;
+export declare const formatTooltipXValue: (dataOption: Value | Category | undefined, value: number | string | undefined, displayValue: string) => string;
+export type TooltipSettings = {
+    enabled?: boolean;
+    animation?: boolean;
+    backgroundColor?: string;
+    borderColor?: string;
+    borderRadius?: number;
+    borderWidth?: number;
+    useHTML?: boolean;
+    formatter?: () => string;
+    style?: {
+        fontFamily?: string;
+    };
+};
+export type InternalSeries = {
+    series: {
+        name: string;
+        color: string;
+    };
+    x: string;
+    y: number;
+    point: {
+        x?: number | string;
+        y?: number;
+        z?: number;
+        name: string;
+        color: string;
+        custom?: {
+            number1?: number;
+            string1?: string;
+            xDisplayValue?: string;
+            xValue?: (number | string)[];
+        };
+    };
+    percentage?: number;
+};

package/dist/chart-options-processor/translations/tooltip.d.ts

@@ -0,0 +1,3 @@
+import { ChartDataOptionsInternal } from '../../chart-data-options/types';
+import { TooltipSettings } from './tooltip-utils';
+export declare const getTooltipSettings: (showDecimals: boolean | undefined, chartDataOptions: ChartDataOptionsInternal) => TooltipSettings;

package/dist/chart-options-processor/translations/translations-to-highcharts.d.ts

@@ -0,0 +1,73 @@
+import { ChartType } from '../../types';
+import { ChartDataOptionsInternal, CategoricalChartDataOptionsInternal, CartesianChartDataOptionsInternal } from '../../chart-data-options/types';
+import { CategoricalSeriesValues, ChartData, CartesianChartData } from '../../chart-data/types';
+import { StackableChartDesignOptions } from './design-options';
+import { AxisMinMax } from './axis-section';
+import { Stacking } from '../chart-options-service';
+import { ChartDesignOptions } from './types';
+export type LineType = 'straight' | 'smooth';
+export type StackType = 'classic' | 'stacked' | 'stack100';
+export type HighchartsType = ChartType | 'spline' | 'areaspline' | 'bubble';
+export type HighchartsSeriesValues = {
+    name: string;
+    data: SeriesPointStructure[];
+    levels?: any;
+};
+export type SeriesPointStructure = {
+    name?: string;
+    y?: number | null;
+    x?: number | null;
+    z?: number | null;
+    color?: string;
+    marker?: {
+        enabled?: boolean;
+        isIsolatedPoint?: boolean;
+        lineColor?: string;
+        lineWidth?: number;
+    };
+    selected?: boolean;
+    custom?: {
+        number1?: number;
+        string1?: string;
+        level?: number;
+        [k: string]: unknown;
+    };
+    value?: number | null;
+    id?: string;
+    drilldown?: string;
+    parent?: string;
+};
+/**
+ * Translate public-facing chart type and chart design options to internal highcharts chart type
+ *
+ * @param chartType - public-facing chart type
+ * @param chartDesignOptions - public-facing chart design options
+ * @returns internal highcharts chart type
+ */
+export declare const determineHighchartsChartType: (chartType: ChartType, chartDesignOptions: ChartDesignOptions) => HighchartsType;
+export declare const addStackingIfSpecified: (chartType: ChartType, designOptions: StackableChartDesignOptions) => {
+    stacking?: Stacking | undefined;
+    showTotal: boolean;
+};
+/**
+ * In cartesian charts when a chart has only Y columns and since we for each Y column build a separate series
+ * to match the legend correctly in order to correctly map x-axis labels
+ * This method returns the indexMap for the series with the index
+ * for a series with one data, index map has -1 for all x-axis locations except where the series lands
+ *
+ * @param categories -
+ * @param index -
+ */
+export declare const indexMapWhenOnlyY: (categories: string[], index: number) => (0 | -1)[];
+export declare const formatSeriesContinuousXAxis: (series: CategoricalSeriesValues, indexMap: number[], treatNullDataAsZeros: boolean, interval: number, maxCategories: number) => HighchartsSeriesValues;
+export declare const formatSeries: (series: CategoricalSeriesValues, indexMap: number[], treatNullDataAsZeros: boolean, categories?: string[], categoryColors?: string[]) => HighchartsSeriesValues;
+export declare const adjustMinWhenColumnBar: (chartType: ChartType, autoMinMax: AxisMinMax) => {
+    min: number;
+    max: number;
+};
+export declare const autoCalculateYAxisMinMax: (chartType: ChartType, chartData: CartesianChartData, chartDesignOptions: ChartDesignOptions, yAxisSide: number[], yTreatNullDataAsZeros: boolean[], side: number) => {
+    min: number;
+    max: number;
+};
+export declare const determineYAxisOptions: (chartData: ChartData, dataOptions: ChartDataOptionsInternal) => [number[], (HighchartsType | undefined)[], boolean[]];
+export declare const getColorSetting: (dataOptions: CartesianChartDataOptionsInternal | CategoricalChartDataOptionsInternal, key: string) => string | undefined;

package/dist/chart-options-processor/translations/treemap/treemap-labels.d.ts

@@ -0,0 +1,6 @@
+import { CategoricalChartDataOptionsInternal } from '../../../chart-data-options/types';
+import { TreemapChartDesignOptions } from '../design-options';
+import { CompleteThemeSettings } from '../../../types';
+import Highcharts, { PointLabelObject } from '@sisense/sisense-charts';
+export declare function prepareTreemapLevels(dataOptions: CategoricalChartDataOptionsInternal, chartDesignOptions: TreemapChartDesignOptions, themeSettings?: CompleteThemeSettings): Highcharts.PlotTreegraphLevelsOptions[];
+export declare function treemapLabelFormatter(this: PointLabelObject): string;

package/dist/chart-options-processor/translations/treemap/treemap-options.d.ts

@@ -0,0 +1,6 @@
+import { CategoricalChartData } from '../../../chart-data/types';
+import { HighchartsOptionsInternal } from '../../chart-options-service';
+import { CategoricalChartDataOptionsInternal } from '../../../chart-data-options/types';
+import { CompleteThemeSettings } from '../../../types';
+import { TreemapChartDesignOptions } from '../design-options';
+export declare function prepareTreemapOptions(chartData: CategoricalChartData, dataOptions: CategoricalChartDataOptionsInternal, designOptions: TreemapChartDesignOptions, themeSettings?: CompleteThemeSettings): HighchartsOptionsInternal;

package/dist/chart-options-processor/translations/treemap/treemap-series.d.ts

@@ -0,0 +1,5 @@
+import { CategoricalChartData } from '../../../chart-data/types';
+import { SeriesPointStructure } from '../translations-to-highcharts';
+import { CategoricalChartDataOptionsInternal } from '../../../chart-data-options/types';
+import { CompleteThemeSettings } from '../../../types';
+export declare function prepareTreemapDataItems(chartData: CategoricalChartData, dataOptions: CategoricalChartDataOptionsInternal, themeSettings?: CompleteThemeSettings): SeriesPointStructure[];

package/dist/chart-options-processor/translations/treemap/treemap-tooltip.d.ts

@@ -0,0 +1,6 @@
+import { CategoricalChartDataOptionsInternal } from '../../../chart-data-options/types';
+import { TreemapChartDesignOptions } from '../design-options';
+import { TooltipSettings } from '../../tooltip';
+import { TooltipFormatterContextObject } from '@sisense/sisense-charts';
+export declare const getTreemapTooltipSettings: (chartDataOptions: CategoricalChartDataOptionsInternal, designOptions: TreemapChartDesignOptions) => TooltipSettings;
+export declare function treemapTooltipFormatter(context: TooltipFormatterContextObject, chartDataOptions: CategoricalChartDataOptionsInternal, designOptions: TreemapChartDesignOptions): string;

package/dist/chart-options-processor/translations/treemap/types.d.ts

@@ -0,0 +1,19 @@
+import { Chart, PointLabelObject } from '@sisense/sisense-charts';
+export type ParentValues = {
+    direction: number;
+    height: number;
+    val: number;
+    width: number;
+    x: number;
+    y: number;
+};
+export type LayoutPointResult = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type TreemapLayoutAlgorithmContext = {
+    chart: Chart;
+    squarified: (parent: ParentValues, children: PointLabelObject[]) => LayoutPointResult[];
+};

package/dist/chart-options-processor/translations/types.d.ts

@@ -0,0 +1,36 @@
+import { ChartDataOptionsInternal } from '../../chart-data-options/types';
+import { ChartType } from '../../types';
+import { LineChartDesignOptions, AreaChartDesignOptions, BarChartDesignOptions, ColumnChartDesignOptions, PieChartDesignOptions, FunnelChartDesignOptions, IndicatorChartDesignOptions, PolarChartDesignOptions, ScatterChartDesignOptions, TreemapChartDesignOptions } from './design-options';
+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"];
+/** Cartesian family of chart types @expandType */
+export type CartesianChartType = (typeof CARTESIAN_CHART_TYPES)[number];
+export declare const CATEGORICAL_CHART_TYPES: readonly ["pie", "funnel", "treemap"];
+/** Categorical family of chart types  @expandType */
+export type CategoricalChartType = (typeof CATEGORICAL_CHART_TYPES)[number];
+export declare const SCATTER_CHART_TYPES: readonly ["scatter"];
+/** Scatter chart types  @expandType */
+export type ScatterChartType = (typeof SCATTER_CHART_TYPES)[number];
+export declare const TABLE_TYPES: readonly ["table"];
+/** Table chart types @expandType */
+export type TableType = (typeof TABLE_TYPES)[number];
+declare const INDICATOR_CHART_TYPES: readonly ["indicator"];
+/** Indicator chart types @expandType */
+export type IndicatorChartType = (typeof INDICATOR_CHART_TYPES)[number];
+declare const IMAGE_CHART_TYPES: readonly ["image"];
+export type ImageChartType = (typeof IMAGE_CHART_TYPES)[number];
+export type ChartDataType = 'cartesian' | 'categorical' | 'scatter' | 'table' | 'indicator';
+export type ChartDesignOptions = LineChartDesignOptions | AreaChartDesignOptions | BarChartDesignOptions | ColumnChartDesignOptions | PieChartDesignOptions | FunnelChartDesignOptions | PolarChartDesignOptions | IndicatorChartDesignOptions | ScatterChartDesignOptions | TreemapChartDesignOptions;
+export type ChartConfig = {
+    chartType: ChartType;
+    dataOptions: ChartDataOptionsInternal;
+    designOptions: ChartDesignOptions;
+};
+export declare const isCartesian: (chartType: ChartType) => chartType is "area" | "line" | "bar" | "column" | "polar";
+export declare const isCategorical: (chartType: ChartType) => chartType is "pie" | "funnel" | "treemap";
+export declare const isScatter: (chartType: ChartType) => chartType is "scatter";
+export declare const isIndicator: (chartType: ChartType) => chartType is "indicator";
+export declare const isPolar: (chartType: ChartType) => chartType is "polar";
+export declare const isTable: (chartType: ChartType | TableType) => chartType is "table";
+export {};

package/dist/chart-options-processor/translations/value-label-section.d.ts

@@ -0,0 +1,28 @@
+import { Style } from '../chart-options-service';
+import { NumberFormatConfig } from './number-format-config';
+import { AxisOrientation } from './axis-section';
+import { InternalSeries } from './tooltip-utils';
+import { PolarType } from './design-options';
+export type ValueLabel = 'horizontal' | 'diagonal' | 'vertical' | null;
+export type ValueLabelSettings = {
+    enabled?: boolean;
+    align?: string;
+    crop?: boolean;
+    rotation?: number;
+    y?: number;
+    x?: number;
+    style?: Style;
+    overflow?: string;
+    allowOverlap?: boolean;
+    verticalAlign?: 'bottom' | 'middle' | 'top';
+    padding?: number;
+    types?: {
+        count: boolean;
+        relative: boolean;
+        totals: boolean;
+    };
+    formatter?: (this: InternalSeries) => string;
+};
+export declare const createValueLabelFormatter: (numberFormatConfig?: NumberFormatConfig) => (this: InternalSeries) => string;
+export declare const getValueLabelSettings: (xAxisOrientation: AxisOrientation, valueLabel: ValueLabel, inside?: boolean) => ValueLabelSettings;
+export declare const getPolarValueLabelSettings: (valueLabel: ValueLabel, polarType: PolarType) => ValueLabelSettings;