@sisense/sdk-ui 2.8.0 → 2.9.0

package/dist/packages/sdk-ui/src/pivot-table/formatters/formatter-utils.d.ts

@@ -0,0 +1,23 @@
+import type { CustomDataCellFormatter, CustomHeaderCellFormatter, CellFormattingResult } from './types.js';
+import type { JaqlPanel, PivotDataNode, PivotTreeNode } from '@sisense/sdk-pivot-client';
+import type { PivotTableDataOptionsInternal } from '../../chart-data-options/types';
+/**
+ * Applies a formatting result to a data cell, mutating the cell object
+ * @param cell - The cell to apply formatting to
+ * @param result - The formatting result to apply
+ */
+export declare function applyCellFormattingResult(cell: PivotDataNode | PivotTreeNode, result: CellFormattingResult): void;
+/**
+ * Creates a unified formatter that handles functional formatters by applying their results
+ *
+ * @param formatter - A functional formatter that returns formatting information
+ * @returns A function that applies the formatter result to the cell
+ */
+export declare function createUnifiedDataCellFormatter(formatter: CustomDataCellFormatter, dataOptions: PivotTableDataOptionsInternal): (cell: PivotDataNode, rowItem: PivotTreeNode, columnItem: PivotTreeNode, jaqlPanelItem: JaqlPanel) => void;
+/**
+ * Creates a unified header cell formatter that handles functional formatters by applying their results
+ *
+ * @param formatter - A functional header formatter that returns formatting information
+ * @returns A function that applies the formatter result to the header cell
+ */
+export declare function createUnifiedHeaderCellFormatter(formatter: CustomHeaderCellFormatter, dataOptions: PivotTableDataOptionsInternal): (cell: PivotTreeNode, jaqlPanelItem: JaqlPanel | undefined) => void;

package/dist/packages/sdk-ui/src/pivot-table/formatters/types.d.ts

@@ -1,4 +1,47 @@
+/// <reference types="react" />
 import type { JaqlPanel, JaqlRequest, PivotDataNode, PivotTreeNode } from '@sisense/sdk-pivot-client';
-export type DataCellFormatter = (cell: PivotDataNode, rowItem: PivotTreeNode, columnItem: PivotTreeNode, jaqlPanelItem: JaqlPanel) => void;
-export type HeaderCellFormatter = (cell: PivotTreeNode, jaqlPanelItem: JaqlPanel, jaql: JaqlRequest) => void;
+import { AnyColumn } from '../../chart-data-options/types';
+/**
+ * Formatting result that can be applied to a header cell
+ */
+export interface CellFormattingResult {
+    /** Text content to display in the cell */
+    content?: string;
+    /** Inline styles to apply to the cell */
+    style?: React.CSSProperties;
+}
+/**
+ * Data cell formatter that returns formatting information instead of mutating parameters
+ */
+export type DataCellFormatter = (cell: PivotDataNode, rowItem: PivotTreeNode, columnItem: PivotTreeNode, jaqlPanelItem: JaqlPanel) => CellFormattingResult | void;
+/**
+ * Applies custom formatting to pivot table data cells.
+ *
+ * This function is called for each data cell in the pivot table and can return
+ * formatting information to customize the cell's appearance and behavior.
+ *
+ * @param cell - The pivot data cell being formatted
+ * @param jaqlPanelItem - JAQL panel metadata for the cell
+ * @param dataOption - The data option configuration for this cell
+ * @param id - Unique identifier for the data option
+ * @returns Formatting result object or void to skip formatting
+ */
+export type CustomDataCellFormatter = (cell: PivotDataNode, jaqlPanelItem: JaqlPanel, dataOption: AnyColumn, id: string) => CellFormattingResult | void;
+/**
+ * Header cell formatter that returns formatting information instead of mutating parameters
+ */
+export type HeaderCellFormatter = (cell: PivotTreeNode, jaqlPanelItem: JaqlPanel, jaql: JaqlRequest) => CellFormattingResult | void;
+/**
+ * Applies custom formatting to pivot table header cells.
+ *
+ * This function is called for each row and column header cell in the pivot table
+ * and can return formatting information to customize the header's appearance and behavior.
+ *
+ * @param cell - The pivot header cell being formatted
+ * @param jaqlPanelItem - JAQL panel metadata for the cell (may be undefined for certain header types)
+ * @param dataOption - The data option configuration for this cell (optional)
+ * @param id - Unique identifier for the data option (optional)
+ * @returns Formatting result object or void to skip formatting
+ */
+export type CustomHeaderCellFormatter = (cell: PivotTreeNode, jaqlPanelItem: JaqlPanel | undefined, dataOption?: AnyColumn, id?: string) => CellFormattingResult | void;
 export type DateFormatter = (date: Date, format: string) => string;

