@orbcharts/core 3.0.0-alpha.21

package/dist/src/types/ComputedData.d.ts

@@ -0,0 +1,28 @@
+import { ChartType } from './Chart';
+import { ComputedDataSeries, ComputedDatumSeries } from './ComputedDataSeries';
+import { ComputedDataGrid, ComputedDatumGrid } from './ComputedDataGrid';
+import { ComputedDataMultiGrid } from './ComputedDataMultiGrid';
+import { ComputedDataMultiValue, ComputedDatumMultiValue } from './ComputedDataMultiValue';
+import { ComputedDataRelationship, ComputedNode } from './ComputedDataRelationship';
+import { ComputedDataTree } from './ComputedDataTree';
+import { DataFormatterContext } from './DataFormatter';
+
+export interface ComputedDataFn<T extends ChartType> {
+    (dataFormatterContext: DataFormatterContext<T>): ComputedDataTypeMap<T>;
+}
+export interface ComputedDatumBase {
+    id: string;
+    index: number;
+    label: string;
+    value: number | null;
+    visible: boolean;
+    tooltipContent: string;
+    data: any;
+}
+export interface ComputedDatumSeriesValue {
+    color: string;
+    seriesIndex: number;
+    seriesLabel: string;
+}
+export type ComputedDataTypeMap<T extends ChartType> = T extends 'series' ? ComputedDataSeries : T extends 'grid' ? ComputedDataGrid : T extends 'multiGrid' ? ComputedDataMultiGrid : T extends 'multiValue' ? ComputedDataMultiValue : T extends 'relationship' ? ComputedDataRelationship : T extends 'tree' ? ComputedDataTree : ComputedDatumBase;
+export type ComputedDatumTypeMap<T extends ChartType> = T extends 'series' ? ComputedDatumSeries : T extends 'grid' ? ComputedDatumGrid : T extends 'multiGrid' ? ComputedDatumGrid : T extends 'multiValue' ? ComputedDatumMultiValue : T extends 'relationship' ? ComputedNode : T extends 'tree' ? ComputedDataTree : unknown;

package/dist/src/types/ComputedDataGrid.d.ts

@@ -0,0 +1,10 @@
+import { ComputedDatumBase, ComputedDatumSeriesValue } from './ComputedData';
+
+export interface ComputedDatumGrid extends ComputedDatumBase, ComputedDatumSeriesValue {
+    groupIndex: number;
+    groupLabel: string;
+    axisX: number;
+    axisY: number;
+    axisYFromZero: number;
+}
+export type ComputedDataGrid = ComputedDatumGrid[][];

package/dist/src/types/ComputedDataMultiGrid.d.ts

@@ -0,0 +1,3 @@
+import { ComputedDataGrid } from './ComputedDataGrid';
+
+export type ComputedDataMultiGrid = ComputedDataGrid[];

package/dist/src/types/ComputedDataMultiValue.d.ts

@@ -0,0 +1,6 @@
+import { ComputedDatumBase } from './ComputedData';
+
+export type ComputedDataMultiValue = ComputedDatumMultiValue[][];
+export interface ComputedDatumMultiValue extends ComputedDatumBase {
+    axis: number;
+}

package/dist/src/types/ComputedDataRelationship.d.ts

@@ -0,0 +1,18 @@
+import { ComputedDatumBase } from './ComputedData';
+
+export type ComputedDataRelationship = {
+    nodes: ComputedNode[];
+    edges: ComputedEdge[];
+};
+export interface ComputedNode extends ComputedDatumBase {
+    startNodes: ComputedNode[];
+    startNodeIds: string[];
+    endNodes: ComputedNode[];
+    endNodeIds: string[];
+}
+export interface ComputedEdge extends ComputedDatumBase {
+    startNode: ComputedNode;
+    startNodeId: string;
+    endNode: ComputedNode;
+    endNodeId: string;
+}

package/dist/src/types/ComputedDataSeries.d.ts

