@sisense/sdk-ui 0.11.3

package/dist/dashboard-widget/types.d.ts

@@ -0,0 +1,336 @@
+export declare const enum WidgetType {
+    PieChart = "chart/pie",
+    ColumnChart = "chart/column",
+    BarChart = "chart/bar",
+    LineChart = "chart/line",
+    AreaChart = "chart/area",
+    FunnelChart = "chart/funnel",
+    TreemapChart = "treemap",
+    ScatterChart = "chart/scatter",
+    IndicatorChart = "indicator",
+    PolarChart = "chart/polar",
+    Table = "tablewidget",
+    TableWithAggregation = "tablewidgetagg"
+}
+export type WidgetSubtype = 'area/basic' | 'area/stacked' | 'area/stacked100' | 'area/spline' | 'area/stackedspline' | 'area/stackedspline100' | 'bar/classic' | 'bar/stacked' | 'bar/stacked100' | 'column/classic' | 'column/stackedcolumn' | 'column/stackedcolumn100' | 'line/basic' | 'line/spline' | 'pie/classic' | 'pie/donut' | 'pie/ring' | 'column/polar' | 'area/polar' | 'line/polar' | 'indicator/numeric' | 'indicator/gauge' | 'bubble/scatter' | 'treemap';
+/**
+ * The data transfer object (DTO) containing info of a widget on a dashboard.
+ *
+ * This is the (not-comprehensive) structure of the response from the
+ * `/api/v1/dashboards/${dashboardOid}/widgets/${widgetOid}` endpoint.
+ */
+export interface WidgetDto {
+    oid: string;
+    type: WidgetType | string;
+    subtype: WidgetSubtype | string;
+    datasource: {
+        title: string;
+        id: string;
+        fullname: string;
+        live: boolean;
+    };
+    metadata: {
+        panels: Panel[];
+    };
+    style: WidgetStyle;
+    title: string;
+    desc: string;
+}
+export declare const enum DataType {
+    TEXT = "text",
+    NUMERIC = "numeric",
+    DATETIME = "datetime"
+}
+export type Panel = {
+    name: string;
+    items: PanelItem[];
+};
+export declare enum SortDirection {
+    ASC = "asc",
+    DESC = "desc"
+}
+export type BaseJaql = {
+    agg?: string;
+    datatype: DataType;
+    dim: string;
+    table: string;
+    column: string;
+    title: string;
+    level?: 'years' | 'quarters' | 'months' | 'weeks' | 'minutes' | 'days';
+    sort?: SortDirection;
+};
+type FormulaID = string;
+type FormulaContext = BaseJaql | FilterJaql;
+export type FormulaJaql = {
+    type?: 'measure';
+    sort?: SortDirection;
+    title: string;
+    formula: string;
+    context?: Record<FormulaID, FormulaContext>;
+};
+type IncludeAllFilter = {
+    all: true;
+};
+export type IncludeMembersFilter = {
+    members: string[];
+};
+type ExcludeMembersFilter = {
+    exclude: {
+        members: string[];
+    };
+};
+export type MembersFilter = IncludeMembersFilter | ExcludeMembersFilter;
+type BaseFilter = IncludeAllFilter | MembersFilter;
+type BackgroundFilter = BaseFilter;
+type TurnOffMembersFilter = ExcludeMembersFilter & {
+    turnedOff: boolean;
+};
+type Filter = BaseFilter & {
+    filter?: BackgroundFilter | TurnOffMembersFilter;
+};
+export type FilterJaql = BaseJaql & {
+    filter: Filter;
+};
+export type Jaql = BaseJaql | FormulaJaql | FilterJaql;
+type SeriesType = 'auto' | 'line' | 'spline' | 'areaspline' | 'bar' | 'area' | 'column';
+interface DecimalAbbreviations {
+    k: boolean;
+    m: boolean;
+    b: boolean;
+    t: boolean;
+}
+export declare enum CurrencyPosition {
+    PRE = "pre",
+    POST = "post"
+}
+export type NumericMask = {
+    isdefault?: boolean;
+    abbreviations?: DecimalAbbreviations;
+    decimals?: 'auto' | number;
+    currency?: {
+        symbol: string;
+        position: CurrencyPosition;
+    };
+    percent?: boolean;
+    number?: {
+        separated: boolean;
+    };
+    separated?: boolean;
+    type?: string;
+};
+export type DatetimeMask = {
+    isdefault?: boolean;
+    years: string;
+    quarters: string;
+    months: string;
+    weeks: string;
+    minutes: string;
+    days: string;
+    type: string;
+    dateAndTime?: string;
+};
+export type PanelItem = {
+    format?: {
+        color?: PanelColorFormat;
+        mask?: DatetimeMask | NumericMask;
+        members?: PanelMembersFormat;
+    };
+    jaql: Jaql;
+    disabled?: boolean;
+    y2?: boolean;
+    parent?: PanelItem;
+    through?: PanelItem;
+    singleSeriesType?: SeriesType;
+    categoriesSorting?: SortDirection;
+    isColored?: boolean;
+};
+export type PanelColorFormat = PanelColorFormatSingle | PanelColorFormatRange | PanelColorFormatConditional;
+export type PanelMembersFormat = Record<string, {
+    color: string;
+}>;
+export type PanelColorFormatSingle = {
+    type: 'color';
+    color?: string;
+    colorIndex?: number;
+};
+export type PanelColorFormatRange = {
+    type: 'range';
+    steps: number;
+    rangeMode: 'min' | 'max' | 'both' | 'auto';
+    min?: string;
+    max?: string;
+    minvalue?: string | null;
+    midvalue?: string | null;
+    maxvalue?: string | null;
+};
+export type PanelColorFormatConditional = {
+    type: 'condition';
+    conditions: PanelColorFormatCondition[];
+};
+export type PanelColorFormatCondition = PanelColorFormatConditionSimple | PanelColorFormatConditionJaql;
+export type PanelColorFormatConditionSimple = {
+    color: string;
+    expression: string;
+    operator: PanelColorFormatConditionOperator;
+};
+export type PanelColorFormatConditionJaql = {
+    color: string;
+    expression: {
+        jaql: unknown;
+    };
+    operator: PanelColorFormatConditionOperator;
+};
+export type PanelColorFormatConditionOperator = '<' | '>' | '≤' | '<=' | '≥' | '>=' | '=' | '≠' | '!=';
+type LabelsStyle = {
+    enabled: boolean;
+    rotation: number;
+};
+type AxisTitleStyle = {
+    enabled: boolean;
+    text?: string;
+};
+export type AxisStyle = {
+    enabled: boolean;
+    ticks: boolean;
+    labels: LabelsStyle;
+    title?: AxisTitleStyle;
+    gridLines: boolean;
+    isIntervalEnabled: boolean;
+    logarithmic?: boolean;
+    min?: number | null;
+    max?: number | null;
+};
+type BaseWidgetStyle = {
+    legend: {
+        position: string;
+        enabled: boolean;
+    };
+    navigator: {
+        enabled: boolean;
+    };
+};
+export type CartesianWidgetStyle = BaseWidgetStyle & {
+    seriesLabels: LabelsStyle;
+    xAxis: AxisStyle & {
+        x2Title?: AxisTitleStyle;
+    };
+    yAxis: AxisStyle;
+    y2Axis?: AxisStyle;
+    lineWidth?: {
+        width: string;
+    };
+    markers?: {
+        enabled: boolean;
+        size: number;
+        fill: string;
+    };
+};
+export type PolarWidgetStyle = BaseWidgetStyle & {
+    categories?: AxisStyle;
+    axis?: AxisStyle;
+};
+type ScatterMarkerSize = {
+    defaultSize: number;
+    min: number;
+    max: number;
+};
+export type ScatterWidgetStyle = BaseWidgetStyle & {
+    xAxis: AxisStyle;
+    yAxis: AxisStyle;
+    markerSize?: ScatterMarkerSize;
+};
+export type FunnelWidgetStyle = BaseWidgetStyle & {
+    size: string;
+    type: string;
+    direction: string;
+    labels: {
+        enabled: boolean;
+        categories: boolean;
+        percent: boolean;
+        value: boolean;
+        decimals: boolean;
+    };
+};
+export type TableWidgetStyle = {
+    'colors/columns': boolean;
+    'colors/headers': boolean;
+    'colors/rows': boolean;
+};
+export type IndicatorWidgetStyle = {
+    'indicator/gauge': {
+        subtype: string;
+        skin: string;
+        components: {
+            ticks: {
+                inactive: boolean;
+                enabled: boolean;
+            };
+            labels: {
+                inactive: boolean;
+                enabled: boolean;
+            };
+            title: {
+                inactive: boolean;
+                enabled: boolean;
+            };
+            secondaryTitle: {
+                inactive: boolean;
+                enabled: boolean;
+            };
+        };
+    };
+    'indicator/numeric': {
+        subtype: string;
+        skin: '1' | '2';
+        components: {
+            title: {
+                inactive: boolean;
+                enabled: boolean;
+            };
+            icon: {
+                inactive: boolean;
+                enabled: boolean;
+            };
+            secondaryTitle: {
+                inactive: boolean;
+                enabled: boolean;
+            };
+        };
+    };
+    skin: '1' | '2' | 'vertical' | 'horizontal';
+    subtype: 'simple' | 'bar' | 'round';
+    'indicator/pictogram': {};
+    components: {
+        ticks: {
+            inactive: boolean;
+            enabled: boolean;
+        };
+        labels: {
+            inactive: boolean;
+            enabled: boolean;
+        };
+        title: {
+            inactive: boolean;
+            enabled: boolean;
+        };
+        secondaryTitle: {
+            inactive: boolean;
+            enabled: boolean;
+        };
+    };
+};
+export type TreemapWidgetStyle = {
+    'title/1': boolean;
+    'title/2': boolean;
+    'title/3': boolean;
+    'tooltip/contribution': boolean;
+    'tooltip/value': boolean;
+};
+export type WidgetStyle = CartesianWidgetStyle | PolarWidgetStyle | FunnelWidgetStyle | ScatterWidgetStyle | TableWidgetStyle | IndicatorWidgetStyle | TreemapWidgetStyle;
+export declare enum FiltersMergeStrategyEnum {
+    WIDGET_FIRST = "widgetFirst",
+    CODE_FIRST = "codeFirst",
+    CODE_ONLY = "codeOnly"
+}
+export type FiltersMergeStrategy = `${FiltersMergeStrategyEnum}`;
+export {};

