@sisense/sdk-ui 0.11.3

package/dist/area-chart.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="react" />
+import { AreaChartProps } from './props';
+/**
+ * A React component similar to a {@link LineChart},
+ * but with filled in areas under each line and an option to display them as stacked.
+ * More info on [Sisense Documentation page](https://docs.sisense.com/main/SisenseLinux/area-chart.htm).
+ *
+ * @example
+ * An example of using the component to visualize the `Sample ECommerce` data source:
+ * ```tsx
+ * <AreaChart
+ *   dataSet={DM.DataSource}
+ *   dataOptions={{
+ *     category: [DM.Commerce.Date.Years],
+ *     value: [measures.sum(DM.Commerce.Revenue)],
+ *     breakBy: [DM.Commerce.Gender],
+ *   }}
+ *   styleOptions={{ subtype: 'area/stacked' }}
+ *   filters={[filters.members(DM.Commerce.Gender, ['Female', 'Male'])]}
+ *   onDataPointClick={(point, nativeEvent) => {
+ *     console.log('clicked', point, nativeEvent);
+ *   }}
+ * />
+ * ```
+ *
+ * <img src="media://area-chart-example-1.png" width="800"/>
+ * @param props - Area chart properties
+ * @returns Area Chart component
+ */
+export declare const AreaChart: import("react").FunctionComponent<AreaChartProps>;

package/dist/bar-chart.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="react" />
+import { BarChartProps } from './props';
+/**
+ * A React component representing categorical data with horizontal rectangular bars,
+ * whose lengths are proportional to the values that they represent.
+ * See [Bar Chart](https://docs.sisense.com/main/SisenseLinux/bar-chart.htm) for more information.
+ *
+ * @example
+ * An example of using the component to visualize the `Sample ECommerce` data source:
+ * ```tsx
+ * <BarChart
+ *   dataSet={DM.DataSource}
+ *   dataOptions={{
+ *     category: [DM.Commerce.AgeRange],
+ *     value: [measures.sum(DM.Commerce.Revenue)],
+ *     breakBy: [DM.Commerce.Gender],
+ *   }}
+ *   filters={[filters.greaterThan(DM.Commerce.Revenue, 1000)]}
+ *   onDataPointClick={(point, nativeEvent) => {
+ *     console.log('clicked', point, nativeEvent);
+ *   }}
+ * />
+ * ```
+ *
+ * <img src="media://bar-chart-example-1.png" width="800"/>
+ * @param props - Bar chart properties
+ * @returns Bar Chart component
+ */
+export declare const BarChart: import("react").FunctionComponent<BarChartProps>;

package/dist/chart-data/cartesian-data.d.ts

@@ -0,0 +1,5 @@
+import { DataTable } from '../chart-data-processor/table-processor';
+import { CartesianChartData } from './types';
+import { CartesianChartDataOptionsInternal } from '../chart-data-options/types';
+export declare const validateCartesianChartDataOptions: (chartDataOptions: CartesianChartDataOptionsInternal) => CartesianChartDataOptionsInternal;
+export declare const cartesianData: (chartDataOptions: CartesianChartDataOptionsInternal, dataTable: DataTable) => CartesianChartData;

package/dist/chart-data/categorical-data.d.ts

@@ -0,0 +1,5 @@
+import { CategoricalChartDataOptionsInternal } from '../chart-data-options/types';
+import { DataTable } from '../chart-data-processor/table-processor';
+import { CategoricalChartData } from './types';
+export declare const validateCategoricalChartDataOptions: (chartDataOptions: CategoricalChartDataOptionsInternal) => CategoricalChartDataOptionsInternal;
+export declare const categoricalData: (chartDataOptions: CategoricalChartDataOptionsInternal, dataTable: DataTable) => CategoricalChartData;

package/dist/chart-data/chart-data-service.d.ts

