@axdspub/axiom-charts 0.0.3

package/library/axiom-charts.d.ts

@@ -0,0 +1,195 @@
+import { IRequestItemProps, IDataResult, INumericDataAccessor, IRequestItemData, IRequestItemImplementation } from '@axdspub/axiom-ui-data-services';
+import { ReactElement } from 'react';
+
+interface IUnit {
+    code: string;
+    label: string;
+}
+interface IChartAxis {
+    label?: string;
+    unit?: IUnit;
+    plots: IPlot[];
+    key: string;
+    scale?: IChartScale;
+    offset?: {
+        x?: number;
+        y?: number;
+    };
+}
+declare enum EChartAxes {
+    x = "x",
+    y = "y",
+    z = "z",
+    color = "color"
+}
+interface IChartAxes {
+    [EChartAxes.x]?: IChartAxis;
+    [EChartAxes.y]?: IChartAxis;
+    [EChartAxes.z]?: IChartAxis;
+    [EChartAxes.color]?: IChartAxis;
+}
+type IChartDimensionParameter = string;
+interface IPlotAxisSetting {
+    reverse?: boolean;
+    accessProperties?: Record<string, string>;
+    parameter?: IChartDimensionParameter;
+}
+type IPlotAxisSettings = Record<string, IPlotAxisSetting | undefined>;
+type IChartDimensionDomain = Array<Date | number>;
+type IChartDimensionAccessor = (row: any) => number | number[] | Record<string, number> | Date;
+type INumericScale = (d: any) => number;
+interface IChartScale {
+    range: INumericRange;
+    domain: IChartDimensionDomain;
+}
+type INumericRange = number[];
+interface IChartDimension {
+    accessor?: IChartDimensionAccessor;
+    parameter?: IChartDimensionParameter;
+    domain?: IChartDimensionDomain;
+    range?: INumericRange;
+    scale?: IChartScale;
+    label?: string;
+    displayUnits?: IUnit;
+    sourceUnits?: IUnit;
+    axes?: IChartAxes;
+    property?: string;
+    properties?: string[];
+}
+type IChartDimensions = Record<string, IChartDimension>;
+declare enum EPlotTypes {
+    line = "line",
+    area = "area",
+    scatter = "scatter",
+    box = "box",
+    bar = "bar",
+    stacked = "stacked",
+    anomaly = "anomaly",
+    curtain = "curtain",
+    curtain_anomaly = "curtain_anomaly",
+    seasonal = "seasonal",
+    radial = "radial",
+    pie = "pie"
+}
+interface IPlotStyle {
+    strokeWidth?: number;
+    strokeColor?: string;
+    strokeDash?: [number, number];
+    fill?: string;
+    radius?: number;
+}
+interface IPlot extends IRequestItemProps {
+    id: string;
+    type: EPlotTypes;
+    dimensions: IChartDimensions;
+    data?: IDataResult;
+    axes?: IChartAxes;
+    style?: IPlotStyle;
+    axisSettings?: IPlotAxisSettings;
+}
+interface IPlotImplementationProps extends IPlot {
+    chart: IChartImplementation;
+}
+type IPlotDataAccessors = {
+    [key in EChartAxes]?: INumericDataAccessor;
+};
+interface IPlotData extends IRequestItemData {
+    accessors: IPlotDataAccessors;
+}
+interface IPlotImplementation extends IPlotImplementationProps, IRequestItemImplementation {
+    chart: IChartImplementation;
+    draw: () => Promise<void>;
+    destroy: () => void;
+    getDomain: (axis: EChartAxes) => Promise<IChartDimensionDomain>;
+    getYDomain: () => Promise<IChartDimensionDomain>;
+    getAxisSetting: (axis: string) => IPlotAxisSetting;
+    runtime: any;
+}
+interface IPlotImplementationGroup {
+    plots: IPlotImplementation[];
+    reverse: boolean;
+    parameter: IChartDimensionParameter;
+}
+type IPlotImplementationGroups = Record<string, IPlotImplementationGroup>;
+type IPlotTypes = {
+    [key in EPlotTypes]?: ((props: IPlotImplementationProps) => IPlotImplementation);
+};
+interface IChartLibrary {
+    Chart: (props: IChartImplementationProps) => IChartImplementation;
+    RadialChart: (props: IChartImplementationProps) => IChartImplementation;
+}
+interface IChartSettings {
+    margin: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    width: number | 'auto';
+    height: number;
+    layout?: 'radial' | 'timeseries' | undefined;
+}
+interface IChart {
+    settings: IChartSettings;
+    plots: IPlot[];
+    label?: string;
+    description?: string;
+    help?: string;
+}
+interface IChartImplementationProps extends IChart {
+    element?: HTMLElement;
+}
+interface IChartImplementation extends IChartImplementationProps {
+    init: (drawImmediately: boolean) => Promise<void>;
+    draw: () => Promise<void>;
+    destroy: () => void;
+}
+
+declare class ChartRoot implements IChartImplementation {
+    plots: IPlot[];
+    element?: HTMLElement;
+    settings: IChartSettings;
+    plotImplementations?: IPlotImplementation[];
+    runtime: {
+        prevWidth: number;
+        prevHeight: number;
+        xDomain?: IChartDimensionDomain;
+        yDomain?: IChartDimensionDomain;
+        axisGroups?: {
+            x: {
+                domain: IChartDimensionDomain;
+            };
+            y: {
+                domain: IChartDimensionDomain;
+            };
+        };
+        [index: string]: any;
+    };
+    constructor(props: IChartImplementationProps);
+    protected onError(e: Error): void;
+    onResize(prevWidth: number, prevHeight: number): void;
+    getWidth(): number;
+    onDraw(): void;
+    protected getDomainForPlotImplementations(plotImplementations: IPlotImplementation[], axis: EChartAxes): Promise<IChartDimensionDomain>;
+    protected reversePlotAxis(plot: IPlotImplementation, axis: string): boolean;
+    protected getDimensionAxisParam(plot: IPlotImplementation, axis: string): string;
+    protected getPlotImplementationGroups(plots: IPlotImplementation[], axis: string): IPlotImplementationGroups;
+    protected getXRange(chartWidth: number): [number, number];
+    protected getYRange(chartHeight: number): [number, number];
+    protected getChartWidth(): number;
+    protected getChartHeight(): number;
+    protected getYAxesWidth(): number;
+    init(drawImmediately?: boolean): Promise<void>;
+    showAxes(xGroup: Record<string, IPlotImplementation[]>, yGroup: Record<string, IPlotImplementation[]>): void;
+    showYAxes(yAxes: IChartAxis[]): void;
+    showXAxes(xAxes: IChartAxis[]): void;
+    draw(): Promise<void>;
+    destroy(): void;
+    createPlots(): IPlotImplementation[];
+    protected getPlotImplementationProps(plot: IPlot): IPlotImplementationProps;
+    protected createPlot(plot: IPlot): IPlotImplementation;
+}
+
+declare const AxiomChartComponent: (props: IChart) => ReactElement;
+
+export { AxiomChartComponent as Chart, ChartRoot, EChartAxes, EPlotTypes, IChart, IChartAxes, IChartAxis, IChartDimension, IChartDimensionAccessor, IChartDimensionDomain, IChartDimensionParameter, IChartDimensions, IChartImplementation, IChartImplementationProps, IChartLibrary, IChartScale, IChartSettings, INumericRange, INumericScale, IPlot, IPlotAxisSetting, IPlotAxisSettings, IPlotData, IPlotDataAccessors, IPlotImplementation, IPlotImplementationGroup, IPlotImplementationGroups, IPlotImplementationProps, IPlotStyle, IPlotTypes };