semiotic 2.0.2 → 3.0.0-beta.1

package/dist/svg/frameFunctions.d.ts

@@ -0,0 +1,108 @@
+import * as React from "react";
+import { AxisProps } from "../types/annotationTypes";
+import { MarginType, ProjectionTypes } from "../types/generalTypes";
+import { ScaleLinear } from "d3-scale";
+export type TitleType = string | Element | {
+    title?: string | Element;
+    orient?: string;
+};
+type PieceType = {
+    type: string;
+    innerRadius?: number;
+};
+type CalculateMarginTypes = {
+    margin?: number | object;
+    axes?: Array<AxisProps>;
+    title: TitleType;
+    oLabel?: boolean | Function | {
+        label?: boolean | Function;
+        orient?: string;
+        padding?: number;
+    };
+    projection?: ProjectionTypes;
+    size?: number[];
+};
+type AdjustedPositionSizeTypes = {
+    size: Array<number>;
+    position?: Array<number>;
+    margin: MarginType;
+    projection?: ProjectionTypes;
+};
+type ORFrameConnectionRendererTypes = {
+    type: {
+        type: Function;
+    };
+    data: {
+        keyedData: Record<string, any>;
+        oExtent: string[];
+    };
+    renderMode: Function;
+    eventListenersGenerator: Function;
+    styleFn: Function;
+    classFn: Function;
+    projection: ProjectionTypes;
+    canvasRender: Function;
+    canvasDrawing: Array<object>;
+    pieceType: PieceType;
+};
+type ORFrameAxisGeneratorTypes = {
+    projection: ProjectionTypes;
+    axis?: Array<AxisProps>;
+    adjustedSize: Array<number>;
+    size: Array<number>;
+    rScale: ScaleLinear<number, number>;
+    rScaleType: ScaleLinear<number, number>;
+    pieceType: PieceType;
+    rExtent: Array<number>;
+    data: Array<object>;
+    maxColumnValues?: number;
+    xyData: Array<{
+        value: number;
+        data: object;
+    }>;
+    margin: MarginType;
+    thresholds?: number[];
+};
+export declare const circlePath: (cx: number, cy: number, r: number) => string;
+export declare const drawMarginPath: ({ margin, size, inset }: {
+    margin: MarginType;
+    size: Array<number>;
+    inset: number;
+}) => string;
+export declare const calculateMargin: ({ margin, axes, title: rawTitle, oLabel, projection, size }: CalculateMarginTypes) => MarginType;
+type ObjectifyType = {
+    type?: string | Function;
+};
+export declare function objectifyType(type?: string | Function | ObjectifyType): ObjectifyType;
+export declare function generateOrdinalFrameEventListeners(customHoverBehavior: Function, customClickBehavior: Function): (d?: object, i?: number) => {
+    onMouseEnter?: (e: any) => void;
+    onMouseLeave?: (e: any) => void;
+    onClick?: (e: any) => void;
+};
+export declare function keyAndObjectifyBarData({ data, renderKey, oAccessor, rAccessor: baseRAccessor, originalRAccessor, originalOAccessor, multiAxis }: {
+    data: Array<object | number>;
+    renderKey: Function;
+    oAccessor: Array<Function>;
+    rAccessor: Array<(d: number | object, i?: number) => number>;
+    multiAxis?: boolean;
+    originalOAccessor: Array<string | Function>;
+    originalRAccessor: Array<string | Function>;
+}): {
+    allData: Array<object>;
+    multiExtents?: Array<Array<number>>;
+};
+export declare function adjustedPositionSize({ size, position, margin, projection }: AdjustedPositionSizeTypes): {
+    adjustedPosition: number[];
+    adjustedSize: number[];
+};
+export declare function generateFrameTitle({ title: rawTitle, size }: {
+    title: TitleType;
+    size: Array<number>;
+}): any;
+export declare function orFrameConnectionRenderer({ type, data, renderMode, eventListenersGenerator, styleFn, classFn, projection, canvasRender, canvasDrawing, pieceType }: ORFrameConnectionRendererTypes): any[];
+export declare const orFrameAxisGenerator: ({ projection, axis, adjustedSize, size, rScale, rScaleType, pieceType, rExtent, data, maxColumnValues, xyData, margin, thresholds }: ORFrameAxisGeneratorTypes) => {
+    axis: JSX.Element[];
+    axesTickLines: Object[];
+};
+export declare const canvasEvent: (canvasContext: any, overlayRegions: any, canvasMap: any, e: any) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+export {};