@@ -0,0 +1,18 @@
+import { ChartDataOptionsInternal } from '../chart-data-options/types';
+import { DataTable } from '../chart-data-processor/table-processor';
+import { ChartType, NumberFormatConfig, SeriesChartType } from '../types';
+import { ChartData } from './types';
+export declare const chartDataService: (chartType: ChartType, chartDataOptions: ChartDataOptionsInternal, dataTable: DataTable) => ChartData;
+export type ValueColumn = {
+    column: string;
+    agg: string;
+    columnTitle: string;
+    enabled: boolean;
+    sort: SortDirection;
+    showOnRightAxis?: boolean;
+    numberFormatConfig?: NumberFormatConfig;
+    chartType?: SeriesChartType;
+    color?: string;
+    legacyInstanceId?: string;
+};
+export type SortDirection = 'sortAsc' | 'sortDesc' | 'sortNone';

package/dist/chart-data/filter-and-aggregate-chart-data.d.ts

@@ -0,0 +1,4 @@
+import { Category, Value } from '../chart-data-options/types';
+import { DataColumnNamesMapping } from '../chart-data-options/validate-data-options';
+import { DataTable } from '../chart-data-processor/table-processor';
+export declare const filterAndAggregateChartData: (sourceTable: DataTable, attributes: Category[], measures: Value[], dataColumnNamesMapping?: DataColumnNamesMapping) => DataTable;

package/dist/chart-data/indicator-data.d.ts

@@ -0,0 +1,4 @@
+import { DataTable } from '../chart-data-processor/table-processor';
+import { IndicatorDataOptionsInternal } from '../chart-data-options/types';
+import { IndicatorChartData } from './types';
+export declare const indicatorData: (chartDataOptions: IndicatorDataOptionsInternal, dataTable: DataTable) => IndicatorChartData;

package/dist/chart-data/scatter-data.d.ts

@@ -0,0 +1,23 @@
+import { ComparableData, DataTable } from '../chart-data-processor/table-processor';
+import { ScatterCategories, ScatterChartData, ScatterAxisCategoriesMap, ScatterDataTable } from './types';
+import { ScatterChartDataOptionsInternal } from '../chart-data-options/types';
+export declare const defaultScatterDataValue: ComparableData;
+export type AxisColumnName = 'xAxis' | 'yAxis';
+export interface DataOptionsIndexes {
+    x: number;
+    y: number;
+    breakByPoint: number;
+    breakByColor: number;
+    size: number;
+}
+export declare const buildCategories: (data: ScatterDataTable, axisColumnName: AxisColumnName) => string[];
+export declare const createCategoriesMap: (xCategories?: ScatterCategories, yCategories?: ScatterCategories) => ScatterAxisCategoriesMap;
+export declare const groupData: (chartDataOptions: ScatterChartDataOptionsInternal, dataTable: DataTable) => ScatterDataTable;
+/**
+ * Creates data for scatter charts given chart data table and data options,
+ *
+ * @param chartDataOptions - Data options for scatter chart
+ * @param dataTable - Chart data table
+ * @returns Scatter chart data
+ */
+export declare const scatterData: (chartDataOptions: ScatterChartDataOptionsInternal, dataTable: DataTable) => ScatterChartData;

package/dist/chart-data/series-data-color-service/index.d.ts

@@ -0,0 +1,3 @@
+export * from './legend-color';
+export * from './series-data-color-service';
+export * from './types';

package/dist/chart-data/series-data-color-service/legend-color.d.ts

@@ -0,0 +1,2 @@
+import { DataColorOptions } from './types';
+export declare const legendColor: (colorOpts?: DataColorOptions) => string | undefined;

package/dist/chart-data/series-data-color-service/series-data-color-service.d.ts

@@ -0,0 +1,4 @@
+import { SeriesValueData } from '../types';
+import { DataColorOptions } from './types';
+export declare function seriesDataColorService(seriesValues: SeriesValueData[], colorOpts: DataColorOptions): SeriesValueData[];
+export declare function generateColorsForDataStructures<DataStructure extends {}>(dataStructures: DataStructure[], colorOpts: DataColorOptions, getValueFromDataStructure: (data: DataStructure) => number, applyColorToDataStructure: (data: DataStructure, color: string | undefined) => DataStructure): DataStructure[];

package/dist/chart-data/series-data-color-service/types.d.ts

