semiotic 2.0.3 → 3.0.0-beta.1

package/dist/charts/xy/StackedAreaChart.d.ts

@@ -0,0 +1,131 @@
+import * as React from "react";
+import type { XYFrameProps } from "../../types/xyTypes";
+import type { BaseChartProps, AxisConfig, ChartAccessor } from "../shared/types";
+import { type TooltipProp } from "../../Tooltip/Tooltip";
+/**
+ * StackedAreaChart component props
+ */
+export interface StackedAreaChartProps<TDatum extends Record<string, any> = Record<string, any>> extends BaseChartProps, AxisConfig {
+    /**
+     * Array of data points, grouped by category.
+     * @example
+     * ```ts
+     * [{x: 1, y: 10, category: 'A'}, {x: 2, y: 20, category: 'A'}, {x: 1, y: 15, category: 'B'}]
+     * ```
+     */
+    data: TDatum[];
+    /**
+     * Field name or function to access x values
+     * @default "x"
+     */
+    xAccessor?: ChartAccessor<TDatum, number>;
+    /**
+     * Field name or function to access y values
+     * @default "y"
+     */
+    yAccessor?: ChartAccessor<TDatum, number>;
+    /**
+     * Field name or function to group data into multiple areas
+     * @example
+     * ```ts
+     * areaBy="category"  // Group by category field
+     * areaBy={d => d.group}  // Use function
+     * ```
+     */
+    areaBy?: ChartAccessor<TDatum, string>;
+    /**
+     * Field name in area objects that contains coordinate arrays
+     * Used when data is in area objects format
+     * @default "coordinates"
+     */
+    lineDataAccessor?: string;
+    /**
+     * Field name or function to determine area color
+     * @example
+     * ```ts
+     * colorBy="category"
+     * colorBy={d => d.label}
+     * ```
+     */
+    colorBy?: ChartAccessor<TDatum, string>;
+    /**
+     * Color scheme for categorical data or custom colors array
+     * @default "category10"
+     */
+    colorScheme?: string | string[];
+    /**
+     * Curve interpolation type
+     * @default "monotoneX"
+     */
+    curve?: "linear" | "monotoneX" | "monotoneY" | "step" | "stepAfter" | "stepBefore" | "basis" | "cardinal" | "catmullRom";
+    /**
+     * Area opacity
+     * @default 0.7
+     */
+    areaOpacity?: number;
+    /**
+     * Show line on top of area
+     * @default true
+     */
+    showLine?: boolean;
+    /**
+     * Line stroke width when showLine is true
+     * @default 2
+     */
+    lineWidth?: number;
+    /**
+     * Normalize to 100% stacked (proportional)
+     * @default false
+     */
+    normalize?: boolean;
+    /**
+     * Enable hover annotations
+     * @default true
+     */
+    enableHover?: boolean;
+    /**
+     * Show grid lines
+     * @default false
+     */
+    showGrid?: boolean;
+    /**
+     * Show legend for multiple areas
+     * @default true (when multiple areas)
+     */
+    showLegend?: boolean;
+    /**
+     * Tooltip configuration
+     */
+    tooltip?: TooltipProp;
+    /**
+     * Additional XYFrame props for advanced customization
+     * For full control, consider using XYFrame directly
+     * @see https://semiotic.nteract.io/guides/xy-frame
+     */
+    frameProps?: Partial<Omit<XYFrameProps, "lines" | "size">>;
+}
+/**
+ * StackedAreaChart - Visualize quantities stacked on top of each other over continuous intervals
+ *
+ * Each series is stacked so that the total height represents the sum of all series.
+ * Use `normalize` for 100% stacked (proportional) areas.
+ *
+ * For overlapping (non-stacked) areas use {@link AreaChart}.
+ *
+ * @example
+ * ```tsx
+ * <StackedAreaChart
+ *   data={[
+ *     {x: 1, y: 10, category: 'A'},
+ *     {x: 2, y: 20, category: 'A'},
+ *     {x: 1, y: 15, category: 'B'},
+ *     {x: 2, y: 25, category: 'B'}
+ *   ]}
+ *   areaBy="category"
+ *   colorBy="category"
+ *   xLabel="Time"
+ *   yLabel="Value"
+ * />
+ * ```
+ */
+export declare function StackedAreaChart<TDatum extends Record<string, any> = Record<string, any>>(props: StackedAreaChartProps<TDatum>): React.JSX.Element;