package/dist/packages/sdk-ui/src/pivot-table/formatters/utils.d.ts

@@ -1,5 +1,6 @@
 import { type Column } from '@sisense/sdk-data';
 import { type PivotTableDataOptions, type StyledColumn, type AnyColumn } from '../../chart-data-options/types';
 export declare const getPivotDataOptionByJaqlIndex: (dataOptions: PivotTableDataOptions, dataOptionIndex?: number) => AnyColumn | undefined;
+export declare const getPivotDataOptionIdByJaqlIndex: (dataOptions: PivotTableDataOptions, dataOptionIndex?: number) => string | undefined;
 export declare const getNumberFormatConfig: (dataOption?: AnyColumn) => Required<import("../..").NumberFormatConfig>;
 export declare const getDateFormatConfig: (dataOption: Column | StyledColumn) => string | undefined;

package/dist/packages/sdk-ui/src/pivot-table/hooks/use-apply-pivot-table-formatting.d.ts

@@ -1,11 +1,14 @@
 import { type DataService } from '@sisense/sdk-pivot-client';
 import { type PivotTableDataOptionsInternal } from '../../chart-data-options/types';
+import { type CustomDataCellFormatter, type CustomHeaderCellFormatter } from '../../pivot-table/formatters/types';
 /**
  * A hook that applies formatting over pivot table cells.
  *
  * @internal
  */
