semiotic 2.0.3 → 3.0.0-beta.2

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

@@ -0,0 +1,73 @@
+import * as React from "react";
+import type { StreamXYFrameProps } from "../../stream/types";
+import type { BaseChartProps, AxisConfig, ChartAccessor } from "../shared/types";
+import { type TooltipProp } from "../../Tooltip/Tooltip";
+export interface MinimapConfig {
+    /** Height of the minimap overview (default: 60) */
+    height?: number;
+    /** Margin for the minimap chart */
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    /** Line style override for the minimap */
+    lineStyle?: (d: Record<string, any>) => Record<string, any>;
+    /** Show axes in minimap (default: false) */
+    showAxes?: boolean;
+    /** Background color for minimap */
+    background?: string;
+    /** Brush direction: "x" (default) or "y" */
+    brushDirection?: "x" | "y";
+}
+export interface MinimapChartProps<TDatum extends Record<string, any> = Record<string, any>> extends BaseChartProps, AxisConfig {
+    /** Array of data points or line objects with coordinates */
+    data: TDatum[];
+    /** X accessor (default: "x") */
+    xAccessor?: ChartAccessor<TDatum, number>;
+    /** Y accessor (default: "y") */
+    yAccessor?: ChartAccessor<TDatum, number>;
+    /** Group data into multiple lines */
+    lineBy?: ChartAccessor<TDatum, string>;
+    /** Field containing coordinate arrays in line objects (default: "coordinates") */
+    lineDataAccessor?: string;
+    /** Color-by field or function */
+    colorBy?: ChartAccessor<TDatum, string>;
+    /** Color scheme (default: "category10") */
+    colorScheme?: string | string[];
+    /** Curve type (default: "linear") */
+    curve?: "linear" | "monotoneX" | "monotoneY" | "step" | "stepAfter" | "stepBefore" | "basis" | "cardinal" | "catmullRom";
+    /** Line stroke width (default: 2) */
+    lineWidth?: number;
+    /** Fill area under lines */
+    fillArea?: boolean;
+    /** Area opacity when fillArea is true (default: 0.3) */
+    areaOpacity?: number;
+    /** Show points on lines */
+    showPoints?: boolean;
+    /** Point radius (default: 3) */
+    pointRadius?: number;
+    /** Enable hover (default: true) */
+    enableHover?: boolean;
+    /** Show grid (default: false) */
+    showGrid?: boolean;
+    /** Show legend */
+    showLegend?: boolean;
+    /** Tooltip config */
+    tooltip?: TooltipProp;
+    /** Minimap configuration */
+    minimap?: MinimapConfig;
+    /** Show minimap above the main chart (default: false — below) */
+    renderBefore?: boolean;
+    /** Callback when brush extent changes */
+    onBrush?: (extent: [number, number] | null) => void;
+    /** Controlled brush extent */
+    brushExtent?: [number, number];
+    /** Additional StreamXYFrame props */
+    frameProps?: Partial<Omit<StreamXYFrameProps, "chartType" | "data" | "size">>;
+}
+export declare function MinimapChart<TDatum extends Record<string, any> = Record<string, any>>(props: MinimapChartProps<TDatum>): React.JSX.Element;
+export declare namespace MinimapChart {
+    var displayName: string;
+}

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

