@orbcharts/plugin-basic 4.0.0-pre-alpha.0

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/BarsPN.d.ts

@@ -0,0 +1,16 @@
+import { BarsParams, SeriesPlotPluginParams, SeriesPlotExtendContext } from '../types';
+
+export declare const Bars: {
+    new (): {
+        _name: string;
+        _defaultParams: BarsParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, BarsParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<BarsParams>) => void;
+        _forceReplaceParams: (params: BarsParams) => void;
+        _getParams: () => Readonly<BarsParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/BarsTriangle.d.ts

@@ -0,0 +1,16 @@
+import { BarsTriangleParams, SeriesPlotPluginParams, SeriesPlotExtendContext } from '../types';
+
+export declare const BarsTriangle: {
+    new (): {
+        _name: string;
+        _defaultParams: BarsTriangleParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, BarsTriangleParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<BarsTriangleParams>) => void;
+        _forceReplaceParams: (params: BarsTriangleParams) => void;
+        _getParams: () => Readonly<BarsTriangleParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/CategoryAux.d.ts

@@ -0,0 +1,16 @@
+import { CategoryAuxParams, SeriesPlotPluginParams, SeriesPlotExtendContext } from '../types';
+
+export declare const CategoryAux: {
+    new (): {
+        _name: string;
+        _defaultParams: CategoryAuxParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, CategoryAuxParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<CategoryAuxParams>) => void;
+        _forceReplaceParams: (params: CategoryAuxParams) => void;
+        _getParams: () => Readonly<CategoryAuxParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/CategoryAxis.d.ts

@@ -0,0 +1,16 @@
+import { CategoryAxisParams, SeriesPlotPluginParams, SeriesPlotExtendContext } from '../types';
+
+export declare const CategoryAxis: {
+    new (): {
+        _name: string;
+        _defaultParams: CategoryAxisParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, CategoryAxisParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<CategoryAxisParams>) => void;
+        _forceReplaceParams: (params: CategoryAxisParams) => void;
+        _getParams: () => Readonly<CategoryAxisParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/CategoryZoom.d.ts

@@ -0,0 +1,16 @@
+import { CategoryZoomParams, SeriesPlotPluginParams, SeriesPlotExtendContext } from '../types';
+
+export declare const CategoryZoom: {
+    new (): {
+        _name: string;
+        _defaultParams: CategoryZoomParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, CategoryZoomParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<CategoryZoomParams>) => void;
+        _forceReplaceParams: (params: CategoryZoomParams) => void;
+        _getParams: () => Readonly<CategoryZoomParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/Dots.d.ts

@@ -0,0 +1,16 @@
+import { DotsParams, SeriesPlotPluginParams, SeriesPlotExtendContext } from '../types';
+
+export declare const Dots: {
+    new (): {
+        _name: string;
+        _defaultParams: DotsParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, DotsParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<DotsParams>) => void;
+        _forceReplaceParams: (params: DotsParams) => void;
+        _getParams: () => Readonly<DotsParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/LineAreas.d.ts

@@ -0,0 +1,16 @@
+import { LineAreasParams, SeriesPlotPluginParams, SeriesPlotExtendContext } from '../types';
+
+export declare const LineAreas: {
+    new (): {
+        _name: string;
+        _defaultParams: LineAreasParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, LineAreasParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<LineAreasParams>) => void;
+        _forceReplaceParams: (params: LineAreasParams) => void;
+        _getParams: () => Readonly<LineAreasParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/Lines.d.ts

@@ -0,0 +1,16 @@
+import { LinesParams, SeriesPlotPluginParams, SeriesPlotExtendContext } from '../types';
+
+export declare const Lines: {
+    new (): {
+        _name: string;
+        _defaultParams: LinesParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, LinesParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<LinesParams>) => void;
+        _forceReplaceParams: (params: LinesParams) => void;
+        _getParams: () => Readonly<LinesParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/StackedBars.d.ts

@@ -0,0 +1,16 @@
+import { SeriesPlotPluginParams, StackedBarsParams, SeriesPlotExtendContext } from '../types';
+
+export declare const StackedBars: {
+    new (): {
+        _name: string;
+        _defaultParams: StackedBarsParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, StackedBarsParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<StackedBarsParams>) => void;
+        _forceReplaceParams: (params: StackedBarsParams) => void;
+        _getParams: () => Readonly<StackedBarsParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/StackedValueAxis.d.ts

@@ -0,0 +1,16 @@
+import { StackedValueAxisParams, SeriesPlotPluginParams, SeriesPlotExtendContext } from '../types';
+
+export declare const StackedValueAxis: {
+    new (): {
+        _name: string;
+        _defaultParams: StackedValueAxisParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, StackedValueAxisParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<StackedValueAxisParams>) => void;
+        _forceReplaceParams: (params: StackedValueAxisParams) => void;
+        _getParams: () => Readonly<StackedValueAxisParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/ValueAxis.d.ts

@@ -0,0 +1,16 @@
+import { ValueAxisParams, SeriesPlotPluginParams, SeriesPlotExtendContext } from '../types';
+
+export declare const ValueAxis: {
+    new (): {
+        _name: string;
+        _defaultParams: ValueAxisParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<SeriesPlotExtendContext, SeriesPlotPluginParams, ValueAxisParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<ValueAxisParams>) => void;
+        _forceReplaceParams: (params: ValueAxisParams) => void;
+        _getParams: () => Readonly<ValueAxisParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/SeriesPlot/types.d.ts

@@ -0,0 +1,140 @@
+import { Observable } from 'rxjs';
+import { ColorType } from '../../../../core/src/index.ts';
+import { ContainerPositionScaled, Container, GraphicStyles, Layout, VisibleFilter, ValueAxis, CategoryAxis } from '../../types/PluginParams';
+import { ComputedDatumGrid } from '../../types/ComputedData';
+import { ContainerSize, TransformData } from '../../types/Common';
+
+export interface ComputedLayoutDatumGrid extends ComputedDatumGrid {
+    axisX: number;
+    axisY: number;
+    axisYFromZero: number;
+}
+export type ComputedAxesDataGrid = ComputedLayoutDatumGrid[][];
+export interface SeriesPlotExtendContext {
+    layout$: Observable<Layout>;
+    computedData$: Observable<ComputedDatumGrid[][]>;
+    fontSizePx$: Observable<number>;
+    containerSize$: Observable<ContainerSize>;
+    gridHighlight$: Observable<ComputedDatumGrid[]>;
+    isSeriesSeprate$: Observable<boolean>;
+    gridContainerPosition$: Observable<ContainerPositionScaled[]>;
+    gridAxesSize$: Observable<ContainerSize>;
+    gridAxesContainerSize$: Observable<ContainerSize>;
+    seriesLabels$: Observable<string[]>;
+    SeriesDataMap$: Observable<Map<string, ComputedDatumGrid[]>>;
+    CategoryDataMap$: Observable<Map<string, ComputedDatumGrid[]>>;
+    computedAxesData$: Observable<ComputedAxesDataGrid>;
+    visibleComputedData$: Observable<ComputedDatumGrid[][]>;
+    visibleComputedAxesData$: Observable<ComputedAxesDataGrid>;
+    computedStackedData$: Observable<ComputedDatumGrid[][]>;
+    categoryScaleDomainValue$: Observable<[number, number]>;
+    filteredMinMaxValue$: Observable<[number, number]>;
+    filteredStackedMinMaxValue$: Observable<[number, number]>;
+    gridAxesTransform$: Observable<TransformData>;
+    gridAxesReverseTransform$: Observable<TransformData>;
+    gridGraphicTransform$: Observable<TransformData>;
+    gridGraphicReverseScale$: Observable<[number, number][]>;
+    zoomedCategoryAxis$: Observable<CategoryAxis>;
+}
+export interface SeriesPlotPluginParams {
+    styles: GraphicStyles;
+    visibleFilter: VisibleFilter<'grid'>;
+    container: Container;
+    valueAxis: ValueAxis;
+    categoryAxis: CategoryAxis;
+    separateSeries: boolean;
+    datasetIndex: number;
+}
+export interface SeriesPlotAllLayerParams {
+    Lines: LinesParams;
+    LineAreas: LineAreasParams;
+    Dots: DotsParams;
+    CategoryAux: CategoryAuxParams;
+    Bars: BarsParams;
+    BarsPN: BarsPNParams;
+    StackedBars: StackedBarsParams;
+    BarsTriangle: BarsTriangleParams;
+    CategoryAxis: CategoryAxisParams;
+    ValueAxis: ValueAxisParams;
+    StackedValueAxis: StackedValueAxisParams;
+    CategoryZoom: CategoryZoomParams;
+}
+export interface LinesParams {
+    lineCurve: string;
+    lineWidth: number;
+}
+export interface LineAreasParams {
+    lineCurve: string;
+    linearGradientOpacity: [number, number];
+}
+export interface DotsParams {
+    radius: number;
+    fillColorType: ColorType;
+    strokeColorType: ColorType;
+    strokeWidth: number;
+    onlyShowHighlighted: boolean;
+}
+export interface CategoryAuxParams {
+    showLine: boolean;
+    showLabel: boolean;
+    lineDashArray: string;
+    lineColorType: ColorType;
+    labelColorType: ColorType;
+    labelTextColorType: ColorType;
+    labelTextFormat: string | ((text: any) => string);
+    labelPadding: number;
+    labelRotate: number;
+}
+export interface BarsParams {
+    barWidth: number;
+    barPadding: number;
+    barGroupPadding: number;
+    barRadius: number | boolean;
+}
+export interface BarsPNParams extends BarsParams {
+}
+export interface StackedBarsParams {
+    barWidth: number;
+    barGroupPadding: number;
+    barRadius: number | boolean;
+}
+export interface BarsTriangleParams {
+    barWidth: number;
+    barPadding: number;
+    barGroupPadding: number;
+    linearGradientOpacity: [number, number];
+}
+export interface CategoryAxisParams {
+    labelOffset: [number, number];
+    labelColorType: ColorType;
+    axisLineVisible: boolean;
+    axisLineColorType: ColorType;
+    ticks: number | null | 'all';
+    tickFormat: string | ((text: any) => string | d3.NumberValue);
+    tickLineVisible: boolean;
+    tickPadding: number;
+    tickFullLine: boolean;
+    tickFullLineDasharray: string;
+    tickColorType: ColorType;
+    tickTextRotate: number;
+    tickTextColorType: ColorType;
+}
+export interface ValueAxisParams {
+    labelOffset: [number, number];
+    labelColorType: ColorType;
+    axisLineVisible: boolean;
+    axisLineColorType: ColorType;
+    ticks: number | null;
+    tickFormat: string | ((text: d3.NumberValue) => string | d3.NumberValue);
+    tickLineVisible: boolean;
+    tickPadding: number;
+    tickFullLine: boolean;
+    tickFullLineDasharray: string;
+    tickColorType: ColorType;
+    tickTextRotate: number;
+    tickTextColorType: ColorType;
+}
+export interface StackedValueAxisParams extends ValueAxisParams {
+}
+export interface CategoryZoomParams {
+}

package/dist/plugin-basic/src/plugins/Tooltip/Tooltip.d.ts

@@ -0,0 +1,22 @@
+import { TooltipPluginParams, TooltipAllLayerParams } from './types';
+
+export declare const Tooltip: {
+    new (params?: import('../../../../core/src/index.ts').DeepPartial<TooltipPluginParams | TooltipAllLayerParams>): {
+        _name: string;
+        _elementType: "svg";
+        _getId: () => string;
+        _setId: (id: string) => void;
+        _injectContext: (context: import('../../../../core/src/index.ts').ChartContext<{}>) => void;
+        show: (names: "Tooltip" | "Tooltip"[]) => void;
+        showOnly: (names: "Tooltip" | "Tooltip"[]) => void;
+        showAll: () => void;
+        hide: (names: "Tooltip" | "Tooltip"[]) => void;
+        hideAll: () => void;
+        toggle: (names: "Tooltip" | "Tooltip"[]) => void;
+        getShownLayerNames: () => "Tooltip"[];
+        updateParams: (patch: import('../../../../core/src/index.ts').DeepPartial<TooltipPluginParams | TooltipAllLayerParams>) => void;
+        forceReplaceParams: (full: TooltipPluginParams | TooltipAllLayerParams) => void;
+        getParams: () => Readonly<TooltipPluginParams | TooltipAllLayerParams>;
+        destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/Tooltip/contextObservables.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { ModelDataSeries } from '../../../../core/src/index.ts';
+import { TooltipPluginParams } from './types';
+import { ComputedDatumSeries } from '../../types/ComputedData';
+
+export declare const seriesComputedDataObservable: ({ selectedSeriesData$, pluginParams$ }: {
+    selectedSeriesData$: Observable<ModelDataSeries>;
+    pluginParams$: Observable<TooltipPluginParams>;
+}) => Observable<ComputedDatumSeries[][]>;

package/dist/plugin-basic/src/plugins/Tooltip/defaults.d.ts

@@ -0,0 +1,4 @@
+import { TooltipParams, TooltipPluginParams } from './types';
+
+export declare const DEFAULT_SERIES_TOOLTIP_PLUGIN_PARAMS: TooltipPluginParams;
+export declare const DEFAULT_SERIES_TOOLTIP_PARAMS: TooltipParams;

package/dist/plugin-basic/src/plugins/Tooltip/index.d.ts

@@ -0,0 +1,3 @@
+export { Tooltip } from './Tooltip';
+export * from './defaults';
+export * from './types';

package/dist/plugin-basic/src/plugins/Tooltip/layers/Tooltip.d.ts

@@ -0,0 +1,16 @@
+import { TooltipExtendContext, TooltipPluginParams, TooltipParams } from '../types';
+
+export declare const Tooltip: {
+    new (): {
+        _name: string;
+        _defaultParams: TooltipParams;
+        _layerIndex: number;
+        _initShow: boolean;
+        _enable: (enableProps: import('../../../../../core/src/index.ts').SVGLayerEnableProps<TooltipExtendContext, TooltipPluginParams, TooltipParams>) => void;
+        _disable: () => void;
+        _updateParams: (params: Partial<TooltipParams>) => void;
+        _forceReplaceParams: (params: TooltipParams) => void;
+        _getParams: () => Readonly<TooltipParams>;
+        _destroy: () => void;
+    };
+};

package/dist/plugin-basic/src/plugins/Tooltip/types.d.ts

@@ -0,0 +1,35 @@
+import { Observable } from 'rxjs';
+import { ColorType, ModelDatumSeries, EventData } from '../../../../core/src/index.ts';
+import { GraphicStyles, Layout, VisibleFilter } from '../../types/PluginParams';
+import { ComputedDatum, ComputedDatumSeries } from '../../types/ComputedData';
+import { BaseTooltipStyle, BaseTooltipUtils } from '../../baseLayers/types';
+
+export interface TooltipExtendContext {
+    layout$: Observable<Layout>;
+    fontSizePx$: Observable<number>;
+    SeriesDataMap$: Observable<Map<string, ComputedDatumSeries[]>>;
+    CategoryDataMap$: Observable<Map<string, ComputedDatumSeries[]>>;
+}
+export interface TooltipPluginParams {
+    styles: GraphicStyles;
+    visibleFilter: VisibleFilter<'series'>;
+    sort: ((a: ModelDatumSeries, b: ModelDatumSeries) => number) | null;
+    datasetIndex: number;
+}
+export interface TooltipAllLayerParams {
+    Tooltip: TooltipParams;
+}
+export interface TooltipParams {
+    backgroundColorType: ColorType;
+    backgroundOpacity: number;
+    strokeColorType: ColorType;
+    textColorType: ColorType;
+    offset: [number, number];
+    padding: number;
+    renderFn: ((eventData: EventData, context: {
+        styles: BaseTooltipStyle;
+        utils: BaseTooltipUtils;
+        seriesData: ComputedDatum<'series'>[];
+        categoryData: ComputedDatum<'series'>[];
+    }) => string[] | string);
+}

package/dist/plugin-basic/src/plugins/Tooltip/utils.d.ts

@@ -0,0 +1,19 @@
+import { ComputedDatumSeries } from '../../types/ComputedData';
+
+export interface D3PieDatum {
+    data: any;
+    index: number;
+    value: number;
+    startAngle: number;
+    endAngle: number;
+    padAngle: number;
+}
+export interface PieDatum extends D3PieDatum {
+    data: ComputedDatumSeries;
+    id: string;
+}
+export declare function makePieData({ data, startAngle, endAngle }: {
+    data: ComputedDatumSeries[];
+    startAngle: number;
+    endAngle: number;
+}): PieDatum[];

package/dist/plugin-basic/src/plugins/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ScatterPlot';
+export * from './SeriesPlot';
+export * from './HierarchyPlot';
+export * from './Legend';
+export * from './NetworkPlot';
+export * from './Tooltip';
+export * from './CompositionPlot';

package/dist/plugin-basic/src/types/BaseLayer.d.ts

@@ -0,0 +1,3 @@
+export interface BaseLayerFn<Context> {
+    (context: Context): () => void;
+}

package/dist/plugin-basic/src/types/Common.d.ts

@@ -0,0 +1,14 @@
+export type ArcScaleType = 'area' | 'radius';
+export type Placement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+export interface ContainerSize {
+    width: number;
+    height: number;
+}
+export interface TransformData {
+    translate: [number, number];
+    scale: [number, number];
+    rotate: number;
+    rotateX: number;
+    rotateY: number;
+    value: string;
+}

package/dist/plugin-basic/src/types/ComputedData.d.ts

@@ -0,0 +1,27 @@
+import { ModelType, RenderDatumGraphEdge, RenderDatumBase } from '../../../core/src/index.ts';
+
+export interface ComputedDatumSeries extends RenderDatumBase<'series'> {
+    visible: boolean;
+    seq: number;
+}
+export interface ComputedDatumGrid extends RenderDatumBase<'grid'> {
+    visible: boolean;
+}
+export interface ComputedDatumMultivariate extends RenderDatumBase<'multivariate'> {
+    visible: boolean;
+}
+export interface ComputedDatumGraphNode extends RenderDatumBase<'graph'> {
+    visible: boolean;
+}
+export interface ComputedDatumGraphEdge extends RenderDatumGraphEdge {
+    visible: boolean;
+}
+export interface ComputedDatumTree extends RenderDatumBase<'tree'> {
+    visible: boolean;
+    children: ComputedDatumTree[];
+}
+export type ComputedDatum<T extends ModelType> = T extends 'series' ? ComputedDatumSeries : T extends 'grid' ? ComputedDatumGrid : T extends 'multivariate' ? ComputedDatumMultivariate : T extends 'graph' ? ComputedDatumGraphNode : T extends 'tree' ? ComputedDatumTree : unknown;
+export type ComputedData<T extends ModelType> = T extends 'series' ? ComputedDatumSeries[] : T extends 'grid' ? ComputedDatumGrid[][] : T extends 'multivariate' ? ComputedDatumMultivariate[][] : T extends 'graph' ? {
+    nodes: ComputedDatumGraphNode[];
+    edges: ComputedDatumGraphEdge[];
+} : T extends 'tree' ? ComputedDatumTree : unknown;

package/dist/plugin-basic/src/types/PluginParams.d.ts

@@ -0,0 +1,66 @@
+import { ModelType, ModelDatum } from '../../../core/src/index.ts';
+
+export type AxisPosition = 'top' | 'bottom' | 'left' | 'right';
+export interface XYAxis {
+    scaleDomain: [number | 'min' | 'auto', number | 'max' | 'auto'];
+    scaleRange: [number, number];
+    label: string;
+}
+export interface ValueAxis {
+    position: AxisPosition;
+    scaleDomain: [number | 'min' | 'auto', number | 'max' | 'auto'];
+    scaleRange: [number, number];
+    label: string;
+}
+export interface CategoryAxis {
+    position: AxisPosition;
+    scaleDomain: [number, number | 'max'];
+    scalePadding: number;
+    label: string;
+}
+export type VisibleFilter<T extends ModelType> = (datum: ModelDatum<T>) => boolean | null;
+export interface Container {
+    columnAmount: number;
+    rowAmount: number;
+    columnGap: number | 'auto';
+    rowGap: number | 'auto';
+}
+export interface ContainerPosition {
+    slotIndex: number;
+    rowIndex: number;
+    columnIndex: number;
+    startX: number;
+    startY: number;
+    centerX: number;
+    centerY: number;
+    width: number;
+    height: number;
+}
+export interface ContainerPositionScaled {
+    slotIndex: number;
+    rowIndex: number;
+    columnIndex: number;
+    translate: [number, number];
+    scale: [number, number];
+}
+export interface Padding {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface Layout extends Padding {
+    width: number;
+    height: number;
+    rootWidth: number;
+    rootHeight: number;
+}
+export type HighlightTarget = 'series' | 'category' | 'datum' | 'none';
+export interface GraphicStyles {
+    padding: Padding;
+    highlightTarget: HighlightTarget;
+    highlightDefault: string | null;
+    unhighlightedOpacity: number;
+    transitionDuration: number;
+    transitionEase: string;
+}

package/dist/plugin-basic/src/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Common';
+export * from './ComputedData';
+export * from './PluginParams';

package/dist/plugin-basic/src/utils/commonUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function measureTextWidth(text: string, size?: number): number;
+export declare function getMinMax(data: number[]): [number, number];
+export declare function toCurrency(num: number | null): string;

package/dist/plugin-basic/src/utils/d3Graphics.d.ts

@@ -0,0 +1,24 @@
+type RenderCircleTextParams = {
+    text: string;
+    radius: number;
+    lineHeight: number;
+    isBreakAll: boolean;
+    limit?: number;
+};
+type Line = {
+    width: number;
+    text: string;
+};
+export declare function renderCircleText(selection: d3.Selection<any, any, any, any>, { text, radius, lineHeight, isBreakAll, limit }: RenderCircleTextParams): d3.Selection<SVGTSpanElement, Line, SVGTextElement, any> | undefined;
+export declare function renderTspansOnAxis(textSelection: d3.Selection<d3.BaseType, unknown, null, undefined>, { textArr, textSizePx, categoryAxisPosition, isContainerRotated }: {
+    textArr: string[];
+    textSizePx: number;
+    categoryAxisPosition: 'top' | 'right' | 'bottom' | 'left';
+    isContainerRotated: boolean;
+}): void;
+export declare function renderTspansOnQuadrant(textSelection: d3.Selection<d3.BaseType, unknown, null, undefined>, { textArr, fontSizePx, quadrant }: {
+    textArr: string[];
+    fontSizePx: number;
+    quadrant: number;
+}): void;
+export {};

package/dist/plugin-basic/src/utils/d3Scale.d.ts

@@ -0,0 +1,28 @@
+import * as d3 from 'd3';
+export declare const createValueToAxisScale: ({ maxValue, minValue, axisWidth, scaleDomain, scaleRange, reverse }: {
+    maxValue: number;
+    minValue: number;
+    axisWidth: number;
+    scaleDomain: [number | "min" | "auto", number | "max" | "auto"];
+    scaleRange: [number, number];
+    reverse?: boolean;
+}) => d3.ScaleLinear<number, number, never>;
+export declare const createAxisToValueScale: ({ maxValue, minValue, axisWidth, scaleDomain, scaleRange, reverse }: {
+    maxValue: number;
+    minValue: number;
+    axisWidth: number;
+    scaleDomain: [number | "min" | "auto", number | "max" | "auto"];
+    scaleRange: [number, number];
+    reverse?: boolean;
+}) => d3.ScaleLinear<number, number, never>;
+export declare const createLabelToAxisScale: ({ axisLabels, axisWidth, padding }: {
+    axisLabels: string[];
+    axisWidth: number;
+    padding?: number;
+}) => d3.ScalePoint<string>;
+export declare const createAxisToLabelIndexScale: ({ axisLabels, axisWidth, padding, reverse }: {
+    axisLabels: string[] | Date[];
+    axisWidth: number;
+    padding?: number;
+    reverse?: boolean;
+}) => d3.ScaleQuantize<number, never>;

package/dist/plugin-basic/src/utils/d3Utils.d.ts

@@ -0,0 +1,14 @@
+import * as d3 from 'd3';
+export declare function getSvgGElementSize(selection: d3.Selection<SVGGElement, any, any, any>): DOMRect;
+export declare function appendSvg(selection: d3.Selection<any, any, any, any>, svgString: string): void;
+export declare function getD3TransitionEase(easeName: string): any;
+export declare function makeD3Arc({ axisWidth, innerRadius, outerRadius, padAngle, cornerRadius }: {
+    axisWidth: number;
+    innerRadius: number;
+    outerRadius: number;
+    padAngle: number;
+    cornerRadius: number;
+}): d3.Arc<any, d3.DefaultArcObject>;
+export declare const parseTickFormatValue: (value: any, tickFormat: string | ((text: d3.NumberValue) => string | d3.NumberValue)) => string;
+export declare const parseDateTickFormatValue: (value: any, tickFormat: string | ((text: d3.NumberValue) => string | d3.NumberValue)) => string;
+export declare function isLightColor(color: string): boolean;