semiotic 2.0.2 → 2.0.3

package/dist/svg/summaryLayouts.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="react" />
+import { GenericObject } from "../types/generalTypes";
+declare type BoxplotFnType = {
+    data: GenericObject[];
+    type: GenericObject;
+    renderMode: Function;
+    eventListenersGenerator: Function;
+    styleFn: Function;
+    classFn: Function;
+    projection: "horizontal" | "vertical" | "radial";
+    adjustedSize: number[];
+    baseMarkProps: GenericObject;
+};
+export declare function ckBinsRenderFn(props: BoxplotFnType): {
+    marks: any;
+    xyPoints: any[];
+};
+export declare function boxplotRenderFn({ data, type, renderMode, eventListenersGenerator, styleFn, classFn, projection, adjustedSize, baseMarkProps }: BoxplotFnType): {
+    marks: any[];
+    xyPoints: any[];
+};
+export declare function contourRenderFn({ data, type, renderMode, eventListenersGenerator, styleFn, classFn, adjustedSize, baseMarkProps }: {
+    data: any;
+    type: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    classFn: any;
+    adjustedSize: any;
+    baseMarkProps: any;
+}): {
+    marks: any[];
+    xyPoints: any[];
+};
+export declare function bucketizedRenderingFn({ data, type, renderMode, eventListenersGenerator, styleFn, classFn, projection, adjustedSize, chartSize, baseMarkProps }: {
+    data: any;
+    type: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    classFn: any;
+    projection: any;
+    adjustedSize: any;
+    chartSize: any;
+    baseMarkProps: any;
+}): {
+    marks: any[];
+    xyPoints: any[];
+    thresholds: any[];
+};
+export declare const drawSummaries: ({ data, type, renderMode, eventListenersGenerator, styleFn, classFn, projection, adjustedSize, margin, baseMarkProps }: {
+    data: any;
+    type: any;
+    renderMode: any;
+    eventListenersGenerator: any;
+    styleFn: any;
+    classFn: any;
+    projection: any;
+    adjustedSize: any;
+    margin: any;
+    baseMarkProps: any;
+}) => any;
+interface summaryInstruction {
+    Mark?: JSX.Element;
+    containerProps?: object;
+    elements: object[];
+}
+export declare function summaryInstructionsToMarks(data: summaryInstruction[]): JSX.Element[];
+export declare const renderLaidOutSummaries: ({ data, canvasRender, canvasDrawing }: {
+    data: any;
+    canvasRender: any;
+    canvasDrawing: any;
+}) => JSX.Element[];
+export {};

package/dist/types/annotationTypes.d.ts