@@ -0,0 +1,55 @@
+import * as React from "react";
+import type { StreamXYFrameProps, MarginalGraphicsConfig } from "../../stream/types";
+import type { BaseChartProps, AxisConfig, ChartAccessor } from "../shared/types";
+import { type TooltipProp } from "../../Tooltip/Tooltip";
+/**
+ * Scatterplot component props
+ */
+export interface ScatterplotProps<TDatum extends Record<string, any> = Record<string, any>> extends BaseChartProps, AxisConfig {
+    /** Array of data points. Each point should have x and y properties. */
+    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 determine point color */
+    colorBy?: ChartAccessor<TDatum, string>;
+    /** Color scheme for categorical data or custom colors array @default "category10" */
+    colorScheme?: string | string[];
+    /** Field name or function to determine point size */
+    sizeBy?: ChartAccessor<TDatum, number>;
+    /** Min and max radius for points @default [3, 15] */
+    sizeRange?: [number, number];
+    /** Default point radius when sizeBy is not specified @default 5 */
+    pointRadius?: number;
+    /** Point opacity @default 0.8 */
+    pointOpacity?: number;
+    /** Enable hover annotations @default true */
+    enableHover?: boolean;
+    /** Show grid lines @default false */
+    showGrid?: boolean;
+    /** Show legend @default true (when colorBy is specified) */
+    showLegend?: boolean;
+    /** Tooltip configuration */
+    tooltip?: TooltipProp;
+    /** Marginal distribution plots in axis margins */
+    marginalGraphics?: MarginalGraphicsConfig;
+    /** Additional StreamXYFrame props for advanced customization */
+    frameProps?: Partial<Omit<StreamXYFrameProps, "chartType" | "data" | "size">>;
+}
+/**
+ * Scatterplot - Visualize relationships between two continuous variables
+ *
+ * @example
+ * ```tsx
+ * <Scatterplot
+ *   data={[{x: 1, y: 10}, {x: 2, y: 20}]}
+ *   xLabel="Time"
+ *   yLabel="Value"
+ * />
+ * ```
+ */
+export declare function Scatterplot<TDatum extends Record<string, any> = Record<string, any>>(props: ScatterplotProps<TDatum>): React.JSX.Element;
+export declare namespace Scatterplot {
+    var displayName: string;
+}

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

@@ -0,0 +1,71 @@
+import * as React from "react";
+import type { BaseChartProps, ChartAccessor } from "../shared/types";
+import { type TooltipProp } from "../../Tooltip/Tooltip";
+export interface ScatterplotMatrixProps<TDatum extends Record<string, any> = Record<string, any>> extends BaseChartProps {
+    /** Array of data objects */
+    data: TDatum[];
+    /** Array of field names to include in the matrix */
+    fields: string[];
+    /** Optional display labels for fields */
+    fieldLabels?: Record<string, string>;
+    /** Field or function to determine point color */
+    colorBy?: ChartAccessor<TDatum, string>;
+    /** Color scheme @default "category10" */
+    colorScheme?: string | string[];
+    /** Size of each cell in pixels @default 150 */
+    cellSize?: number;
+    /** Gap between cells in pixels @default 4 */
+    cellGap?: number;
+    /** Point radius @default 2 */
+    pointRadius?: number;
+    /** Point opacity @default 0.5 */
+    pointOpacity?: number;
+    /** What to show on the diagonal @default "histogram" */
+    diagonal?: "histogram" | "density" | "label";
+    /** Number of histogram bins @default 20 */
+    histogramBins?: number;
+    /** Brush interaction mode @default "crossfilter" */
+    brushMode?: "crossfilter" | "intersect" | false;
+    /** Enable hover cross-highlighting @default true */
+    hoverMode?: boolean;
+    /** Opacity for unselected points @default 0.1 */
+    unselectedOpacity?: number;
+    /** Show grid lines @default false */
+    showGrid?: boolean;
+    /** Tooltip configuration */
+    tooltip?: TooltipProp;
+    /** Show legend @default true when colorBy is set */
+    showLegend?: boolean;
+    /** Field or function to identify each data point in tooltips. Defaults to "Row {index}" */
+    idAccessor?: string | ((d: TDatum) => string);
+}
+/**
+ * ScatterplotMatrix (SPLOM) — multi-dimensional scatter visualization
+ *
+ * Renders an N×N grid of scatterplots for all pairwise combinations of the
+ * specified fields. Diagonal cells show histograms. Supports two interaction
+ * modes:
+ *
+ * - **Hover** (default): hover a point to cross-highlight the same datum
+ *   in every cell. Set `hoverMode={true}` (the default).
+ * - **Brush**: drag to select a region in one cell; matching points are
+ *   highlighted across all cells (crossfilter: the brushed cell excludes
+ *   its own filter). Set `hoverMode={false}` to enable brush mode.
+ *
+ * The two modes are mutually exclusive — hover takes priority when enabled.
+ *
+ * @example
+ * ```tsx
+ * <ScatterplotMatrix
+ *   data={iris}
+ *   fields={["sepalLength", "sepalWidth", "petalLength", "petalWidth"]}
+ *   colorBy="species"
+ *   cellSize={160}
+ *   diagonal="histogram"
+ * />
+ * ```
+ */
+export declare function ScatterplotMatrix<TDatum extends Record<string, any> = Record<string, any>>(props: ScatterplotMatrixProps<TDatum>): React.JSX.Element;
+export declare namespace ScatterplotMatrix {
+    var displayName: string;
+}

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

