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

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

@@ -0,0 +1,117 @@
+import { Observable } from 'rxjs';
+import { ColorType } from '../../../../core/src/index.ts';
+import { GraphicStyles, Layout, VisibleFilter } from '../../types/PluginParams';
+import { ComputedData, ComputedDatumGraphNode, ComputedDatumGraphEdge } from '../../types';
+
+export interface NetworkPlotExtendContext {
+    layout$: Observable<Layout>;
+    computedData$: Observable<ComputedData<'graph'>>;
+    fontSizePx$: Observable<number>;
+    graphHighlightNodes$: Observable<ComputedDatumGraphNode[]>;
+    graphHighlightEdges$: Observable<ComputedDatumGraphEdge[]>;
+    categoryLabels$: Observable<string[]>;
+    CategoryNodeMap$: Observable<Map<string, ComputedDatumGraphNode[]>>;
+    CategoryEdgeMap$: Observable<Map<string, ComputedDatumGraphEdge[]>>;
+    NodeMap$: Observable<Map<string, ComputedDatumGraphNode>>;
+    EdgeMap$: Observable<Map<string, ComputedDatumGraphEdge>>;
+    visibleComputedData$: Observable<ComputedData<'graph'>>;
+}
+export interface NetworkPlotPluginParams {
+    styles: GraphicStyles;
+    visibleFilter: VisibleFilter<'grid'>;
+    datasetIndex: number;
+}
+export interface NetworkPlotAllLayerParams {
+    ForceDirected: ForceDirectedParams;
+    ForceDirectedBubbles: ForceDirectedBubblesParams;
+}
+export interface ForceDirectedParams {
+    dot: {
+        radius: number;
+        fillColorType: ColorType;
+        strokeColorType: ColorType;
+        strokeWidth: number;
+        styleFn: (node: ComputedDatumGraphNode) => string;
+    };
+    dotLabel: {
+        colorType: ColorType;
+        sizeFixed: boolean;
+        styleFn: (node: ComputedDatumGraphNode) => string;
+    };
+    arrow: {
+        colorType: ColorType;
+        strokeWidth: number;
+        pointerWidth: number;
+        pointerHeight: number;
+        styleFn: (edge: ComputedDatumGraphEdge) => string;
+    };
+    arrowLabel: {
+        colorType: ColorType;
+        sizeFixed: boolean;
+        styleFn: (edge: ComputedDatumGraphEdge) => string;
+    };
+    force: {
+        nodeStrength: number;
+        linkDistance: number;
+        velocityDecay: number;
+        alphaDecay: number;
+    };
+    zoomable: boolean;
+    transform: {
+        x: number;
+        y: number;
+        k: number;
+    };
+    scaleExtent: {
+        min: number;
+        max: number;
+    };
+}
+export interface ForceDirectedBubblesParams {
+    bubble: {
+        radiusMin: number;
+        radiusMax: number;
+        arcScaleType: 'area' | 'radius';
+        fillColorType: ColorType;
+        strokeColorType: ColorType;
+        strokeWidth: number;
+        styleFn: (node: ComputedDatumGraphNode) => string;
+    };
+    bubbleLabel: {
+        fillRate: number;
+        lineHeight: number;
+        maxLineLength: number;
+        wordBreakAll: boolean;
+        colorType: ColorType;
+        styleFn: (node: ComputedDatumGraphNode) => string;
+    };
+    arrow: {
+        colorType: ColorType;
+        strokeWidthMin: number;
+        strokeWidthMax: number;
+        pointerWidth: number;
+        pointerHeight: number;
+        styleFn: (edge: ComputedDatumGraphEdge) => string;
+    };
+    arrowLabel: {
+        colorType: ColorType;
+        sizeFixed: boolean;
+        styleFn: (edge: ComputedDatumGraphEdge) => string;
+    };
+    force: {
+        nodeStrength: number;
+        linkDistance: number;
+        velocityDecay: number;
+        alphaDecay: number;
+    };
+    zoomable: boolean;
+    transform: {
+        x: number;
+        y: number;
+        k: number;
+    };
+    scaleExtent: {
+        min: number;
+        max: number;
+    };
+}

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

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

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

