semiotic 2.0.2 → 3.0.0-beta.1

package/dist/processing/networkDefaults.d.ts

@@ -0,0 +1,36 @@
+export declare const emptyArray: any[];
+export declare const baseNodeProps: {
+    id: any;
+    degree: number;
+    inDegree: number;
+    outDegree: number;
+    x: number;
+    y: number;
+    x1: number;
+    x0: number;
+    y1: number;
+    y0: number;
+    height: number;
+    width: number;
+    radius: number;
+    r: number;
+    direction: any;
+    textHeight: number;
+    textWidth: number;
+    fontSize: number;
+    scale: number;
+    nodeSize: number;
+    component: number;
+    shapeNode: boolean;
+};
+export declare const baseNetworkSettings: {
+    hierarchicalNetwork: boolean;
+};
+export declare const baseGraphSettings: {
+    nodeHash: Map<any, any>;
+    edgeHash: Map<any, any>;
+    nodes: any[];
+    edges: any[];
+    hierarchicalNetwork: boolean;
+    type: string;
+};

package/dist/processing/networkLayoutHelpers.d.ts

@@ -0,0 +1,54 @@
+export { hierarchicalTypeHash } from "./layouts/hierarchyLayout";
+export { sankeyOrientHash } from "./layouts/sankeyLayout";
+export declare function determineNodeIcon(baseCustomNodeIcon: any, networkSettings: any, size: any, nodes: any): any;
+export declare function determineEdgeIcon({ baseCustomEdgeIcon, networkSettings, size, graph, nodes }: {
+    baseCustomEdgeIcon: any;
+    networkSettings: any;
+    size: any;
+    graph: any;
+    nodes: any;
+}): any;
+export declare const basicMiddle: (d: any) => {
+    edge: any;
+    x: number;
+    y: number;
+};
+export declare const edgePointHash: {
+    sankey: (d: any) => {
+        edge: any;
+        x: number;
+        y: any;
+    };
+    force: (d: any) => {
+        edge: any;
+        x: number;
+        y: number;
+    };
+    tree: (d: any) => {
+        edge: any;
+        x: number;
+        y: number;
+    };
+    cluster: (d: any) => {
+        edge: any;
+        x: number;
+        y: number;
+    };
+    matrix: (d: any) => {
+        edge: any;
+        x: any;
+        y: any;
+    };
+};
+export declare const hierarchicalProjectable: {
+    partition: boolean;
+    cluster: boolean;
+    tree: boolean;
+    dendrogram: boolean;
+};
+export declare const radialProjectable: {
+    partition: boolean;
+    cluster: boolean;
+    tree: boolean;
+    dendrogram: boolean;
+};

package/dist/processing/ordinal.d.ts

