semiotic 2.0.2 → 3.0.0-beta.1

package/dist/types/generalTypes.d.ts

@@ -0,0 +1,238 @@
+import { CustomHoverType, AnnotationHandling } from "./annotationTypes";
+import { TitleType } from "../svg/frameFunctions";
+import { Interactivity, AdvancedInteractionSettings } from "./interactionTypes";
+import { LegendProps } from "./legendTypes";
+import { AxisProps } from "./annotationTypes";
+/** @deprecated Use Record<string, any> instead */
+export type GenericObject = Record<string, any>;
+export interface MarginType {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+export type ProjectionTypes = "vertical" | "horizontal" | "radial";
+export type ExtentType = number[] | {
+    extent?: number[];
+    onChange?: Function;
+    includeAnnotations?: boolean;
+};
+export interface ProjectedPoint {
+    x?: number;
+    y?: number;
+    xTop?: number;
+    xMiddle?: number;
+    xBottom?: number;
+    yTop?: number;
+    yMiddle?: number;
+    yBottom?: number;
+    parentSummary?: ProjectedSummary;
+    parentLine?: ProjectedLine;
+    percent?: number;
+    data?: object;
+    _XYFrameRank?: number;
+    style?: Function | object;
+    class?: Function | string;
+    coordinates?: object[];
+}
+export type PieceLayoutType = (args: {
+    type: string | {
+        type: string;
+    };
+    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;
+    adjustedSize: number[];
+    chartSize: number[];
+    margin: MarginType;
+    rScale?: Function;
+}) => Record<string, any>[];
+export interface ProjectedLine {
+    data: ProjectedPoint[];
+    key: string | number;
+    __lineIndex?: number;
+    coordinates: object[];
+}
+export interface ProjectedSummary {
+    _baseData: object[];
+    _xyfCoordinates: [number | Date, number | Date][];
+    coordinates: {
+        x: number;
+        y: number;
+    }[];
+    data: object[];
+    y: number;
+    x: number;
+    parentSummary?: Record<string, any>;
+    bounds: object[] | number[];
+    customMark?: Function;
+    type?: string;
+    curve?: Function;
+    processedData?: boolean;
+    binMax?: number;
+}
+export type RoughType = {
+    canvas: Function;
+    generator: Function;
+};
+export type CanvasPostProcessTypes = Function;
+export type ExtentSettingsType = {
+    extent?: Array<number>;
+    onChange?: Function;
+};
+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: Record<string, any>): T;
+}
+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 type BasicSummaryTypes = "basic" | "contour" | "hexbin" | "heatmap" | "trendline" | "linebounds";
+export interface SummaryTypeSettings {
+    showSlope?: boolean;
+    type: BasicSummaryTypes | Function;
+    label?: string | Function;
+    cellPx?: number;
+    xCellPx?: number;
+    yCellPx?: number;
+    bins?: number;
+    xBins?: number;
+    yBins?: number;
+    binValue?: Function;
+    binMax?: number;
+    customMark?: Function;
+}
+export interface RawLine<TDatum = Record<string, any>> {
+    coordinates?: TDatum[];
+}
+export interface RawSummary<TDatum = Record<string, any>> {
+    processedData?: TDatum[];
+    coordinates?: TDatum[];
+    preprocess?: boolean;
+}
+export interface RawPoint<TDatum = Record<string, any>> {
+}
+export interface CustomAreaMarkProps {
+    d: object;
+    margin: object;
+    styleFn: Function;
+    classFn: Function;
+    renderFn: Function;
+    chartSize: Function;
+    adjustedSize: number[];
+}
+export interface ProjectedBin {
+    x: number;
+    y: number;
+    binItems: object[];
+    customMark?: (props: CustomAreaMarkProps) => JSX.Element;
+    _xyfCoordinates: Array<number[]>;
+    value: number;
+    percent: number;
+    data: object;
+    parentSummary: object;
+    centroid: boolean;
+}
+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?: object[];
+        ariaLabel?: {
+            chart?: string;
+            items?: string;
+        };
+        behavior?: Function;
+        styleFn?: Function;
+    };
+};
+export type OrdinalSummaryTypes = "none" | "histogram" | "heatmap" | "violin" | "joy" | "ridgeline" | "boxplot" | "contour";
+export type OrdinalSummaryTypeSettings = {
+    type: OrdinalSummaryTypes;
+    amplitude?: number;
+    eventListenersGenerator?: Function;
+    flip?: boolean;
+    bins?: number;
+    axis?: AxisProps;
+};
+export interface AxisSummaryTypeSettings extends OrdinalSummaryTypeSettings {
+    summaryStyle?: object;
+    pointStyle?: object;
+    renderMode?: object | string;
+    summaryClass?: string;
+    r?: number;
+    showPoints?: boolean;
+    filter?: Function;
+}
+export interface TransitionConfig {
+    /** Duration in milliseconds. @default 300 */
+    duration?: number;
+    /** CSS easing function. @default "ease" */
+    ease?: string;
+}
+export interface GeneralFrameProps {
+    title?: string | object;
+    margin?: number | {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    } | ((args: object) => number | {
+        top?: number;
+        left?: number;
+        right?: number;
+        bottom?: number;
+    });
+    name?: string;
+    dataVersion?: string;
+    frameKey?: string;
+    size?: number[];
+    canvasPostProcess?: CanvasPostProcessTypes;
+    additionalDefs?: React.ReactNode;
+    className?: string;
+    customHoverBehavior?: Function;
+    customClickBehavior?: Function;
+    customDoubleClickBehavior?: Function;
+    hoverAnnotation?: CustomHoverType;
+    disableContext?: boolean;
+    interaction?: Interactivity;
+    svgAnnotationRules?: Function;
+    htmlAnnotationRules?: Function;
+    tooltipContent?: Function;
+    optimizeCustomTooltipPosition?: boolean;
+    annotations?: object[];
+    backgroundGraphics?: React.ReactNode | Function;
+    foregroundGraphics?: React.ReactNode | Function;
+    beforeElements?: React.ReactNode;
+    afterElements?: React.ReactNode;
+    annotationSettings?: AnnotationHandling;
+    renderKey?: string | GenericAccessor<string>;
+    legend?: object | boolean;
+    matte?: object;
+    onUnmount?: Function;
+    sketchyRenderingEngine?: RoughType;
+    frameRenderOrder?: Array<string>;
+    disableCanvasInteraction?: boolean;
+    interactionSettings?: AdvancedInteractionSettings;
+    disableProgressiveRendering?: boolean;
+    transition?: boolean | TransitionConfig;
+}
+export interface GeneralFrameState {
+    dataVersion?: string;
+    adjustedPosition: number[];
+    adjustedSize: number[];
+    backgroundGraphics?: React.ReactNode | Function;
+    foregroundGraphics?: React.ReactNode | Function;
+    title: TitleType;
+    margin: MarginType;
+    legendSettings?: LegendProps;
+    renderNumber: number;
+}