@@ -0,0 +1,134 @@
+import * as React from "react";
+import type { StreamXYFrameProps } from "../../stream/types";
+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 StreamXYFrame props for advanced customization
+     * For full control, consider using StreamXYFrame directly
+     * @see https://semiotic.nteract.io/guides/xy-frame
+     */
+    frameProps?: Partial<Omit<StreamXYFrameProps, "chartType" | "data" | "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;
+export declare namespace StackedAreaChart {
+    var displayName: string;
+}

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/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[];
+    calculatedXExtent: number[];
+    calculatedYExtent: number[];
 };
 export {};

package/dist/data/transforms.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Data transform helpers for common data shapes.
+ * Import from "semiotic/data"
+ */
+/**
+ * Bin continuous data into histogram-ready format.
+ * Returns array of { category, value } objects suitable for BarChart.
+ */
+export declare function bin<T extends Record<string, any>>(data: T[], options: {
+    field: string;
+    bins?: number;
+    domain?: [number, number];
+}): {
+    category: string;
+    value: number;
+}[];
+/**
+ * Group and aggregate data.
+ * Returns array of { [groupBy]: string, value: number } objects.
+ */
+export declare function rollup<T extends Record<string, any>>(data: T[], options: {
+    groupBy: string;
+    value: string;
+    agg?: "sum" | "mean" | "count" | "min" | "max";
+}): Record<string, any>[];
+/**
+ * Group flat rows into line-chart-ready nested format.
+ * Returns array of { id, coordinates } objects for LineChart with lineBy.
+ */
+export declare function groupBy<T extends Record<string, any>>(data: T[], options: {
+    key: string;
+    fields?: string[];
+}): {
+    id: string;
+    coordinates: Record<string, any>[];
+}[];
+/**
+ * Pivot wide data to long format.
+ * Converts column-per-variable to row-per-variable.
+ */
+export declare function pivot<T extends Record<string, any>>(data: T[], options: {
+    columns: string[];
+    nameField?: string;
+    valueField?: string;
+}): Record<string, any>[];

package/dist/export/exportChart.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Export a semiotic chart to SVG or PNG from the browser.
+ *
+ * @example
+ * ```tsx
+ * const ref = useRef<HTMLDivElement>(null)
+ * // ... render chart inside ref ...
+ * <button onClick={() => exportChart(ref.current!)}>Download</button>
+ * ```
+ */
+export declare function exportChart(container: HTMLElement, options?: {
+    format?: "svg" | "png";
+    filename?: string;
+    scale?: number;
+    background?: string;
+}): Promise<void>;

package/dist/{svg → geometry}/areaDrawing.d.ts

@@ -1,23 +1,13 @@
 import { SummaryLayoutType } from "../types/xyTypes";
 import { ProjectedSummary } from "../types/generalTypes";
+export { contouring } from "./contourLayout";
+export { hexbinning } from "./hexbinLayout";
 export declare function lineBounding({ summaryType, data, defined }: {
     summaryType: any;
     data: any;
     defined: any;
 }): any[];