@@ -0,0 +1,102 @@
+import * as React from "react";
+import { OrdinalPipelineCache } from "../data/ordinalPipelineCache";
+import { OrdinalFrameProps, OrdinalFrameState, PieceTypeSettings } from "../types/ordinalTypes";
+import { AxisProps } from "../types/annotationTypes";
+import { ScaleBand, ScaleLinear } from "d3-scale";
+export { layoutHash, midMod, zeroFunction, twoPI, naturalLanguageTypes } from "./ordinalConstants";
+export { generateColumnOverlays } from "./ordinalOverlays";
+export type { GenerateColumnOverlaysArgs } from "./ordinalOverlays";
+export { assembleRenderPipeline } from "./ordinalRenderPipeline";
+export type { AssembleRenderPipelineArgs } from "./ordinalRenderPipeline";
+export declare const calculateMappedMiddles: (oScale: ScaleBand<string>, middleMax: number, padding: number) => {};
+export declare const calculateOrdinalFrame: (currentProps: OrdinalFrameProps, currentState: OrdinalFrameState, cache: OrdinalPipelineCache) => {
+    adjustedPosition: number[];
+    adjustedSize: number[];
+    backgroundGraphics: Function | React.ReactNode;
+    foregroundGraphics: Function | React.ReactNode;
+    axisData: AxisProps[];
+    axes: React.ReactNode[];
+    axesTickLines: object[];
+    oLabels: {
+        labels: React.ReactNode;
+    };
+    title: object;
+    columnOverlays: Record<string, any>[];
+    renderNumber: number;
+    oScaleType: ScaleBand<string>;
+    rScaleType: ScaleLinear<number, number, never>;
+    oExtent: string[];
+    rExtent: number[];
+    oScale: ScaleBand<string>;
+    rScale: ScaleLinear<number, number, never>;
+    calculatedOExtent: string[];
+    calculatedRExtent: number[];
+    projectedColumns: {
+        [key: string]: Record<string, any>;
+    };
+    margin: import("../types/generalTypes").MarginType;
+    legendSettings: any;
+    orFrameRender: {
+        connectors: {
+            accessibleTransform: (data: any, i: any) => any;
+            projection: string;
+            data: object[];
+            styleFn: Function;
+            classFn: Function;
+            renderMode: Function;
+            canvasRender: Function;
+            behavior: typeof import("../svg/frameFunctions").orFrameConnectionRenderer;
+            type: Record<string, any>;
+            eventListenersGenerator: () => Record<string, never>;
+            pieceType: PieceTypeSettings;
+        };
+        summaries: {
+            accessibleTransform: (data: any, i: any) => {
+                type: string;
+                column: Record<string, any>;
+                pieces: any;
+                summary: any;
+                oAccessor: Function[];
+            };
+            data: object[];
+            behavior: ({ data, canvasRender, canvasDrawing }: {
+                data: any;
+                canvasRender: any;
+                canvasDrawing: any;
+            }) => JSX.Element[];
+            canvasRender: Function;
+            styleFn: Function;
+            classFn: Function;
+        };
+        pieces: {
+            accessibleTransform: (data: any, i: any) => any;
+            shouldRender: boolean;
+            data: Record<string, any>[];
+            behavior: ({ data, shouldRender, canvasRender, canvasDrawing, styleFn, classFn, renderKeyFn, ariaLabel, axis }: {
+                data: any;
+                shouldRender: any;
+                canvasRender: any;
+                canvasDrawing: any;
+                styleFn: any;
+                classFn: any;
+                renderKeyFn: any;
+                ariaLabel: any;
+                axis: any;
+            }) => any[];
+            canvasRender: Function;
+            styleFn: Function;
+            classFn: Function;
+            axis: AxisProps[];
+            ariaLabel: any;
+        };
+    };
+    pieceIDAccessor: import("../types/generalTypes").GenericAccessor<string>;
+    props: OrdinalFrameProps<Record<string, any>>;
+    pieceDataXY: any;
+    oAccessor: ((arg?: Record<string, any>, index?: number) => string | number)[];
+    rAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+    summaryType: {
+        type?: string | Function;
+    };
+    type: PieceTypeSettings;
+};

package/dist/processing/ordinalConstants.d.ts

@@ -0,0 +1,33 @@
+import { clusterBarLayout, barLayout, pointLayout, swarmLayout, timelineLayout } from "../svg/pieceLayouts";
+export declare const layoutHash: {
+    clusterbar: typeof clusterBarLayout;
+    bar: typeof barLayout;
+    point: typeof pointLayout;
+    swarm: typeof swarmLayout;
+    timeline: typeof timelineLayout;
+};
+export declare const midMod: (d: any) => any;
+export declare const zeroFunction: () => any;
+export declare const twoPI: number;
+export declare const naturalLanguageTypes: {
+    bar: {
+        items: string;
+        chart: string;
+    };
+    clusterbar: {
+        items: string;
+        chart: string;
+    };
+    swarm: {
+        items: string;
+        chart: string;
+    };
+    point: {
+        items: string;
+        chart: string;
+    };
+    timeline: {
+        items: string;
+        chart: string;
+    };
+};

package/dist/processing/ordinalOverlays.d.ts