package/dist/dashboard-widget/utils.d.ts

@@ -0,0 +1,32 @@
+import { type Filter } from '@sisense/sdk-data';
+import { ChartSubtype } from '../chart-options-processor/subtype-to-design-options';
+import { ChartType, SortDirection } from '../types';
+import { FiltersMergeStrategy, Panel, PanelItem, SortDirection as JaqlSortDirection, WidgetSubtype, WidgetType } from './types';
+export declare function getChartType(widgetType: WidgetType): ChartType;
+export declare function getChartSubtype(widgetSubtype: WidgetSubtype): ChartSubtype | undefined;
+type WidgetTypeOrString = string | WidgetType;
+export declare function isSupportedWidgetType(widgetType: WidgetTypeOrString): widgetType is WidgetType;
+export declare function isTableWidget(widgetType: WidgetTypeOrString): boolean;
+export declare function getEnabledPanelItems(panels: Panel[], panelName: string): PanelItem[];
+export declare function getRootPanelItem(item: PanelItem): PanelItem;
+export declare function getSortType(jaqlSort: JaqlSortDirection | undefined): SortDirection;
+/**
+ * Merges two arrays of filter objects, prioritizing 'targetFilters' over 'sourceFilters',
+ * and removes duplicates based on filter attribute expression (dim)
+ *
+ * @param {Filter[]} [sourceFilters=[]] - The source array of filter objects.
+ * @param {Filter[]} [targetFilters=[]] - The target array of filter objects.
+ * @returns {Filter[]} - The merged array of filter objects.
+ */
+export declare function mergeFilters(sourceFilters?: Filter[], targetFilters?: Filter[]): Filter[];
+/**
+ * Merge two arrays of filters using the specified merge strategy.
+ *
+ * @param {Filter[]} widgetFilters - The filters from the widget.
+ * @param {Filter[]} codeFilters - The filters from the code.
+ * @param {FiltersMergeStrategy} [mergeStrategy] - The strategy to use for merging filters.
+ *
+ * @returns {Filter[]} The merged filters based on the selected strategy.
+ */
+export declare function mergeFiltersByStrategy(widgetFilters?: Filter[], codeFilters?: Filter[], mergeStrategy?: FiltersMergeStrategy): Filter[];
+export {};

