semiotic 2.0.1 → 2.0.3

package/dist/data/dataFunctions.d.ts

@@ -0,0 +1,46 @@
+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 = {
+    lineDataAccessor: Array<Function>;
+    summaryDataAccessor: Array<Function>;
+    summaryStyleFn: Function;
+    summaryClassFn: Function;
+    summaryRenderModeFn: Function;
+    xAccessor: Array<Function>;
+    yAccessor: Array<Function>;
+    summaries?: Array<RawSummary>;
+    points?: Array<RawPoint>;
+    lines?: Array<RawLine>;
+    lineType: LineTypeSettings;
+    showLinePoints?: boolean | string;
+    showSummaryPoints?: boolean;
+    xExtent?: ExtentType;
+    yExtent?: ExtentType;
+    invertX?: boolean;
+    invertY?: boolean;
+    summaryType: SummaryTypeSettings;
+    adjustedSize: Array<number>;
+    chartSize: Array<number>;
+    xScaleType: Function;
+    yScaleType: Function;
+    baseMarkProps?: object;
+    margin: MarginType;
+    defined?: Function;
+    annotations: object[];
+    filterRenderedLines: (value: ProjectedLine, index: number, array: ProjectedLine[]) => any;
+    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[];
+    projectedLines: ProjectedLine[];
+    projectedPoints: ProjectedPoint[];
+    projectedSummaries: ProjectedSummary[];
+    fullDataset: (ProjectedPoint | ProjectedSummary | ProjectedBin)[];
+    calculatedXExtent: any[];
+    calculatedYExtent: any[];
+};
+export {};

package/dist/data/multiAccessorUtils.d.ts

@@ -0,0 +1 @@
+export declare const findFirstAccessorValue: (accessorArray: any, data: any) => any;

package/dist/data/unflowedFunctions.d.ts

@@ -0,0 +1 @@
+export declare const extentValue: (extent: any) => any;

package/dist/generic_utilities/functions.d.ts

@@ -0,0 +1 @@
+export declare const genericFunction: (value: any) => () => any;

package/dist/index.d.ts

@@ -0,0 +1,125 @@
+/// <reference types="react" />
+import AnnotationLayer from "./AnnotationLayer";
+import DividedLine from "./DividedLine";
+import XYFrame from "./XYFrame";
+import OrdinalFrame from "./OrdinalFrame";
+import MinimapXYFrame from "./MinimapXYFrame";
+import MiniMap from "./MiniMap";
+import Axis from "./Axis";
+import Legend from "./Legend";
+import Annotation from "./Annotation";
+import Brush from "./Brush";
+import InteractionLayer from "./InteractionLayer";
+import VisualizationLayer from "./VisualizationLayer";
+import NetworkFrame from "./NetworkFrame";
+import { funnelize } from "./svg/lineDrawing";
+import { calculateDataExtent } from "./data/dataFunctions";
+import FacetController from "./FacetController";
+import { ResponsiveNetworkFrame } from "./ResponsiveNetworkFrame";
+import { ResponsiveMinimapXYFrame } from "./ResponsiveMinimapXYFrame";
+import { ResponsiveXYFrame } from "./ResponsiveXYFrame";
+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";
+declare const _default: {
+    AnnotationLayer: typeof AnnotationLayer;
+    DividedLine: typeof DividedLine;
+    XYFrame: import("react").NamedExoticComponent<import("./semiotic").XYFrameProps>;
+    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>;
+    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: {
+        sparkStyle?: object;
+        size?: number | number[];
+    }) => import("react").JSX.Element;
+    SparkNetworkFrame: (props: {
+        sparkStyle?: object;
+        size?: number | number[];
+    }) => import("react").JSX.Element;
+    SparkXYFrame: (props: {
+        sparkStyle?: object;
+        size?: number | number[];
+    }) => import("react").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[];
+        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;
+        showSummaryPoints?: boolean;
+        xExtent?: import("./semiotic").ExtentType;
+        yExtent?: import("./semiotic").ExtentType;
+        invertX?: boolean;
+        invertY?: boolean;
+        summaryType: import("./semiotic").SummaryTypeSettings;
+        adjustedSize: number[];
+        chartSize: number[];
+        xScaleType: Function;
+        yScaleType: Function;
+        baseMarkProps?: object;
+        margin: import("./semiotic").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;
+    }) => {
+        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[];
+    };
+    hexbinning: typeof hexbinning;
+    heatmapping: typeof heatmapping;
+    nodesEdgesFromHierarchy: (baseRootNode: any, idAccessor?: (d: any) => any) => {
+        edges: any[];
+        nodes: any[];
+    };
+};
+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 };