@@ -0,0 +1,140 @@
+import { Observable } from 'rxjs';
+import { ContainerSize, ComputedDatumMultivariate, ComputedData, XYAxis, TransformData, Layout } from '../../types';
+import { ContainerPositionScaled } from '../../types/PluginParams';
+import { ComputedXYDatumMultivariate, ComputedXYDataMultivariate, ScatterPlotPluginParams } from './types';
+import { Encoding, ModelDataMultivariate } from '../../../../core/src/index.ts';
+
+interface ComputedDatumWithSumMultivariate extends ComputedDatumMultivariate {
+    sum: number;
+}
+export declare const multivariateComputedDataObservable: ({ selectedMultivariateData$, pluginParams$ }: {
+    selectedMultivariateData$: Observable<ModelDataMultivariate>;
+    pluginParams$: Observable<ScatterPlotPluginParams>;
+}) => Observable<ComputedDatumMultivariate[][]>;
+export declare const valueLabelsObservable: ({ encoding$ }: {
+    encoding$: Observable<Encoding>;
+}) => Observable<string[]>;
+export declare const xyMinMaxObservable: ({ computedData$, xyValueIndex$ }: {
+    computedData$: Observable<ComputedData<"multivariate">>;
+    xyValueIndex$: Observable<[number, number]>;
+}) => Observable<{
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+}>;
+export declare const computedXYDataObservable: ({ computedData$, xyMinMax$, xyValueIndex$, layout$ }: {
+    computedData$: Observable<ComputedData<"multivariate">>;
+    xyMinMax$: Observable<{
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    }>;
+    xyValueIndex$: Observable<[number, number]>;
+    layout$: Observable<Layout>;
+}) => Observable<ComputedXYDataMultivariate>;
+export declare const seriesLabelsObservable: ({ computedData$ }: {
+    computedData$: Observable<ComputedData<"multivariate">>;
+}) => Observable<string[]>;
+export declare const visibleComputedDataObservable: ({ computedData$ }: {
+    computedData$: Observable<ComputedData<"multivariate">>;
+}) => Observable<ComputedDatumMultivariate[][]>;
+export declare const ordinalScaleDomainObservable: ({ visibleComputedData$, xAxis$ }: {
+    visibleComputedData$: Observable<ComputedData<"multivariate">>;
+    xAxis$: Observable<XYAxis>;
+}) => Observable<[number, number]>;
+export declare const visibleComputedSumDataObservable: ({ visibleComputedData$, ordinalScaleDomain$ }: {
+    visibleComputedData$: Observable<ComputedData<"multivariate">>;
+    ordinalScaleDomain$: Observable<[number, number]>;
+}) => Observable<ComputedDatumWithSumMultivariate[][]>;
+export declare const visibleComputedRankingByIndexDataObservable: ({ xyValueIndex$, isSeriesSeprate$, visibleComputedData$ }: {
+    xyValueIndex$: Observable<[number, number]>;
+    isSeriesSeprate$: Observable<boolean>;
+    visibleComputedData$: Observable<ComputedDatumMultivariate[][]>;
+}) => Observable<ComputedDatumMultivariate[][]>;
+export declare const visibleComputedRankingBySumDataObservable: ({ isSeriesSeprate$, visibleComputedSumData$ }: {
+    isSeriesSeprate$: Observable<boolean>;
+    visibleComputedSumData$: Observable<ComputedDatumWithSumMultivariate[][]>;
+}) => Observable<ComputedDatumWithSumMultivariate[][]>;
+export declare const visibleComputedXYDataObservable: ({ computedXYData$ }: {
+    computedXYData$: Observable<ComputedXYDataMultivariate>;
+}) => Observable<ComputedXYDatumMultivariate[][]>;
+export declare const containerPositionObservable: ({ computedData$, pluginParams$, layout$ }: {
+    computedData$: Observable<ComputedData<"multivariate">>;
+    pluginParams$: Observable<ScatterPlotPluginParams>;
+    layout$: Observable<Layout>;
+}) => Observable<ContainerPositionScaled[]>;
+export declare const filteredXYMinMaxDataObservable: ({ visibleComputedXYData$, xyMinMax$, xyValueIndex$, xAxis$, yAxis$ }: {
+    visibleComputedXYData$: Observable<ComputedXYDataMultivariate>;
+    xyMinMax$: Observable<{
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    }>;
+    xyValueIndex$: Observable<[number, number]>;
+    xAxis$: Observable<XYAxis>;
+    yAxis$: Observable<XYAxis>;
+}) => Observable<{
+    datumList: ComputedXYDatumMultivariate[];
+    minXDatum: ComputedXYDatumMultivariate;
+    maxXDatum: ComputedXYDatumMultivariate;
+    minYDatum: ComputedXYDatumMultivariate;
+    maxYDatum: ComputedXYDatumMultivariate;
+}>;
+export declare const graphicTransformObservable: ({ xyMinMax$, xyValueIndex$, filteredXYMinMaxData$, xAxis$, yAxis$, layout$ }: {
+    xyMinMax$: Observable<{
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    }>;
+    xyValueIndex$: Observable<[number, number]>;
+    filteredXYMinMaxData$: Observable<{
+        minXDatum: ComputedXYDatumMultivariate;
+        maxXDatum: ComputedXYDatumMultivariate;
+        minYDatum: ComputedXYDatumMultivariate;
+        maxYDatum: ComputedXYDatumMultivariate;
+    }>;
+    xAxis$: Observable<XYAxis>;
+    yAxis$: Observable<XYAxis>;
+    layout$: Observable<Layout>;
+}) => Observable<TransformData>;
+export declare const graphicReverseScaleObservable: ({ containerPosition$, graphicTransform$ }: {
+    containerPosition$: Observable<ContainerPositionScaled[]>;
+    graphicTransform$: Observable<TransformData>;
+}) => Observable<[number, number][]>;
+export declare const xScaleObservable: ({ visibleComputedSumData$, filteredXYMinMaxData$, xAxis$, containerSize$ }: {
+    visibleComputedSumData$: Observable<ComputedDatumMultivariate[][]>;
+    filteredXYMinMaxData$: Observable<{
+        minXDatum: ComputedXYDatumMultivariate;
+        maxXDatum: ComputedXYDatumMultivariate;
+        minYDatum: ComputedXYDatumMultivariate;
+        maxYDatum: ComputedXYDatumMultivariate;
+    }>;
+    xAxis$: Observable<XYAxis>;
+    containerSize$: Observable<ContainerSize>;
+}) => Observable<import('d3').ScaleLinear<number, number, never>>;
+export declare const yScaleObservable: ({ yAxis$, filteredXYMinMaxData$, containerSize$ }: {
+    yAxis$: Observable<XYAxis>;
+    filteredXYMinMaxData$: Observable<{
+        minXDatum: ComputedXYDatumMultivariate;
+        maxXDatum: ComputedXYDatumMultivariate;
+        minYDatum: ComputedXYDatumMultivariate;
+        maxYDatum: ComputedXYDatumMultivariate;
+    }>;
+    containerSize$: Observable<ContainerSize>;
+}) => Observable<import('d3').ScaleLinear<number, number, never>>;
+export declare const ordinalPaddingObservable: ({ ordinalScaleDomain$, computedData$, containerSize$ }: {
+    ordinalScaleDomain$: Observable<[number, number]>;
+    computedData$: Observable<ComputedData<"multivariate">>;
+    containerSize$: Observable<ContainerSize>;
+}) => Observable<number>;
+export declare const ordinalScaleObservable: ({ ordinalScaleDomain$, computedData$, containerSize$, ordinalPadding$ }: {
+    ordinalScaleDomain$: Observable<[number, number]>;
+    computedData$: Observable<ComputedData<"multivariate">>;
+    containerSize$: Observable<ContainerSize>;
+    ordinalPadding$: Observable<number>;
+}) => Observable<import('d3').ScaleLinear<number, number, never>>;
+export {};

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

