semiotic 2.0.3 → 3.0.0-beta.2

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,98 +1,5 @@
-/// <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 { SummaryTypeSettings, MarginType } from "./generalTypes";
 import { ScaleLinear } from "d3-scale";
-export interface XYFrameProps extends GeneralFrameProps {
-    lines?: RawLine[] | RawLine;
-    points?: RawPoint[];
-    summaries?: RawSummary[] | RawSummary;
-    axes?: Array<AxisProps | AxisGeneratingFunction>;
-    xScaleType?: ScaleLinear<number, number>;
-    yScaleType?: ScaleLinear<number, number>;
-    xExtent?: ExtentType;
-    yExtent?: ExtentType;
-    invertX?: boolean;
-    invertY?: boolean;
-    xAccessor?: accessorType<number>;
-    yAccessor?: accessorType<number>;
-    lineDataAccessor?: accessorType<RawPoint[]>;
-    summaryDataAccessor?: accessorType<RawPoint[]>;
-    lineType?: LineTypeSettings | string;
-    summaryType?: SummaryTypeSettings;
-    lineRenderMode?: string | object | Function;
-    pointRenderMode?: string | object | Function;
-    summaryRenderMode?: string | object | Function;
-    showLinePoints?: boolean | string;
-    showSummaryPoints?: boolean;
-    defined?: Function;
-    lineStyle?: GenericAccessor<object> | object;
-    pointStyle?: GenericAccessor<object> | object;
-    summaryStyle?: GenericAccessor<object> | object;
-    lineClass?: GenericAccessor<string> | string;
-    pointClass?: GenericAccessor<string> | string;
-    summaryClass?: GenericAccessor<string> | string;
-    canvasPoints?: GenericAccessor<boolean> | boolean;
-    canvasLines?: GenericAccessor<boolean> | boolean;
-    canvasSummaries?: GenericAccessor<boolean> | boolean;
-    customPointMark?: Function | object;
-    customLineMark?: Function;
-    customSummaryMark?: Function;
-    lineIDAccessor?: GenericAccessor<string> | string;
-    minimap?: object;
-    fullDataset?: Array<ProjectedPoint | ProjectedBin | ProjectedSummary>;
-    projectedLines?: ProjectedLine[];
-    projectedSummaries?: Array<ProjectedSummary>;
-    projectedPoints?: ProjectedPoint[];
-    renderOrder?: ReadonlyArray<"lines" | "points" | "summaries">;
-    useSummariesAsInteractionLayer?: boolean;
-    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 type AnnotatedSettingsProps = {
-    xAccessor?: GenericAccessor<number>[];
-    yAccessor?: GenericAccessor<number>[];
-    summaryDataAccessor?: GenericAccessor<RawPoint[]>[];
-    lineDataAccessor?: GenericAccessor<RawPoint[]>[];
-    renderKeyFn?: GenericAccessor<string>;
-    lineType?: LineTypeSettings;
-    summaryType?: SummaryTypeSettings;
-    lineIDAccessor?: GenericAccessor<string>;
-    summaries?: object[];
-    lines?: object[];
-    title?: TitleType;
-    xExtent?: number[];
-    yExtent?: number[];
-};
-export interface XYFrameState extends GeneralFrameState {
-    lineData?: RawLine[] | RawLine;
-    pointData?: RawPoint[] | RawPoint;
-    summaryData?: RawSummary[] | RawSummary;
-    projectedLines?: ProjectedLine[];
-    projectedPoints?: ProjectedPoint[];
-    projectedSummaries?: ProjectedSummary[];
-    fullDataset: Array<ProjectedPoint | ProjectedBin | ProjectedSummary>;
-    axesData?: AxisProps[];
-    axes?: React.ReactNode[];
-    axesTickLines?: React.ReactNode;
-    calculatedXExtent: number[];
-    calculatedYExtent: number[];
-    xAccessor: GenericAccessor<number>[];
-    yAccessor: GenericAccessor<number>[];
-    xScale: ScaleLinear<number, number>;
-    yScale: ScaleLinear<number, number>;
-    xExtent: number[];
-    yExtent: number[];
-    areaAnnotations: object[];
-    xyFrameRender: RenderPipelineType;
-    canvasDrawing: object[];
-    size: number[];
-    annotatedSettings: AnnotatedSettingsProps;
-    overlay?: object[];
-    props: XYFrameProps;
-    SpanOrDiv: Function;
-}
 export interface SummaryLayoutType {
     preprocess?: boolean;
     processedData?: boolean;
@@ -110,7 +17,6 @@ export interface SummaryLayoutType {
     xScaleType?: ScaleLinear<Number, Number>;
     yScaleType?: ScaleLinear<Number, Number>;
     margin?: MarginType;
-    baseMarkProps?: object;
     styleFn?: Function;
     classFn?: Function;
     renderFn?: Function;

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.DetailedReactHTMLElement<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement> | React.CElement<{}, React.Component<{}, any, any>>;