@@ -0,0 +1,33 @@
+import { ProjectionTypes } from "../types/generalTypes";
+interface PieArc {
+    markD: string;
+    centroid: number[];
+    translate: number[];
+    midAngle: number;
+}
+interface ProjectedColumn {
+    width: number;
+    x: number;
+    middle: number;
+    y: number;
+    pieceData: Record<string, any>[];
+    pieArc?: PieArc;
+    [key: string]: unknown;
+}
+export interface GenerateColumnOverlaysArgs {
+    oExtent: string[];
+    projectedColumns: {
+        [key: string]: ProjectedColumn;
+    };
+    rScale: {
+        range: () => number[];
+    };
+    pieArcs: PieArc[];
+    padding: number;
+    projection: ProjectionTypes;
+    customDoubleClickBehavior?: Function;
+    customClickBehavior?: Function;
+    customHoverBehavior?: Function;
+}
+export declare function generateColumnOverlays({ oExtent, projectedColumns, rScale, pieArcs, padding, projection, customDoubleClickBehavior, customClickBehavior, customHoverBehavior }: GenerateColumnOverlaysArgs): Record<string, any>[];
+export {};

package/dist/processing/ordinalRenderPipeline.d.ts

@@ -0,0 +1,148 @@
+import * as React from "react";
+import { orFrameConnectionRenderer } from "../svg/frameFunctions";
+import { OrdinalFrameProps, OrdinalFrameState, PieceTypeSettings, ProjectedOrdinalSummary } from "../types/ordinalTypes";
+import { AxisProps } from "../types/annotationTypes";
+import { MarginType, GenericAccessor } from "../types/generalTypes";
+import { ScaleBand, ScaleLinear } from "d3-scale";
+export interface AssembleRenderPipelineArgs {
+    usesPieceOverlays: boolean;
+    shouldRecalculateOverlay: boolean;
+    calculatedPieceData: Record<string, any>[];
+    projection: string;
+    customClickBehavior?: Function;
+    customDoubleClickBehavior?: Function;
+    customHoverBehavior?: Function;
+    currentState: OrdinalFrameState;
+    connectorStyle: Function;
+    connectorClass: Function;
+    connectorRenderMode: Function;
+    connectorCanvasRender: Function;
+    summaryCanvasRender: Function;
+    pieceCanvasRender: Function;
+    connectorType: Record<string, any>;
+    eventListenersGenerator: () => Record<string, never>;
+    pieceType: PieceTypeSettings;
+    summaryStyle: Function;
+    summaryClass: Function;
+    pieceStyle: Function;
+    pieceClass: Function;
+    keyedData: {
+        [key: string]: Record<string, any>[];
+    };
+    oExtent: string[];
+    projectedColumns: {
+        [key: string]: Record<string, any>;
+    };
+    calculatedSummaries: ProjectedOrdinalSummary;
+    oAccessor: Function[];
+    rScale: ScaleLinear<number, number>;
+    calculatedRExtent: number[];
+    calculatedOExtent: string[];
+    rExtentSettings: Record<string, any>;
+    oExtentSettings: {
+        extent?: string[];
+        onChange?: Function;
+    };
+    adjustedPosition: number[];
+    adjustedSize: number[];
+    margin: MarginType;
+    backgroundGraphics?: React.ReactNode | Function;
+    foregroundGraphics?: React.ReactNode | Function;
+    arrayWrappedAxis?: AxisProps[];
+    axis: React.ReactNode[];
+    axesTickLines: object[];
+    oLabels: React.ReactNode;
+    title: object;
+    columnOverlays: Record<string, any>[];
+    oScaleType: ScaleBand<string>;
+    instantiatedRScaleType: ScaleLinear<number, number>;
+    oScale: ScaleBand<string>;
+    rExtent: number[];
+    legend?: object | boolean;
+    pieceIDAccessor: GenericAccessor<string>;
+    currentProps: OrdinalFrameProps;
+}
+export declare function assembleRenderPipeline(args: AssembleRenderPipelineArgs): {
+    adjustedPosition: number[];
+    adjustedSize: number[];
+    backgroundGraphics: Function | React.ReactNode;
+    foregroundGraphics: Function | React.ReactNode;
+    axisData: AxisProps[];
+    axes: React.ReactNode[];
+    axesTickLines: object[];
+    oLabels: {
+        labels: React.ReactNode;
+    };
+    title: object;
+    columnOverlays: Record<string, any>[];
+    renderNumber: number;
+    oScaleType: ScaleBand<string>;
+    rScaleType: ScaleLinear<number, number, never>;
+    oExtent: string[];
+    rExtent: number[];
+    oScale: ScaleBand<string>;
+    rScale: ScaleLinear<number, number, never>;
+    calculatedOExtent: string[];
+    calculatedRExtent: number[];
+    projectedColumns: {
+        [key: string]: Record<string, any>;
+    };
+    margin: MarginType;
+    legendSettings: any;
+    orFrameRender: {
+        connectors: {
+            accessibleTransform: (data: any, i: any) => any;
+            projection: string;
+            data: object[];
+            styleFn: Function;
+            classFn: Function;
+            renderMode: Function;
+            canvasRender: Function;
+            behavior: typeof orFrameConnectionRenderer;
+            type: Record<string, any>;
+            eventListenersGenerator: () => Record<string, never>;
+            pieceType: PieceTypeSettings;
+        };
+        summaries: {
+            accessibleTransform: (data: any, i: any) => {
+                type: string;
+                column: Record<string, any>;
+                pieces: any;
+                summary: any;
+                oAccessor: Function[];
+            };
+            data: object[];
+            behavior: ({ data, canvasRender, canvasDrawing }: {
+                data: any;
+                canvasRender: any;
+                canvasDrawing: any;
+            }) => JSX.Element[];
+            canvasRender: Function;
+            styleFn: Function;
+            classFn: Function;
+        };
+        pieces: {
+            accessibleTransform: (data: any, i: any) => any;
+            shouldRender: boolean;
+            data: Record<string, any>[];
+            behavior: ({ data, shouldRender, canvasRender, canvasDrawing, styleFn, classFn, renderKeyFn, ariaLabel, axis }: {
+                data: any;
+                shouldRender: any;
+                canvasRender: any;
+                canvasDrawing: any;
+                styleFn: any;
+                classFn: any;
+                renderKeyFn: any;
+                ariaLabel: any;
+                axis: any;
+            }) => any[];
+            canvasRender: Function;
+            styleFn: Function;
+            classFn: Function;
+            axis: AxisProps[];
+            ariaLabel: any;
+        };
+    };
+    pieceIDAccessor: GenericAccessor<string>;
+    props: OrdinalFrameProps<Record<string, any>>;
+};