@@ -0,0 +1,6 @@
+import { ComputedDatumBase, ComputedDatumSeriesValue } from './ComputedData';
+
+export interface ComputedDatumSeries extends ComputedDatumBase, ComputedDatumSeriesValue {
+    sortedIndex: number;
+}
+export type ComputedDataSeries = ComputedDatumSeries[];

package/dist/src/types/ComputedDataTree.d.ts

@@ -0,0 +1,7 @@
+import { ComputedDatumBase } from './ComputedData';
+
+export interface ComputedDataTree extends ComputedDatumBase {
+    level: number;
+    seq: number;
+    children?: ComputedDataTree[];
+}

package/dist/src/types/ContextObserver.d.ts

@@ -0,0 +1,28 @@
+import { Observable } from 'rxjs';
+import { ChartType } from './Chart';
+import { ChartParams } from './ChartParams';
+import { DataFormatterTypeMap } from './DataFormatter';
+import { ComputedDataTypeMap } from './ComputedData';
+import { Layout } from './Layout';
+import { ContextObserverGrid } from './ContextObserverGrid';
+import { ContextObserverMultiGrid } from './ContextObserverMultiGrid';
+import { ContextObserverMultiValue } from './ContextObserverMultiValue';
+import { ContextObserverRelationship } from './ContextObserverRelationship';
+import { ContextObserverSeries } from './ContextObserverSeries';
+import { ContextObserverTree } from './ContextObserverTree';
+import { ContextSubject } from './ContextSubject';
+
+export interface ContextObserverFn<T extends ChartType> {
+    ({ subject, observer }: {
+        subject: ContextSubject<T>;
+        observer: ContextObserverBase<T, unknown>;
+    }): ContextObserverTypeMap<T, unknown>;
+}
+export type ContextObserverTypeMap<T extends ChartType, PluginParams> = T extends 'series' ? ContextObserverSeries<PluginParams> : T extends 'grid' ? ContextObserverGrid<PluginParams> : T extends 'multiGrid' ? ContextObserverMultiGrid<PluginParams> : T extends 'multiValue' ? ContextObserverMultiValue<PluginParams> : T extends 'relationship' ? ContextObserverRelationship<PluginParams> : T extends 'tree' ? ContextObserverTree<PluginParams> : ContextObserverBase<ChartType, PluginParams>;
+export interface ContextObserverBase<T extends ChartType, PluginParams> {
+    fullParams$: Observable<PluginParams>;
+    fullChartParams$: Observable<ChartParams>;
+    fullDataFormatter$: Observable<DataFormatterTypeMap<T>>;
+    computedData$: Observable<ComputedDataTypeMap<T>>;
+    layout$: Observable<Layout>;
+}

package/dist/src/types/ContextObserverGrid.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+import { ContextObserverBase } from './ContextObserver';
+import { ComputedDataGrid, ComputedDatumGrid } from './ComputedDataGrid';
+import { TransformData } from './TransformData';
+
+export interface ContextObserverGrid<PluginParams> extends ContextObserverBase<'grid', PluginParams> {
+    gridAxesTransform$: Observable<TransformData>;
+    gridGraphicTransform$: Observable<TransformData>;
+    gridAxesOppositeTransform$: Observable<TransformData>;
+    gridAxesSize$: Observable<{
+        width: number;
+        height: number;
+    }>;
+    gridHighlight$: Observable<string[]>;
+    SeriesDataMap$: Observable<Map<string, ComputedDatumGrid[]>>;
+    GroupDataMap$: Observable<Map<string, ComputedDatumGrid[]>>;
+    visibleComputedData$: Observable<ComputedDataGrid>;
+}

package/dist/src/types/ContextObserverMultiGrid.d.ts

@@ -0,0 +1,4 @@
+import { ContextObserverBase } from './ContextObserver';
+
+export interface ContextObserverMultiGrid<PluginParams> extends ContextObserverBase<'multiGrid', PluginParams> {
+}