package/dist/interactionLayerBehavior/InteractionCanvas.d.ts

@@ -0,0 +1,20 @@
+import * as React from "react";
+import { MarginType } from "../types/generalTypes";
+declare type InteractionCanvasProps = {
+    height: number;
+    width: number;
+    overlayRegions: Array<{
+        props: {
+            d?: string;
+            children: Array<{
+                props: {
+                    d?: string;
+                };
+            }>;
+        };
+    }>;
+    margin: MarginType;
+    voronoiHover: Function;
+};
+declare const _default: React.NamedExoticComponent<InteractionCanvasProps>;
+export default _default;

package/dist/processing/InteractionItems.d.ts

@@ -0,0 +1,12 @@
+import { CustomHoverType } from "../types/annotationTypes";
+import { InteractionLayerProps } from "../types/interactionTypes";
+export declare const changeVoronoi: (voronoiHover: Function, d: {
+    type?: string;
+    data?: object[];
+}, customHoverTypes: CustomHoverType, customHoverBehavior: Function, points: Object[], e: any) => void;
+export declare const clickVoronoi: (d: Object, customClickBehavior: Function, points: Object[], e: any) => void;
+export declare const doubleclickVoronoi: (d: Object, customDoubleClickBehavior: Function, points: Object[], e: any) => void;
+export declare const brushStart: (e?: number[] | number[][], columnName?: string, data?: object, columnData?: object, interaction?: any) => void;
+export declare const brushing: (e?: number[] | number[][], columnName?: string, data?: object, columnData?: object, interaction?: any) => void;
+export declare const brushEnd: (e?: number[] | number[][], columnName?: string, data?: object, columnData?: object, interaction?: any) => void;
+export declare const calculateOverlay: (props: InteractionLayerProps, voronoiHover: Function) => any[];

package/dist/processing/network.d.ts

