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

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

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

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

@@ -0,0 +1,40 @@
+import { Observable } from 'rxjs';
+import { ModelDataSeries } from '../../../../core/src/index.ts';
+import { CompositionPlotPluginParams } from './types';
+import { Layout, ContainerPosition } from '../../types/PluginParams';
+import { ComputedDatumSeries } from '../../types/ComputedData';
+
+export declare const seriesComputedDataObservable: ({ selectedSeriesData$, pluginParams$ }: {
+    selectedSeriesData$: Observable<ModelDataSeries>;
+    pluginParams$: Observable<CompositionPlotPluginParams>;
+}) => Observable<ComputedDatumSeries[][]>;
+export declare const datumLabelsObservable: ({ selectedSeriesData$ }: {
+    selectedSeriesData$: Observable<ModelDataSeries>;
+}) => Observable<string[]>;
+export declare const separateSeriesObservable: ({ pluginParams$ }: {
+    pluginParams$: Observable<CompositionPlotPluginParams>;
+}) => Observable<boolean>;
+export declare const separateNameObservable: ({ pluginParams$ }: {
+    pluginParams$: Observable<CompositionPlotPluginParams>;
+}) => Observable<boolean>;
+export declare const seriesLabelsObservable: ({ selectedSeriesData$ }: {
+    selectedSeriesData$: Observable<ModelDataSeries>;
+}) => Observable<string[]>;
+export declare const seriesVisibleComputedDataObservable: ({ seriesComputedData$ }: {
+    seriesComputedData$: Observable<ComputedDatumSeries[][]>;
+}) => Observable<ComputedDatumSeries[][]>;
+export declare const seriesComputedSortedDataObservable: ({ seriesComputedData$, separateSeries$, separateName$, datumLabels$ }: {
+    seriesComputedData$: Observable<ComputedDatumSeries[][]>;
+    separateSeries$: Observable<boolean>;
+    separateName$: Observable<boolean>;
+    datumLabels$: Observable<string[]>;
+}) => Observable<ComputedDatumSeries[][]>;
+export declare const seriesContainerPositionObservable: ({ computedSortedData$, pluginParams$, layout$ }: {
+    computedSortedData$: Observable<ComputedDatumSeries[][]>;
+    pluginParams$: Observable<CompositionPlotPluginParams>;
+    layout$: Observable<Layout>;
+}) => Observable<ContainerPosition[]>;
+export declare const datumContainerPositionMapObservable: ({ seriesContainerPosition$, computedSortedData$ }: {
+    seriesContainerPosition$: Observable<ContainerPosition[]>;
+    computedSortedData$: Observable<ComputedDatumSeries[][]>;
+}) => Observable<Map<string, ContainerPosition>>;

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

