semiotic 2.0.3 → 3.0.0-beta.1

package/dist/types/generalTypes.d.ts

@@ -1,20 +1,18 @@
-/// <reference types="react" />
 import { CustomHoverType, AnnotationHandling } from "./annotationTypes";
 import { TitleType } from "../svg/frameFunctions";
 import { Interactivity, AdvancedInteractionSettings } from "./interactionTypes";
 import { LegendProps } from "./legendTypes";
 import { AxisProps } from "./annotationTypes";
-export declare type GenericObject = {
-    [key: string]: any;
-};
+/** @deprecated Use Record<string, any> instead */
+export type GenericObject = Record<string, any>;
 export interface MarginType {
     top: number;
     bottom: number;
     left: number;
     right: number;
 }
-export declare type ProjectionTypes = "vertical" | "horizontal" | "radial";
-export declare type ExtentType = number[] | {
+export type ProjectionTypes = "vertical" | "horizontal" | "radial";
+export type ExtentType = number[] | {
     extent?: number[];
     onChange?: Function;
     includeAnnotations?: boolean;
@@ -37,13 +35,13 @@ export interface ProjectedPoint {
     class?: Function | string;
     coordinates?: object[];
 }
-export declare type PieceLayoutType = (args: {
+export type PieceLayoutType = (args: {
     type: string | {
         type: string;
     };
-    data: any;
-    renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
-    eventListenersGenerator: any;
+    data: Record<string, any>;
+    renderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+    eventListenersGenerator: (d: object, i: number) => Record<string, Function>;
     styleFn: (d: object) => object;
     projection: string;
     classFn: (d: object) => string;
@@ -51,8 +49,7 @@ export declare type PieceLayoutType = (args: {
     chartSize: number[];
     margin: MarginType;
     rScale?: Function;
-    baseMarkProps: object;
-}) => GenericObject[];
+}) => Record<string, any>[];
 export interface ProjectedLine {
     data: ProjectedPoint[];
     key: string | number;
@@ -69,7 +66,7 @@ export interface ProjectedSummary {
     data: object[];
     y: number;
     x: number;
-    parentSummary?: GenericObject;
+    parentSummary?: Record<string, any>;
     bounds: object[] | number[];
     customMark?: Function;
     type?: string;
@@ -77,27 +74,28 @@ export interface ProjectedSummary {
     processedData?: boolean;
     binMax?: number;
 }
-export declare type RoughType = {
+export type RoughType = {
     canvas: Function;
     generator: Function;
 };
-export declare type CanvasPostProcessTypes = Function;
-export declare type ExtentSettingsType = {
+export type CanvasPostProcessTypes = Function;
+export type ExtentSettingsType = {
     extent?: Array<number>;
     onChange?: Function;
 };
-export declare type accessorType<ReturnValue> = string | ((args?: unknown, index?: number) => ReturnValue);
+export type accessorType<ReturnValue> = string | ((args?: unknown, index?: number) => ReturnValue);
+export type DataAccessor<TDatum, ReturnValue> = (keyof TDatum & string) | ((datum: TDatum, index?: number) => ReturnValue);
 export interface AccessorFnType {
-    <T>(arg: GenericObject): T;
+    <T>(arg: Record<string, any>): T;
 }
-export declare type BasicLineTypes = "line" | "area" | "summary" | "cumulative" | "cumulative-reverse" | "linepercent" | "stackedarea" | "stackedarea-invert" | "stackedpercent" | "bumparea" | "bumparea-invert" | "bumpline" | "stackedpercent-invert" | "difference";
+export type BasicLineTypes = "line" | "area" | "summary" | "cumulative" | "cumulative-reverse" | "linepercent" | "stackedarea" | "stackedarea-invert" | "stackedpercent" | "bumparea" | "bumparea-invert" | "bumpline" | "stackedpercent-invert" | "difference";
 export interface LineTypeSettings {
     type: BasicLineTypes | Function;
     simpleLine?: boolean;
     y1?: (d?: ProjectedPoint, index?: number) => number;
     interpolator: string | Function;
 }
-export declare type BasicSummaryTypes = "basic" | "contour" | "hexbin" | "heatmap" | "trendline" | "linebounds";
+export type BasicSummaryTypes = "basic" | "contour" | "hexbin" | "heatmap" | "trendline" | "linebounds";
 export interface SummaryTypeSettings {
     showSlope?: boolean;
     type: BasicSummaryTypes | Function;
@@ -112,19 +110,18 @@ export interface SummaryTypeSettings {
     binMax?: number;
     customMark?: Function;
 }
-export interface RawLine {
-    coordinates?: object[];
+export interface RawLine<TDatum = Record<string, any>> {
+    coordinates?: TDatum[];
 }
-export interface RawSummary {
-    processedData?: object[];
-    coordinates?: object[];
+export interface RawSummary<TDatum = Record<string, any>> {
+    processedData?: TDatum[];
+    coordinates?: TDatum[];
     preprocess?: boolean;
 }
-export interface RawPoint {
+export interface RawPoint<TDatum = Record<string, any>> {
 }
 export interface CustomAreaMarkProps {
     d: object;
-    baseMarkProps: object;
     margin: object;
     styleFn: Function;
     classFn: Function;
@@ -144,11 +141,11 @@ export interface ProjectedBin {
     parentSummary: object;
     centroid: boolean;
 }
-export declare type GenericAccessor<GenericValue> = (args?: GenericObject, index?: number) => GenericValue;
-export declare type VizLayerTypes = "pieces" | "summaries" | "connectors" | "edges" | "nodes" | "lines" | "points";
-export declare type RenderPipelineType = {
+export type GenericAccessor<GenericValue> = (args?: Record<string, any>, index?: number) => GenericValue;
+export type VizLayerTypes = "pieces" | "summaries" | "connectors" | "edges" | "nodes" | "lines" | "points";
+export type RenderPipelineType = {
     [key in VizLayerTypes]?: {
-        data?: any;
+        data?: object[];
         ariaLabel?: {
             chart?: string;
             items?: string;
@@ -157,8 +154,8 @@ export declare type RenderPipelineType = {
         styleFn?: Function;
     };
 };
-export declare type OrdinalSummaryTypes = "none" | "histogram" | "heatmap" | "violin" | "joy" | "ridgeline" | "boxplot" | "contour";
-export declare type OrdinalSummaryTypeSettings = {
+export type OrdinalSummaryTypes = "none" | "histogram" | "heatmap" | "violin" | "joy" | "ridgeline" | "boxplot" | "contour";
+export type OrdinalSummaryTypeSettings = {
     type: OrdinalSummaryTypes;
     amplitude?: number;
     eventListenersGenerator?: Function;
@@ -175,8 +172,13 @@ export interface AxisSummaryTypeSettings extends OrdinalSummaryTypeSettings {
     showPoints?: boolean;
     filter?: Function;
 }
+export interface TransitionConfig {
+    /** Duration in milliseconds. @default 300 */
+    duration?: number;
+    /** CSS easing function. @default "ease" */
+    ease?: string;
+}
 export interface GeneralFrameProps {
-    useSpans?: boolean;
     title?: string | object;
     margin?: number | {
         top?: number;
@@ -207,7 +209,6 @@ export interface GeneralFrameProps {
     tooltipContent?: Function;
     optimizeCustomTooltipPosition?: boolean;
     annotations?: object[];
-    baseMarkProps?: object;
     backgroundGraphics?: React.ReactNode | Function;
     foregroundGraphics?: React.ReactNode | Function;
     beforeElements?: React.ReactNode;
@@ -222,6 +223,7 @@ export interface GeneralFrameProps {
     disableCanvasInteraction?: boolean;
     interactionSettings?: AdvancedInteractionSettings;
     disableProgressiveRendering?: boolean;
+    transition?: boolean | TransitionConfig;
 }
 export interface GeneralFrameState {
     dataVersion?: string;

package/dist/types/interactionTypes.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="react" />
+import * as React from "react";
 import { ScaleLinear } from "d3-scale";
 import { CustomHoverType } from "./annotationTypes";
 import { MarginType } from "./generalTypes";
@@ -17,7 +17,7 @@ export interface Interactivity {
     projectedColumns?: object;
     startEmpty?: boolean;
 }
-export declare type InteractionLayerProps = {
+export type InteractionLayerProps = {
     name?: string;
     interaction?: Interactivity;
     overlay?: Array<object>;
@@ -38,11 +38,10 @@ export declare type InteractionLayerProps = {
     projectedX: string;
     projectedY: string;
     points?: Array<{
-        data: any;
+        data: Record<string, any>;
     }>;
     position?: number[];
     enabled?: boolean;
-    useSpans?: boolean;
     margin: MarginType;
     projection?: string;
     customDoubleClickBehavior?: Function;
@@ -54,21 +53,20 @@ export declare type InteractionLayerProps = {
     renderPipeline: object;
     advancedSettings?: AdvancedInteractionSettings;
 };
-export declare type VoronoiEntryType = {
+export type VoronoiEntryType = {
     voronoiX: number;
     voronoiY: number;
     coincidentPoints: object[];
     type?: string;
-    data?: object[];
+    data?: Record<string, any>;
 };
-export declare type BaseColumnType = {
+export type BaseColumnType = {
     x: number;
     width: number;
 };
-export declare type InteractionLayerState = {
+export type InteractionLayerState = {
     overlayRegions: Array<React.ReactElement>;
     props: InteractionLayerProps;
     canvasMap: Map<string, number>;
     interactionCanvas: React.ReactNode;
-    SpanOrDiv: Function;
 };

package/dist/types/legendTypes.d.ts

@@ -1,5 +1,5 @@
-export declare type SupportedLegendGlyphs = "fill" | "line";
-export declare type ItemType = SupportedLegendGlyphs | Function;
+export type SupportedLegendGlyphs = "fill" | "line";
+export type ItemType = SupportedLegendGlyphs | Function;
 export interface LegendItem {
     label: string;
 }

package/dist/types/networkTypes.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="react" />
-import { GenericObject, RenderPipelineType } from "./generalTypes";
+import { RenderPipelineType, DataAccessor } from "./generalTypes";
 import { GeneralFrameProps, GeneralFrameState } from "./generalTypes";
+import { NetworkLayoutMap } from "../processing/layouts/types";
 export interface NodeType {
     degree: number;
     inDegree: number;
@@ -38,7 +38,15 @@ export interface NodeType {
 }
 export interface EdgeType {
     circular?: boolean;
-    circularPathData?: any;
+    circularPathData?: {
+        sourceX: number;
+        sourceY: number;
+        leftFullExtent: number;
+        rightFullExtent: number;
+        verticalFullExtent: number;
+        targetX: number;
+        targetY: number;
+    };
     source?: NodeType;
     target?: NodeType;
     d?: string;
@@ -105,29 +113,29 @@ export interface NetworkSettingsType {
     graphSettings: GraphSettingsType;
     sortGroups?: Function;
     simulation?: Function;
-    sort?: (a: GenericObject, b: GenericObject) => number;
+    sort?: (a: Record<string, any>, b: Record<string, any>) => number;
     zoom?: boolean | "stretch" | ((nodes: NodeType[], edges: EdgeType[], size: number[]) => void);
     fixExistingNodes?: boolean | Function;
     showArrows?: boolean;
 }
-export interface NetworkFrameState extends GeneralFrameState {
+export interface NetworkFrameState<TNode = Record<string, any>, TEdge = Record<string, any>> extends GeneralFrameState {
     nodeData: object[];
     edgeData: object[];
     projectedNodes: NodeType[];
     projectedEdges: EdgeType[];
     projectedXYPoints: object[];
     overlay: object[];
-    nodeIDAccessor: (args: GenericObject) => string;
-    sourceAccessor: (args: GenericObject) => GenericObject | string;
-    targetAccessor: (args: GenericObject) => GenericObject | string;
-    nodeSizeAccessor: (args: GenericObject) => number;
-    edgeWidthAccessor: (args: GenericObject) => number;
+    nodeIDAccessor: (args: Record<string, any>) => string;
+    sourceAccessor: (args: Record<string, any>) => Record<string, any> | string;
+    targetAccessor: (args: Record<string, any>) => Record<string, any> | string;
+    nodeSizeAccessor: (args: Record<string, any>) => number;
+    edgeWidthAccessor: (args: Record<string, any>) => number;
     nodeLabelAnnotations: object[];
     graphSettings: GraphSettingsType;
     networkFrameRender: RenderPipelineType;
-    props: NetworkFrameProps;
+    props: NetworkFrameProps<TNode, TEdge>;
 }
-export interface NetworkFrameProps extends GeneralFrameProps {
+export interface NetworkFrameProps<TNode = Record<string, any>, TEdge = Record<string, any>> extends GeneralFrameProps {
     graph?: {
         nodes: NodeType[];
         edges: EdgeType[];
@@ -138,28 +146,30 @@ export interface NetworkFrameProps extends GeneralFrameProps {
         node: Function;
         edge: Function;
     };
-    nodes?: object[];
-    edges?: object[] | object;
+    nodes?: TNode[];
+    edges?: TEdge[] | TEdge;
     networkType?: string | object;
-    nodeStyle?: GenericObject | ((args: GenericObject) => GenericObject);
-    nodeClass?: string | ((args: GenericObject) => string);
-    canvasNodes?: boolean | ((args: GenericObject) => boolean);
-    edgeStyle?: GenericObject | ((args: GenericObject) => GenericObject);
-    edgeClass?: string | ((args: GenericObject) => string);
-    canvasEdges?: boolean | ((args: GenericObject) => boolean);
-    nodeRenderMode?: string | ((args: GenericObject) => string);
-    edgeRenderMode?: string | ((args: GenericObject) => string);
-    nodeLabels?: boolean | ((args: GenericObject) => JSX.Element | string | null);
-    edgeRenderKey?: (args: GenericObject) => string;
-    nodeRenderKey?: (args: GenericObject) => string;
-    edgeWidthAccessor?: string | ((args: GenericObject) => number);
-    nodeSizeAccessor?: string | ((args: GenericObject) => number);
-    targetAccessor?: string | ((args: GenericObject) => string | GenericObject);
-    sourceAccessor?: string | ((args: GenericObject) => string | GenericObject);
-    nodeIDAccessor?: string | ((args: GenericObject) => string);
+    nodeStyle?: Record<string, any> | ((args: Record<string, any>) => Record<string, any>);
+    nodeClass?: string | ((args: Record<string, any>) => string);
+    canvasNodes?: boolean | ((args: Record<string, any>) => boolean);
+    edgeStyle?: Record<string, any> | ((args: Record<string, any>) => Record<string, any>);
+    edgeClass?: string | ((args: Record<string, any>) => string);
+    canvasEdges?: boolean | ((args: Record<string, any>) => boolean);
+    nodeRenderMode?: string | ((args: Record<string, any>) => string);
+    edgeRenderMode?: string | ((args: Record<string, any>) => string);
+    nodeLabels?: boolean | ((args: Record<string, any>) => JSX.Element | string | null);
+    edgeRenderKey?: (args: Record<string, any>) => string;
+    nodeRenderKey?: (args: Record<string, any>) => string;
+    edgeWidthAccessor?: DataAccessor<TEdge, number>;
+    nodeSizeAccessor?: DataAccessor<TNode, number> | number;
+    targetAccessor?: DataAccessor<TEdge, string | Record<string, any>>;
+    sourceAccessor?: DataAccessor<TEdge, string | Record<string, any>>;
+    nodeIDAccessor?: DataAccessor<TNode, string>;
     edgeType?: string | Function;
     customNodeIcon?: Function;
     customEdgeIcon?: Function;
     renderOrder?: ReadonlyArray<"edges" | "nodes">;
     filterRenderedNodes?: (value?: NodeType, index?: number, array?: NodeType[]) => any;
+    /** @internal Layout map for tree-shaking optimization. Do not use directly. */
+    _layoutMap?: NetworkLayoutMap;
 }

package/dist/types/ordinalTypes.d.ts

@@ -1,23 +1,23 @@
-/// <reference types="react" />
 import { CustomHoverType } from "./annotationTypes";
-import { CanvasPostProcessTypes, ProjectionTypes, accessorType, GenericObject, GenericAccessor, RenderPipelineType, OrdinalSummaryTypeSettings, GeneralFrameState, GeneralFrameProps } from "./generalTypes";
+import { CanvasPostProcessTypes, ProjectionTypes, accessorType, DataAccessor, GenericAccessor, RenderPipelineType, OrdinalSummaryTypeSettings, GeneralFrameState, GeneralFrameProps } from "./generalTypes";
 import { ScaleLinear, ScaleBand } from "d3-scale";
 import { AxisProps, AxisGeneratingFunction } from "./annotationTypes";
-export declare type OExtentObject = {
+export type OExtentObject = {
     extent?: Array<string>;
     onChange?: Function;
 };
-declare type OExtentSettingsType = Array<string> | OExtentObject;
+type OExtentSettingsType = Array<string> | OExtentObject;
 interface RExtentObject {
     extent?: Array<number>;
     onChange?: Function;
     includeAnnotations?: boolean;
 }
-export declare type PieceTypes = "none" | "bar" | "clusterbar" | "point" | "swarm" | "timeline" | "barpercent";
+export type PieceTypes = "none" | "bar" | "clusterbar" | "point" | "swarm" | "timeline" | "barpercent";
 export interface PieceTypeSettings {
     type: PieceTypes;
     offsetAngle?: number;
     angleRange?: number[];
+    innerRadius?: number;
 }
 export interface ProjectedOrdinalSummary {
     originalData?: {
@@ -26,14 +26,14 @@ export interface ProjectedOrdinalSummary {
     };
     xyPoints?: object[];
     marks?: object[];
-    thresholds?: any;
+    thresholds?: number[];
 }
-export interface OrdinalFrameProps extends GeneralFrameProps {
+export interface OrdinalFrameProps<TDatum = Record<string, any>> extends GeneralFrameProps {
     type?: PieceTypes | PieceTypeSettings;
     summaryType?: OrdinalSummaryTypeSettings;
     connectorType?: Function;
-    rAccessor?: accessorType<number>;
-    oAccessor?: accessorType<string | number>;
+    rAccessor?: DataAccessor<TDatum, number> | DataAccessor<TDatum, number>[];
+    oAccessor?: DataAccessor<TDatum, string | number> | DataAccessor<TDatum, string | number>[];
     oExtent?: OExtentSettingsType;
     rExtent?: RExtentObject | number[];
     invertR?: boolean;
@@ -47,8 +47,8 @@ export interface OrdinalFrameProps extends GeneralFrameProps {
     connectorClass?: string | accessorType<string>;
     pieceClass?: string | accessorType<string>;
     summaryClass?: string | accessorType<string>;
-    connectorRenderMode?: string | accessorType<string | GenericObject>;
-    connectorStyle?: object | accessorType<GenericObject>;
+    connectorRenderMode?: string | accessorType<string | Record<string, any>>;
+    connectorStyle?: object | accessorType<Record<string, any>>;
     canvasConnectors?: boolean | accessorType<boolean>;
     summaryStyle?: object | accessorType<object>;
     style?: object | accessorType<object>;
@@ -56,23 +56,32 @@ export interface OrdinalFrameProps extends GeneralFrameProps {
     dynamicColumnWidth?: string | accessorType<number>;
     pieceIDAccessor?: string | accessorType<string>;
     ordinalAlign?: string;
-    oLabel?: boolean | ((labelValue: string, columnData: any, index: number, column: any) => string | Element);
+    oLabel?: boolean | ((labelValue: string, columnData: object[], index: number, column: {
+        name: string;
+        pieceData: object[];
+        x: number;
+        y: number;
+        middle: number;
+        width: number;
+        padding: number;
+        pieces: object[];
+    }) => string | Element);
     renderMode?: object | string | accessorType<string | object>;
     summaryRenderMode?: object | string | accessorType<string | object>;
     pixelColumnWidth?: number;
-    oScaleType?: any;
+    oScaleType?: ScaleBand<string>;
     rScaleType?: () => ScaleLinear<number, number>;
-    data: Array<object | number>;
+    data: TDatum[];
     oPadding?: number;
     axes?: AxisGeneratingFunction | AxisProps | Array<AxisProps | AxisGeneratingFunction>;
     renderOrder?: ReadonlyArray<"pieces" | "summaries" | "connectors">;
     multiAxis?: boolean;
 }
-export interface OrdinalFrameState extends GeneralFrameState {
+export interface OrdinalFrameState<TDatum = Record<string, any>> extends GeneralFrameState {
     pieceDataXY: Array<object>;
     axisData?: AxisProps[];
     axes?: React.ReactNode[];
-    axesTickLines?: any;
+    axesTickLines?: Object[];
     oLabels: {
         labels: React.ReactNode;
     };
@@ -92,12 +101,12 @@ export interface OrdinalFrameState extends GeneralFrameState {
     pieceIDAccessor: GenericAccessor<string>;
     type: object;
     summaryType: object;
-    props: OrdinalFrameProps;
+    props: OrdinalFrameProps<TDatum>;
 }
 export interface LabelSettingsType {
     orient?: string;
     padding?: number;
-    label?: any;
+    label?: boolean | Function;
     labelFormatter?: Function;
 }
 export {};

package/dist/types/xyTypes.d.ts

@@ -1,12 +1,11 @@
-/// <reference types="react" />
 import { AxisProps, AxisGeneratingFunction } from "./annotationTypes";
 import { TitleType } from "../svg/frameFunctions";
-import { GenericAccessor, RawLine, RawPoint, RawSummary, ExtentType, accessorType, LineTypeSettings, SummaryTypeSettings, ProjectedPoint, ProjectedBin, ProjectedSummary, ProjectedLine, RenderPipelineType, GeneralFrameState, GeneralFrameProps, MarginType } from "./generalTypes";
+import { GenericAccessor, DataAccessor, RawLine, RawPoint, RawSummary, ExtentType, accessorType, LineTypeSettings, SummaryTypeSettings, ProjectedPoint, ProjectedBin, ProjectedSummary, ProjectedLine, RenderPipelineType, GeneralFrameState, GeneralFrameProps, MarginType } from "./generalTypes";
 import { ScaleLinear } from "d3-scale";
-export interface XYFrameProps extends GeneralFrameProps {
-    lines?: RawLine[] | RawLine;
-    points?: RawPoint[];
-    summaries?: RawSummary[] | RawSummary;
+export interface XYFrameProps<TDatum = Record<string, any>> extends GeneralFrameProps {
+    lines?: RawLine<TDatum>[] | RawLine<TDatum>;
+    points?: TDatum[];
+    summaries?: RawSummary<TDatum>[] | RawSummary<TDatum>;
     axes?: Array<AxisProps | AxisGeneratingFunction>;
     xScaleType?: ScaleLinear<number, number>;
     yScaleType?: ScaleLinear<number, number>;
@@ -14,8 +13,8 @@ export interface XYFrameProps extends GeneralFrameProps {
     yExtent?: ExtentType;
     invertX?: boolean;
     invertY?: boolean;
-    xAccessor?: accessorType<number>;
-    yAccessor?: accessorType<number>;
+    xAccessor?: DataAccessor<TDatum, number> | DataAccessor<TDatum, number>[];
+    yAccessor?: DataAccessor<TDatum, number> | DataAccessor<TDatum, number>[];
     lineDataAccessor?: accessorType<RawPoint[]>;
     summaryDataAccessor?: accessorType<RawPoint[]>;
     lineType?: LineTypeSettings | string;
@@ -50,7 +49,7 @@ export interface XYFrameProps extends GeneralFrameProps {
     filterRenderedSummaries?: (value: ProjectedSummary, index: number, array: ProjectedSummary[]) => any;
     filterRenderedPoints?: (value: ProjectedPoint | ProjectedBin | ProjectedSummary, index: number, array: (ProjectedPoint | ProjectedBin | ProjectedSummary)[]) => any;
 }
-export declare type AnnotatedSettingsProps = {
+export type AnnotatedSettingsProps = {
     xAccessor?: GenericAccessor<number>[];
     yAccessor?: GenericAccessor<number>[];
     summaryDataAccessor?: GenericAccessor<RawPoint[]>[];
@@ -65,10 +64,10 @@ export declare type AnnotatedSettingsProps = {
     xExtent?: number[];
     yExtent?: number[];
 };
-export interface XYFrameState extends GeneralFrameState {
-    lineData?: RawLine[] | RawLine;
-    pointData?: RawPoint[] | RawPoint;
-    summaryData?: RawSummary[] | RawSummary;
+export interface XYFrameState<TDatum = Record<string, any>> extends GeneralFrameState {
+    lineData?: RawLine<TDatum>[] | RawLine<TDatum>;
+    pointData?: RawPoint<TDatum>[] | RawPoint<TDatum>;
+    summaryData?: RawSummary<TDatum>[] | RawSummary<TDatum>;
     projectedLines?: ProjectedLine[];
     projectedPoints?: ProjectedPoint[];
     projectedSummaries?: ProjectedSummary[];
@@ -90,8 +89,7 @@ export interface XYFrameState extends GeneralFrameState {
     size: number[];
     annotatedSettings: AnnotatedSettingsProps;
     overlay?: object[];
-    props: XYFrameProps;
-    SpanOrDiv: Function;
+    props: XYFrameProps<TDatum>;
 }
 export interface SummaryLayoutType {
     preprocess?: boolean;
@@ -110,7 +108,6 @@ export interface SummaryLayoutType {
     xScaleType?: ScaleLinear<Number, Number>;
     yScaleType?: ScaleLinear<Number, Number>;
     margin?: MarginType;
-    baseMarkProps?: object;
     styleFn?: Function;
     classFn?: Function;
     renderFn?: Function;

package/dist/useLegacyUnmountCallback.d.ts

@@ -1 +1,2 @@
-export declare function useLegacyUnmountCallback(props: any, state: any): void;
+import { GeneralFrameProps, GeneralFrameState } from "./types/generalTypes";
+export declare function useLegacyUnmountCallback(props: GeneralFrameProps, state: GeneralFrameState): void;

package/dist/visualizationLayerBehavior/axis.d.ts

@@ -1,8 +1,7 @@
 import * as React from "react";
-import { GenericObject } from "../types/generalTypes";
 import { ScaleLinear } from "d3-scale";
-declare type RenderModeFnType = (d: number, i: number) => string | GenericObject;
-declare type AxisPiecesFnType = {
+type RenderModeFnType = (d: number, i: number) => string | Record<string, any>;
+type AxisPiecesFnType = {
     renderMode?: RenderModeFnType;
     padding: number;
     scale: ScaleLinear<number, number>;
@@ -25,11 +24,10 @@ export declare const axisLabels: ({ axisParts, tickFormat, rotate, center, orien
     orient: any;
 }) => any;
 export declare const baselineGenerator: (orient: any, size: any, className: any) => React.JSX.Element;
-export declare const axisLines: ({ axisParts, orient, tickLineGenerator, baseMarkProps, className, jaggedBase, scale, showOutboundTickLines }: {
+export declare const axisLines: ({ axisParts, orient, tickLineGenerator, className, jaggedBase, scale, showOutboundTickLines }: {
     axisParts: object[];
     orient: string;
     tickLineGenerator: Function;
-    baseMarkProps?: GenericObject;
     className: string;
     jaggedBase?: boolean;
     scale: ScaleLinear<number, number>;

package/dist/visualizationLayerBehavior/general.d.ts

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { GenericObject, ProjectedSummary } from "../types/generalTypes";
+import { ProjectedSummary } from "../types/generalTypes";
 import { ScaleLinear } from "d3-scale";
 export declare const curveHash: {
     step: any;
@@ -23,7 +23,7 @@ export declare function lineGeneratorDecorator({ generator, projectedCoordinateN
     interpolator: any;
     simpleLine: any;
 }): void;
-export declare function createPoints({ xScale, yScale, canvasDrawing, data, projectedCoordinateNames, customMark, canvasRender, styleFn, classFn, renderKeyFn, renderMode, baseMarkProps, showLinePoints: baseShowLinePoints }: {
+export declare function createPoints({ xScale, yScale, canvasDrawing, data, projectedCoordinateNames, customMark, canvasRender, styleFn, classFn, renderKeyFn, renderMode, showLinePoints: baseShowLinePoints }: {
     xScale: any;
     yScale: any;
     canvasDrawing: any;
@@ -35,10 +35,9 @@ export declare function createPoints({ xScale, yScale, canvasDrawing, data, proj
     classFn: any;
     renderKeyFn: any;
     renderMode: any;
-    baseMarkProps: any;
     showLinePoints: any;
 }): any[];
-export declare function createLines({ xScale, yScale, canvasDrawing, data, projectedCoordinateNames, customMark, canvasRender, styleFn, classFn, renderMode, renderKeyFn, type, defined, baseMarkProps, ariaLabel, axesData }: {
+export declare function createLines({ xScale, yScale, canvasDrawing, data, projectedCoordinateNames, customMark, canvasRender, styleFn, classFn, renderMode, renderKeyFn, type, defined, ariaLabel, axesData }: {
     xScale: any;
     yScale: any;
     canvasDrawing: any;
@@ -52,11 +51,10 @@ export declare function createLines({ xScale, yScale, canvasDrawing, data, proje
     renderKeyFn: any;
     type: any;
     defined: any;
-    baseMarkProps: any;
     ariaLabel: any;
     axesData?: any[];
 }): any[];
-export declare function createSummaries({ xScale, yScale, canvasDrawing, data, canvasRender, styleFn, classFn, renderKeyFn, renderMode, baseMarkProps, customMark }: {
+export declare function createSummaries({ xScale, yScale, canvasDrawing, data, canvasRender, styleFn, classFn, renderKeyFn, renderMode, customMark }: {
     xScale: ScaleLinear<number, number>;
     yScale: ScaleLinear<number, number>;
     canvasDrawing?: object[];
@@ -66,19 +64,17 @@ export declare function createSummaries({ xScale, yScale, canvasDrawing, data, c
     classFn?: Function;
     renderKeyFn?: Function;
     renderMode?: Function;
-    baseMarkProps?: GenericObject;
     customMark?: Function;
 }): any[];
-export declare function clonedAppliedElement({ tx, ty, d, i, markProps, styleFn, renderFn, classFn, renderKeyFn, baseClass, yi }: {
+export declare function clonedAppliedElement({ tx, ty, d, i, markProps, styleFn, classFn, renderKeyFn, baseClass, yi }: {
     tx?: number;
     ty?: number;
-    d: GenericObject;
+    d: Record<string, any>;
     i: number;
-    markProps: GenericObject;
+    markProps: Record<string, any>;
     styleFn: Function;
-    renderFn: Function;
     classFn: Function;
     renderKeyFn: Function;
     baseClass: string;
     yi?: number;
-}): React.JSX.Element;
+}): React.CElement<{}, React.Component<{}, any, any>> | React.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>;