package/dist/decorators/as-sisense-component.d.ts

@@ -0,0 +1,19 @@
+import type { FunctionComponent } from 'react';
+/**
+ * Configuration for the {@link asSisenseComponent} decorator
+ */
+export type SisenseComponentConfig = {
+    /** The name of the component to be used in the tracking events and error messages */
+    componentName: string;
+    /** If set to true (or function returns true), the component will not wait for the Sisense context to be initialized */
+    shouldSkipSisenseContextWaiting?: boolean | ((props: any) => boolean);
+    /** If set to true (or function returns true), the component will not be tracked */
+    shouldSkipTracking?: boolean | ((props: any) => boolean);
+};
+export type ComponentDecorator<DecoratorConfig> = (decoratorConfig: DecoratorConfig) => <ComponentProps extends Record<string, any>>(Component: FunctionComponent<ComponentProps>) => FunctionComponent<ComponentProps>;
+/**
+ * Decorator that adds sisense-specific functionality to a component
+ * @param componentConfig - component configuration
+ * @returns A component with sisense-specific functionality
+ */
+export declare const asSisenseComponent: ComponentDecorator<SisenseComponentConfig>;

package/dist/decorators/with-error-boundary.d.ts

@@ -0,0 +1,5 @@
+import { ComponentDecorator } from './as-sisense-component';
+/**
+ * Adds error boundary to the component
+ */
+export declare const withErrorBoundary: ComponentDecorator<void>;