package/dist/types/interactionTypes.d.ts

@@ -0,0 +1,72 @@
+import * as React from "react";
+import { ScaleLinear } from "d3-scale";
+import { CustomHoverType } from "./annotationTypes";
+import { MarginType } from "./generalTypes";
+export interface AdvancedInteractionSettings {
+    voronoiClipping?: boolean | number;
+    voronoiFilter?: Function;
+}
+export interface Interactivity {
+    start?: Function;
+    during?: Function;
+    end?: Function;
+    brush?: string;
+    extent?: Array<number[]> | number[];
+    columnsBrush?: boolean;
+    projection?: string;
+    projectedColumns?: object;
+    startEmpty?: boolean;
+}
+export type InteractionLayerProps = {
+    name?: string;
+    interaction?: Interactivity;
+    overlay?: Array<object>;
+    oColumns?: object;
+    xScale: ScaleLinear<number, number>;
+    yScale: ScaleLinear<number, number>;
+    rScale?: ScaleLinear<number, number>;
+    svgSize: Array<number>;
+    hoverAnnotation?: CustomHoverType;
+    interactionOverflow?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+    size: Array<number>;
+    projectedYMiddle?: string;
+    projectedX: string;
+    projectedY: string;
+    points?: Array<{
+        data: Record<string, any>;
+    }>;
+    position?: number[];
+    enabled?: boolean;
+    margin: MarginType;
+    projection?: string;
+    customDoubleClickBehavior?: Function;
+    customClickBehavior?: Function;
+    customHoverBehavior?: Function;
+    canvasRendering?: boolean;
+    disableCanvasInteraction: boolean;
+    showLinePoints?: string;
+    renderPipeline: object;
+    advancedSettings?: AdvancedInteractionSettings;
+};
+export type VoronoiEntryType = {
+    voronoiX: number;
+    voronoiY: number;
+    coincidentPoints: object[];
+    type?: string;
+    data?: Record<string, any>;
+};
+export type BaseColumnType = {
+    x: number;
+    width: number;
+};
+export type InteractionLayerState = {
+    overlayRegions: Array<React.ReactElement>;
+    props: InteractionLayerProps;
+    canvasMap: Map<string, number>;
+    interactionCanvas: React.ReactNode;
+};