@@ -0,0 +1,114 @@
+import * as React from "react";
+import { TitleType } from "../svg/frameFunctions";
+import { NetworkFrameProps, NetworkFrameState, NetworkSettingsType, NodeType } from "../types/networkTypes";
+import { GenericObject } from "../types/generalTypes";
+export declare const nodesEdgesFromHierarchy: (baseRootNode: any, idAccessor?: (d: any) => any) => {
+    edges: any[];
+    nodes: any[];
+};
+export declare const calculateNetworkFrame: (currentProps: NetworkFrameProps, prevState: NetworkFrameState) => {
+    adjustedPosition: number[];
+    adjustedSize: number[];
+    backgroundGraphics: Function | React.ReactNode;
+    foregroundGraphics: Function | React.ReactNode;
+    title: TitleType;
+    renderNumber: number;
+    projectedNodes: NodeType[];
+    projectedEdges: import("../types/networkTypes").EdgeType[];
+    projectedXYPoints: any;
+    overlay: any[];
+    nodeIDAccessor: (d?: GenericObject, i?: number) => string;
+    sourceAccessor: (d?: GenericObject, i?: number) => string | GenericObject;
+    targetAccessor: (d?: GenericObject, i?: number) => string | GenericObject;
+    nodeSizeAccessor: (args?: GenericObject) => number;
+    edgeWidthAccessor: (d?: GenericObject, i?: number) => number;
+    margin: import("../types/generalTypes").MarginType;
+    legendSettings: any;
+    networkFrameRender: {
+        edges: {
+            accessibleTransform: (data: any, i: any) => any;
+            data: import("../types/networkTypes").EdgeType[];
+            styleFn: (d?: GenericObject, i?: number) => GenericObject;
+            classFn: (d?: GenericObject, i?: number) => string;
+            renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
+            canvasRenderFn: (d?: GenericObject, i?: number) => boolean;
+            renderKeyFn: (d: any) => any;
+            behavior: (settings: any) => any[];
+            projection: "horizontal" | "vertical" | "radial";
+            type: string | Function;
+            customMark: any;
+            networkSettings: NetworkSettingsType;
+            numberOfNodes: number;
+            size: number[];
+        };
+        nodes: {
+            accessibleTransform: (data: any, i: any) => any;
+            data: NodeType[];
+            styleFn: (d?: GenericObject, i?: number) => GenericObject;
+            classFn: (d?: GenericObject, i?: number) => string;
+            renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
+            canvasRenderFn: (d?: GenericObject, i?: number) => boolean;
+            customMark: any;
+            behavior: ({ data, renderKeyFn, customMark, styleFn, classFn, renderMode, canvasDrawing, canvasRenderFn, baseMarkProps, networkSettings }: {
+                data: any;
+                renderKeyFn: any;
+                customMark: any;
+                styleFn: any;
+                classFn: any;
+                renderMode: any;
+                canvasDrawing: any;
+                canvasRenderFn: any;
+                baseMarkProps: any;
+                networkSettings: any;
+            }) => any[];
+            renderKeyFn: (args: GenericObject) => string;
+            networkSettings: NetworkSettingsType;
+        };
+    };
+    nodeLabelAnnotations: any[];
+    graphSettings: {
+        type: string | (({ edges, nodes }: {
+            edges: import("../types/networkTypes").EdgeType[];
+            nodes: NodeType[];
+        }) => void);
+        hierarchyChildren?: Function;
+        hierarchySum?: Function;
+        layout?: Function;
+        nodeSize?: Function;
+        nodes: object[];
+        edges: object;
+        iterations?: number;
+        width?: number;
+        height?: number;
+        projection?: "horizontal" | "vertical" | "radial";
+        customSankey?: Function;
+        groupWidth?: number;
+        padAngle?: number;
+        padding?: number;
+        orient?: string;
+        nodePadding?: number;
+        nodePaddingRatio?: number;
+        nodeWidth?: number;
+        direction?: string;
+        fontSize?: number;
+        rotate?: Function;
+        fontWeight?: number;
+        textAccessor?: Function;
+        edgeStrength?: number;
+        distanceMax?: number;
+        edgeDistance?: number;
+        forceManyBody?: number | Function;
+        hierarchicalNetwork: boolean;
+        graphSettings: import("../types/networkTypes").GraphSettingsType;
+        sortGroups?: Function;
+        simulation?: Function;
+        sort?: (a: GenericObject, b: GenericObject) => number;
+        zoom?: boolean | "stretch" | ((nodes: NodeType[], edges: import("../types/networkTypes").EdgeType[], size: number[]) => void);
+        fixExistingNodes?: boolean | Function;
+        showArrows?: boolean;
+        nodeHash: Map<any, NodeType>;
+        edgeHash: Map<any, import("../types/networkTypes").EdgeType>;
+        filterRenderedNodes?: Function;
+    };
+    props: NetworkFrameProps;
+};

package/dist/processing/ordinal.d.ts