package/dist/svg/graphAlgorithms.d.ts

@@ -0,0 +1,14 @@
+export declare function topologicalSort(nodesArray: any, edgesArray: any): false | any[];
+export declare const softStack: (edges: any, nodes: any, sourceAccessor: any, targetAccessor: any, nodeIDAccessor: any) => {
+    hierarchy: {
+        id: string;
+        children: any[];
+        childMap: Map<any, any>;
+    };
+    isHierarchical: boolean;
+    hasLogicalRoot: boolean;
+} | {
+    hierarchy: {};
+    isHierarchical: boolean;
+    hasLogicalRoot: boolean;
+};

package/dist/svg/hexbinLayout.d.ts

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

package/dist/svg/lineDrawing.d.ts

@@ -0,0 +1,99 @@
+import { ProjectedLine, ProjectedPoint, RawLine, RawSummary } from "../types/generalTypes";
+import { AnnotationType } from "../types/annotationTypes";
+type SummaryProjectionTypes = {
+    data: Array<RawSummary>;
+    summaryDataAccessor: Array<Function>;
+    xAccessor: Array<Function>;
+    yAccessor: Array<Function>;
+};
+type LineProjectionTypes = {
+    data: Array<RawLine>;
+    lineDataAccessor: Array<Function>;
+    xProp: string;
+    xPropTop?: string;
+    xPropBottom?: string;
+    yProp: string;
+    yPropTop?: string;
+    yPropBottom?: string;
+    xAccessor: Array<Function>;
+    yAccessor: Array<Function>;
+};
+type DifferenceLineProps = {
+    data: Array<ProjectedLine>;
+    yProp: string;
+    yPropTop: string;
+    yPropBottom: string;
+};
+type StackedAreaTypes = {
+    type: string;
+    data: Array<ProjectedLine>;
+    xProp: string;
+    yProp: string;
+    yPropMiddle: string;
+    sort?: (a: ProjectedLine, b: ProjectedLine) => number;
+    yPropTop: string;
+    yPropBottom: string;
+};
+type CumulativeLineTypes = {
+    type: string;
+    data: Array<ProjectedLine>;
+    yPropMiddle: string;
+    yPropTop: string;
+    yPropBottom: string;
+    y1?: Function;
+};
+type LineChartTypes = {
+    data: Array<ProjectedLine>;
+    y1?: Function;
+    x1?: Function;
+    yPropTop: string;
+    yPropMiddle: string;
+    yPropBottom: string;
+    xPropTop: string;
+    xPropMiddle: string;
+    xPropBottom: string;
+};
+type RelativeYTypes = {
+    point?: ProjectedPoint | AnnotationType;
+    projectedYMiddle: string;
+    projectedY: string;
+    yAccessor: Array<Function>;
+    yScale: Function;
+    showLinePoints?: boolean | string;
+};
+type RelativeXTypes = {
+    point?: ProjectedPoint | AnnotationType;
+    projectedXMiddle: string;
+    projectedX: string;
+    xAccessor: Array<Function>;
+    xScale: Function;
+};
+export declare const projectSummaryData: ({ data, summaryDataAccessor, xAccessor, yAccessor }: SummaryProjectionTypes) => any[];
+export declare const projectLineData: ({ data, lineDataAccessor, xProp, xPropTop, xPropBottom, yProp, yPropTop, yPropBottom, xAccessor, yAccessor }: LineProjectionTypes) => ProjectedLine[];
+export declare const differenceLine: ({ data, yProp, yPropTop, yPropBottom }: DifferenceLineProps) => ProjectedLine[];
+export declare const stackedArea: ({ type, data, xProp, yProp, yPropMiddle, sort, yPropTop, yPropBottom }: StackedAreaTypes) => ProjectedLine[];
+export declare const lineChart: ({ data, y1, x1, yPropTop, yPropMiddle, yPropBottom, xPropTop, xPropMiddle, xPropBottom }: LineChartTypes) => ProjectedLine[];
+export declare const cumulativeLine: ({ data, y1, yPropTop, yPropMiddle, yPropBottom, type }: CumulativeLineTypes) => ProjectedLine[];
+export declare const bumpChart: ({ type, data, xProp, yProp, yPropMiddle, yPropTop, yPropBottom }: StackedAreaTypes) => ProjectedLine[];
+export declare const dividedLine: (parameters: Function, points: Array<Object>, searchIterations?: number) => {
+    key: any;
+    points: any[];
+}[];
+export declare function funnelize({ data, steps, key }: {
+    data: Array<Object>;
+    steps: Array<string>;
+    key: string;
+}): any[];
+export declare function relativeY({ point, projectedY, yAccessor, yScale, showLinePoints }: RelativeYTypes): any;
+export declare function relativeX({ point, projectedXMiddle, projectedX, xAccessor, xScale }: RelativeXTypes): any;
+export declare function findPointByID({ point, idAccessor, lines, xScale, projectedX, xAccessor }: {
+    point: ProjectedPoint;
+    idAccessor: Function;
+    lines: {
+        data: ProjectedLine[];
+    };
+    xScale: Function;
+    projectedX: string;
+    xAccessor: Array<Function>;
+}): ProjectedPoint;
+export {};