package/dist/decorators/with-sisense-context-validation.d.ts

@@ -0,0 +1,7 @@
+import { ComponentDecorator, SisenseComponentConfig } from './as-sisense-component';
+type SisenseContextValidationConfig = Pick<SisenseComponentConfig, 'shouldSkipSisenseContextWaiting'>;
+/**
+ * Adds waiting for the Sisense context to be initialized
+ */
+export declare const withSisenseContextValidation: ComponentDecorator<SisenseContextValidationConfig>;
+export {};

package/dist/decorators/with-tracking/error-tracker.d.ts

@@ -0,0 +1,20 @@
+import { HttpClient } from '@sisense/sdk-rest-client';
+import { Component, ReactNode } from 'react';
+import { SisenseContextPayload } from '../../sisense-context/sisense-context';
+type ErrorTrackerProps = {
+    children: ReactNode;
+    componentName: string;
+};
+export declare class ErrorTracker extends Component<ErrorTrackerProps, {
+    error: Error | string | null;
+}> {
+    componentName: string;
+    context: SisenseContextPayload;
+    httpClient?: HttpClient;
+    constructor(props: ErrorTrackerProps);
+    static contextType: import("react").Context<SisenseContextPayload>;
+    componentDidMount(): void;
+    componentDidCatch(error: Error): void;
+    render(): ReactNode;
+}
+export {};

package/dist/decorators/with-tracking/index.d.ts

@@ -0,0 +1 @@
+export { withTracking } from './with-tracking';

package/dist/decorators/with-tracking/use-track-component-init.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react';
+export declare const TrackingContextProvider: ({ children }: {
+    children: ReactNode;
+}) => JSX.Element;
+export declare const useTrackComponentInit: <P extends {}>(componentName: string, props: P) => void;

package/dist/decorators/with-tracking/with-tracking.d.ts

@@ -0,0 +1,10 @@
+import { ComponentDecorator } from '../as-sisense-component';
+type TrackingDecoratorConfig = {
+    componentName: string;
+    shouldSkipTracking?: boolean | ((props: any) => boolean);
+};
+/**
+ * Adds tracking to the component
+ */
+export declare const withTracking: ComponentDecorator<TrackingDecoratorConfig>;
+export {};

