semiotic 2.0.3 → 3.0.0-beta.1

package/dist/processing/xyDrawing.d.ts

@@ -1,29 +1,30 @@
 import * as React from "react";
 import { XYFrameProps, XYFrameState } from "../types/xyTypes";
+import { XYPipelineCache } from "../data/xyPipelineCache";
 import { createPoints, createLines, createSummaries } from "../visualizationLayerBehavior/general";
-import { ProjectedLine, GenericObject, LineTypeSettings, SummaryTypeSettings, RawSummary, RawPoint } from "../types/generalTypes";
-export declare const calculateXYFrame: (currentProps: XYFrameProps, prevState: XYFrameState, updateData: boolean) => {
-    lineData: import("../types/generalTypes").RawLine | import("../types/generalTypes").RawLine[];
-    pointData: RawPoint[];
-    summaryData: RawSummary | RawSummary[];
+import { ProjectedSummary, LineTypeSettings, SummaryTypeSettings } from "../types/generalTypes";
+export declare const calculateXYFrame: (currentProps: XYFrameProps, prevState: XYFrameState, updateData: boolean, cache: XYPipelineCache) => {
+    lineData: import("../types/generalTypes").RawLine<Record<string, any>> | import("../types/generalTypes").RawLine<Record<string, any>>[];
+    pointData: Record<string, any>[];
+    summaryData: import("../types/generalTypes").RawSummary<Record<string, any>> | import("../types/generalTypes").RawSummary<Record<string, any>>[];
     dataVersion: string;
-    projectedLines: ProjectedLine[];
+    projectedLines: import("../types/generalTypes").ProjectedLine[];
     projectedPoints: import("../types/generalTypes").ProjectedPoint[];
-    projectedSummaries: import("../types/generalTypes").ProjectedSummary[];
+    projectedSummaries: ProjectedSummary[];
     canvasDrawing: any[];
-    fullDataset: (import("../types/generalTypes").ProjectedPoint | import("../types/generalTypes").ProjectedSummary | import("../types/generalTypes").ProjectedBin)[];
+    fullDataset: (import("../types/generalTypes").ProjectedPoint | import("../types/generalTypes").ProjectedBin | ProjectedSummary)[];
     adjustedPosition: number[];
     adjustedSize: number[];
     backgroundGraphics: Function | React.ReactNode;
     foregroundGraphics: Function | React.ReactNode;
-    axesData: import("../semiotic").AxisProps[];
+    axesData: import("../semiotic-network").AxisProps[];
     axes: any;
     axesTickLines: any;
     renderNumber: number;
     xScale: any;
     yScale: any;
-    xAccessor: ((arg?: GenericObject, index?: number) => number)[];
-    yAccessor: ((arg?: GenericObject, index?: number) => number)[];
+    xAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+    yAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
     xExtent: any[];
     yExtent: any[];
     calculatedXExtent: any[];
@@ -33,16 +34,10 @@ export declare const calculateXYFrame: (currentProps: XYFrameProps, prevState: X
     areaAnnotations: any[];
     xyFrameRender: {
         lines: {
-            accessibleTransform: (data: any, i: any) => any;
-            data: ProjectedLine[];
-            styleFn: (d?: GenericObject, i?: number) => GenericObject;
-            classFn: (d?: GenericObject, i?: number) => string;
-            renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
-            canvasRender: (d?: GenericObject, i?: number) => boolean;
             customMark: Function;
             type: LineTypeSettings;
             defined: Function;
-            renderKeyFn: (d?: GenericObject, i?: number) => string;
+            renderKeyFn: (d?: Record<string, any>, i?: number) => string;
             ariaLabel: {
                 items: string;
                 chart: string;
@@ -86,50 +81,60 @@ export declare const calculateXYFrame: (currentProps: XYFrameProps, prevState: X
                 items: string;
                 chart: string;
             };
-            axesData: import("../semiotic").AxisProps[];
+            axesData: import("../semiotic-network").AxisProps[];
             behavior: typeof createLines;
+            styleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+            classFn: (d?: Record<string, any>, i?: number) => string;
+            renderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+            canvasRender: (d?: Record<string, any>, i?: number) => boolean;
+            accessibleTransform: (data: any, i: any) => any;
+            data: import("../types/generalTypes").ProjectedLine[];
         };
         summaries: {
             accessibleTransform: (data: any, i: any) => any;
-            data: import("../types/generalTypes").ProjectedSummary[];
-            styleFn: (d?: GenericObject, i?: number) => GenericObject;
-            classFn: (d?: GenericObject, i?: number) => string;
-            renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
-            canvasRender: (d?: GenericObject, i?: number) => boolean;
+            data: ProjectedSummary[];
+            styleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+            classFn: (d?: Record<string, any>, i?: number) => string;
+            renderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+            canvasRender: (d?: Record<string, any>, i?: number) => boolean;
             customMark: Function;
             type: SummaryTypeSettings;
-            renderKeyFn: (d?: GenericObject, i?: number) => string;
+            renderKeyFn: (d?: Record<string, any>, i?: number) => string;
             behavior: typeof createSummaries;
         };
         points: {
-            accessibleTransform: (data: any, i: any) => any;
-            data: import("../types/generalTypes").ProjectedPoint[];
-            styleFn: (d?: GenericObject, i?: number) => GenericObject;
-            classFn: (d?: GenericObject, i?: number) => string;
-            renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
-            canvasRender: (d?: GenericObject, i?: number) => boolean;
             customMark: object | Function;
-            renderKeyFn: (d?: GenericObject, i?: number) => string;
+            renderKeyFn: (d?: Record<string, any>, i?: number) => string;
             showLinePoints: string | boolean;
             behavior: typeof createPoints;
+            styleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+            classFn: (d?: Record<string, any>, i?: number) => string;
+            renderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+            canvasRender: (d?: Record<string, any>, i?: number) => boolean;
+            accessibleTransform: (data: any, i: any) => any;
+            data: import("../types/generalTypes").ProjectedPoint[];
         };
     };
     size: number[];
     annotatedSettings: {
-        xAccessor: ((arg?: GenericObject, index?: number) => number)[];
-        yAccessor: ((arg?: GenericObject, index?: number) => number)[];
-        summaryDataAccessor: ((arg?: GenericObject, index?: number) => RawPoint[])[];
-        lineDataAccessor: ((arg?: GenericObject, index?: number) => RawPoint[])[];
-        renderKeyFn: (d?: GenericObject, i?: number) => string;
         lineType: LineTypeSettings;
         summaryType: SummaryTypeSettings;
-        lineIDAccessor: (d?: GenericObject, i?: number) => string;
-        summaries: RawSummary[];
-        lines: import("../types/generalTypes").RawLine[];
+        summaries: import("../types/generalTypes").RawSummary<Record<string, any>>[] | {
+            coordinates: import("../types/generalTypes").RawSummary<Record<string, any>>[];
+        }[];
+        lines: import("../types/generalTypes").RawLine<Record<string, any>>[] | {
+            coordinates: import("../types/generalTypes").RawLine<Record<string, any>>[];
+        }[];
         title: object;
         xExtent: number[];
         yExtent: number[];
+        xAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+        yAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+        summaryDataAccessor: ((arg?: Record<string, any>, index?: number) => import("../types/generalTypes").RawPoint<Record<string, any>>[])[];
+        lineDataAccessor: ((arg?: Record<string, any>, index?: number) => import("../types/generalTypes").RawPoint<Record<string, any>>[])[];
+        renderKeyFn: (d?: Record<string, any>, i?: number) => string;
+        lineIDAccessor: (d?: Record<string, any>, i?: number) => string;
     };
     overlay: any;
-    props: XYFrameProps;
+    props: XYFrameProps<Record<string, any>>;
 };

package/dist/realtime/BinAccumulator.d.ts

@@ -0,0 +1,8 @@
+export interface Bin {
+    start: number;
+    end: number;
+    total: number;
+    categories: Map<string, number>;
+}
+export declare function computeBins(data: Iterable<Record<string, any>>, getTime: (d: Record<string, any>) => number, getValue: (d: Record<string, any>) => number, binSize: number, getCategory?: (d: Record<string, any>) => string): Map<number, Bin>;
+export declare function computeBinExtent(data: Iterable<Record<string, any>>, getTime: (d: Record<string, any>) => number, getValue: (d: Record<string, any>) => number, binSize: number, getCategory?: (d: Record<string, any>) => string): [number, number];

package/dist/realtime/IncrementalExtent.d.ts

@@ -0,0 +1,13 @@
+export declare class IncrementalExtent {
+    private _min;
+    private _max;
+    private _dirty;
+    push(value: number): void;
+    evict(value: number): void;
+    recalculate<T>(values: Iterable<T>, accessor?: (v: T) => number): void;
+    clear(): void;
+    get extent(): [number, number];
+    get min(): number;
+    get max(): number;
+    get dirty(): boolean;
+}

package/dist/realtime/RealtimeFrame.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { RealtimeFrameProps, RealtimeFrameHandle } from "./types";
+declare const RealtimeFrame: React.ForwardRefExoticComponent<RealtimeFrameProps & React.RefAttributes<RealtimeFrameHandle>>;
+export default RealtimeFrame;

package/dist/realtime/RingBuffer.d.ts

@@ -0,0 +1,19 @@
+export declare class RingBuffer<T> {
+    private _capacity;
+    private buffer;
+    private head;
+    private _size;
+    constructor(_capacity: number);
+    push(value: T): T | undefined;
+    pushMany(values: T[]): T[];
+    get(index: number): T | undefined;
+    peek(): T | undefined;
+    peekOldest(): T | undefined;
+    [Symbol.iterator](): Iterator<T>;
+    toArray(): T[];
+    resize(newCapacity: number): T[];
+    clear(): void;
+    get size(): number;
+    get capacity(): number;
+    get full(): boolean;
+}

package/dist/realtime/renderers/barRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { RendererFn } from "./types";
+export declare const barRenderer: RendererFn;

package/dist/realtime/renderers/candlestickRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { RendererFn } from "./types";
+export declare const candlestickRenderer: RendererFn;

package/dist/realtime/renderers/lineRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { RendererFn } from "./types";
+export declare const lineRenderer: RendererFn;

package/dist/realtime/renderers/swarmRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { RendererFn } from "./types";
+export declare const swarmRenderer: RendererFn;

package/dist/realtime/renderers/types.d.ts

@@ -0,0 +1,9 @@
+import type { RealtimeScales, RealtimeLayout, LineStyle, RealtimeAccessors, BarStyle, WaterfallStyle, SwarmStyle } from "../types";
+export interface RendererOptions {
+    binSize?: number;
+    barColors?: Record<string, string>;
+    barStyle?: BarStyle;
+    waterfallStyle?: WaterfallStyle;
+    swarmStyle?: SwarmStyle;
+}
+export type RendererFn = (ctx: CanvasRenderingContext2D, data: Iterable<Record<string, any>>, scales: RealtimeScales, layout: RealtimeLayout, style: LineStyle, accessors: RealtimeAccessors, annotations?: Record<string, any>[], options?: RendererOptions) => void;

package/dist/realtime/renderers/waterfallRenderer.d.ts

@@ -0,0 +1,3 @@
+import type { RendererFn } from "./types";
+export declare function computeWaterfallExtent(data: Iterable<Record<string, any>>, getValue: (d: Record<string, any>) => number): [number, number];
+export declare const waterfallRenderer: RendererFn;

package/dist/realtime/types.d.ts

@@ -0,0 +1,113 @@
+import type { ReactNode } from "react";
+import type { ScaleLinear } from "d3-scale";
+export type ArrowOfTime = "up" | "down" | "left" | "right";
+export type WindowMode = "sliding" | "growing";
+export type ThresholdType = "greater" | "lesser";
+export interface LineStyle {
+    stroke?: string;
+    strokeWidth?: number;
+    strokeDasharray?: string;
+}
+export interface AnnotationContext {
+    scales: {
+        time: ScaleLinear<number, number>;
+        value: ScaleLinear<number, number>;
+    } | null;
+    timeAxis: "x" | "y";
+    width: number;
+    height: number;
+}
+export interface CrosshairStyle {
+    stroke?: string;
+    strokeWidth?: number;
+    strokeDasharray?: string;
+}
+export interface HoverAnnotationConfig {
+    crosshair?: boolean | CrosshairStyle;
+    snapToPoint?: boolean;
+}
+export interface HoverData {
+    data: Record<string, any>;
+    time: number;
+    value: number;
+    x: number;
+    y: number;
+}
+export interface BarStyle {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    gap?: number;
+}
+export interface WaterfallStyle {
+    positiveColor?: string;
+    negativeColor?: string;
+    connectorStroke?: string;
+    connectorWidth?: number;
+    gap?: number;
+    stroke?: string;
+    strokeWidth?: number;
+}
+export interface SwarmStyle {
+    radius?: number;
+    fill?: string;
+    opacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+}
+export interface RealtimeFrameProps {
+    chartType?: "line" | "swarm" | "candlestick" | "waterfall" | "bar";
+    arrowOfTime?: ArrowOfTime;
+    windowMode?: WindowMode;
+    windowSize?: number;
+    data?: Record<string, any>[];
+    timeAccessor?: string | ((d: Record<string, any>) => number);
+    valueAccessor?: string | ((d: Record<string, any>) => number);
+    timeExtent?: [number, number];
+    valueExtent?: [number, number];
+    extentPadding?: number;
+    size?: [number, number];
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    className?: string;
+    lineStyle?: LineStyle;
+    annotations?: Record<string, any>[];
+    svgAnnotationRules?: (annotation: Record<string, any>, index: number, context: AnnotationContext) => ReactNode;
+    hoverAnnotation?: boolean | HoverAnnotationConfig;
+    tooltipContent?: (d: HoverData) => ReactNode;
+    customHoverBehavior?: (d: HoverData | null) => void;
+    showAxes?: boolean;
+    background?: string;
+    categoryAccessor?: string | ((d: Record<string, any>) => string);
+    binSize?: number;
+    barColors?: Record<string, string>;
+    barStyle?: BarStyle;
+    waterfallStyle?: WaterfallStyle;
+    swarmStyle?: SwarmStyle;
+    tickFormatTime?: (value: number) => string;
+    tickFormatValue?: (value: number) => string;
+}
+export interface RealtimeFrameHandle {
+    push(point: Record<string, any>): void;
+    pushMany(points: Record<string, any>[]): void;
+    clear(): void;
+    getData(): Record<string, any>[];
+}
+export interface RealtimeScales {
+    time: ScaleLinear<number, number>;
+    value: ScaleLinear<number, number>;
+}
+export interface RealtimeLayout {
+    width: number;
+    height: number;
+    timeAxis: "x" | "y";
+}
+export interface RealtimeAccessors {
+    time: (d: Record<string, any>) => number;
+    value: (d: Record<string, any>) => number;
+    category?: (d: Record<string, any>) => string;
+}