package/dist/src/types/ContextObserverMultiValue.d.ts

@@ -0,0 +1,4 @@
+import { ContextObserverBase } from './ContextObserver';
+
+export interface ContextObserverMultiValue<PluginParams> extends ContextObserverBase<'multiValue', PluginParams> {
+}

package/dist/src/types/ContextObserverRelationship.d.ts

@@ -0,0 +1,4 @@
+import { ContextObserverBase } from './ContextObserver';
+
+export interface ContextObserverRelationship<PluginParams> extends ContextObserverBase<'relationship', PluginParams> {
+}

package/dist/src/types/ContextObserverSeries.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { ContextObserverBase } from './ContextObserver';
+import { ComputedDatumSeries } from './ComputedDataSeries';
+
+export interface ContextObserverSeries<PluginParams> extends ContextObserverBase<'series', PluginParams> {
+    seriesHighlight$: Observable<string[]>;
+    SeriesDataMap$: Observable<Map<string, ComputedDatumSeries[]>>;
+}

package/dist/src/types/ContextObserverTree.d.ts

@@ -0,0 +1,4 @@
+import { ContextObserverBase } from './ContextObserver';
+
+export interface ContextObserverTree<PluginParams> extends ContextObserverBase<'tree', PluginParams> {
+}

package/dist/src/types/ContextSubject.d.ts

@@ -0,0 +1,15 @@
+import { Subject } from 'rxjs';
+import { ChartType } from './Chart';
+import { EventTypeMap } from './Event';
+import { ChartParamsPartial } from './ChartParams';
+import { DataFormatterPartialTypeMap } from './DataFormatter';
+import { DataTypeMap } from './Data';
+import { PluginEntity } from './Plugin';
+
+export interface ContextSubject<T extends ChartType> {
+    data$: Subject<DataTypeMap<T>>;
+    dataFormatter$: Subject<DataFormatterPartialTypeMap<T>>;
+    plugins$: Subject<PluginEntity<T, any, any>[]>;
+    chartParams$: Subject<ChartParamsPartial>;
+    event$: Subject<EventTypeMap<T>>;
+}

package/dist/src/types/Data.d.ts

@@ -0,0 +1,19 @@
+import { ChartType } from './Chart';
+import { DataSeries, DataSeriesDatum, DataSeriesValue } from './DataSeries';
+import { DataGrid, DataGridDatum, DataGridValue } from './DataGrid';
+import { DataMultiGrid, DataMultiGridDatum, DataMultiGridValue } from './DataMultiGrid';
+import { DataMultiValue, DataMultiValueDatum, DataMultiValueValue } from './DataMultiValue';
+import { DataTree, DataTreeDatum, DataTreeObj } from './DataTree';
+import { DataRelationship, Node, Edge } from './DataRelationship';
+
+export interface DatumBase {
+    id?: string;
+    label?: string;
+    tooltipContent?: string;
+    data?: any;
+}
+export interface DatumValue {
+    value: number | null;
+}
+export type DataTypeMap<T extends ChartType> = T extends 'series' ? DataSeries : T extends 'grid' ? DataGrid : T extends 'multiGrid' ? DataMultiGrid : T extends 'multiValue' ? DataMultiValue : T extends 'relationship' ? DataRelationship : T extends 'tree' ? DataTree : unknown;
+export type DatumTypeMap<T extends ChartType> = T extends 'series' ? DataSeriesDatum | DataSeriesValue : T extends 'grid' ? DataGridDatum | DataGridValue : T extends 'multiGrid' ? DataMultiGridDatum | DataMultiGridValue : T extends 'multiValue' ? DataMultiValueDatum | DataMultiValueValue : T extends 'relationship' ? Node | Edge : T extends 'tree' ? DataTreeDatum | DataTreeObj : unknown;

package/dist/src/types/DataFormatter.d.ts