package/dist/processing/xyDrawing.d.ts

@@ -0,0 +1,140 @@
+import * as React from "react";
+import { XYFrameProps, XYFrameState } from "../types/xyTypes";
+import { XYPipelineCache } from "../data/xyPipelineCache";
+import { createPoints, createLines, createSummaries } from "../visualizationLayerBehavior/general";
+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: import("../types/generalTypes").ProjectedLine[];
+    projectedPoints: import("../types/generalTypes").ProjectedPoint[];
+    projectedSummaries: ProjectedSummary[];
+    canvasDrawing: any[];
+    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-network").AxisProps[];
+    axes: any;
+    axesTickLines: any;
+    renderNumber: number;
+    xScale: any;
+    yScale: any;
+    xAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+    yAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+    xExtent: any[];
+    yExtent: any[];
+    calculatedXExtent: any[];
+    calculatedYExtent: any[];
+    margin: import("../types/generalTypes").MarginType;
+    legendSettings: any;
+    areaAnnotations: any[];
+    xyFrameRender: {
+        lines: {
+            customMark: Function;
+            type: LineTypeSettings;
+            defined: Function;
+            renderKeyFn: (d?: Record<string, any>, i?: number) => string;
+            ariaLabel: {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            } | {
+                items: string;
+                chart: string;
+            };
+            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: 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?: Record<string, any>, i?: number) => string;
+            behavior: typeof createSummaries;
+        };
+        points: {
+            customMark: object | Function;
+            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: {
+        lineType: LineTypeSettings;
+        summaryType: SummaryTypeSettings;
+        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<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;