package/dist/types/legendTypes.d.ts

@@ -0,0 +1,20 @@
+export type SupportedLegendGlyphs = "fill" | "line";
+export type ItemType = SupportedLegendGlyphs | Function;
+export interface LegendItem {
+    label: string;
+}
+export interface LegendGroup {
+    type?: ItemType;
+    styleFn: Function;
+    items: LegendItem[];
+    label: string;
+}
+export interface LegendProps {
+    legendGroups?: LegendGroup[];
+    customClickBehavior?: Function;
+    title?: string;
+    width?: number;
+    height?: number;
+    orientation?: string;
+    position?: "left" | "right";
+}

package/dist/types/networkTypes.d.ts

@@ -0,0 +1,175 @@
+import { RenderPipelineType, DataAccessor } from "./generalTypes";
+import { GeneralFrameProps, GeneralFrameState } from "./generalTypes";
+import { NetworkLayoutMap } from "../processing/layouts/types";
+export interface NodeType {
+    degree: number;
+    inDegree: number;
+    outDegree: number;
+    id?: string;
+    createdByFrame?: boolean;
+    x: number;
+    y: number;
+    x1: number;
+    x0: number;
+    y1: number;
+    y0: number;
+    height: number;
+    width: number;
+    radius: number;
+    direction: string;
+    textHeight: number;
+    textWidth: number;
+    fontSize: number;
+    fontWeight?: number;
+    rotate?: number;
+    scale: number;
+    _NWFText?: string;
+    text?: string;
+    r: number;
+    nodeSize: number;
+    component: number;
+    shapeNode: boolean;
+    depth?: number;
+    d?: string;
+    index?: number;
+    zoomedHeight?: number;
+    zoomedWidth?: number;
+    value?: number;
+}
+export interface EdgeType {
+    circular?: boolean;
+    circularPathData?: {
+        sourceX: number;
+        sourceY: number;
+        leftFullExtent: number;
+        rightFullExtent: number;
+        verticalFullExtent: number;
+        targetX: number;
+        targetY: number;
+    };
+    source?: NodeType;
+    target?: NodeType;
+    d?: string;
+    x?: number;
+    y?: number;
+    y0?: number;
+    y1?: number;
+    sankeyWidth?: number;
+    direction?: string;
+    width?: number;
+    points?: Array<{
+        x: number;
+        y: number;
+    }>;
+    showArrows?: boolean;
+    ephemeral?: boolean;
+    value?: number;
+}
+export interface GraphSettingsType {
+    type: string | (({ edges, nodes }: {
+        edges: EdgeType[];
+        nodes: NodeType[];
+    }) => void);
+    nodes: object[];
+    edges: object[] | object;
+    nodeHash: Map<any, NodeType>;
+    edgeHash: Map<any, EdgeType>;
+    hierarchicalNetwork: boolean;
+    filterRenderedNodes?: Function;
+}
+export interface NetworkSettingsType {
+    type?: string | (({ edges, nodes }: {
+        edges: EdgeType[];
+        nodes: NodeType[];
+    }) => void);
+    hierarchyChildren?: Function;
+    hierarchySum?: Function;
+    layout?: Function;
+    nodeSize?: Function;
+    nodes?: NodeType[];
+    edges?: EdgeType[];
+    iterations?: number;
+    width?: number;
+    height?: number;
+    projection?: "horizontal" | "radial" | "vertical";
+    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?: Function | number;
+    hierarchicalNetwork: boolean;
+    graphSettings: GraphSettingsType;
+    sortGroups?: Function;
+    simulation?: Function;
+    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<TNode = Record<string, any>, TEdge = Record<string, any>> extends GeneralFrameState {
+    nodeData: object[];
+    edgeData: object[];
+    projectedNodes: NodeType[];
+    projectedEdges: EdgeType[];
+    projectedXYPoints: object[];
+    overlay: object[];
+    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<TNode, TEdge>;
+}
+export interface NetworkFrameProps<TNode = Record<string, any>, TEdge = Record<string, any>> extends GeneralFrameProps {
+    graph?: {
+        nodes: NodeType[];
+        edges: EdgeType[];
+    } | EdgeType[] | {
+        (): () => void;
+        nodes: Function;
+        edges: Function;
+        node: Function;
+        edge: Function;
+    };
+    nodes?: TNode[];
+    edges?: TEdge[] | TEdge;
+    networkType?: string | object;
+    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

@@ -0,0 +1,112 @@
+import { CustomHoverType } from "./annotationTypes";
+import { CanvasPostProcessTypes, ProjectionTypes, accessorType, DataAccessor, GenericAccessor, RenderPipelineType, OrdinalSummaryTypeSettings, GeneralFrameState, GeneralFrameProps } from "./generalTypes";
+import { ScaleLinear, ScaleBand } from "d3-scale";
+import { AxisProps, AxisGeneratingFunction } from "./annotationTypes";
+export type OExtentObject = {
+    extent?: Array<string>;
+    onChange?: Function;
+};
+type OExtentSettingsType = Array<string> | OExtentObject;
+interface RExtentObject {
+    extent?: Array<number>;
+    onChange?: Function;
+    includeAnnotations?: boolean;
+}
+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?: {
+        x?: number;
+        y?: number;
+    };
+    xyPoints?: object[];
+    marks?: object[];
+    thresholds?: number[];
+}
+export interface OrdinalFrameProps<TDatum = Record<string, any>> extends GeneralFrameProps {
+    type?: PieceTypes | PieceTypeSettings;
+    summaryType?: OrdinalSummaryTypeSettings;
+    connectorType?: Function;
+    rAccessor?: DataAccessor<TDatum, number> | DataAccessor<TDatum, number>[];
+    oAccessor?: DataAccessor<TDatum, string | number> | DataAccessor<TDatum, string | number>[];
+    oExtent?: OExtentSettingsType;
+    rExtent?: RExtentObject | number[];
+    invertR?: boolean;
+    projection?: ProjectionTypes;
+    summaryHoverAnnotation?: CustomHoverType;
+    pieceHoverAnnotation?: CustomHoverType;
+    hoverAnnotation?: CustomHoverType;
+    canvasPostProcess?: CanvasPostProcessTypes;
+    canvasPieces?: boolean | accessorType<boolean>;
+    canvasSummaries?: boolean | accessorType<boolean>;
+    connectorClass?: string | accessorType<string>;
+    pieceClass?: string | accessorType<string>;
+    summaryClass?: string | accessorType<string>;
+    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>;
+    oSort?: (a: string, b: string, c: object[], d: object[]) => number;
+    dynamicColumnWidth?: string | accessorType<number>;
+    pieceIDAccessor?: string | accessorType<string>;
+    ordinalAlign?: string;
+    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?: ScaleBand<string>;
+    rScaleType?: () => ScaleLinear<number, number>;
+    data: TDatum[];
+    oPadding?: number;
+    axes?: AxisGeneratingFunction | AxisProps | Array<AxisProps | AxisGeneratingFunction>;
+    renderOrder?: ReadonlyArray<"pieces" | "summaries" | "connectors">;
+    multiAxis?: boolean;
+}
+export interface OrdinalFrameState<TDatum = Record<string, any>> extends GeneralFrameState {
+    pieceDataXY: Array<object>;
+    axisData?: AxisProps[];
+    axes?: React.ReactNode[];
+    axesTickLines?: Object[];
+    oLabels: {
+        labels: React.ReactNode;
+    };
+    columnOverlays: Array<object>;
+    oAccessor: Array<Function>;
+    rAccessor: Array<Function>;
+    oScaleType: ScaleBand<string>;
+    rScaleType: ScaleLinear<number, number>;
+    oExtent: Array<string>;
+    rExtent: Array<number>;
+    oScale: ScaleBand<string>;
+    rScale: ScaleLinear<number, number>;
+    calculatedOExtent: Array<string>;
+    calculatedRExtent: Array<number>;
+    projectedColumns: object;
+    orFrameRender: RenderPipelineType;
+    pieceIDAccessor: GenericAccessor<string>;
+    type: object;
+    summaryType: object;
+    props: OrdinalFrameProps<TDatum>;
+}
+export interface LabelSettingsType {
+    orient?: string;
+    padding?: number;
+    label?: boolean | Function;
+    labelFormatter?: Function;
+}
+export {};