package/dist/svg/networkDrawing.d.ts

@@ -0,0 +1,16 @@
+export { circleNodeGenerator, sankeyNodeGenerator, chordNodeGenerator, matrixNodeGenerator, radialRectNodeGenerator, radialLabelGenerator, hierarchicalRectNodeGenerator } from "./nodeGenerators";
+export { matrixEdgeGenerator, arcEdgeGenerator, sankeyArrowGenerator, chordEdgeGenerator, dagreEdgeGenerator } from "./edgeGenerators";
+export { ribbonLink, areaLink, circularAreaLink } from "./sankeyLinks";
+export { topologicalSort, softStack } from "./graphAlgorithms";
+export declare const drawNodes: ({ data, renderKeyFn, customMark, styleFn, classFn, renderMode, canvasDrawing, canvasRenderFn, networkSettings }: {
+    data: any;
+    renderKeyFn: any;
+    customMark: any;
+    styleFn: any;
+    classFn: any;
+    renderMode: any;
+    canvasDrawing: any;
+    canvasRenderFn: any;
+    networkSettings: any;
+}) => any[];
+export declare const drawEdges: (settings: any) => any[];

package/dist/svg/nodeGenerators.d.ts

@@ -0,0 +1,58 @@
+import * as React from "react";
+export declare const circleNodeGenerator: ({ d, i, styleFn, renderMode, key, className, transform }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    transform: any;
+}) => React.JSX.Element;
+export declare const gridProps: (gridSize: any) => {
+    x: number;
+    y: number;
+    width: any;
+    height: any;
+};
+export declare const sankeyNodeGenerator: ({ d, i, styleFn, renderMode, key, className, transform }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+    transform: any;
+}) => React.JSX.Element;
+export declare const chordNodeGenerator: (size: any) => ({ d, i, styleFn, renderMode, key, className }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+}) => React.JSX.Element;
+export declare const matrixNodeGenerator: (size: any, nodes: any) => ({ d, i, styleFn, renderMode, key, className }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+}) => React.JSX.Element;
+export declare const radialRectNodeGenerator: (size: any, center: any, type: any) => ({ d, i, styleFn, renderMode, key, className }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+}) => React.JSX.Element;
+export declare const radialLabelGenerator: (node: any, nodei: any, nodeIDAccessor: any, size: any) => React.JSX.Element;
+export declare const hierarchicalRectNodeGenerator: ({ d, i, styleFn, renderMode, key, className }: {
+    d: any;
+    i: any;
+    styleFn: any;
+    renderMode: any;
+    key: any;
+    className: any;
+}) => React.JSX.Element;