@@ -0,0 +1,10 @@
+import { IndicatorParams, PieEventTextsParams, PieLabelsParams, RoseLabelsParams, RoseParams, CompositionPlotPluginParams, BubblesParams, PieParams } from './types';
+
+export declare const DEFAULT_COMPOSITION_PLOT_PARAMS: CompositionPlotPluginParams;
+export declare const DEFAULT_BUBBLES_PARAMS: BubblesParams;
+export declare const DEFAULT_PIE_PARAMS: PieParams;
+export declare const DEFAULT_PIE_EVENT_TEXTS_PARAMS: PieEventTextsParams;
+export declare const DEFAULT_PIE_LABELS_PARAMS: PieLabelsParams;
+export declare const DEFAULT_ROSE_PARAMS: RoseParams;
+export declare const DEFAULT_ROSE_LABELS_PARAMS: RoseLabelsParams;
+export declare const DEFAULT_INDICATOR_PARAMS: IndicatorParams;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,110 @@
+import { Observable } from 'rxjs';
+import { ColorType, ModelDatumSeries, EventData } from '../../../../core/src/index.ts';
+import { ContainerPosition, Container, GraphicStyles, Layout } from '../../types/PluginParams';
+import { ComputedDatumSeries } from '../../types/ComputedData';
+import { ArcScaleType } from '../../types/Common';
+
+export interface CompositionPlotExtendContext {
+    layout$: Observable<Layout>;
+    computedData$: Observable<ComputedDatumSeries[][]>;
+    fontSizePx$: Observable<number>;
+    datumLabels$: Observable<string[]>;
+    separateSeries$: Observable<boolean>;
+    separateName$: Observable<boolean>;
+    computedSortedData$: Observable<ComputedDatumSeries[][]>;
+    visibleComputedSortedData$: Observable<ComputedDatumSeries[][]>;
+    datumList$: Observable<ComputedDatumSeries[]>;
+    seriesHighlight$: Observable<ComputedDatumSeries[]>;
+    seriesLabels$: Observable<string[]>;
+    SeriesDataMap$: Observable<Map<string, ComputedDatumSeries[]>>;
+    seriesContainerPosition$: Observable<ContainerPosition[]>;
+    DatumContainerPositionMap$: Observable<Map<string, ContainerPosition>>;
+}
+export interface CompositionPlotPluginParams {
+    styles: GraphicStyles;
+    visibleFilter: (datum: ModelDatumSeries) => boolean | null;
+    sort: ((a: ModelDatumSeries, b: ModelDatumSeries) => number) | null;
+    container: Container;
+    separateSeries: boolean;
+    separateName: boolean;
+    datasetIndex: number;
+}
+export interface CompositionPlotAllLayerParams {
+    Bubbles: BubblesParams;
+    Pie: PieParams;
+    PieEventTexts: PieEventTextsParams;
+    PieLabels: PieLabelsParams;
+    Rose: RoseParams;
+    RoseLabels: RoseLabelsParams;
+    Indicator: IndicatorParams;
+}
+export interface BubblesParams {
+    force: {
+        strength: number;
+        velocityDecay: number;
+        collisionSpacing: number;
+    };
+    bubbleLabel: {
+        labelFn: ((d: ComputedDatumSeries) => string);
+        colorType: ColorType;
+        fillRate: number;
+        lineHeight: number;
+        maxLineLength: number;
+        wordBreakAll: boolean;
+    };
+    arcScaleType: ArcScaleType;
+}
+export interface PieParams {
+    outerRadius: number;
+    innerRadius: number;
+    outerRadiusWhileHighlight: number;
+    startAngle: number;
+    endAngle: number;
+    padAngle: number;
+    strokeColorType: ColorType;
+    strokeWidth: number;
+    cornerRadius: number;
+}
+export interface PieEventTextsParams {
+    renderFn: (d: EventData) => string[] | string | null;
+    textAttrs: Array<{
+        [key: string]: string | number;
+    }>;
+    textStyles: Array<{
+        [key: string]: string | number;
+    }>;
+}
+export interface PieLabelsParams {
+    outerRadius: number;
+    outerRadiusWhileHighlight: number;
+    startAngle: number;
+    endAngle: number;
+    labelCentroid: number;
+    labelFn: ((d: ComputedDatumSeries) => string);
+    labelColorType: ColorType;
+}
+export interface RoseParams {
+    outerRadius: number;
+    padAngle: number;
+    strokeColorType: ColorType;
+    strokeWidth: number;
+    cornerRadius: number;
+    arcScaleType: ArcScaleType;
+    angleIncreaseWhileHighlight: number;
+}
+export interface RoseLabelsParams {
+    outerRadius: number;
+    labelCentroid: number;
+    labelFn: ((d: ComputedDatumSeries) => string);
+    labelColorType: ColorType;
+    arcScaleType: ArcScaleType;
+}
+export interface IndicatorParams {
+    startAngle: number;
+    endAngle: number;
+    radius: number;
+    indicatorType: 'line' | 'needle' | 'pin' | 'triangle';
+    size: number;
+    colorType: ColorType;
+    value: number;
+}

package/dist/plugin-basic/src/plugins/CompositionPlot/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/HierarchyPlot/HierarchyPlot.d.ts

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

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

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { ModelData } from '../../../../core/src/index.ts';
+import { ComputedData, ComputedDatumTree } from '../../types';
+import { HierarchyPlotPluginParams } from './types';
+
+export declare const treeComputedDataObservable: ({ selectedTreeData$, pluginParams$ }: {
+    selectedTreeData$: Observable<ModelData<"tree">>;
+    pluginParams$: Observable<HierarchyPlotPluginParams>;
+}) => Observable<ComputedData<"tree">>;
+export declare const nodeListObservable: ({ computedData$ }: {
+    computedData$: Observable<ComputedData<"tree">>;
+}) => Observable<ComputedDatumTree[]>;
+export declare const categoryLabelsObservable: (CategoryDataMap$: Observable<Map<string, ComputedDatumTree[]>>) => Observable<string[]>;
+export declare const treeVisibleComputedDataObservable: ({ computedData$ }: {
+    computedData$: Observable<ComputedData<"tree">>;
+}) => Observable<ComputedDatumTree>;

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