@@ -0,0 +1,143 @@
+/**
+ * All possible color options for data.
+ *
+ * @see {@link https://docs.sisense.com/main/SisenseLinux/selecting-colors-in-widgets.htm | Selecting Colors in Widgets}
+ */
+export type DataColorOptions = string | UniformDataColorOptions | RangeDataColorOptions | ConditionalDataColorOptions;
+/**
+ * Uniform color options for data similar to the Single Color option in the Sisense UI.
+ *
+ * @example
+ * An example of specifying red as a uniform color for all data values.
+ *
+ * ```ts
+ * {
+ *   type: 'uniform',
+ *   color: 'red',
+ * }
+ * ```
+ * @see {@link https://docs.sisense.com/main/SisenseLinux/selecting-colors-in-widgets.htm | Selecting Colors in Widgets}
+ */
+export type UniformDataColorOptions = {
+    /**
+     * Color options type
+     */
+    type: 'uniform';
+    /**
+     * Color name, e.g., `red`, or a hexadecimal value, e.g., `#ff0000`.
+     */
+    color: string;
+};
+/**
+ * Range color options for data similar to the Range option in the Sisense UI.
+ *
+ * Use `minColor` and `maxColor` to define the start and end color of the range.
+ * A color name (for example, `red`), or a hexadecimal value (for example, `#ff0000`) can be specified.
+ *
+ * By default, the color range is set to match the minimum and maximum values of the data.
+ * You can also override the default value range by
+ * setting the `minValue`, `midValue`, and `maxValue` properties.
+ *
+ * @example
+ * An example of specifying colors for data values ranging
+ * from red (for min value) to blue (for max value)
+ * with 2 more colors in between for a total of 4 colors:
+ *
+ * ```ts
+ * {
+ *   type: 'range',
+ *   steps: 4,
+ *   minColor: 'red',
+ *   maxColor: 'blue',
+ * }
+ * ```
+ * @see {@link https://docs.sisense.com/main/SisenseLinux/selecting-colors-in-widgets.htm | Selecting Colors in Widgets}
+ */
+export type RangeDataColorOptions = {
+    /**
+     * Color options type
+     */
+    type: 'range';
+    /**
+     * Distinct number of colors in the range
+     */
+    steps?: number;
+    /**
+     * Start color of the range
+     */
+    minColor?: string;
+    /**
+     * End color of the range
+     */
+    maxColor?: string;
+    /**
+     * Minimum value explicitly set to override the minimum value of the data
+     */
+    minValue?: number;
+    /**
+     * Middle value explicitly set to override the middle value of the data
+     */
+    midValue?: number;
+    /**
+     * Maximum value explicitly set to override the maximum value of the data
+     */
+    maxValue?: number;
+};
+/**
+ * Conditional color options for data similar to the Conditional Color option in the Sisense UI.
+ *
+ * This option allows you to define color conditions.
+ * Each condition is a logical expression that defines how data values are mapped into colors.
+ * These conditions are evaluated in the order in which they appear in the array.
+ *
+ * @example
+ * An example of a condition stating that a negative data value is displayed in red
+ * and another condition stating that a positive data value is green.
+ *
+ * ```ts
+ * {
+ *   type: 'conditional',
+ *   conditions: [
+ *     { color: 'red', expression: '0', operator: '<' },
+ *     { color: 'green', expression: '0', operator: '>=' },
+ *   ],
+ *   defaultColor: 'red',
+ * }
+ * ```
+ * @see {@link https://docs.sisense.com/main/SisenseLinux/selecting-colors-in-widgets.htm | Selecting Colors in Widgets}
+ */
+export type ConditionalDataColorOptions = {
+    /**
+     * Color options type
+     */
+    type: 'conditional';
+    /**
+     * Array of color conditions
+     */
+    conditions?: DataColorCondition[];
+    /**
+     * Default color when no condition is met
+     */
+    defaultColor?: string;
+};
+/**
+ * Color condition for {@link ConditionalDataColorOptions} represented as a logical expression.
+ *
+ * See {@link ConditionalDataColorOptions} for examples.
+ *
+ * @see {@link https://docs.sisense.com/main/SisenseLinux/selecting-colors-in-widgets.htm | Selecting Colors in Widgets}
+ */
+export type DataColorCondition = {
+    /**
+     * Color for this condition
+     */
+    color: string;
+    /**
+     * Expression representing the data value
+     */
+    expression: string;
+    /**
+     * Supported operators for `expression`
+     */
+    operator: '<' | '>' | '≤' | '<=' | '≥' | '>=' | '=' | '≠' | '!=';
+};