package/dist/svg/pieceDrawing.d.ts

@@ -0,0 +1,12 @@
+export declare function pointOnArcAtAngle(center: any, angle: any, distance: any): any[];
+export declare const renderLaidOutPieces: ({ data, shouldRender, canvasRender, canvasDrawing, styleFn, classFn, renderKeyFn, ariaLabel, axis }: {
+    data: any;
+    shouldRender: any;
+    canvasRender: any;
+    canvasDrawing: any;
+    styleFn: any;
+    classFn: any;
+    renderKeyFn: any;
+    ariaLabel: any;
+    axis: any;
+}) => any[];

package/dist/svg/pieceLayouts.d.ts

@@ -0,0 +1,53 @@
+export declare function clusterBarLayout({ type, data, renderMode, eventListenersGenerator, styleFn, projection, classFn, adjustedSize, chartSize, margin, rScale }: {
+    type: any;
+    data: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    projection: any;
+    classFn: any;
+    adjustedSize: any;
+    chartSize: any;
+    margin: any;
+    rScale: any;
+}): any[];
+export declare function barLayout({ type, data, renderMode, eventListenersGenerator, styleFn, projection, classFn, adjustedSize, chartSize, margin, rScale }: {
+    type: any;
+    data: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    projection: any;
+    classFn: any;
+    adjustedSize: any;
+    chartSize: any;
+    margin: any;
+    rScale: any;
+}): any[];
+export declare function timelineLayout({ type, data, renderMode, eventListenersGenerator, styleFn, projection, classFn, adjustedSize, chartSize, margin, rScale }: {
+    type: any;
+    data: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    projection: any;
+    classFn: any;
+    adjustedSize: any;
+    chartSize: any;
+    margin: any;
+    rScale: any;
+}): any[];
+export declare function pointLayout({ type, data, renderMode, eventListenersGenerator, styleFn, projection, classFn, adjustedSize, chartSize, margin, rScale }: {
+    type: any;
+    data: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    projection: any;
+    classFn: any;
+    adjustedSize: any;
+    chartSize: any;
+    margin: any;
+    rScale: any;
+}): any[];
+export { swarmLayout } from "./swarmLayout";

package/dist/svg/sankeyLinks.d.ts

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

package/dist/svg/summaryAxis.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+/**
+ * Generates an Axis component for summary visualizations
+ * This function creates the actual Axis component with the provided props
+ */
+export declare function axisGenerator(axisProps: any, i: any, axisScale: any): React.JSX.Element;

package/dist/svg/summaryLayouts.d.ts

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

package/dist/svg/swarmLayout.d.ts

@@ -0,0 +1,13 @@
+export declare function swarmLayout({ type, data, renderMode, eventListenersGenerator, styleFn, projection, classFn, adjustedSize, chartSize, margin, rScale }: {
+    type: any;
+    data: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    projection: any;
+    classFn: any;
+    adjustedSize: any;
+    chartSize: any;
+    margin: any;
+    rScale: any;
+}): any[];

package/dist/types/annotationTypes.d.ts