@@ -0,0 +1,40 @@
+import { ChartType } from './Chart';
+import { ChartParams } from './ChartParams';
+import { DataTypeMap, DatumTypeMap } from './Data';
+import { DataFormatterSeries, DataFormatterSeriesPartial } from './DataFormatterSeries';
+import { DataFormatterGrid, DataFormatterGridPartial } from './DataFormatterGrid';
+import { DataFormatterMultiGrid, DataFormatterMultiGridPartial } from './DataFormatterMultiGrid';
+import { DataFormatterMultiValue, DataFormatterMultiValuePartial } from './DataFormatterMultiValue';
+import { DataFormatterTree, DataFormatterTreePartial } from './DataFormatterTree';
+import { DataFormatterRelationship, DataFormatterRelationshipPartial } from './DataFormatterRelationship';
+import { AxisPosition } from './Axis';
+import { Layout } from './Layout';
+
+export interface DataFormatterContext<T extends ChartType> {
+    data: DataTypeMap<T>;
+    dataFormatter: DataFormatterTypeMap<T>;
+    chartParams: ChartParams;
+    layout: Layout;
+}
+export type DataFormatterTypeMap<T extends ChartType> = T extends 'series' ? DataFormatterSeries : T extends 'grid' ? DataFormatterGrid : T extends 'multiGrid' ? DataFormatterMultiGrid : T extends 'multiValue' ? DataFormatterMultiValue : T extends 'relationship' ? DataFormatterRelationship : T extends 'tree' ? DataFormatterTree : DataFormatterBase<T>;
+export type DataFormatterPartialTypeMap<T extends ChartType> = T extends 'series' ? DataFormatterSeriesPartial : T extends 'grid' ? DataFormatterGridPartial : T extends 'multiGrid' ? DataFormatterMultiGridPartial : T extends 'multiValue' ? DataFormatterMultiValuePartial : T extends 'relationship' ? DataFormatterRelationshipPartial : T extends 'tree' ? DataFormatterTreePartial : DataFormatterBasePartial<T>;
+export interface DataFormatterBase<T extends ChartType> {
+    type: T;
+    visibleFilter: VisibleFilter<T>;
+    tooltipContentFormat: TooltipContentFormat<T>;
+}
+export type DataFormatterBasePartial<T extends ChartType> = Partial<DataFormatterBase<T>>;
+export interface DataFormatterValueAxis {
+    position: AxisPosition;
+    scaleDomain: [number | 'auto', number | 'auto'];
+    scaleRange: [number, number];
+    label: string;
+}
+export interface DataFormatterGroupAxis {
+    position: AxisPosition;
+    scaleDomain: [number | 'auto', number | 'auto'];
+    scalePadding: number;
+    label: string;
+}
+export type VisibleFilter<T extends ChartType> = (datum: DatumTypeMap<T>, rowIndex: number, columnIndex: number, context: DataFormatterContext<T>) => boolean | null;
+export type TooltipContentFormat<T extends ChartType> = (datum: DatumTypeMap<T>, rowIndex: number, columnIndex: number, context: DataFormatterContext<T>) => string | null;

package/dist/src/types/DataFormatterGrid.d.ts

@@ -0,0 +1,20 @@
+import { DataGridDatum, DataGridValue } from './DataGrid';
+import { DataFormatterBase, DataFormatterValueAxis, DataFormatterGroupAxis, DataFormatterContext } from './DataFormatter';
+
+export type SeriesType = 'row' | 'column';
+export interface DataFormatterGrid extends DataFormatterBase<'grid'> {
+    grid: DataFormatterGridGrid;
+    valueAxis: DataFormatterValueAxis;
+    groupAxis: DataFormatterGroupAxis;
+    colorsPredicate: (datum: DataGridDatum | DataGridValue, rowIndex: number, columnIndex: number, context: DataFormatterContext<'grid'>) => string;
+}
+export type DataFormatterGridPartial = Partial<DataFormatterGrid> | Partial<{
+    grid: Partial<DataFormatterGridGrid>;
+    valueAxis: Partial<DataFormatterValueAxis>;
+    groupAxis: Partial<DataFormatterGroupAxis>;
+}>;
+export interface DataFormatterGridGrid {
+    rowLabels: string[];
+    columnLabels: string[];
+    seriesType: SeriesType;
+}