@@ -0,0 +1,8 @@
+import { ScatterPlotPluginParams, XZoomParams, XYAxesParams, XYAuxParams, ScatterBubblesParams, ScatterParams } from './types';
+
+export declare const DEFAULT_SCATTER_PLOT_PARAMS: ScatterPlotPluginParams;
+export declare const DEFAULT_SCATTER_PARAMS: ScatterParams;
+export declare const DEFAULT_SCATTER_BUBBLES_PARAMS: ScatterBubblesParams;
+export declare const DEFAULT_X_Y_AUX_PARAMS: XYAuxParams;
+export declare const DEFAULT_X_Y_AXES_PARAMS: XYAxesParams;
+export declare const DEFAULT_X_ZOOM_PARAMS: XZoomParams;

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,146 @@
+import { Observable } from 'rxjs';
+import { ColorType } from '../../../../core/src/index.ts';
+import { ContainerPositionScaled, Container, GraphicStyles, Layout, VisibleFilter, XYAxis } from '../../types/PluginParams';
+import { ComputedDatumMultivariate } from '../../types/ComputedData';
+import { ArcScaleType, ContainerSize, TransformData } from '../../types/Common';
+
+export interface ComputedXYDatumMultivariate extends ComputedDatumMultivariate {
+    axisX: number;
+    axisY: number;
+}
+export type ComputedXYDataMultivariate = ComputedXYDatumMultivariate[][];
+export interface ScatterPlotExtendContext {
+    layout$: Observable<Layout>;
+    computedData$: Observable<ComputedDatumMultivariate[][]>;
+    fontSizePx$: Observable<number>;
+    isSeriesSeprate$: Observable<boolean>;
+    containerPosition$: Observable<ContainerPositionScaled[]>;
+    containerSize$: Observable<ContainerSize>;
+    highlight$: Observable<ComputedDatumMultivariate[]>;
+    seriesLabels$: Observable<string[]>;
+    SeriesDataMap$: Observable<Map<string, ComputedDatumMultivariate[]>>;
+    valueLabels$: Observable<string[]>;
+    xyMinMax$: Observable<{
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    }>;
+    xyValueIndex$: Observable<[number, number]>;
+    filteredXYMinMaxData$: Observable<{
+        datumList: ComputedXYDatumMultivariate[];
+        minXDatum: ComputedXYDatumMultivariate | null;
+        maxXDatum: ComputedXYDatumMultivariate | null;
+        minYDatum: ComputedXYDatumMultivariate | null;
+        maxYDatum: ComputedXYDatumMultivariate | null;
+    }>;
+    visibleComputedData$: Observable<ComputedDatumMultivariate[][]>;
+    visibleComputedRankingByIndexData$: Observable<ComputedDatumMultivariate[][]>;
+    visibleComputedXYData$: Observable<ComputedXYDataMultivariate>;
+    graphicTransform$: Observable<TransformData>;
+    graphicReverseScale$: Observable<[number, number][]>;
+    xScale$: Observable<d3.ScaleLinear<number, number>>;
+    yScale$: Observable<d3.ScaleLinear<number, number>>;
+    zoomedXAxis$: Observable<XYAxis>;
+    yAxis$: Observable<XYAxis>;
+}
+export interface ScatterPlotPluginParams {
+    styles: GraphicStyles;
+    visibleFilter: VisibleFilter<'grid'>;
+    container: Container;
+    xAxis: XYAxis;
+    yAxis: XYAxis;
+    separateSeries: boolean;
+    datasetIndex: number;
+}
+export interface ScatterPlotAllLayerParams {
+    Scatter: ScatterParams;
+    ScatterBubbles: ScatterBubblesParams;
+    XYAux: XYAuxParams;
+    XYAxes: XYAxesParams;
+    XZoom: XZoomParams;
+}
+export interface OrdinalBubblesParams {
+    bubble: {
+        sizeAdjust: number;
+        arcScaleType: 'area' | 'radius';
+        valueLinearOpacity: [number, number];
+    };
+    itemLabel: {
+        padding: number;
+        colorType: ColorType;
+    };
+    axisLabel: {
+        offset: [number, number];
+        colorType: ColorType;
+    };
+    rankingAmount: 'auto' | number;
+}
+export interface ScatterParams {
+    radius: number;
+    fillColorType: ColorType;
+    strokeColorType: ColorType;
+    strokeWidth: number;
+}
+export interface ScatterBubblesParams {
+    fillColorType: ColorType;
+    strokeColorType: ColorType;
+    strokeWidth: number;
+    valueLinearOpacity: [number, number];
+    arcScaleType: ArcScaleType;
+    sizeAdjust: number;
+}
+export interface XYAuxParams {
+    xAxis: {
+        showLine: boolean;
+        showLabel: boolean;
+        lineDashArray: string;
+        lineColorType: ColorType;
+        labelColorType: ColorType;
+        labelTextColorType: ColorType;
+        labelTextFormat: string | ((text: any) => string);
+        labelPadding: number;
+    };
+    yAxis: {
+        showLine: boolean;
+        showLabel: boolean;
+        lineDashArray: string;
+        lineColorType: ColorType;
+        labelColorType: ColorType;
+        labelTextColorType: ColorType;
+        labelTextFormat: string | ((text: any) => string);
+        labelPadding: number;
+    };
+}
+export interface XYAxesParams {
+    xAxis: {
+        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;
+        tickTextColorType: ColorType;
+    };
+    yAxis: {
+        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;
+        tickTextColorType: ColorType;
+    };
+}
+export interface XZoomParams {
+}

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

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

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