package/dist/constants/frame_props.d.ts

@@ -1,4 +1,13 @@
 export declare const xyFrameDataProps: string[];
+export declare const xyFrameDataAffectingProps: string[];
+export declare const xyFrameScaleAffectingProps: string[];
+export declare const xyFrameStylingProps: string[];
 export declare const xyFrameChangeProps: string[];
+export declare const orFrameDataAffectingProps: string[];
+export declare const orFrameScaleAffectingProps: string[];
+export declare const orFrameStylingProps: string[];
 export declare const orFrameChangeProps: string[];
+export declare const networkFrameDataAffectingProps: string[];
+export declare const networkFrameScaleAffectingProps: string[];
+export declare const networkFrameStylingProps: string[];
 export declare const networkFrameChangeProps: string[];

package/dist/constants/jsx.d.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
-declare type FilterDefTypes = {
-    matte?: any;
+type FilterDefTypes = {
+    matte?: React.ReactNode;
     key: string;
     additionalDefs?: React.ReactNode;
 };

package/dist/data/dataFunctions.d.ts

@@ -1,8 +1,8 @@
-import { ProjectedPoint, ProjectedLine, ProjectedSummary, ProjectedBin, RawSummary, RawPoint, RawLine, LineTypeSettings, SummaryTypeSettings, GenericObject, ExtentType, MarginType } from "../types/generalTypes";
-declare type validStrFnTypes = boolean | string | number | GenericObject | GenericObject[] | RawPoint | RawPoint[];
-export declare function stringToFn<StrFnType extends validStrFnTypes>(accessor?: ((args?: GenericObject, index?: number) => StrFnType) | string | StrFnType, defaultAccessor?: (arg?: GenericObject, i?: number) => StrFnType, raw?: boolean): (d?: GenericObject, i?: number) => StrFnType;
-export declare function stringToArrayFn<StrFnType extends validStrFnTypes>(accessor?: ((arg?: GenericObject, index?: number) => StrFnType) | string | StrFnType | Array<((arg?: GenericObject, index?: number) => StrFnType) | string | StrFnType>, defaultAccessor?: (arg?: GenericObject, index?: number) => StrFnType, raw?: boolean): Array<(arg?: GenericObject, index?: number) => StrFnType>;
-declare type CalculateDataTypes = {
+import { ProjectedPoint, ProjectedLine, ProjectedSummary, ProjectedBin, RawSummary, RawPoint, RawLine, LineTypeSettings, SummaryTypeSettings, ExtentType, MarginType } from "../types/generalTypes";
+type validStrFnTypes = boolean | string | number | Record<string, any> | Record<string, any>[] | RawPoint | RawPoint[];
+export declare function stringToFn<StrFnType extends validStrFnTypes>(accessor?: ((args?: Record<string, any>, index?: number) => StrFnType) | string | StrFnType, defaultAccessor?: (arg?: Record<string, any>, i?: number) => StrFnType, raw?: boolean): (d?: Record<string, any>, i?: number) => StrFnType;
+export declare function stringToArrayFn<StrFnType extends validStrFnTypes>(accessor?: ((arg?: Record<string, any>, index?: number) => StrFnType) | string | StrFnType | Array<((arg?: Record<string, any>, index?: number) => StrFnType) | string | StrFnType>, defaultAccessor?: (arg?: Record<string, any>, index?: number) => StrFnType, raw?: boolean): Array<(arg?: Record<string, any>, index?: number) => StrFnType>;
+type CalculateDataTypes = {
     lineDataAccessor: Array<Function>;
     summaryDataAccessor: Array<Function>;
     summaryStyleFn: Function;
@@ -25,7 +25,6 @@ declare type CalculateDataTypes = {
     chartSize: Array<number>;
     xScaleType: Function;
     yScaleType: Function;
-    baseMarkProps?: object;
     margin: MarginType;
     defined?: Function;
     annotations: object[];
@@ -33,14 +32,14 @@ declare type CalculateDataTypes = {
     filterRenderedSummaries: (value: ProjectedSummary, index: number, array: ProjectedSummary[]) => any;
     filterRenderedPoints: (value: ProjectedPoint | ProjectedBin | ProjectedSummary, index: number, array: (ProjectedPoint | ProjectedBin | ProjectedSummary)[]) => any;
 };
-export declare const calculateDataExtent: ({ lineDataAccessor, xAccessor, yAccessor, summaries, points, lines, lineType, showLinePoints, showSummaryPoints, xExtent, yExtent, invertX, invertY, summaryDataAccessor, summaryType, adjustedSize: size, margin, baseMarkProps, summaryStyleFn, summaryClassFn, summaryRenderModeFn, chartSize, filterRenderedLines, filterRenderedSummaries, filterRenderedPoints, defined, annotations }: CalculateDataTypes) => {
-    xExtent: any[];
-    yExtent: any[];
+export declare const calculateDataExtent: ({ lineDataAccessor, xAccessor, yAccessor, summaries, points, lines, lineType, showLinePoints, showSummaryPoints, xExtent, yExtent, invertX, invertY, summaryDataAccessor, summaryType, adjustedSize: size, margin, summaryStyleFn, summaryClassFn, summaryRenderModeFn, chartSize, filterRenderedLines, filterRenderedSummaries, filterRenderedPoints, defined, annotations }: CalculateDataTypes) => {
+    xExtent: number[];
+    yExtent: number[];
     projectedLines: ProjectedLine[];
     projectedPoints: ProjectedPoint[];
     projectedSummaries: ProjectedSummary[];
-    fullDataset: (ProjectedPoint | ProjectedSummary | ProjectedBin)[];
-    calculatedXExtent: any[];
-    calculatedYExtent: any[];
+    fullDataset: (ProjectedPoint | ProjectedBin | ProjectedSummary)[];
+    calculatedXExtent: number[];
+    calculatedYExtent: number[];
 };
 export {};

package/dist/data/networkPipelineCache.d.ts

@@ -0,0 +1,27 @@
+export declare function createNetworkPipelineCache(): {
+    marginCalc: (margin: any, title: any, size: number[]) => {
+        margin: import("../semiotic-network").MarginType;
+        adjustedPosition: number[];
+        adjustedSize: number[];
+    };
+    accessorConversions: (nodeIDAccessor: any, sourceAccessor: any, targetAccessor: any, nodeSizeAccessor: any, edgeWidthAccessor: any) => {
+        nodeIDAccessor: (d?: Record<string, any>, i?: number) => string;
+        sourceAccessor: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        targetAccessor: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        nodeSizeAccessor: (() => any) | ((d?: Record<string, any>, i?: number) => number);
+        edgeWidthAccessor: (d?: Record<string, any>, i?: number) => number;
+    };
+    nodeStyleFns: (nodeStyle: any, nodeClass: any, nodeRenderMode: any, canvasNodes: any) => {
+        nodeStyleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        nodeClassFn: (d?: Record<string, any>, i?: number) => string;
+        nodeRenderModeFn: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        nodeCanvasRenderFn: (d?: Record<string, any>, i?: number) => boolean;
+    };
+    edgeStyleFns: (edgeStyle: any, edgeClass: any, edgeRenderMode: any, canvasEdges: any) => {
+        edgeStyleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        edgeClassFn: (d?: Record<string, any>, i?: number) => string;
+        edgeRenderModeFn: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        edgeCanvasRenderFn: (d?: Record<string, any>, i?: number) => boolean;
+    };
+};
+export type NetworkPipelineCache = ReturnType<typeof createNetworkPipelineCache>;

package/dist/data/ordinalPipelineCache.d.ts

@@ -0,0 +1,33 @@
+import { ProjectionTypes } from "../types/generalTypes";
+export declare function createOrdinalPipelineCache(): {
+    marginCalc: (margin: any, axes: any, title: any, oLabel: any, projection: ProjectionTypes, size: number[]) => {
+        margin: import("../types/generalTypes").MarginType;
+        adjustedPosition: number[];
+        adjustedSize: number[];
+    };
+    structureData: (data: any[], renderKey: any, oAccessor: Function[], rAccessor: Array<(d: number | object, i?: number) => number>, originalRAccessor: any[], originalOAccessor: any[], multiAxis: boolean) => {
+        allData: Array<object>;
+        multiExtents?: Array<Array<number>>;
+    };
+    accessorConversions: (baseOAccessor: any, baseRAccessor: any, baseRenderKey: any, basePieceIDAccessor: any) => {
+        oAccessor: ((arg?: Record<string, any>, index?: number) => string | number)[];
+        rAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+        renderKey: (d?: Record<string, any>, i?: number) => string | number;
+        pieceIDAccessor: (d?: Record<string, any>, i?: number) => string;
+    };
+    styleFns: (baseConnectorStyle: any, baseSummaryStyle: any, baseStyle: any, basePieceClass: any, baseSummaryClass: any, baseConnectorClass: any, baseRenderMode: any, baseSummaryRenderMode: any, baseConnectorRenderMode: any, canvasPieces: any, canvasSummaries: any, canvasConnectors: any) => {
+        connectorStyle: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        summaryStyle: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        pieceStyle: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        pieceClass: (d?: Record<string, any>, i?: number) => string;
+        summaryClass: (d?: Record<string, any>, i?: number) => string;
+        connectorClass: (d?: Record<string, any>, i?: number) => string;
+        pieceRenderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        summaryRenderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        connectorRenderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+        pieceCanvasRender: (d?: Record<string, any>, i?: number) => boolean;
+        summaryCanvasRender: (d?: Record<string, any>, i?: number) => boolean;
+        connectorCanvasRender: (d?: Record<string, any>, i?: number) => boolean;
+    };
+};
+export type OrdinalPipelineCache = ReturnType<typeof createOrdinalPipelineCache>;

package/dist/data/xyPipelineCache.d.ts

@@ -0,0 +1,35 @@
+import { RawPoint } from "../types/generalTypes";
+export declare function createXYPipelineCache(): {
+    annotatedSettings: (xAccessor: any, yAccessor: any, summaryDataAccessor: any, lineDataAccessor: any, renderKey: any, lineType: any, summaryType: any, lineIDAccessor: any) => {
+        xAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+        yAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
+        summaryDataAccessor: ((arg?: Record<string, any>, index?: number) => RawPoint<Record<string, any>>[])[];
+        lineDataAccessor: ((arg?: Record<string, any>, index?: number) => RawPoint<Record<string, any>>[])[];
+        renderKeyFn: (d?: Record<string, any>, i?: number) => string;
+        lineIDAccessor: (d?: Record<string, any>, i?: number) => string;
+    };
+    marginCalc: (margin: any, axes: any, title: any, size: number[]) => {
+        margin: import("../types/generalTypes").MarginType;
+        adjustedPosition: number[];
+        adjustedSize: number[];
+    };
+    summaryStyleFns: (summaryStyle: any, summaryClass: any, summaryRenderMode: any) => {
+        summaryStyleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+        summaryClassFn: (d?: Record<string, any>, i?: number) => string;
+        summaryRenderModeFn: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+    };
+    lineStyleFns: (lineStyle: any, lineClass: any, lineRenderMode: any, canvasLines: any) => {
+        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;
+    };
+    pointStyleFns: (pointStyle: any, pointClass: any, pointRenderMode: any, canvasPoints: any) => {
+        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;
+    };
+    summaryCanvasRender: (canvasSummaries: any) => (d?: Record<string, any>, i?: number) => boolean;
+};
+export type XYPipelineCache = ReturnType<typeof createXYPipelineCache>;

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import AnnotationLayer from "./AnnotationLayer";
 import DividedLine from "./DividedLine";
 import XYFrame from "./XYFrame";
@@ -22,97 +21,80 @@ import { ResponsiveOrdinalFrame } from "./ResponsiveOrdinalFrame";
 import { SparkXYFrame } from "./SparkXYFrame";
 import { SparkOrdinalFrame } from "./SparkOrdinalFrame";
 import { SparkNetworkFrame } from "./SparkNetworkFrame";
-import Mark from "./Mark/Mark";
 import { hexbinning, heatmapping } from "./svg/areaDrawing";
 import { nodesEdgesFromHierarchy } from "./processing/network";
+import { Scatterplot, LineChart, AreaChart, Heatmap, BubbleChart, BarChart, StackedBarChart, SwarmPlot, BoxPlot, DotPlot, PieChart, DonutChart, GroupedBarChart, ForceDirectedGraph, ChordDiagram, SankeyDiagram, TreeDiagram, Treemap, CirclePack, RealtimeLineChart, RealtimeBarChart, RealtimeSwarmChart, RealtimeWaterfallChart } from "./charts";
+import { Tooltip, MultiLineTooltip, normalizeTooltip } from "./Tooltip/Tooltip";
 declare const _default: {
-    AnnotationLayer: typeof AnnotationLayer;
+    AnnotationLayer: any;
     DividedLine: typeof DividedLine;
-    XYFrame: import("react").NamedExoticComponent<import("./semiotic").XYFrameProps>;
+    XYFrame: typeof import("./XYFrame").XYFrameInner;
     MinimapXYFrame: typeof MinimapXYFrame;
     MiniMap: (props: import("./MiniMap").MinimapProps) => import("react").JSX.Element;
     Brush: typeof Brush;
     Axis: typeof Axis;
     InteractionLayer: typeof InteractionLayer;
     VisualizationLayer: typeof VisualizationLayer;
-    OrdinalFrame: import("react").NamedExoticComponent<import("./semiotic").OrdinalFrameProps>;
+    OrdinalFrame: typeof import("./OrdinalFrame").OrdinalFrameInner;
     Annotation: typeof Annotation;
-    NetworkFrame: import("react").NamedExoticComponent<import("./semiotic").NetworkFrameProps>;
-    ResponsiveMinimapXYFrame: {
-        (props: import("./ResponsiveFrame").ResponsiveFrameProps & (import("./semiotic").OrdinalFrameProps | import("./semiotic").XYFrameProps | import("./semiotic").NetworkFrameProps)): import("react").JSX.Element;
-        isResizing: number;
-        displayName: string;
-    };
-    ResponsiveOrdinalFrame: {
-        (props: import("./ResponsiveFrame").ResponsiveFrameProps & (import("./semiotic").OrdinalFrameProps | import("./semiotic").XYFrameProps | import("./semiotic").NetworkFrameProps)): import("react").JSX.Element;
-        isResizing: number;
-        displayName: string;
-    };
-    ResponsiveNetworkFrame: {
-        (props: import("./ResponsiveFrame").ResponsiveFrameProps & (import("./semiotic").OrdinalFrameProps | import("./semiotic").XYFrameProps | import("./semiotic").NetworkFrameProps)): import("react").JSX.Element;
-        isResizing: number;
-        displayName: string;
-    };
-    ResponsiveXYFrame: {
-        (props: import("./ResponsiveFrame").ResponsiveFrameProps & (import("./semiotic").OrdinalFrameProps | import("./semiotic").XYFrameProps | import("./semiotic").NetworkFrameProps)): import("react").JSX.Element;
-        isResizing: number;
-        displayName: string;
-    };
-    SparkOrdinalFrame: (props: {
+    NetworkFrame: typeof import("./NetworkFrame").NetworkFrameInner;
+    ResponsiveMinimapXYFrame: <TDatum = Record<string, any>>(props: import("./ResponsiveFrame").ResponsiveFrameProps & import("./semiotic-xy").XYFrameProps<TDatum>) => JSX.Element;
+    ResponsiveOrdinalFrame: <TDatum = Record<string, any>>(props: import("./ResponsiveFrame").ResponsiveFrameProps & import("./semiotic-ordinal").OrdinalFrameProps<TDatum>) => JSX.Element;
+    ResponsiveNetworkFrame: <TNode = Record<string, any>, TEdge = Record<string, any>>(props: import("./ResponsiveFrame").ResponsiveFrameProps & import("./semiotic-network").NetworkFrameProps<TNode, TEdge>) => JSX.Element;
+    ResponsiveXYFrame: <TDatum = Record<string, any>>(props: import("./ResponsiveFrame").ResponsiveFrameProps & import("./semiotic-xy").XYFrameProps<TDatum>) => JSX.Element;
+    SparkOrdinalFrame: <TDatum = Record<string, any>>(props: import("./semiotic-ordinal").OrdinalFrameProps<TDatum> & {
         sparkStyle?: object;
         size?: number | number[];
-    }) => import("react").JSX.Element;
-    SparkNetworkFrame: (props: {
+    }) => JSX.Element;
+    SparkNetworkFrame: <TNode = Record<string, any>, TEdge = Record<string, any>>(props: import("./semiotic-network").NetworkFrameProps<TNode, TEdge> & {
         sparkStyle?: object;
         size?: number | number[];
-    }) => import("react").JSX.Element;
-    SparkXYFrame: (props: {
+    }) => JSX.Element;
+    SparkXYFrame: <TDatum = Record<string, any>>(props: import("./semiotic-xy").XYFrameProps<TDatum> & {
         sparkStyle?: object;
         size?: number | number[];
-    }) => import("react").JSX.Element;
+    }) => JSX.Element;
     Legend: typeof Legend;
-    Mark: typeof Mark;
     FacetController: typeof FacetController;
     funnelize: typeof funnelize;
-    calculateDataExtent: ({ lineDataAccessor, xAccessor, yAccessor, summaries, points, lines, lineType, showLinePoints, showSummaryPoints, xExtent, yExtent, invertX, invertY, summaryDataAccessor, summaryType, adjustedSize: size, margin, baseMarkProps, summaryStyleFn, summaryClassFn, summaryRenderModeFn, chartSize, filterRenderedLines, filterRenderedSummaries, filterRenderedPoints, defined, annotations }: {
-        lineDataAccessor: Function[];
-        summaryDataAccessor: Function[];
+    calculateDataExtent: ({ lineDataAccessor, xAccessor, yAccessor, summaries, points, lines, lineType, showLinePoints, showSummaryPoints, xExtent, yExtent, invertX, invertY, summaryDataAccessor, summaryType, adjustedSize: size, margin, summaryStyleFn, summaryClassFn, summaryRenderModeFn, chartSize, filterRenderedLines, filterRenderedSummaries, filterRenderedPoints, defined, annotations }: {
+        lineDataAccessor: Array<Function>;
+        summaryDataAccessor: Array<Function>;
         summaryStyleFn: Function;
         summaryClassFn: Function;
         summaryRenderModeFn: Function;
-        xAccessor: Function[];
-        yAccessor: Function[];
-        summaries?: import("./semiotic").RawSummary[];
-        points?: import("./semiotic").RawPoint[];
-        lines?: import("./semiotic").RawLine[];
-        lineType: import("./semiotic").LineTypeSettings;
-        showLinePoints?: string | boolean;
+        xAccessor: Array<Function>;
+        yAccessor: Array<Function>;
+        summaries?: Array<import("./semiotic-xy").RawSummary>;
+        points?: Array<import("./semiotic-xy").RawPoint>;
+        lines?: Array<import("./semiotic-xy").RawLine>;
+        lineType: import("./semiotic-xy").LineTypeSettings;
+        showLinePoints?: boolean | string;
         showSummaryPoints?: boolean;
-        xExtent?: import("./semiotic").ExtentType;
-        yExtent?: import("./semiotic").ExtentType;
+        xExtent?: import("./semiotic-network").ExtentType;
+        yExtent?: import("./semiotic-network").ExtentType;
         invertX?: boolean;
         invertY?: boolean;
-        summaryType: import("./semiotic").SummaryTypeSettings;
-        adjustedSize: number[];
-        chartSize: number[];
+        summaryType: import("./semiotic-xy").SummaryTypeSettings;
+        adjustedSize: Array<number>;
+        chartSize: Array<number>;
         xScaleType: Function;
         yScaleType: Function;
-        baseMarkProps?: object;
-        margin: import("./semiotic").MarginType;
+        margin: import("./semiotic-network").MarginType;
         defined?: Function;
         annotations: object[];
-        filterRenderedLines: (value: import("./semiotic").ProjectedLine, index: number, array: import("./semiotic").ProjectedLine[]) => any;
-        filterRenderedSummaries: (value: import("./semiotic").ProjectedSummary, index: number, array: import("./semiotic").ProjectedSummary[]) => any;
-        filterRenderedPoints: (value: import("./semiotic").ProjectedPoint | import("./semiotic").ProjectedSummary | import("./semiotic").ProjectedBin, index: number, array: (import("./semiotic").ProjectedPoint | import("./semiotic").ProjectedSummary | import("./semiotic").ProjectedBin)[]) => any;
+        filterRenderedLines: (value: import("./semiotic-xy").ProjectedLine, index: number, array: import("./semiotic-xy").ProjectedLine[]) => any;
+        filterRenderedSummaries: (value: import("./semiotic-xy").ProjectedSummary, index: number, array: import("./semiotic-xy").ProjectedSummary[]) => any;
+        filterRenderedPoints: (value: import("./semiotic-network").ProjectedPoint | import("./semiotic-xy").ProjectedBin | import("./semiotic-xy").ProjectedSummary, index: number, array: (import("./semiotic-network").ProjectedPoint | import("./semiotic-xy").ProjectedBin | import("./semiotic-xy").ProjectedSummary)[]) => any;
     }) => {
-        xExtent: any[];
-        yExtent: any[];
-        projectedLines: import("./semiotic").ProjectedLine[];
-        projectedPoints: import("./semiotic").ProjectedPoint[];
-        projectedSummaries: import("./semiotic").ProjectedSummary[];
-        fullDataset: (import("./semiotic").ProjectedPoint | import("./semiotic").ProjectedSummary | import("./semiotic").ProjectedBin)[];
-        calculatedXExtent: any[];
-        calculatedYExtent: any[];
+        xExtent: number[];
+        yExtent: number[];
+        projectedLines: import("./semiotic-xy").ProjectedLine[];
+        projectedPoints: import("./semiotic-network").ProjectedPoint[];
+        projectedSummaries: import("./semiotic-xy").ProjectedSummary[];
+        fullDataset: (import("./semiotic-network").ProjectedPoint | import("./semiotic-xy").ProjectedBin | import("./semiotic-xy").ProjectedSummary)[];
+        calculatedXExtent: number[];
+        calculatedYExtent: number[];
     };
     hexbinning: typeof hexbinning;
     heatmapping: typeof heatmapping;
@@ -120,6 +102,32 @@ declare const _default: {
         edges: any[];
         nodes: any[];
     };
+    Scatterplot: typeof Scatterplot;
+    LineChart: typeof LineChart;
+    AreaChart: typeof AreaChart;
+    Heatmap: typeof Heatmap;
+    BubbleChart: typeof BubbleChart;
+    BarChart: typeof BarChart;
+    StackedBarChart: typeof StackedBarChart;
+    SwarmPlot: typeof SwarmPlot;
+    BoxPlot: typeof BoxPlot;
+    DotPlot: typeof DotPlot;
+    PieChart: typeof PieChart;
+    DonutChart: typeof DonutChart;
+    GroupedBarChart: typeof GroupedBarChart;
+    ForceDirectedGraph: typeof ForceDirectedGraph;
+    ChordDiagram: typeof ChordDiagram;
+    SankeyDiagram: typeof SankeyDiagram;
+    TreeDiagram: typeof TreeDiagram;
+    Treemap: typeof Treemap;
+    CirclePack: typeof CirclePack;
+    RealtimeLineChart: import("react").ForwardRefExoticComponent<import("./charts").RealtimeLineChartProps & import("react").RefAttributes<import("./semiotic-realtime").RealtimeFrameHandle>>;
+    RealtimeBarChart: import("react").ForwardRefExoticComponent<import("./charts").RealtimeBarChartProps & import("react").RefAttributes<import("./semiotic-realtime").RealtimeFrameHandle>>;
+    RealtimeSwarmChart: import("react").ForwardRefExoticComponent<import("./charts").RealtimeSwarmChartProps & import("react").RefAttributes<import("./semiotic-realtime").RealtimeFrameHandle>>;
+    RealtimeWaterfallChart: import("react").ForwardRefExoticComponent<import("./charts").RealtimeWaterfallChartProps & import("react").RefAttributes<import("./semiotic-realtime").RealtimeFrameHandle>>;
+    Tooltip: typeof Tooltip;
+    MultiLineTooltip: typeof MultiLineTooltip;
+    normalizeTooltip: typeof normalizeTooltip;
 };
 export default _default;
-export { AnnotationLayer, DividedLine, XYFrame, MinimapXYFrame, MiniMap, Brush, Axis, InteractionLayer, VisualizationLayer, OrdinalFrame, Annotation, NetworkFrame, ResponsiveMinimapXYFrame, ResponsiveOrdinalFrame, ResponsiveNetworkFrame, ResponsiveXYFrame, SparkOrdinalFrame, SparkNetworkFrame, SparkXYFrame, Legend, Mark, funnelize, calculateDataExtent, FacetController, hexbinning, heatmapping, nodesEdgesFromHierarchy };
+export { AnnotationLayer, DividedLine, XYFrame, MinimapXYFrame, MiniMap, Brush, Axis, InteractionLayer, VisualizationLayer, OrdinalFrame, Annotation, NetworkFrame, ResponsiveMinimapXYFrame, ResponsiveOrdinalFrame, ResponsiveNetworkFrame, ResponsiveXYFrame, SparkOrdinalFrame, SparkNetworkFrame, SparkXYFrame, Legend, funnelize, calculateDataExtent, FacetController, hexbinning, heatmapping, nodesEdgesFromHierarchy, Scatterplot, LineChart, AreaChart, Heatmap, BubbleChart, BarChart, StackedBarChart, SwarmPlot, BoxPlot, DotPlot, PieChart, DonutChart, GroupedBarChart, ForceDirectedGraph, ChordDiagram, SankeyDiagram, TreeDiagram, Treemap, CirclePack, RealtimeLineChart, RealtimeBarChart, RealtimeSwarmChart, RealtimeWaterfallChart, Tooltip, MultiLineTooltip, normalizeTooltip };

package/dist/interactionLayerBehavior/InteractionCanvas.d.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { MarginType } from "../types/generalTypes";
-declare type InteractionCanvasProps = {
+type InteractionCanvasProps = {
     height: number;
     width: number;
     overlayRegions: Array<{