package/dist/src/types/DataFormatterMultiGrid.d.ts

@@ -0,0 +1,16 @@
+import { DataGridDatum, DataGridValue } from './DataGrid';
+import { DataFormatterGridGrid } from './DataFormatterGrid';
+import { DataFormatterBase, DataFormatterValueAxis, DataFormatterGroupAxis, DataFormatterContext } from './DataFormatter';
+
+export interface DataFormatterMultiGrid extends DataFormatterBase<'multiGrid'> {
+    multiGrid: Array<DataFormatterMultiGridMultiGrid>;
+}
+export type DataFormatterMultiGridPartial = Partial<DataFormatterMultiGrid> | Partial<{
+    multiGrid: Array<Partial<DataFormatterMultiGridMultiGrid>>;
+}>;
+export interface DataFormatterMultiGridMultiGrid {
+    grid: DataFormatterGridGrid;
+    valueAxis: DataFormatterValueAxis;
+    groupAxis: DataFormatterGroupAxis;
+    colorsPredicate: (datum: DataGridDatum | DataGridValue, rowIndex: number, columnIndex: number, context: DataFormatterContext<'grid'>) => string;
+}

package/dist/src/types/DataFormatterMultiValue.d.ts

@@ -0,0 +1,13 @@
+import { DataFormatterBase, DataFormatterValueAxis } from './DataFormatter';
+
+export interface DataFormatterMultiValue extends DataFormatterBase<'multiValue'> {
+    multiValue: Array<DataFormatterMultiValueMultiValue>;
+    xAxis: DataFormatterValueAxis;
+    yAxis: DataFormatterValueAxis;
+}
+export type DataFormatterMultiValuePartial = Partial<DataFormatterMultiValue> | Partial<{
+    multiValue: Array<Partial<DataFormatterMultiValueMultiValue>>;
+}>;
+export interface DataFormatterMultiValueMultiValue {
+    unitLabel: string;
+}

package/dist/src/types/DataFormatterRelationship.d.ts

@@ -0,0 +1,5 @@
+import { DataFormatterBase } from './DataFormatter';
+
+export interface DataFormatterRelationship extends DataFormatterBase<'relationship'> {
+}
+export type DataFormatterRelationshipPartial = Partial<DataFormatterRelationship> | Partial<{}>;

package/dist/src/types/DataFormatterSeries.d.ts

@@ -0,0 +1,10 @@
+import { DataSeriesDatum, DataSeriesValue } from './DataSeries';
+import { DataFormatterBase, DataFormatterContext } from './DataFormatter';
+
+export interface DataFormatterSeries extends DataFormatterBase<'series'> {
+    unitLabel: string;
+    seriesLabels: string[];
+    colorsPredicate: (datum: DataSeriesDatum | DataSeriesValue, rowIndex: number, columnIndex: number, context: DataFormatterContext<'series'>) => string;
+    sort: ((a: DataSeriesDatum | DataSeriesValue, b: DataSeriesDatum | number) => number) | null;
+}
+export type DataFormatterSeriesPartial = Partial<DataFormatterSeries> | Partial<{}>;

package/dist/src/types/DataFormatterTree.d.ts

@@ -0,0 +1,5 @@
+import { DataFormatterBase } from './DataFormatter';
+
+export interface DataFormatterTree extends DataFormatterBase<'tree'> {
+}
+export type DataFormatterTreePartial = Partial<DataFormatterTree>;

package/dist/src/types/DataGrid.d.ts

@@ -0,0 +1,6 @@
+import { DatumBase, DatumValue } from './Data';
+
+export type DataGrid = (DataGridDatum | DataGridValue)[][];
+export type DataGridValue = number | null;
+export interface DataGridDatum extends DatumBase, DatumValue {
+}