-export declare function contouring({ summaryType, data, finalXExtent, finalYExtent }: {
-    summaryType: any;
-    data: any;
-    finalXExtent: any;
-    finalYExtent: any;
-}): any[];
-export declare function hexbinning({ preprocess, processedData, summaryType: baseSummaryType, data: baseData, finalXExtent: baseXExtent, finalYExtent: baseYExtent, size, xScaleType, yScaleType, margin, baseMarkProps, styleFn, classFn, renderFn, chartSize }: SummaryLayoutType): any[] | {
-    type: string;
-    processedData: boolean;
-    coordinates: any[];
-    binMax: any;
-};
-export declare function heatmapping({ preprocess, processedData, summaryType: baseSummaryType, data: baseData, finalXExtent, finalYExtent, size, xScaleType, yScaleType, margin, baseMarkProps, styleFn, classFn, renderFn, chartSize }: SummaryLayoutType): ProjectedSummary | {
+export declare function heatmapping({ preprocess, processedData, summaryType: baseSummaryType, data: baseData, finalXExtent, finalYExtent, size, xScaleType, yScaleType, margin, styleFn, classFn, renderFn, chartSize }: SummaryLayoutType): ProjectedSummary | {
     x: number;
     y: number;
 }[];

package/dist/geometry/contourLayout.d.ts

@@ -0,0 +1,6 @@
+export declare function contouring({ summaryType, data, finalXExtent, finalYExtent }: {
+    summaryType: any;
+    data: any;
+    finalXExtent: any;
+    finalYExtent: any;
+}): any[];

package/dist/geometry/hexbinLayout.d.ts

@@ -0,0 +1,7 @@
+import { SummaryLayoutType } from "../types/xyTypes";
+export declare function hexbinning({ preprocess, processedData, summaryType: baseSummaryType, data: baseData, finalXExtent: baseXExtent, finalYExtent: baseYExtent, size, xScaleType, yScaleType, margin, styleFn, classFn, renderFn, chartSize }: SummaryLayoutType): any[] | {
+    type: string;
+    processedData: boolean;
+    coordinates: any[];
+    binMax: any;
+};

package/dist/{svg → geometry}/lineDrawing.d.ts

@@ -1,12 +1,11 @@
-import { ProjectedLine, ProjectedPoint, RawLine, RawSummary } from "../types/generalTypes";
-import { AnnotationType } from "../types/annotationTypes";
-declare type SummaryProjectionTypes = {
+import { ProjectedLine, RawLine, RawSummary } from "../types/generalTypes";
+type SummaryProjectionTypes = {
     data: Array<RawSummary>;
     summaryDataAccessor: Array<Function>;
     xAccessor: Array<Function>;
     yAccessor: Array<Function>;
 };
-declare type LineProjectionTypes = {
+type LineProjectionTypes = {
     data: Array<RawLine>;
     lineDataAccessor: Array<Function>;
     xProp: string;
@@ -18,13 +17,13 @@ declare type LineProjectionTypes = {
     xAccessor: Array<Function>;
     yAccessor: Array<Function>;
 };
-declare type DifferenceLineProps = {
+type DifferenceLineProps = {
     data: Array<ProjectedLine>;
     yProp: string;
     yPropTop: string;
     yPropBottom: string;
 };
-declare type StackedAreaTypes = {
+type StackedAreaTypes = {
     type: string;
     data: Array<ProjectedLine>;
     xProp: string;
@@ -34,7 +33,7 @@ declare type StackedAreaTypes = {
     yPropTop: string;
     yPropBottom: string;
 };
-declare type CumulativeLineTypes = {
+type CumulativeLineTypes = {
     type: string;
     data: Array<ProjectedLine>;
     yPropMiddle: string;
@@ -42,7 +41,7 @@ declare type CumulativeLineTypes = {
     yPropBottom: string;
     y1?: Function;
 };
-declare type LineChartTypes = {
+type LineChartTypes = {
     data: Array<ProjectedLine>;
     y1?: Function;
     x1?: Function;
@@ -53,21 +52,6 @@ declare type LineChartTypes = {
     xPropMiddle: string;
     xPropBottom: string;
 };
-declare type RelativeYTypes = {
-    point?: ProjectedPoint | AnnotationType;
-    projectedYMiddle: string;
-    projectedY: string;
-    yAccessor: Array<Function>;
-    yScale: Function;
-    showLinePoints?: boolean | string;
-};
-declare type RelativeXTypes = {
-    point?: ProjectedPoint | AnnotationType;
-    projectedXMiddle: string;
-    projectedX: string;
-    xAccessor: Array<Function>;
-    xScale: Function;
-};
 export declare const projectSummaryData: ({ data, summaryDataAccessor, xAccessor, yAccessor }: SummaryProjectionTypes) => any[];
 export declare const projectLineData: ({ data, lineDataAccessor, xProp, xPropTop, xPropBottom, yProp, yPropTop, yPropBottom, xAccessor, yAccessor }: LineProjectionTypes) => ProjectedLine[];
 export declare const differenceLine: ({ data, yProp, yPropTop, yPropBottom }: DifferenceLineProps) => ProjectedLine[];
@@ -84,16 +68,4 @@ export declare function funnelize({ data, steps, key }: {
     steps: Array<string>;
     key: string;
 }): any[];
-export declare function relativeY({ point, projectedY, yAccessor, yScale, showLinePoints }: RelativeYTypes): any;
-export declare function relativeX({ point, projectedXMiddle, projectedX, xAccessor, xScale }: RelativeXTypes): any;
-export declare function findPointByID({ point, idAccessor, lines, xScale, projectedX, xAccessor }: {
-    point: ProjectedPoint;
-    idAccessor: Function;
-    lines: {
-        data: ProjectedLine[];
-    };
-    xScale: Function;
-    projectedX: string;
-    xAccessor: Array<Function>;
-}): ProjectedPoint;
 export {};

package/dist/geometry/sankeyLinks.d.ts

@@ -0,0 +1,2 @@
+export declare const areaLink: (d: any) => string;
+export declare function circularAreaLink(link: any): any;

package/dist/geometry/summaryLayouts.d.ts

@@ -0,0 +1,45 @@
+import { ProjectionTypes } from "../types/generalTypes";
+type SummaryType = {
+    type: string | Function;
+};
+type ORFrameSummaryRendererTypes = {
+    data: Array<object>;
+    type: SummaryType;
+    renderMode: Function;
+    eventListenersGenerator: Function;
+    styleFn: Function;
+    classFn: Function;
+    projection: ProjectionTypes;
+    adjustedSize: Array<number>;
+    chartSize: number;
+    margin: object;
+    axisCreator?: Function;
+};
+export declare function orFrameSummaryRenderer({ data, type, renderMode, eventListenersGenerator, styleFn, classFn, projection, adjustedSize, chartSize, margin, axisCreator }: ORFrameSummaryRendererTypes): any;
+/**
+ * Main drawing function for summary visualizations
+ */
+export declare const drawSummaries: ({ data, type, renderMode, eventListenersGenerator, styleFn, classFn, projection, adjustedSize, margin, axisCreator }: {
+    data: object;
+    type: {
+        type?: string | Function;
+    };
+    renderMode: Function;
+    eventListenersGenerator: Function;
+    styleFn: Function;
+    classFn: Function;
+    projection: ProjectionTypes;
+    adjustedSize: number[];
+    margin: object;
+    axisCreator?: Function;
+}) => any;
+interface summaryInstruction {
+    Mark?: JSX.Element;
+    containerProps?: object;
+    elements: object[];
+}
+/**
+ * Converts summary instructions to rendered SVG elements
+ */
+export declare function summaryInstructionsToMarks(data: summaryInstruction[]): JSX.Element[];
+export {};