@@ -0,0 +1,102 @@
+import * as React from "react";
+import { orFrameConnectionRenderer } from "../svg/frameFunctions";
+import { OrdinalFrameProps, OrdinalFrameState, PieceTypeSettings } from "../types/ordinalTypes";
+import { AxisProps } from "../types/annotationTypes";
+import { GenericObject } from "../types/generalTypes";
+import { ScaleBand } from "d3-scale";
+export declare const calculateMappedMiddles: (oScale: ScaleBand<string>, middleMax: number, padding: number) => {};
+export declare const calculateOrdinalFrame: (currentProps: OrdinalFrameProps, currentState: OrdinalFrameState) => {
+    pieceDataXY: any;
+    adjustedPosition: number[];
+    adjustedSize: number[];
+    backgroundGraphics: Function | React.ReactNode;
+    foregroundGraphics: Function | React.ReactNode;
+    axisData: AxisProps[];
+    axes: JSX.Element[];
+    axesTickLines: Object[];
+    oLabels: {
+        labels: any;
+    };
+    title: object;
+    columnOverlays: any;
+    renderNumber: number;
+    oAccessor: ((arg?: GenericObject, index?: number) => string | number)[];
+    rAccessor: ((arg?: GenericObject, index?: number) => number)[];
+    oScaleType: any;
+    rScaleType: any;
+    oExtent: string[];
+    rExtent: number[];
+    oScale: any;
+    rScale: any;
+    calculatedOExtent: string[];
+    calculatedRExtent: number[];
+    projectedColumns: {};
+    margin: import("../types/generalTypes").MarginType;
+    legendSettings: any;
+    orFrameRender: {
+        connectors: {
+            accessibleTransform: (data: any, i: any) => any;
+            projection: import("../types/generalTypes").ProjectionTypes;
+            data: {
+                keyedData: any;
+                oExtent: string[];
+            };
+            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;
+            behavior: typeof orFrameConnectionRenderer;
+            type: {
+                type?: string | Function;
+            };
+            eventListenersGenerator: () => {};
+            pieceType: PieceTypeSettings;
+        };
+        summaries: {
+            accessibleTransform: (data: any, i: any) => {
+                type: string;
+                column: any;
+                pieces: any;
+                summary: any;
+                oAccessor: ((arg?: GenericObject, index?: number) => string | number)[];
+            };
+            data: object[];
+            behavior: ({ data, canvasRender, canvasDrawing }: {
+                data: any;
+                canvasRender: any;
+                canvasDrawing: any;
+            }) => JSX.Element[];
+            canvasRender: (d?: GenericObject, i?: number) => boolean;
+            styleFn: (d?: GenericObject, i?: number) => GenericObject;
+            classFn: (d?: GenericObject, i?: number) => string;
+        };
+        pieces: {
+            accessibleTransform: (data: any, i: any) => any;
+            shouldRender: boolean;
+            data: any[];
+            behavior: ({ data, shouldRender, canvasRender, canvasDrawing, styleFn, classFn, baseMarkProps, renderKeyFn, ariaLabel, axis }: {
+                data: any;
+                shouldRender: any;
+                canvasRender: any;
+                canvasDrawing: any;
+                styleFn: any;
+                classFn: any;
+                baseMarkProps: any;
+                renderKeyFn: any;
+                ariaLabel: any;
+                axis: any;
+            }) => any[];
+            canvasRender: (d?: GenericObject, i?: number) => boolean;
+            styleFn: (d?: GenericObject, i?: number) => GenericObject;
+            classFn: (d?: GenericObject, i?: number) => string;
+            axis: AxisProps[];
+            ariaLabel: any;
+        };
+    };
+    summaryType: {
+        type?: string | Function;
+    };
+    type: PieceTypeSettings;
+    pieceIDAccessor: (d?: GenericObject, i?: number) => string;
+    props: OrdinalFrameProps;
+};

package/dist/processing/xyDrawing.d.ts