package/dist/src/types/DataMultiGrid.d.ts

@@ -0,0 +1,6 @@
+import { DataGrid, DataGridDatum, DataGridValue } from './DataGrid';
+
+export type DataMultiGrid = DataGrid[];
+export interface DataMultiGridDatum extends DataGridDatum {
+}
+export type DataMultiGridValue = DataGridValue;

package/dist/src/types/DataMultiValue.d.ts

@@ -0,0 +1,6 @@
+import { DatumBase, DatumValue } from './Data';
+
+export type DataMultiValue = (DataMultiValueDatum | DataMultiValueValue)[][];
+export type DataMultiValueValue = number;
+export interface DataMultiValueDatum extends DatumBase, DatumValue {
+}

package/dist/src/types/DataRelationship.d.ts

@@ -0,0 +1,20 @@
+import { DatumBase } from './Data';
+
+export type DataRelationship = DataRelationshipObj | DataRelationshipList;
+export interface DataRelationshipObj {
+    nodes: Node[];
+    edges: Edge[];
+}
+export type DataRelationshipList = [
+    Node[],
+    Edge[]
+];
+export interface Node extends DatumBase {
+    id: string;
+    value?: number;
+}
+export interface Edge extends DatumBase {
+    start: string;
+    end: string;
+    value?: number;
+}

package/dist/src/types/DataSeries.d.ts

@@ -0,0 +1,6 @@
+import { DatumBase, DatumValue } from './Data';
+
+export type DataSeries = (DataSeriesDatum | DataSeriesValue)[][] | (DataSeriesDatum | DataSeriesValue)[];
+export type DataSeriesValue = number | null;
+export interface DataSeriesDatum extends DatumBase, DatumValue {
+}

package/dist/src/types/DataTree.d.ts

@@ -0,0 +1,13 @@
+import { DatumBase } from './Data';
+
+export type DataTree = DataTreeObj | DataTreeDatum[];
+export interface DataTreeObj extends DatumBase {
+    id: string;
+    value?: number;
+    children?: DataTreeObj[];
+}
+export interface DataTreeDatum extends DatumBase {
+    id: string;
+    value?: number;
+    parent?: string;
+}

package/dist/src/types/Event.d.ts

@@ -0,0 +1,64 @@
+import { ChartType } from './Chart';
+import { ComputedDatumBase } from './ComputedData';
+import { ComputedDataSeries, ComputedDatumSeries } from './ComputedDataSeries';
+import { ComputedDataGrid, ComputedDatumGrid } from './ComputedDataGrid';
+import { ComputedDataMultiGrid } from './ComputedDataMultiGrid';
+import { ComputedDatumMultiValue } from './ComputedDataMultiValue';
+import { ComputedNode } from './ComputedDataRelationship';
+import { ComputedDataTree } from './ComputedDataTree';
+import { HighlightTarget } from './ChartParams';
+
+export type EventName = 'click' | 'mouseover' | 'mousemove' | 'mouseout' | 'dragstart' | 'drag' | 'dragend' | 'resize' | 'transitionMove' | 'transitionEnd';
+export type EventTypeMap<T extends ChartType> = T extends 'series' ? EventSeries : T extends 'grid' ? EventGrid : T extends 'multiGrid' ? EventMultiGrid : T extends 'multiValue' ? EventMultiValue : T extends 'relationship' ? EventRelationship : T extends 'tree' ? EventTree : EventBase;
+export interface EventBase {
+    eventName: EventName;
+    pluginName: string;
+    type: ChartType;
+    event: MouseEvent | undefined;
+    highlightTarget: HighlightTarget;
+    datum: ComputedDatumBase | null;
+    tween?: number;
+}
+export interface EventSeries extends EventBase {
+    type: 'series';
+    data: ComputedDataSeries;
+    series: ComputedDatumSeries[];
+    seriesIndex: number;
+    seriesLabel: string;
+    datum: ComputedDatumSeries | null;
+}
+export interface EventGrid extends EventBase {
+    type: 'grid';
+    data: ComputedDataGrid;
+    series: ComputedDatumGrid[];
+    seriesIndex: number;
+    seriesLabel: string;
+    groups: ComputedDatumGrid[];
+    groupIndex: number;
+    groupLabel: string;
+    datum: ComputedDatumGrid | null;
+}
+export interface EventMultiGrid extends EventBase {
+    type: 'multiGrid';
+    data: ComputedDataMultiGrid;
+    gridIndex: number;
+    series: ComputedDatumGrid[];
+    seriesIndex: number;
+    seriesLabel: string;
+    group: ComputedDatumGrid[];
+    groupIndex: number;
+    groupLabel: string;
+    datum: ComputedDatumGrid | null;
+}
+export interface EventMultiValue extends EventBase {
+    type: 'multiValue';
+    datum: ComputedDatumMultiValue | null;
+}
+export interface EventRelationship extends EventBase {
+    type: 'relationship';
+    datum: ComputedNode | null;
+}
+export interface EventTree extends EventBase {
+    type: 'tree';
+    datum: ComputedDataTree | null;
+}