package/dist/chart-data/table-data.d.ts

@@ -0,0 +1,6 @@
+import { Column as DataTableColumn, DataTable } from '../chart-data-processor/table-processor';
+import { Category, TableDataOptionsInternal, Value } from '../chart-data-options/types';
+export declare const unifySortToDirection: (category: Category | Value) => number;
+export declare const syncDataTableWithDataOptionsSort: (chartDataOptions: TableDataOptionsInternal, dataTable: DataTable) => DataTable;
+export declare const updateInnerDataOptionsSort: (dataOptions: TableDataOptionsInternal, sortColumn: DataTableColumn) => TableDataOptionsInternal;
+export declare const tableData: (chartDataOptions: TableDataOptionsInternal, dataTable: DataTable) => DataTable;

package/dist/chart-data/types.d.ts

@@ -0,0 +1,80 @@
+import { NumberFormatConfig } from '../types';
+import { IndicatorChartType } from '../chart-options-processor/translations/types';
+import { ComparableData, Value } from '../chart-data-processor/table-processor';
+export type CategoricalXValues = {
+    key: string;
+    xValues: string[];
+    rawValues?: (string | number)[];
+    compareValues?: Value[];
+};
+export type SeriesValueData = {
+    value: number;
+    blur?: boolean;
+    color?: string;
+    rawValue?: string | number;
+    xValue?: (string | number)[];
+    xDisplayValue?: string[];
+    xCompareValue?: (string | number)[];
+    parent?: string;
+};
+export type CategoricalSeriesValues = {
+    name: string;
+    title?: string;
+    data: SeriesValueData[];
+};
+export type Column = {
+    name: string;
+    type: string;
+    enabled: boolean;
+    numberFormatConfig?: NumberFormatConfig;
+};
+export type CartesianChartData = {
+    type: 'cartesian';
+    xAxisCount: number;
+    xValues: CategoricalXValues[];
+    series: CategoricalSeriesValues[];
+};
+export type CategoricalChartData = {
+    type: 'categorical';
+    xAxisCount: number;
+    xValues: CategoricalXValues[];
+    series: CategoricalSeriesValues[];
+};
+export interface ScatterDataRow {
+    xAxis: ComparableData;
+    yAxis: ComparableData;
+    breakByPoint?: ComparableData;
+    breakByColor?: ComparableData;
+    size?: ComparableData;
+}
+export type ScatterDataTable = ScatterDataRow[];
+export type ScatterCategories = string[] | undefined;
+export type ScatterCategoryMap = Map<string, number>;
+export interface ScatterAxisCategoriesMap {
+    xCategoriesMap: ScatterCategoryMap;
+    yCategoriesMap: ScatterCategoryMap;
+}
+export type ScatterChartData = {
+    type: 'scatter';
+    scatterDataTable: ScatterDataTable;
+    xCategories: ScatterCategories;
+    yCategories: ScatterCategories;
+};
+/**
+ * Fact final data that will be passed to chart-component to render
+ *
+ * @internal
+ */
+export type IndicatorChartData = {
+    type: IndicatorChartType;
+    value?: number;
+    secondary?: number;
+    min?: number;
+    max?: number;
+};
+/**
+ * Fact final data that will be passed to chart-component to render
+ *
+ * @internal
+ */
+export type ChartData = CartesianChartData | CategoricalChartData | ScatterChartData | IndicatorChartData;

package/dist/chart-data/utils.d.ts