package/dist/dynamic-size-container/default-size.d.ts

@@ -0,0 +1,14 @@
+import { TableType } from '../chart-options-processor/translations/types';
+import { ChartType } from '../types';
+export declare const getChartDefaultSize: (chartType: ChartType | TableType) => {
+    width: number;
+    height: number;
+};
+type WidgetSizeOptions = {
+    hasHeader?: boolean;
+};
+export declare const getWidgetDefaultSize: (chartType: ChartType | TableType, { hasHeader }?: WidgetSizeOptions) => {
+    width: number;
+    height: number;
+};
+export {};

package/dist/dynamic-size-container/dynamic-size-container.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+type ContainerSize = {
+    width: number;
+    height: number;
+};
+export type DynamicSizeContainerProps = {
+    children: React.ReactNode | ((size: ContainerSize) => React.ReactNode);
+    defaultSize: ContainerSize;
+    size?: Partial<ContainerSize>;
+};
+/**
+ * A container component that adjusts its content size according to provided sizes
+ * or dynamically based on inherited size from the parent/containing element.
+ *
+ * Priorities: If a "size" is provided, it takes the highest priority.
+ * If not, the container's size is used, otherwise the "defaultSize" is used.
+ *
+ * @param {DynamicSizeContainerProps} props - DynamicSizeContainer properties.
+ * @returns {JSX.Element} The DynamicSizeContainer component.
+ */
+export declare const DynamicSizeContainer: ({ children, defaultSize, size, }: DynamicSizeContainerProps) => JSX.Element;
+export {};

package/dist/dynamic-size-container/index.d.ts

@@ -0,0 +1,2 @@
+export { DynamicSizeContainer, type DynamicSizeContainerProps } from './dynamic-size-container';
+export * from './default-size';

package/dist/error-boundary/error-boundary-box.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+/**
+ * This component is used to display an error message when a component fails to render.
+ * It is used by the ErrorBoundary component.
+ *
+ * @param props - component properties
+ * @param props.errorText - The error message to display
+ * @returns A component which will replace the component when it fails to render
+ */
+declare const ErrorBoundaryBox: ({ errorText }: {
+    errorText?: string | undefined;
+}) => JSX.Element;
+export default ErrorBoundaryBox;

package/dist/error-boundary/error-boundary.d.ts

@@ -0,0 +1,34 @@
+import { Component, ReactNode } from 'react';
+import { SisenseContextPayload } from '../sisense-context/sisense-context';
+/**
+ * @internal
+ */
+interface ErrorBoundaryProps {
+    showErrorBox?: boolean;
+    error?: Error | string;
+    children: ReactNode;
+    resetKeys?: any[];
+}
+type ErrorBoundaryState = {
+    error: Error | string | null;
+};
+/**
+ * This component is used to catch errors thrown by the UI component and display an error message
+ *
+ * @param props - component properties
+ * @param props.children - The chart to render
+ * @returns A ErrorBoundaryBox component with specific error message
+ * @internal
+ */
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    showErrorBox: boolean;
+    context: SisenseContextPayload;
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: Error): void;
+    componentDidUpdate(prevProps: ErrorBoundaryProps, prevState: ErrorBoundaryState): void;
+    render(): string | number | boolean | JSX.Element | import("react").ReactFragment | null | undefined;
+}
+export {};

package/dist/error-boundary/use-set-error.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const useSetError: () => import("react").Dispatch<import("react").SetStateAction<Error | undefined>>;

package/dist/filters/components/common/buttons.d.ts

@@ -0,0 +1,10 @@
+import { type ButtonHTMLAttributes, type FunctionComponent } from 'react';
+export type ButtonProps = ButtonHTMLAttributes<HTMLButtonElement>;
+export declare const PrimaryButton: FunctionComponent<ButtonProps>;
+export declare const SecondaryButton: FunctionComponent<ButtonProps>;
+export type ButtonWithTooltipProps = ButtonProps & {
+    tooltipTitle: string;
+    disableTooltip: boolean;
+};
+export declare const SecondaryButtonWithTooltip: FunctionComponent<ButtonWithTooltipProps>;
+export declare const LinkButton: FunctionComponent<ButtonProps>;