package/dist/src/types/Layout.d.ts

@@ -0,0 +1,8 @@
+import { Padding } from './Padding';
+
+export interface Layout extends Padding {
+    width: number;
+    height: number;
+    rootWidth: number;
+    rootHeight: number;
+}

package/dist/src/types/Padding.d.ts

@@ -0,0 +1,6 @@
+export interface Padding {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}

package/dist/src/types/Plugin.d.ts

@@ -0,0 +1,37 @@
+import { Subject } from 'rxjs';
+import { ChartType } from './Chart';
+import { ContextSubject } from './ContextSubject';
+import { ContextObserverTypeMap } from './ContextObserver';
+import * as d3 from 'd3';
+export interface CreateBasePlugin {
+    <T extends ChartType>(): DefinePlugin<T>;
+}
+export interface DefinePlugin<T extends ChartType> {
+    <PluginName, PluginParams>(name: PluginName, defaultParams: PluginParams): DefinePluginInitFn<T, PluginName, PluginParams>;
+}
+export interface DefinePluginInitFn<T extends ChartType, PluginName, PluginParams> {
+    (initFn: PluginInitFn<T, PluginName, PluginParams>): PluginConstructor<T, PluginName, PluginParams>;
+}
+export interface PluginConstructor<T extends ChartType, PluginName, PluginParams> {
+    new (): PluginEntity<T, PluginName, PluginParams>;
+}
+export interface PluginEntity<T extends ChartType, PluginName, PluginParams> {
+    params$: Subject<Partial<PluginParams>>;
+    name: PluginName;
+    defaultParams: PluginParams;
+    init: () => void;
+    destroy: () => void;
+    setPresetParams: (presetParams: Partial<PluginParams>) => void;
+    setContext: (pluginContext: PluginContext<T, PluginName, PluginParams>) => void;
+}
+export interface PluginInitFn<T extends ChartType, PluginName, PluginParams> {
+    (pluginContext: PluginContext<T, PluginName, PluginParams>): () => void;
+}
+export interface PluginContext<T extends ChartType, PluginName, PluginParams> {
+    selection: d3.Selection<any, unknown, any, unknown>;
+    rootSelection: d3.Selection<any, unknown, any, unknown>;
+    name: PluginName;
+    chartType: ChartType;
+    subject: ContextSubject<T>;
+    observer: ContextObserverTypeMap<T, PluginParams>;
+}

package/dist/src/types/TransformData.d.ts

@@ -0,0 +1,8 @@
+export interface TransformData {
+    translate: [number, number];
+    scale: [number, number];
+    rotate: number;
+    rotateX: number;
+    rotateY: number;
+    value: string;
+}

package/dist/src/types/index.d.ts