@@ -0,0 +1,140 @@
+import { RawPoint, GenericObject, MarginType, AxisSummaryTypeSettings, OrdinalSummaryTypes } from "./generalTypes";
+import { NodeType } from "./networkTypes";
+import { ScaleLinear } from "d3-scale";
+export declare type AnnotationType = {
+    type?: string | Function;
+    column?: {
+        name: string;
+    };
+    facetColumn?: string;
+    bounds?: RawPoint[];
+    x?: number;
+    y?: number;
+    yTop?: number;
+    yBottom?: number;
+    yMiddle?: number;
+    coordinates?: object[];
+    key?: string;
+    percent?: number;
+    style?: GenericObject | ((arg?: GenericObject, index?: number) => GenericObject);
+    ids?: string[];
+    edge?: any;
+    source?: NodeType;
+    target?: NodeType;
+    id?: string;
+    element?: Element;
+    label?: string | Element;
+    neighbors?: object[];
+    isColumnAnnotation?: boolean;
+};
+export declare type CustomHoverType = boolean | Array<AnnotationType | Function> | object | Function | "all" | "edge" | "node" | "area";
+export declare 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;
+        onDragEnd?: Function;
+        onDragStart?: Function;
+        onDrag?: Function;
+        type: string | Function;
+        editMode?: boolean;
+        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;
+    };
+}
+declare type GlyphProps = {
+    lineHeight: number;
+    lineWidth: number;
+    value: number;
+};
+declare 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, baseMarkProps, className }: {
+        xy?: object;
+        orient?: string;
+        i?: number;
+        baseMarkProps?: object;
+        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 declare type AxisGeneratingFunction = (args: object) => AxisProps;
+export {};

package/dist/types/canvasTypes.d.ts

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

package/dist/types/generalTypes.d.ts

@@ -0,0 +1,236 @@
+/// <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;
+};
+export interface MarginType {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+export declare type ProjectionTypes = "vertical" | "horizontal" | "radial";
+export declare 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 declare type PieceLayoutType = (args: {
+    type: string | {
+        type: string;
+    };
+    data: any;
+    renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
+    eventListenersGenerator: any;
+    styleFn: (d: object) => object;
+    projection: string;
+    classFn: (d: object) => string;
+    adjustedSize: number[];
+    chartSize: number[];
+    margin: MarginType;
+    rScale?: Function;
+    baseMarkProps: object;
+}) => GenericObject[];
+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?: GenericObject;
+    bounds: object[] | number[];
+    customMark?: Function;
+    type?: string;
+    curve?: Function;
+    processedData?: boolean;
+    binMax?: number;
+}
+export declare type RoughType = {
+    canvas: Function;
+    generator: Function;
+};
+export declare type CanvasPostProcessTypes = Function;
+export declare type ExtentSettingsType = {
+    extent?: Array<number>;
+    onChange?: Function;
+};
+export declare type accessorType<ReturnValue> = string | ((args?: unknown, index?: number) => ReturnValue);
+export interface AccessorFnType {
+    <T>(arg: GenericObject): T;
+}
+export declare 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 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 {
+    coordinates?: object[];
+}
+export interface RawSummary {
+    processedData?: object[];
+    coordinates?: object[];
+    preprocess?: boolean;
+}
+export interface RawPoint {
+}
+export interface CustomAreaMarkProps {
+    d: object;
+    baseMarkProps: 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 declare type GenericAccessor<GenericValue> = (args?: GenericObject, index?: number) => GenericValue;
+export declare type VizLayerTypes = "pieces" | "summaries" | "connectors" | "edges" | "nodes" | "lines" | "points";
+export declare type RenderPipelineType = {
+    [key in VizLayerTypes]?: {
+        data?: any;
+        ariaLabel?: {
+            chart?: string;
+            items?: string;
+        };
+        behavior?: Function;
+        styleFn?: Function;
+    };
+};
+export declare type OrdinalSummaryTypes = "none" | "histogram" | "heatmap" | "violin" | "joy" | "ridgeline" | "boxplot" | "contour";
+export declare 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 GeneralFrameProps {
+    useSpans?: boolean;
+    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[];
+    baseMarkProps?: 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;
+}
+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,74 @@
+/// <reference types="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 declare 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: any;
+    }>;
+    position?: number[];
+    enabled?: boolean;
+    useSpans?: boolean;
+    margin: MarginType;
+    projection?: string;
+    customDoubleClickBehavior?: Function;
+    customClickBehavior?: Function;
+    customHoverBehavior?: Function;
+    canvasRendering?: boolean;
+    disableCanvasInteraction: boolean;
+    showLinePoints?: string;
+    renderPipeline: object;
+    advancedSettings?: AdvancedInteractionSettings;
+};
+export declare type VoronoiEntryType = {
+    voronoiX: number;
+    voronoiY: number;
+    coincidentPoints: object[];
+    type?: string;
+    data?: object[];
+};
+export declare type BaseColumnType = {
+    x: number;
+    width: number;
+};
+export declare type InteractionLayerState = {
+    overlayRegions: Array<React.ReactElement>;
+    props: InteractionLayerProps;
+    canvasMap: Map<string, number>;
+    interactionCanvas: React.ReactNode;
+    SpanOrDiv: Function;
+};

package/dist/types/legendTypes.d.ts

@@ -0,0 +1,20 @@
+export declare type SupportedLegendGlyphs = "fill" | "line";
+export declare 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";
+}