@@ -0,0 +1,77 @@
+import { Observable } from 'rxjs';
+import { ModelDataGrid } from '../../../../core/src/index.ts';
+import { ComputedData, ComputedDatumGrid } from '../../types/ComputedData';
+import { ComputedLayoutDatumGrid, ComputedAxesDataGrid, SeriesPlotPluginParams } from './types';
+import { ValueAxis, CategoryAxis, Layout, ContainerPositionScaled } from '../../types/PluginParams';
+import { ContainerSize, TransformData } from '../..';
+
+export declare const gridComputedDataObservable: ({ selectedGridData$, pluginParams$ }: {
+    selectedGridData$: Observable<ModelDataGrid>;
+    pluginParams$: Observable<SeriesPlotPluginParams>;
+}) => Observable<ComputedDatumGrid[][]>;
+export declare const gridComputedAxesDataObservable: ({ computedData$, categoryAxis$, valueAxis$, layout$ }: {
+    computedData$: Observable<ComputedDatumGrid[][]>;
+    categoryAxis$: Observable<CategoryAxis>;
+    valueAxis$: Observable<ValueAxis>;
+    layout$: Observable<Layout>;
+}) => Observable<ComputedLayoutDatumGrid[][]>;
+export declare const gridAxesSizeObservable: ({ categoryAxis$, valueAxis$, layout$ }: {
+    categoryAxis$: Observable<CategoryAxis>;
+    valueAxis$: Observable<ValueAxis>;
+    layout$: Observable<Layout>;
+}) => Observable<{
+    width: number;
+    height: number;
+}>;
+export declare const gridAxesContainerSizeObservable: ({ categoryAxis$, valueAxis$, containerSize$ }: {
+    containerSize$: Observable<ContainerSize>;
+    categoryAxis$: Observable<CategoryAxis>;
+    valueAxis$: Observable<ValueAxis>;
+}) => Observable<ContainerSize>;
+export declare const gridSeriesLabelsObservable: ({ computedData$ }: {
+    computedData$: Observable<ComputedData<"grid">>;
+}) => Observable<string[]>;
+export declare const gridVisibleComputedDataObservable: ({ computedData$ }: {
+    computedData$: Observable<ComputedData<"grid">>;
+}) => Observable<ComputedDatumGrid[][]>;
+export declare const gridVisibleComputedAxesDataObservable: ({ computedAxesData$ }: {
+    computedAxesData$: Observable<ComputedAxesDataGrid>;
+}) => Observable<ComputedLayoutDatumGrid[][]>;
+export declare const gridContainerPositionObservable: ({ selectedGridData$, pluginParams$, layout$ }: {
+    selectedGridData$: Observable<ModelDataGrid>;
+    pluginParams$: Observable<SeriesPlotPluginParams>;
+    layout$: Observable<Layout>;
+}) => Observable<ContainerPositionScaled[]>;
+export declare const computedStackedDataObservables: ({ isSeriesSeprate$, computedData$ }: {
+    isSeriesSeprate$: Observable<boolean>;
+    computedData$: Observable<ComputedData<"grid">>;
+}) => Observable<ComputedData<"grid">>;
+export declare const categoryScaleDomainValueObservable: ({ selectedGridData$, categoryAxis$ }: {
+    selectedGridData$: Observable<ModelDataGrid>;
+    categoryAxis$: Observable<CategoryAxis>;
+}) => Observable<[number, number]>;
+export declare const filteredMinMaxValueObservable: ({ computedData$, categoryScaleDomainValue$ }: {
+    computedData$: Observable<ComputedData<"grid">>;
+    categoryScaleDomainValue$: Observable<[number, number]>;
+}) => Observable<[number, number]>;
+export declare const gridAxesTransformObservable: ({ categoryAxis$, valueAxis$, layout$ }: {
+    categoryAxis$: Observable<CategoryAxis>;
+    valueAxis$: Observable<ValueAxis>;
+    layout$: Observable<Layout>;
+}) => Observable<TransformData>;
+export declare const gridAxesReverseTransformObservable: ({ gridAxesTransform$ }: {
+    gridAxesTransform$: Observable<TransformData>;
+}) => Observable<TransformData>;
+export declare const gridGraphicTransformObservable: ({ computedData$, categoryScaleDomainValue$, filteredMinMaxValue$, categoryAxis$, valueAxis$, layout$ }: {
+    computedData$: Observable<ComputedData<"grid">>;
+    categoryScaleDomainValue$: Observable<[number, number]>;
+    filteredMinMaxValue$: Observable<[number, number]>;
+    categoryAxis$: Observable<CategoryAxis>;
+    valueAxis$: Observable<ValueAxis>;
+    layout$: Observable<Layout>;
+}) => Observable<TransformData>;
+export declare const gridGraphicReverseScaleObservable: ({ gridContainerPosition$, gridAxesTransform$, gridGraphicTransform$ }: {
+    gridContainerPosition$: Observable<ContainerPositionScaled[]>;
+    gridAxesTransform$: Observable<TransformData>;
+    gridGraphicTransform$: Observable<TransformData>;
+}) => Observable<[number, number][]>;

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