@@ -0,0 +1,4 @@
+import { TreeMapParams, HierarchyPlotPluginParams } from './types';
+
+export declare const DEFAULT_HIERARCHY_PLOT_PARAMS: HierarchyPlotPluginParams;
+export declare const DEFAULT_TREE_MAP_PARAMS: TreeMapParams;

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { Observable } from 'rxjs';
+import { ColorType } from '../../../../core/src/index.ts';
+import { GraphicStyles, Layout, VisibleFilter } from '../../types/PluginParams';
+import { ComputedData, ComputedDatumTree } from '../../types';
+
+export interface HierarchyPlotExtendContext {
+    layout$: Observable<Layout>;
+    computedData$: Observable<ComputedData<'tree'>>;
+    fontSizePx$: Observable<number>;
+    treeHighlight$: Observable<ComputedDatumTree[]>;
+    categoryLabels$: Observable<string[]>;
+    CategoryDataMap$: Observable<Map<string, ComputedDatumTree[]>>;
+    visibleComputedData$: Observable<ComputedData<'tree'>>;
+}
+export interface HierarchyPlotPluginParams {
+    styles: GraphicStyles;
+    visibleFilter: VisibleFilter<'grid'>;
+    datasetIndex: number;
+}
+export interface HierarchyPlotAllLayerParams {
+    TreeMap: TreeMapParams;
+}
+export interface TreeMapParams {
+    paddingInner: number;
+    paddingOuter: number;
+    labelColorType: ColorType;
+    squarifyRatio: number;
+    sort: (a: ComputedDatumTree, b: ComputedDatumTree) => number;
+}

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

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

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

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

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

@@ -0,0 +1,4 @@
+import { LegendParams, LegendPluginParams } from './types';
+
+export declare const DEFAULT_SERIES_LEGEND_PLUGIN_PARAMS: LegendPluginParams;
+export declare const DEFAULT_SERIES_LEGEND_PARAMS: LegendParams;

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

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

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

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

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

@@ -0,0 +1,31 @@
+import { Observable } from 'rxjs';
+import { ColorType, ModelDatumSeries } from '../../../../core/src/index.ts';
+import { GraphicStyles, Layout } from '../../types/PluginParams';
+import { ComputedDatumSeries } from '../../types/ComputedData';
+import { Placement } from '../../types/Common';
+
+export interface LegendExtendContext {
+    layout$: Observable<Layout>;
+    fontSizePx$: Observable<number>;
+    SeriesDataMap$: Observable<Map<string, ComputedDatumSeries[]>>;
+}
+export interface LegendPluginParams {
+    styles: GraphicStyles;
+    visibleFilter: (datum: ModelDatumSeries) => boolean | null;
+    sort: ((a: ModelDatumSeries, b: ModelDatumSeries) => number) | null;
+    datasetIndex: number;
+}
+export interface LegendAllLayerParams {
+    Legend: LegendParams;
+}
+export interface LegendParams {
+    placement: Placement;
+    padding: number;
+    backgroundFill: ColorType;
+    backgroundStroke: ColorType;
+    gap: number;
+    listRectWidth: number;
+    listRectHeight: number;
+    listRectRadius: number;
+    textColorType: ColorType;
+}

package/dist/plugin-basic/src/plugins/Legend/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/NetworkPlot/NetworkPlot.d.ts

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

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

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { ModelData } from '../../../../core/src/index.ts';
+import { ComputedData, ComputedDatumGraphNode, ComputedDatumGraphEdge } from '../../types';
+import { NetworkPlotPluginParams } from './types';
+
+export declare const multivariateComputedDataObservable: ({ selectedGraphData$, pluginParams$ }: {
+    selectedGraphData$: Observable<ModelData<"graph">>;
+    pluginParams$: Observable<NetworkPlotPluginParams>;
+}) => Observable<ComputedData<"graph">>;
+export declare const categoryLabelsObservable: (CategoryNodeMap$: Observable<Map<string, ComputedDatumGraphNode[]>>, CategoryEdgeMap$: Observable<Map<string, ComputedDatumGraphEdge[]>>) => Observable<string[]>;
+export declare const NodeMapObservable: (computedData$: Observable<ComputedData<"graph">>) => Observable<Map<string, ComputedDatumGraphNode>>;
+export declare const EdgeMapObservable: (computedData$: Observable<ComputedData<"graph">>) => Observable<Map<string, ComputedDatumGraphEdge>>;
+export declare const graphVisibleComputedDataObservable: ({ computedData$, NodeMap$ }: {
+    computedData$: Observable<ComputedData<"graph">>;
+    NodeMap$: Observable<Map<string, ComputedDatumGraphNode>>;
+}) => Observable<{
+    nodes: ComputedDatumGraphNode[];
+    edges: ComputedDatumGraphEdge[];
+}>;

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

@@ -0,0 +1,5 @@
+import { ForceDirectedParams, ForceDirectedBubblesParams, NetworkPlotPluginParams } from './types';
+
+export declare const DEFAULT_NETWORK_PLOT_PARAMS: NetworkPlotPluginParams;
+export declare const DEFAULT_FORCE_DIRECTED_PARAMS: ForceDirectedParams;
+export declare const DEFAULT_FORCE_DIRECTED_BUBBLES_PARAMS: ForceDirectedBubblesParams;

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

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

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

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

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

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