@@ -0,0 +1,135 @@
+import * as React from "react";
+import { XYFrameProps, XYFrameState } from "../types/xyTypes";
+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[];
+    dataVersion: string;
+    projectedLines: ProjectedLine[];
+    projectedPoints: import("../types/generalTypes").ProjectedPoint[];
+    projectedSummaries: import("../types/generalTypes").ProjectedSummary[];
+    canvasDrawing: any[];
+    fullDataset: (import("../types/generalTypes").ProjectedPoint | import("../types/generalTypes").ProjectedSummary | import("../types/generalTypes").ProjectedBin)[];
+    adjustedPosition: number[];
+    adjustedSize: number[];
+    backgroundGraphics: Function | React.ReactNode;
+    foregroundGraphics: Function | React.ReactNode;
+    axesData: import("../semiotic").AxisProps[];
+    axes: any;
+    axesTickLines: any;
+    renderNumber: number;
+    xScale: any;
+    yScale: any;
+    xAccessor: ((arg?: GenericObject, index?: number) => number)[];
+    yAccessor: ((arg?: GenericObject, index?: number) => number)[];
+    xExtent: any[];
+    yExtent: any[];
+    calculatedXExtent: any[];
+    calculatedYExtent: any[];
+    margin: import("../types/generalTypes").MarginType;
+    legendSettings: any;
+    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;
+            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").AxisProps[];
+            behavior: typeof createLines;
+        };
+        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;
+            customMark: Function;
+            type: SummaryTypeSettings;
+            renderKeyFn: (d?: GenericObject, 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;
+            showLinePoints: string | boolean;
+            behavior: typeof createPoints;
+        };
+    };
+    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[];
+        title: object;
+        xExtent: number[];
+        yExtent: number[];
+    };
+    overlay: any;
+    props: XYFrameProps;
+};

package/dist/semiotic.d.ts