@@ -0,0 +1,7 @@
+import { CartesianChartDataOptionsInternal } from '../chart-data-options/types';
+export declare const onlyY: ({ x, y, breakBy }: CartesianChartDataOptionsInternal) => boolean;
+export declare const onlyYAndSeries: ({ x, y, breakBy }: CartesianChartDataOptionsInternal) => boolean;
+export declare const isEnabled: (enabled?: boolean) => boolean;
+export declare const fraction: (base: number, percentage: number) => number;
+export declare const fromFraction: (base: number, value: number) => number;
+export declare const withPercentSign: (x: number | string) => string;

package/dist/chart-data-options/coloring/coloring-service.d.ts

@@ -0,0 +1,22 @@
+import { DataColorOptions } from '../../types.js';
+/**
+ * Type representing the coloring types.
+ * Static - all values have the same color independent of the value.
+ * Absolute - each value has a color based on the value.
+ * Relative - each value has a color based on the value and the other values.
+ */
+export type ColoringType = 'Static' | 'Absolute' | 'Relative';
+export type StaticColoringFunction = () => string | undefined;
+export type AbsoluteColoringFunction = (value: number) => string | undefined;
+export type RelativeColoringFunction = (allValuesForComparison: number[]) => (value: number) => string | undefined;
+export type ColoringService<Type extends ColoringType = ColoringType> = {
+    type: Type;
+    getColor: Type extends 'Static' ? StaticColoringFunction : Type extends 'Absolute' ? AbsoluteColoringFunction : Type extends 'Relative' ? RelativeColoringFunction : never;
+};
+/**
+ * Retrieves the coloring service based on the provided color options.
+ *
+ * @param colorOptions - The color options to determine the coloring service.
+ * @returns The coloring service.
+ */
+export declare function getColoringServiceByColorOptions(colorOptions: DataColorOptions): ColoringService;

package/dist/chart-data-options/coloring/conditional-coloring.d.ts

@@ -0,0 +1,9 @@
+import { AbsoluteColoringFunction } from '.';
+import { ConditionalDataColorOptions } from '../../types';
+/**
+ * Retrieves the conditional coloring function based on the provided color options.
+ *
+ * @param colorOpts - The color options for conditional coloring.
+ * @returns The conditional coloring function.
+ */
+export declare function getConditionalColoringFunction(colorOpts: ConditionalDataColorOptions): AbsoluteColoringFunction;

package/dist/chart-data-options/coloring/consts.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_COLOR = "#dcdcdc";

package/dist/chart-data-options/coloring/index.d.ts

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

package/dist/chart-data-options/coloring/range-coloring.d.ts

@@ -0,0 +1,9 @@
+import { RelativeColoringFunction } from '.';
+import { RangeDataColorOptions } from '../../types';
+/**
+ * Returns a relative coloring function based on the provided color options.
+ *
+ * @param colorOpts - The color options for range coloring.
+ * @returns The relative coloring function.
+ */
+export declare function getRangeColoringFunction(colorOpts: RangeDataColorOptions): RelativeColoringFunction;

package/dist/chart-data-options/coloring/uniform-coloring.d.ts

@@ -0,0 +1,4 @@
+import { StaticColoringFunction } from '.';
+import { UniformDataColorOptions } from '../../types';
+export declare const getUniformColorOptionsFromString: (color: string) => UniformDataColorOptions;
+export declare function getUniformColoringFunction(colorOpts: UniformDataColorOptions): StaticColoringFunction;

package/dist/chart-data-options/translate-data-options.d.ts

@@ -0,0 +1,7 @@
+import { Attribute, Measure } from '@sisense/sdk-data';
+import { ChartType } from '../types';
+import { ChartDataOptions, ChartDataOptionsInternal, TableDataOptionsInternal, TableDataOptions } from './types';
+export declare function translateChartDataOptions(chartType: ChartType, dataOptions: ChartDataOptions): ChartDataOptionsInternal;
+export declare function getAttributes(dataOptions: ChartDataOptionsInternal, chartType: ChartType): Attribute[];
+export declare function getMeasures(dataOptions: ChartDataOptionsInternal, chartType: ChartType): Measure[];
+export declare function translateTableDataOptions(dataOptions: TableDataOptions): TableDataOptionsInternal;