-export declare const useApplyPivotTableFormatting: ({ dataService, dataOptions, }: {
+export declare const useApplyPivotTableFormatting: ({ dataService, dataOptions, onDataCellFormat, onHeaderCellFormat, }: {
     dataService: DataService;
     dataOptions: PivotTableDataOptionsInternal;
+    onDataCellFormat?: CustomDataCellFormatter | undefined;
+    onHeaderCellFormat?: CustomHeaderCellFormatter | undefined;
 }) => void;

package/dist/packages/sdk-ui/src/props.d.ts

@@ -1,5 +1,6 @@
 import { Attribute, Filter, Measure, DataSource, Data, QueryResultData, FilterRelations } from '@sisense/sdk-data';
 import { ChartDataOptions, CartesianChartDataOptions, CategoricalChartDataOptions, ThemeSettings, PolarStyleOptions, PieStyleOptions, StackableStyleOptions, LineStyleOptions, AreaStyleOptions, FunnelStyleOptions, ScatterStyleOptions, ChartStyleOptions, ChartType, IndicatorStyleOptions, DrilldownOptions, ThemeOid, TreemapStyleOptions, CustomDrilldownResult, MenuPosition, MenuAlignment, MenuItemSection, SunburstStyleOptions, ChartWidgetStyleOptions, TableWidgetStyleOptions, WidgetByIdStyleOptions, BoxplotStyleOptions, ScattermapStyleOptions, AreamapStyleOptions, DataPoint, ScatterDataPoint, AreamapDataPoint, BoxplotDataPoint, ChartDataPoints, ScattermapDataPoint, PivotTableStyleOptions, PivotTableWidgetStyleOptions, RegularChartType, RegularChartStyleOptions, TabularChartStyleOptions, TableStyleOptions, AreaRangeStyleOptions, DrilldownSelection, TextWidgetStyleOptions, GenericDataOptions, IndicatorRenderOptions, TabberStyleProps, IndicatorDataPoint, TextWidgetDataPoint, CustomWidgetStyleOptions, PivotTableDataPoint } from './types';
+import { type CustomDataCellFormatter, type CustomHeaderCellFormatter } from './pivot-table/formatters/types';
 import { HighchartsOptions } from './chart-options-processor/chart-options-service';
 import { ComponentType, PropsWithChildren, ReactNode } from 'react';
 import { IndicatorChartDataOptions, BoxplotChartCustomDataOptions, BoxplotChartDataOptions, ScatterChartDataOptions, TableDataOptions, ScattermapChartDataOptions, AreamapChartDataOptions, PivotTableDataOptions, RegularChartDataOptions, TabularChartDataOptions, RangeChartDataOptions } from './chart-data-options/types';
@@ -891,6 +892,50 @@ export interface PivotTableProps {
      * @internal
      */
     onDataPointContextMenu?: PivotTableDataPointEventHandler;
+    /**
+     * Applies custom styling and behavior to pivot table data cells.
+     *
+     * This formatter function returns formatting objects instead of mutating parameters,
+     * following functional programming principles. Use this single callback to combine
+     * multiple handlers and control the call sequence from outside the pivot.
+     *
+     * @example
+     * ```typescript
+     * const customDataFormatter: CustomDataCellFormatter = (cell, jaqlPanelItem, dataOption, id) => {
+     *   if (cell.value > 1000) {
+     *     return {
+     *       style: { backgroundColor: 'lightgreen' },
+     *       content: `${cell.value} (High)`
+     *     };
+     *   }
+     * };
+     * ```
+     *
+     * @internal
+     */
+    onDataCellFormat?: CustomDataCellFormatter;
+    /**
+     * Applies custom styling and behavior to pivot table row and column headers.
+     *
+     * This formatter function returns formatting objects instead of mutating parameters,
+     * following functional programming principles. Use this single callback to combine
+     * multiple handlers and control the call sequence from outside the pivot.
+     *
+     * @example
+     * ```typescript
+     * const customHeaderFormatter: CustomHeaderCellFormatter = (cell, jaqlPanelItem, dataOption, id) => {
+     *   if (cell.content === 'Total') {
+     *     return {
+     *       style: { fontWeight: 'bold', color: 'blue' },
+     *       className: 'total-header'
+     *     };
+     *   }
+     * };
+     * ```
+     *
+     * @internal
+     */
+    onHeaderCellFormat?: CustomHeaderCellFormatter;
 }
 /**
  * Props of the {@link ScatterChart} component.
@@ -1214,6 +1259,50 @@ export interface PivotTableWidgetProps {
      * @internal
      */
     onDataPointContextMenu?: PivotTableDataPointEventHandler;
+    /**
+     * Applies custom styling and behavior to pivot table data cells.
+     *
+     * This formatter function returns formatting objects instead of mutating parameters,
+     * following functional programming principles. Use this single callback to combine
+     * multiple handlers and control the call sequence from outside the pivot.
+     *
+     * @example
+     * ```typescript
+     * const customDataFormatter: CustomDataCellFormatter = (cell, jaqlPanelItem, dataOption, id) => {
+     *   if (cell.value > 1000) {
+     *     return {
+     *       style: { backgroundColor: 'lightgreen' },
+     *       content: `${cell.value} (High)`
+     *     };
+     *   }
+     * };
+     * ```
+     *
+     * @internal
+     */
+    onDataCellFormat?: CustomDataCellFormatter;
+    /**
+     * Applies custom styling and behavior to pivot table row and column headers.
+     *
+     * This formatter function returns formatting objects instead of mutating parameters,
+     * following functional programming principles. Use this single callback to combine
+     * multiple handlers and control the call sequence from outside the pivot.
+     *
+     * @example
+     * ```typescript
+     * const customHeaderFormatter: CustomHeaderCellFormatter = (cell, jaqlPanelItem, dataOption, id) => {
+     *   if (cell.content === 'Total') {
+     *     return {
+     *       style: { fontWeight: 'bold', color: 'blue' },
+     *       className: 'total-header'
+     *     };
+     *   }
+     * };
+     * ```
+     *
+     * @internal
+     */
+    onHeaderCellFormat?: CustomHeaderCellFormatter;
 }
 /**
  * Props for the `TextWidget` component.

package/dist/packages/sdk-ui/src/query/date-formats/apply-date-format.d.ts

@@ -53,13 +53,14 @@ export type DateConfig = {
 };
 export declare const defaultDateConfig: DateConfig;
 /**
- * Returns a formatted date, according to the provided date format string.
+ * Safely formats a date value, handling special cases like 'N\A'
  *
- * @param date -
- * @param format -
- * @param locale -
- * @param cfg -
+ * @param value - The date value to format, can be a Date object, ISO string, or special value like 'N\A'
+ * @param format - The date format to apply
+ * @param locale - Optional locale for formatting
+ * @param cfg - Optional date configuration
+ * @returns Formatted date string or the original value for special cases
  */
-export declare function applyDateFormat(date: Date, format: DateFormat, locale?: Locale, cfg?: DateConfig): string;
+export declare function formatDateValue(value: Date | string, format: DateFormat, locale?: Locale, cfg?: DateConfig): string;
 export declare function getDefaultDateMask(granularity?: string): "HH:mm:ss" | "yyyy" | "MM/yyyy" | "ww yyyy" | "HH:mm" | "Q yyyy" | "shortDate" | "fullDate";
 export {};

package/dist/packages/sdk-ui/src/query/date-formats/index.d.ts

@@ -1,2 +1,2 @@
 export type { DateFormat, DateConfig } from './apply-date-format';
-export { applyDateFormat, defaultDateConfig } from './apply-date-format';
+export { formatDateValue, defaultDateConfig } from './apply-date-format';

package/dist/packages/sdk-ui/src/query/execute-query.d.ts

@@ -1,5 +1,5 @@
 import { CreateCacheKeyFn } from '../utils/create-cache';
-import { Attribute, Measure, PivotAttribute, PivotMeasure, PivotQueryResultData, QueryResultData } from '@sisense/sdk-data';
+import { Attribute, DataSource, Measure, PivotAttribute, PivotMeasure, PivotQueryResultData, QueryResultData } from '@sisense/sdk-data';
 import type { QueryDescription as InternalQueryDescription, PivotQueryDescription as InternalPivotQueryDescription, QueryExecutionConfig } from '@sisense/sdk-query-client';
 import { ClientApplication } from '../app/client-application';
 /**
@@ -26,6 +26,8 @@ export type PivotQueryDescription = Partial<Omit<InternalPivotQueryDescription,
     values?: (Measure | PivotMeasure)[];
 };
 /** @internal */
+export declare const prepareQueryParams: (queryDescription: QueryDescription, defaultDataSource?: DataSource) => InternalQueryDescription;
+/** @internal */
 export declare function executeQuery(queryDescription: QueryDescription, app: ClientApplication, executionConfig?: QueryExecutionConfig): Promise<QueryResultData>;
 /** @internal */
 export declare const executeCsvQuery: (queryDescription: QueryDescription, app: ClientApplication, executionConfig?: QueryExecutionConfig) => Promise<Blob>;

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

@@ -5,4 +5,4 @@ export { ExecuteQueryByWidgetId } from './execute-query-by-widget-id';
 export { useExecuteQueryByWidgetId, executeQueryByWidgetId, } from './use-execute-query-by-widget-id';
 export { useExecutePivotQuery } from './use-execute-pivot-query';
 export { useQueryCache } from './use-query-cache';
-export type { QueryState, QueryLoadingState, QuerySuccessState, QueryErrorState, CsvQueryState, CsvQueryLoadingState, CsvQuerySuccessState, CsvQueryErrorState, PivotQueryState, PivotQueryLoadingState, PivotQuerySuccessState, PivotQueryErrorState, ExecuteQueryParams, ExecuteQueryResult, ExecuteCsvQueryParams, ExecuteCSVQueryConfig, ExecuteQueryByWidgetIdParams, QueryByWidgetIdState, QueryByWidgetIdQueryParams, ExecutePivotQueryParams, } from './types';
+export type { QueryState, QueryLoadingState, QuerySuccessState, QueryErrorState, CsvQueryState, CsvQueryLoadingState, CsvQuerySuccessState, CsvQueryErrorState, PivotQueryState, PivotQueryLoadingState, PivotQuerySuccessState, PivotQueryErrorState, BaseQueryParams, ExecuteQueryParams, ExecuteQueryResult, ExecuteCsvQueryParams, ExecuteCSVQueryConfig, ExecuteQueryByWidgetIdParams, QueryByWidgetIdState, QueryByWidgetIdQueryParams, ExecutePivotQueryParams, } from './types';

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

@@ -171,9 +171,11 @@ export type QueryByWidgetIdQueryParams = {
  */
 export type QueryByWidgetIdState = QueryState & QueryByWidgetIdQueryParams;
 /**
- * Parameters for {@link useExecuteQuery} hook.
+ * Base query parameters
+ *
+ * @internal
  */
-export interface ExecuteQueryParams {
+export interface BaseQueryParams {
     /**
      * Data source the query is run against - e.g. `Sample ECommerce`
      *
@@ -188,6 +190,11 @@ export interface ExecuteQueryParams {
     filters?: Filter[] | FilterRelations;
     /** Highlight filters that will highlight results that pass filter criteria */
     highlights?: Filter[];
+}
+/**
+ * Parameters for {@link useExecuteQuery} hook.
+ */
+export interface ExecuteQueryParams extends BaseQueryParams {
     /**
      * Number of rows to return in the query result
      *

package/dist/packages/sdk-ui/src/utils/__development-utils__/highcharts-options-builder-collector.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Utility for decorating HighchartsOptionsBuilder objects with input/output collection.
+ * This enables comprehensive runtime data collection for all builder methods,
+ * making it easier to generate unit tests and understand builder behavior.
+ */
+import { HighchartsOptionsBuilder, HighchartBasedChartTypes } from '../../chart/restructured-charts/highchart-based-charts/types';
+/**
+ * Generic decorator that wraps all methods of an object with input/output collection.
+ * Uses currying pattern: withMethodsInputOutputCollection(config)(objectToDecorate)
+ *
+ * This enables comprehensive runtime data collection for all object methods,
+ * making it easier to generate unit tests and understand object behavior.
+ *
+ * @param options - Configuration options for the collection behavior
+ * @returns Function that takes the object to decorate and returns the decorated object
+ *
+ * @example
+ * ```ts
+ * // Basic usage:
+ * const instrumentedBuilder = withMethodsInputOutputCollection({
+ *   objectName: 'myChartBuilder',
+ *   maxSnapshots: 50
+ * })(myChartBuilder);
+ *
+ * // After running the application:
+ * printCollectedInfo(); // Shows data for all object methods
+ * ```
+ */
+export declare function withMethodsInputOutputCollection<T extends Record<string, any>>(options: {
+    /** Name identifier for the object (used in collection namespacing) */
+    objectName: string;
+    /** Maximum number of unique snapshots to collect per method (default: 100) */
+    maxSnapshots?: number;
+}): (obj: T) => T;
+/**
+ * Specific decorator for HighchartsOptionsBuilder that follows the generic pattern.
+ * Uses currying pattern: withHighchartsOptionsBuilderCollection(config)(builderToDecorate)
+ *
+ * Each method gets its own collection namespace (e.g., "barBuilder.getChart", "barBuilder.getSeries")
+ * to enable granular analysis of how different parts of the chart configuration are built.
+ *
+ * @param options - Configuration options for the collection behavior
+ * @returns Function that takes the builder to decorate and returns the decorated builder
+ *
+ * @example
+ * ```ts
+ * const instrumentedBuilder = withHighchartsOptionsBuilderDataCollections({
+ *   builderName: 'myChartBuilder',
+ *   maxSnapshots: 50
+ * })(myChartBuilder);
+ *
+ * // After running the application:
+ * printCollectedInfo(); // Shows data for all builder methods
+ * ```
+ */
+export declare function withHighchartsOptionsBuilderDataCollection<CT extends HighchartBasedChartTypes>(options: {
+    /** Name identifier for the builder (used in collection namespacing) */
+    builderName: string;
+    /** Maximum number of unique snapshots to collect per method (default: 100) */
+    maxSnapshots?: number;
+}): (builder: HighchartsOptionsBuilder<CT>) => HighchartsOptionsBuilder<CT>;

package/dist/packages/sdk-ui/src/utils/__development-utils__/input-output-collector.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Input/Output Collection Decorator for Runtime Test Data Generation
+ *
+ * This module provides a decorator that collects unique input/output snapshots
+ * of function calls during runtime. This is useful for generating unit test data
+ * from actual application usage.
+ *
+ * Usage:
+ * 1. Wrap your function with the decorator:
+ *    ```ts
+ *    // With configuration:
+ *    const myFunction = withInputOutputCollection({ maxSnapshots: 100 })(originalFunction);
+ *
+ *    // With custom function name:
+ *    const myFunction = withInputOutputCollection({
+ *      maxSnapshots: 100,
+ *      functionName: 'myCustomName'
+ *    })(originalFunction);
+ *
+
+ *    ```
+ *
+ * 2. Run your application and exercise the function with various inputs
+ *
+ * 3. In the browser console (development only), call:
+ *    - `printCollectedInfo()` - to view all collected data
+ *    - `getCollectedData()` - to get data programmatically
+ *    - `exportCollectedDataAsJson()` - to export as JSON string with function serialization
+ *    - `parseCollectedDataFromJson(jsonString)` - to parse exported JSON and get function placeholders
+ *    - `clearCollectedData()` - to clear collected data
+ *    - `cleanup()` - to completely clean up the collector
+ *
+ * Features:
+ * - Intelligent deduplication prevents collecting identical input/output pairs
+ * - Robust deep equality checking handles functions, dates, and complex objects
+ * - Statistics tracking shows total calls vs unique snapshots
+ * - Configurable maximum number of snapshots
+ * - Deep cloning of inputs and outputs to avoid reference issues
+ * - Proper function serialization for unit test generation
+ * - Browser console integration for easy access (development only)
+ * - Automatic cleanup when no collected data remains
+ */
+interface CollectedData {
+    id: string;
+    timestamp: number;
+    args: any[];
+    result: any;
+}
+interface CollectionStore {
+    functionName: string;
+    data: CollectedData[];
+    totalCalls: number;
+    duplicateSkips: number;
+}
+/**
+ * Decorator that collects unique input/output snapshots for a function during runtime.
+ * Useful for generating unit test data from actual application usage.
+ *
+ * Uses currying pattern: withInputOutputCollection(config)(functionToDecorate)
+ *
+ * @param options - Configuration options for the collector
+ * @returns Function that takes the function to decorate and returns the decorated function
+ */
+export declare function withInputOutputCollection<TFunction extends (...args: any[]) => any>(options?: {
+    /** Maximum number of unique snapshots to collect (default: 100) */
+    maxSnapshots?: number;
+    /** Custom equality function for comparing arguments (default: deep equality) */
+    equalityFn?: (a: any[], b: any[]) => boolean;
+    /** Optional custom function name (defaults to function.name) */
+    functionName?: string;
+}): (originalFunction: TFunction) => TFunction;
+/**
+ * Prints all collected input/output data to the console.
+ * This function is attached to the window object for easy access in the browser.
+ */
+export declare function printCollectedInfo(): void;
+/**
+ * Returns all collected data as a serializable object.
+ * Useful for exporting test data programmatically.
+ */
+export declare function getCollectedData(): Record<string, CollectionStore>;
+/**
+ * Clears all collected data.
+ * Useful for resetting the collection state.
+ * Removes window utilities if no data remains.
+ */
+export declare function clearCollectedData(functionName?: string): void;
+/**
+ * Completely cleans up the input/output collector.
+ * Clears all data and removes window utilities.
+ * Useful for cleanup in test environments or when the collector is no longer needed.
+ */
+export declare function cleanup(): void;
+/**
+ * Exports collected data as JSON string with proper function serialization.
+ * Functions are represented as `[[Function - {functionName}]]` strings for easy replacement in unit tests.
+ *
+ * Example output:
+ * ```json
+ * {
+ *   "buildHighchartsOptions": {
+ *     "functionName": "buildHighchartsOptions",
+ *     "data": [{
+ *       "args": [{ "onBeforeRender": "[[Function - customRenderer]]" }],
+ *       "result": { "chart": { "type": "line" } }
+ *     }]
+ *   }
+ * }
+ * ```
+ *
+ * Useful for saving test data to files.
+ */
+export declare function exportCollectedDataAsJson(): string;
+/**
+ * Parses JSON data exported by exportCollectedDataAsJson and provides a function map for mocking.
+ * This is a utility function for unit tests to easily replace function placeholders with mocks.
+ *
+ * @param jsonData - The JSON string exported by exportCollectedDataAsJson
+ * @returns Object containing parsed data and a list of function placeholders found
+ */
+export declare function parseCollectedDataFromJson(jsonData: string): {
+    data: Record<string, CollectionStore>;
+    functionPlaceholders: string[];
+};
+export {};

package/dist/packages/sdk-ui/src/widget-by-id/translate-dashboard-filters.d.ts

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

package/dist/packages/sdk-ui/src/widget-by-id/translate-panel-color-format.d.ts

@@ -3,4 +3,13 @@ import { ValueToColorMap, MultiColumnValueToColorMap, Color } from '../types.js'
 import { PanelColorFormat, PanelItem, PanelMembersFormat } from './types.js';
 export declare const createValueColorOptions: (format?: PanelColorFormat, customPaletteColors?: Color[]) => DataColorOptions | undefined;
 export declare const createValueToColorMap: (membersFormat: PanelMembersFormat) => ValueToColorMap;
+/**
+ * Creates a PanelColorFormat from DataColorOptions
+ *
+ * TODO: basic use cases done for the studio assistant, need more testing with real Fusion widgets
+ *
+ * @param options The DataColorOptions to convert
+ * @returns The corresponding PanelColorFormat
+ */
+export declare const createPanelColorFormat: (options: DataColorOptions | undefined, paletteColors?: Color[]) => PanelColorFormat | undefined;
 export declare const createValueToColorMultiColumnsMap: (items: PanelItem[]) => MultiColumnValueToColorMap;

package/dist/packages/sdk-ui/src/widget-by-id/translate-statistical-models.d.ts

@@ -0,0 +1,10 @@
+import { StyledMeasureColumn } from '../types.js';
+import { StatisticalModels } from './types.js';
+/** @internal */
+export declare function applyStatisticalModels(dataOption: StyledMeasureColumn, statisticalModels?: StatisticalModels): StyledMeasureColumn;
+/**
+ * Create statistical models from styled measure column
+ *
+ * @internal
+ */
+export declare function createStatisticalModels(column: StyledMeasureColumn): StatisticalModels | undefined;

package/dist/packages/sdk-ui/src/widget-by-id/translate-widget-data-options.d.ts

@@ -2,20 +2,6 @@ import { JaqlDataSource } from '@sisense/sdk-data';
 import { StyledMeasureColumn, StyledColumn, Color } from '../types.js';
 import { Panel, PanelItem, FusionWidgetType, WidgetStyle, BoxplotWidgetStyle } from './types.js';
 import { WidgetDataOptions } from '../models/index.js';
-/** @internal */
-export declare function applyStatisticalModels(dataOption: StyledMeasureColumn, statisticalModels?: {
-    forecast?: {
-        isEnabled: boolean;
-        isViewerDisabled: boolean;
-        confidence: number;
-        forecastPeriod: number;
-    };
-    trend?: {
-        isEnabled: boolean;
-        isViewerDisabled: boolean;
-        trendType: string;
-    };
-}): StyledMeasureColumn;
 export declare function createDataColumn(item: PanelItem, customPaletteColors?: Color[]): StyledColumn | StyledMeasureColumn;
 /** @internal */
 export declare function createPanelItem(column: StyledColumn | StyledMeasureColumn): PanelItem;

package/dist/packages/sdk-ui/src/widget-by-id/types.d.ts

@@ -184,25 +184,26 @@ export type StatisticalModels = {
         };
         forecastPeriod: number;
         confidence: number;
-        modelType: string;
+        modelType: 'en' | 'aa' | 'hw' | 'fb';
         boundaries: {
             upper: {
                 isEnabled: boolean;
-                value: null;
+                value: number | null;
             };
             lower: {
                 isEnabled: boolean;
-                value: null;
+                value: number | null;
             };
             isInt: {
                 isEnabled: boolean;
             };
         };
+        isAccessible: boolean;
     };
     trend?: {
         isEnabled: boolean;
         isViewerDisabled: boolean;
-        trendType: string;
+        trendType: 'linear' | 'logarithmic' | 'smooth' | 'local';
         ignoreAnomalies: boolean;
         trendOnForecast: boolean;
         compare: {
@@ -261,6 +262,7 @@ export type PanelColorFormatSingle = {
     type: 'color';
     color?: string;
     colorIndex?: number;
+    isHandPickedColor?: boolean;
 };
 export type PanelColorFormatRange = {
     type: 'range';

package/dist/types-BYUVZb6u.js

@@ -0,0 +1,80 @@
+import { f as i, g as l, h as n, i as o, D as d, k as u, M as s } from "./execute-query-agpyzZz6.js";
+class m extends d {
+  constructor(e, t) {
+    var r;
+    super((r = e.jaql.title) !== null && r !== void 0 ? r : "", t), this.__serializable = "JaqlElement", this.expression = e.jaql.dim || e.jaql.formula, this.metadataItem = e, e.jaql.agg ? this.aggregation = e.jaql.agg : delete this.aggregation, e.jaql.formula ? this.formula = e.jaql.formula : delete this.formula, e.jaql.sort ? this.sortType = u(e.jaql.sort) : delete this.sortType, this.skipValidation = !0;
+  }
+  get id() {
+    return this.expression;
+  }
+  jaql(e) {
+    return e === !0 ? this.metadataItem.jaql : this.metadataItem;
+  }
+  /**
+   * Gets a serializable representation of the element
+   */
+  serialize() {
+    const e = super.serialize();
+    return e.metadataItem = this.metadataItem, e.type = this.type, e;
+  }
+}
+const c = {
+  text: s.TextAttribute,
+  numeric: s.NumericAttribute,
+  datetime: s.DateLevel
+}, h = (a) => a && a.__serializable === "JaqlElement";
+function p(a) {
+  var e;
+  return new m(a, (e = c[a.jaql.datatype]) !== null && e !== void 0 ? e : "numeric");
+}
+function y(a) {
+  const { jaql: e } = a;
+  if (e.formula)
+    return i(e);
+  const t = l(e);
+  return "agg" in e && e.dim && e.datatype ? n({
+    expression: e.dim,
+    dataType: e.datatype,
+    agg: e.agg || "",
+    granularity: t,
+    format: void 0,
+    sort: e.sort,
+    title: e.title,
+    dataSource: e.datasource
+  }) : e.dim && e.datatype ? o({
+    expression: e.dim,
+    dataType: e.datatype,
+    granularity: t,
+    sort: e.sort,
+    title: e.title,
+    panel: a.panel,
+    dataSource: e.datasource
+  }) : p(a);
+}
+const q = {
+  jaql: {
+    datasource: {
+      title: "",
+      type: "elasticube"
+    },
+    metadata: []
+  },
+  queryTitle: "",
+  chartRecommendations: {}
+}, f = {
+  model: "",
+  metadata: [],
+  chart: {},
+  queryTitle: ""
+}, E = (a) => "widgetProps" in a, j = (a) => "dashboardOid" in a && "widgetOid" in a, b = (a) => "dashboardProps" in a, T = (a) => "dashboardOid" in a;
+export {
+  f as E,
+  m as J,
+  T as a,
+  q as b,
+  y as c,
+  E as d,
+  b as e,
+  h as f,
+  j as i
+};

package/dist/types-QUSMO7gF.cjs

@@ -0,0 +1 @@
+"use strict";const a=require("./execute-query-Cp3se7Yb.cjs");class s extends a.DimensionalElement{constructor(e,r){var i;super((i=e.jaql.title)!==null&&i!==void 0?i:"",r),this.__serializable="JaqlElement",this.expression=e.jaql.dim||e.jaql.formula,this.metadataItem=e,e.jaql.agg?this.aggregation=e.jaql.agg:delete this.aggregation,e.jaql.formula?this.formula=e.jaql.formula:delete this.formula,e.jaql.sort?this.sortType=a.getSortType(e.jaql.sort):delete this.sortType,this.skipValidation=!0}get id(){return this.expression}jaql(e){return e===!0?this.metadataItem.jaql:this.metadataItem}serialize(){const e=super.serialize();return e.metadataItem=this.metadataItem,e.type=this.type,e}}const l={text:a.MetadataTypes.TextAttribute,numeric:a.MetadataTypes.NumericAttribute,datetime:a.MetadataTypes.DateLevel},d=t=>t&&t.__serializable==="JaqlElement";function n(t){var e;return new s(t,(e=l[t.jaql.datatype])!==null&&e!==void 0?e:"numeric")}function o(t){const{jaql:e}=t;if(e.formula)return a.createCalculatedMeasureHelper(e);const r=a.getGranularityFromJaql(e);return"agg"in e&&e.dim&&e.datatype?a.createMeasureHelper({expression:e.dim,dataType:e.datatype,agg:e.agg||"",granularity:r,format:void 0,sort:e.sort,title:e.title,dataSource:e.datasource}):e.dim&&e.datatype?a.createAttributeHelper({expression:e.dim,dataType:e.datatype,granularity:r,sort:e.sort,title:e.title,panel:t.panel,dataSource:e.datasource}):n(t)}const u={jaql:{datasource:{title:"",type:"elasticube"},metadata:[]},queryTitle:"",chartRecommendations:{}},m={model:"",metadata:[],chart:{},queryTitle:""},c=t=>"widgetProps"in t,p=t=>"dashboardOid"in t&&"widgetOid"in t,g=t=>"dashboardProps"in t,y=t=>"dashboardOid"in t;exports.EMPTY_EXPANDED_QUERY_MODEL=u;exports.EMPTY_SIMPLE_QUERY_MODEL=m;exports.JaqlElement=s;exports.createDimensionalElementFromMetadataItem=o;exports.isByIdDashboardCodeParams=y;exports.isByIdWidgetCodeParams=p;exports.isClientSideDashboardCodeParams=g;exports.isClientSideWidgetCodeParams=c;exports.isJaqlElement=d;