@@ -1,35 +1,35 @@
-import AnnotationLayer from "./AnnotationLayer";
-import DividedLine from "./DividedLine";
-import XYFrame from "./XYFrame";
-import OrdinalFrame from "./OrdinalFrame";
-import MinimapXYFrame from "./MinimapXYFrame";
-import MiniMap from "./MiniMap";
-import Axis from "./Axis";
-import Legend from "./Legend";
-import Annotation from "./Annotation";
-import Brush from "./Brush";
-import InteractionLayer from "./InteractionLayer";
-import VisualizationLayer from "./VisualizationLayer";
-import NetworkFrame from "./NetworkFrame";
-import { funnelize } from "./svg/lineDrawing";
-import { calculateDataExtent } from "./data/dataFunctions";
-import FacetController from "./FacetController";
-import { ResponsiveNetworkFrame } from "./ResponsiveNetworkFrame";
-import { ResponsiveMinimapXYFrame } from "./ResponsiveMinimapXYFrame";
-import { ResponsiveXYFrame } from "./ResponsiveXYFrame";
-import { ResponsiveOrdinalFrame } from "./ResponsiveOrdinalFrame";
-import { SparkXYFrame } from "./SparkXYFrame";
-import { SparkOrdinalFrame } from "./SparkOrdinalFrame";
-import { SparkNetworkFrame } from "./SparkNetworkFrame";
-import Mark from "../components/Mark/Mark";
-import { hexbinning, heatmapping } from "./svg/areaDrawing";
-import { nodesEdgesFromHierarchy } from "./processing/network";
-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 { NodeType, EdgeType, GraphSettingsType, NetworkSettingsType, NetworkFrameState, NetworkFrameProps } from "./types/networkTypes";
-export { AnnotationType, CustomHoverType, AnnotationTypes, AnnotationHandling, AnnotationProps, AxisProps, AxisGeneratingFunction } from "./types/annotationTypes";
-export { ContextType } from "./types/canvasTypes";
-export { GenericObject, MarginType, ProjectionTypes, ExtentType, ProjectedPoint, PieceLayoutType, ProjectedLine, ProjectedSummary, RoughType, CanvasPostProcessTypes, ExtentSettingsType, accessorType, AccessorFnType, BasicLineTypes, LineTypeSettings, BasicSummaryTypes, SummaryTypeSettings, RawLine, RawSummary, RawPoint, CustomAreaMarkProps, ProjectedBin, GenericAccessor, VizLayerTypes, RenderPipelineType, OrdinalSummaryTypes, OrdinalSummaryTypeSettings, AxisSummaryTypeSettings, GeneralFrameProps, GeneralFrameState } from "./types/generalTypes";
-export { AdvancedInteractionSettings, Interactivity, InteractionLayerProps, VoronoiEntryType, BaseColumnType, InteractionLayerState } from "./types/interactionTypes";
-export { SupportedLegendGlyphs, ItemType, LegendItem, LegendGroup, LegendProps } from "./types/legendTypes";
-export { OExtentObject, PieceTypes, PieceTypeSettings, ProjectedOrdinalSummary, OrdinalFrameProps, OrdinalFrameState } from "./types/ordinalTypes";
-export { XYFrameProps, AnnotatedSettingsProps, XYFrameState, SummaryLayoutType } from "./types/xyTypes";
+import AnnotationLayer from "./AnnotationLayer/AnnotationLayer";
+import DividedLine from "./DividedLine";
+import XYFrame from "./XYFrame";
+import OrdinalFrame from "./OrdinalFrame";
+import MinimapXYFrame from "./MinimapXYFrame";
+import MiniMap from "./MiniMap";
+import Axis from "./Axis";
+import Legend from "./Legend";
+import Annotation from "./Annotation";
+import Brush from "./Brush";
+import InteractionLayer from "./InteractionLayer";
+import VisualizationLayer from "./VisualizationLayer";
+import NetworkFrame from "./NetworkFrame";
+import { funnelize } from "./svg/lineDrawing";
+import { calculateDataExtent } from "./data/dataFunctions";
+import FacetController from "./FacetController";
+import { ResponsiveNetworkFrame } from "./ResponsiveNetworkFrame";
+import { ResponsiveMinimapXYFrame } from "./ResponsiveMinimapXYFrame";
+import { ResponsiveXYFrame } from "./ResponsiveXYFrame";
+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";
+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 { NodeType, EdgeType, GraphSettingsType, NetworkSettingsType, NetworkFrameState, NetworkFrameProps } from "./types/networkTypes";
+export { AnnotationType, CustomHoverType, AnnotationTypes, AnnotationHandling, AnnotationProps, AxisProps, AxisGeneratingFunction } from "./types/annotationTypes";
+export { ContextType } from "./types/canvasTypes";
+export { GenericObject, MarginType, ProjectionTypes, ExtentType, ProjectedPoint, PieceLayoutType, ProjectedLine, ProjectedSummary, RoughType, CanvasPostProcessTypes, ExtentSettingsType, accessorType, AccessorFnType, BasicLineTypes, LineTypeSettings, BasicSummaryTypes, SummaryTypeSettings, RawLine, RawSummary, RawPoint, CustomAreaMarkProps, ProjectedBin, GenericAccessor, VizLayerTypes, RenderPipelineType, OrdinalSummaryTypes, OrdinalSummaryTypeSettings, AxisSummaryTypeSettings, GeneralFrameProps, GeneralFrameState } from "./types/generalTypes";
+export { AdvancedInteractionSettings, Interactivity, InteractionLayerProps, VoronoiEntryType, BaseColumnType, InteractionLayerState } from "./types/interactionTypes";
+export { SupportedLegendGlyphs, ItemType, LegendItem, LegendGroup, LegendProps } from "./types/legendTypes";
+export { OExtentObject, PieceTypes, PieceTypeSettings, ProjectedOrdinalSummary, OrdinalFrameProps, OrdinalFrameState } from "./types/ordinalTypes";
+export { XYFrameProps, AnnotatedSettingsProps, XYFrameState, SummaryLayoutType } from "./types/xyTypes";