@@ -0,0 +1,37 @@
+export * from './Axis';
+export * from './Chart';
+export * from './ChartParams';
+export * from './ComputedData';
+export * from './ComputedDataGrid';
+export * from './ComputedDataMultiGrid';
+export * from './ComputedDataMultiValue';
+export * from './ComputedDataRelationship';
+export * from './ComputedDataSeries';
+export * from './ComputedDataTree';
+export * from './ContextObserver';
+export * from './ContextObserverGrid';
+export * from './ContextObserverMultiGrid';
+export * from './ContextObserverMultiValue';
+export * from './ContextObserverRelationship';
+export * from './ContextObserverSeries';
+export * from './ContextObserverTree';
+export * from './ContextSubject';
+export * from './Data';
+export * from './DataFormatter';
+export * from './DataFormatterGrid';
+export * from './DataFormatterMultiGrid';
+export * from './DataFormatterMultiValue';
+export * from './DataFormatterRelationship';
+export * from './DataFormatterSeries';
+export * from './DataFormatterTree';
+export * from './DataGrid';
+export * from './DataMultiGrid';
+export * from './DataMultiValue';
+export * from './DataRelationship';
+export * from './DataSeries';
+export * from './DataTree';
+export * from './Event';
+export * from './Layout';
+export * from './Padding';
+export * from './Plugin';
+export * from './TransformData';

package/dist/src/utils/commonUtils.d.ts

@@ -0,0 +1,8 @@
+export declare function isObject(variable: any): boolean;
+export declare function isFunction(fn: any): boolean;
+export declare function mergeOptionsWithDefault<Options extends {
+    [key: string]: any;
+}>(options: {
+    [key: string]: any;
+}, defaultOptions: Options): Options;
+export declare function formatCommaNumber(num?: number): string;

package/dist/src/utils/d3Utils.d.ts

@@ -0,0 +1,25 @@
+import * as d3 from 'd3';
+export declare const createAxisLinearScale: ({ maxValue, minValue, axisWidth, scaleDomain, scaleRange, }: {
+    maxValue: number;
+    minValue: number;
+    axisWidth: number;
+    scaleDomain: [
+        number | 'auto',
+        number | 'auto'
+    ];
+    scaleRange: [
+        number,
+        number
+    ];
+}) => d3.ScaleLinear<number, number, never>;
+export declare const createAxisPointScale: ({ axisLabels, axisWidth, padding }: {
+    axisLabels: string[];
+    axisWidth: number;
+    padding?: number;
+}) => d3.ScalePoint<string>;
+export declare const createAxisQuantizeScale: ({ axisLabels, axisWidth, padding, reverse }: {
+    axisLabels: string[] | Date[];
+    axisWidth: number;
+    padding?: number;
+    reverse?: boolean;
+}) => d3.ScaleQuantize<number, never>;

package/dist/src/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './orbchartsUtils';
+export * from './observables';
+export * from './d3Utils';
+export * from './commonUtils';

package/dist/src/utils/observables.d.ts

@@ -0,0 +1,14 @@
+import { Subject, Observable } from 'rxjs';
+import { ChartType, ChartParams, ComputedDatumTypeMap } from '../types';
+
+export declare const highlightObservable: ({ datumList$, fullChartParams$, event$ }: {
+    datumList$: Observable<ComputedDatumTypeMap<'series' | 'grid'>[]>;
+    fullChartParams$: Observable<ChartParams>;
+    event$: Subject<any>;
+}) => Observable<string[]>;
+export declare const seriesDataMapObservable: <DatumType extends ComputedDatumTypeMap<ChartType>>({ datumList$ }: {
+    datumList$: Observable<DatumType[]>;
+}) => Observable<Map<string, DatumType[]>>;
+export declare const groupDataMapObservable: <DatumType extends ComputedDatumTypeMap<ChartType>>({ datumList$ }: {
+    datumList$: Observable<DatumType[]>;
+}) => Observable<Map<string, DatumType[]>>;