package/dist/filters/components/common/checkbox.d.ts

@@ -0,0 +1,7 @@
+import type { FunctionComponent, InputHTMLAttributes } from 'react';
+type CheckboxProps = {
+    label?: string;
+    wrapperClassName?: string;
+} & InputHTMLAttributes<HTMLInputElement>;
+export declare const Checkbox: FunctionComponent<CheckboxProps>;
+export {};

package/dist/filters/components/common/date-range-field-button.d.ts

@@ -0,0 +1,13 @@
+import { CompleteThemeSettings } from '../../../types';
+import { type FunctionComponent, type ButtonHTMLAttributes } from 'react';
+type InputProps = {
+    variant?: 'white' | 'grey';
+    label: string;
+    isActive?: boolean;
+} & ButtonHTMLAttributes<HTMLButtonElement>;
+type ThemeMixin = {
+    theme: CompleteThemeSettings;
+};
+export type DateRangeFieldButtonProps = InputProps & ThemeMixin;
+export declare const DateRangeFieldButton: FunctionComponent<DateRangeFieldButtonProps>;
+export {};

package/dist/filters/components/common/index.d.ts

@@ -0,0 +1,5 @@
+export { LinkButton, PrimaryButton, SecondaryButton } from './buttons';
+export { Checkbox } from './checkbox';
+export { Input } from './input';
+export { Radio } from './radio';
+export { SisenseSwitchButton } from './switch';

package/dist/filters/components/common/input.d.ts

@@ -0,0 +1,7 @@
+import { type FunctionComponent, type InputHTMLAttributes } from 'react';
+type InputProps = {
+    variant?: 'white' | 'grey';
+    label: string;
+} & InputHTMLAttributes<HTMLInputElement>;
+export declare const Input: FunctionComponent<InputProps>;
+export {};

package/dist/filters/components/common/radio.d.ts

@@ -0,0 +1,6 @@
+import type { FunctionComponent, InputHTMLAttributes } from 'react';
+type RadioProps = {
+    label?: string;
+} & InputHTMLAttributes<HTMLInputElement>;
+export declare const Radio: FunctionComponent<RadioProps>;
+export {};

package/dist/filters/components/common/switch.d.ts

@@ -0,0 +1 @@
+export declare const SisenseSwitchButton: import("@emotion/styled").StyledComponent<import("@mui/material/Switch").SwitchProps & import("@mui/system").MUIStyledCommonProps<import("@mui/material/styles").Theme>, {}, {}>;

package/dist/filters/components/date-filter/consts.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_FORMAT = "YYYY-MM-DD";

package/dist/filters/components/date-filter/date-filter/calendar-date-selector.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import dayjs from 'dayjs';
+export type SelectorMode = 'fromSelector' | 'toSelector';
+export type DateRangeLimits = {
+    maxDate: dayjs.Dayjs;
+    minDate: dayjs.Dayjs;
+};
+type DayjsDateRange = {
+    from: dayjs.Dayjs;
+    to: dayjs.Dayjs;
+};
+export type CalendarDateSelectorProps = {
+    selectorMode: SelectorMode;
+    limit: DateRangeLimits;
+    onDateRangeChanged: (dateRange: DayjsDateRange) => void;
+    onSelectorModeChanged: (newSelectorMode: SelectorMode) => void;
+    selectedDateRange: DayjsDateRange;
+};
+export declare function CalendarDateSelector({ selectedDateRange, limit, onDateRangeChanged, selectorMode, onSelectorModeChanged, }: CalendarDateSelectorProps): JSX.Element;
+export {};

package/dist/filters/components/date-filter/date-filter/calendar-header.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+type HeaderProps = {
+    date: Date;
+    changeYear: (value: number) => void;
+    changeMonth: (value: number) => void;
+    decreaseMonth: () => void;
+    increaseMonth: () => void;
+    prevMonthButtonDisabled: boolean;
+    nextMonthButtonDisabled: boolean;
+};
+export declare const CalendarHeader: (props: HeaderProps) => JSX.Element;
+export {};