@@ -0,0 +1,15 @@
+import { BarsParams, BarsTriangleParams, DotsParams, SeriesPlotPluginParams, CategoryAuxParams, CategoryAxisParams, CategoryZoomParams, LineAreasParams, LinesParams, StackedBarsParams, StackedValueAxisParams, ValueAxisParams } from './types';
+
+export declare const DEFAULT_SERIES_PLOT_PARAMS: SeriesPlotPluginParams;
+export declare const DEFAULT_LINES_PARAMS: LinesParams;
+export declare const DEFAULT_LINE_AREAS_PARAMS: LineAreasParams;
+export declare const DEFAULT_DOTS_PARAMS: DotsParams;
+export declare const DEFAULT_CATEGORY_AUX_PARAMS: CategoryAuxParams;
+export declare const DEFAULT_BARS_PARAMS: BarsParams;
+export declare const DEFAULT_BARS_DIVERGING_PARAMS: BarsParams;
+export declare const DEFAULT_STACKED_BARS_PARAMS: StackedBarsParams;
+export declare const DEFAULT_BARS_TRIANGLE_PARAMS: BarsTriangleParams;
+export declare const DEFAULT_CATEGORY_AXIS_PARAMS: CategoryAxisParams;
+export declare const DEFAULT_VALUE_AXIS_PARAMS: ValueAxisParams;
+export declare const DEFAULT_STACKED_VALUE_AXIS_PARAMS: StackedValueAxisParams;
+export declare const DEFAULT_CATEGORY_ZOOM_PARAMS: CategoryZoomParams;

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

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

package/dist/plugin-basic/src/plugins/SeriesPlot/layers/Bars.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;
+    };
+};