@@ -0,0 +1,135 @@
+import { RawPoint, MarginType, AxisSummaryTypeSettings, OrdinalSummaryTypes } from "./generalTypes";
+import { NodeType, EdgeType } from "./networkTypes";
+import { ScaleLinear } from "d3-scale";
+export type AnnotationType = {
+    type?: string;
+    column?: {
+        name: string;
+    };
+    facetColumn?: string;
+    bounds?: RawPoint[];
+    x?: number;
+    y?: number;
+    yTop?: number;
+    yBottom?: number;
+    yMiddle?: number;
+    coordinates?: object[];
+    key?: string;
+    percent?: number;
+    style?: Record<string, any> | ((arg?: Record<string, any>, index?: number) => Record<string, any>);
+    ids?: string[];
+    edge?: EdgeType;
+    source?: NodeType;
+    target?: NodeType;
+    id?: string;
+    element?: Element;
+    label?: string | Element;
+    neighbors?: object[];
+    isColumnAnnotation?: boolean;
+};
+export type CustomHoverType = boolean | Array<AnnotationType | Function> | object | Function | "all" | "edge" | "node" | "area";
+export type AnnotationTypes = "marginalia" | "bump" | false;
+interface AnnotationLayout {
+    type: AnnotationTypes;
+    orient?: "nearest" | "left" | "right" | "top" | "bottom" | Array<string>;
+    characterWidth?: number;
+    noteHeight?: Function | number;
+    noteWidth?: Function | number;
+    lineWidth?: number;
+    lineHeight?: number;
+    padding?: number;
+    iterations?: number;
+    pointSizeFunction?: Function;
+    labelSizeFunction?: Function;
+    marginOffset?: number;
+    axisMarginOverride?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+}
+export interface AnnotationHandling {
+    dataVersion?: string;
+    layout: AnnotationLayout;
+}
+export interface AnnotationProps {
+    noteData: {
+        eventListeners?: object;
+        events?: object;
+        type: string;
+        screenCoordinates?: Array<Array<number>>;
+        coordinates?: boolean;
+        noteHeight?: Function | number;
+        noteWidth?: Function | number;
+        x: number | number[];
+        y: number | number[];
+        nx?: number;
+        ny?: number;
+        dx?: number;
+        dy?: number;
+        note: {
+            label?: string;
+            title?: string;
+        };
+        i?: number;
+        fixedPosition?: boolean;
+        label?: string;
+    };
+}
+type GlyphProps = {
+    lineHeight: number;
+    lineWidth: number;
+    value: number;
+};
+type AxisPart = {
+    value: number;
+};
+export interface AxisProps {
+    orient: "left" | "right" | "top" | "bottom";
+    label?: {
+        position?: {
+            anchor?: string;
+            location?: string;
+            rotation?: string;
+        };
+        name: string;
+        locationDistance: number;
+    };
+    dynamicLabelPosition?: boolean;
+    position?: number[];
+    rotate?: number;
+    tickFormat?: Function;
+    size?: number[];
+    width?: number;
+    height?: number;
+    className?: string;
+    padding?: number;
+    tickValues?: number[] | Function;
+    scale?: ScaleLinear<number, number>;
+    ticks?: number;
+    footer?: boolean;
+    tickSize?: number;
+    tickLineGenerator?: ({ xy, orient, i, className }: {
+        xy?: object;
+        orient?: string;
+        i?: number;
+        className?: string;
+    }) => SVGElement;
+    baseline?: boolean | "under";
+    jaggedBase?: boolean;
+    margin?: MarginType;
+    center?: boolean;
+    axisParts?: AxisPart[];
+    annotationFunction?: (args: any) => void;
+    glyphFunction?: (args: GlyphProps) => SVGElement;
+    axis?: object;
+    extentOverride?: number[];
+    key?: string | number;
+    axisAnnotationFunction?: (args: object) => void;
+    xyPoints?: object[];
+    marginalSummaryType?: AxisSummaryTypeSettings | OrdinalSummaryTypes;
+    showOutboundTickLines?: boolean;
+}
+export type AxisGeneratingFunction = (args: object) => AxisProps;
+export {};

package/dist/types/canvasTypes.d.ts

@@ -0,0 +1,9 @@
+export type ContextType = {
+    getContext: Function;
+    width: number;
+    height: number;
+    style: {
+        width: number;
+        height: number;
+    };
+} | null;