semiotic 2.0.2 → 2.0.3

package/dist/components/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/components/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";
+}

package/dist/components/types/networkTypes.d.ts

@@ -0,0 +1,165 @@
+/// <reference types="react" />
+import { GenericObject, RenderPipelineType } from "./generalTypes";
+import { GeneralFrameProps, GeneralFrameState } from "./generalTypes";
+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?: any;
+    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: GenericObject, b: GenericObject) => number;
+    zoom?: boolean | "stretch" | ((nodes: NodeType[], edges: EdgeType[], size: number[]) => void);
+    fixExistingNodes?: boolean | Function;
+    showArrows?: boolean;
+}
+export interface NetworkFrameState 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;
+    nodeLabelAnnotations: object[];
+    graphSettings: GraphSettingsType;
+    networkFrameRender: RenderPipelineType;
+    props: NetworkFrameProps;
+}
+export interface NetworkFrameProps extends GeneralFrameProps {
+    graph?: {
+        nodes: NodeType[];
+        edges: EdgeType[];
+    } | EdgeType[] | {
+        (): () => void;
+        nodes: Function;
+        edges: Function;
+        node: Function;
+        edge: Function;
+    };
+    nodes?: object[];
+    edges?: object[] | object;
+    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);
+    edgeType?: string | Function;
+    customNodeIcon?: Function;
+    customEdgeIcon?: Function;
+    renderOrder?: ReadonlyArray<"edges" | "nodes">;
+    filterRenderedNodes?: (value?: NodeType, index?: number, array?: NodeType[]) => any;
+}

package/dist/components/types/ordinalTypes.d.ts

@@ -0,0 +1,103 @@
+/// <reference types="react" />
+import { CustomHoverType } from "./annotationTypes";
+import { CanvasPostProcessTypes, ProjectionTypes, accessorType, GenericObject, GenericAccessor, RenderPipelineType, OrdinalSummaryTypeSettings, GeneralFrameState, GeneralFrameProps } from "./generalTypes";
+import { ScaleLinear, ScaleBand } from "d3-scale";
+import { AxisProps, AxisGeneratingFunction } from "./annotationTypes";
+export declare type OExtentObject = {
+    extent?: Array<string>;
+    onChange?: Function;
+};
+declare 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 interface PieceTypeSettings {
+    type: PieceTypes;
+    offsetAngle?: number;
+    angleRange?: number[];
+}
+export interface ProjectedOrdinalSummary {
+    originalData?: {
+        x?: number;
+        y?: number;
+    };
+    xyPoints?: object[];
+    marks?: object[];
+    thresholds?: any;
+}
+export interface OrdinalFrameProps extends GeneralFrameProps {
+    type?: PieceTypes | PieceTypeSettings;
+    summaryType?: OrdinalSummaryTypeSettings;
+    connectorType?: Function;
+    rAccessor?: accessorType<number>;
+    oAccessor?: accessorType<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 | GenericObject>;
+    connectorStyle?: object | accessorType<GenericObject>;
+    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: any, index: number, column: any) => string | Element);
+    renderMode?: object | string | accessorType<string | object>;
+    summaryRenderMode?: object | string | accessorType<string | object>;
+    pixelColumnWidth?: number;
+    oScaleType?: any;
+    rScaleType?: () => ScaleLinear<number, number>;
+    data: Array<object | number>;
+    oPadding?: number;
+    axes?: AxisGeneratingFunction | AxisProps | Array<AxisProps | AxisGeneratingFunction>;
+    renderOrder?: ReadonlyArray<"pieces" | "summaries" | "connectors">;
+    multiAxis?: boolean;
+}
+export interface OrdinalFrameState extends GeneralFrameState {
+    pieceDataXY: Array<object>;
+    axisData?: AxisProps[];
+    axes?: React.ReactNode[];
+    axesTickLines?: any;
+    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;
+}
+export interface LabelSettingsType {
+    orient?: string;
+    padding?: number;
+    label?: any;
+    labelFormatter?: Function;
+}
+export {};

package/dist/components/types/xyTypes.d.ts

@@ -0,0 +1,118 @@
+/// <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 { 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;
+    summaryType: SummaryTypeSettings;
+    data: {
+        _xyfCoordinates?: [number | Date, number | Date][];
+        coordinates: {
+            x: number;
+            y: number;
+        }[];
+    };
+    finalXExtent?: number[];
+    finalYExtent?: number[];
+    size?: number[];
+    xScaleType?: ScaleLinear<Number, Number>;
+    yScaleType?: ScaleLinear<Number, Number>;
+    margin?: MarginType;
+    baseMarkProps?: object;
+    styleFn?: Function;
+    classFn?: Function;
+    renderFn?: Function;
+    chartSize?: number[];
+}

package/dist/components/useBoundingRect.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from "react";
+export declare function useBoundingRect(ref: RefObject<HTMLElement>): DOMRect | null;

package/dist/components/useDerivedStateFromProps.d.ts

@@ -0,0 +1 @@
+export declare function useDerivedStateFromProps<Props, State>(fn: (nextProps: Props, prevState: State) => Partial<State> | null, props: Props, initialState: State): State;

package/dist/components/useLegacyUnmountCallback.d.ts

@@ -0,0 +1 @@
+export declare function useLegacyUnmountCallback(props: any, state: any): void;

package/dist/components/visualizationLayerBehavior/axis.d.ts

@@ -0,0 +1,38 @@
+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 = {
+    renderMode?: RenderModeFnType;
+    padding: number;
+    scale: ScaleLinear<number, number>;
+    ticks: number;
+    tickValues: number[] | Function;
+    orient: "left" | "right" | "top" | "bottom";
+    size: number[];
+    footer: boolean;
+    tickSize: number;
+    baseline?: boolean | "under";
+    jaggedBase?: boolean;
+};
+export declare function generateTickValues(tickValues: any, ticks: any, scale: any): any;
+export declare function axisPieces({ renderMode, padding, scale, ticks, tickValues, orient, size, footer, tickSize, jaggedBase }: AxisPiecesFnType): any;
+export declare const axisLabels: ({ axisParts, tickFormat, rotate, center, orient }: {
+    axisParts: any;
+    tickFormat: any;
+    rotate?: number;
+    center?: boolean;
+    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 }: {
+    axisParts: object[];
+    orient: string;
+    tickLineGenerator: Function;
+    baseMarkProps?: GenericObject;
+    className: string;
+    jaggedBase?: boolean;
+    scale: ScaleLinear<number, number>;
+    showOutboundTickLines?: boolean;
+}) => React.ReactNode[];
+export {};

package/dist/components/visualizationLayerBehavior/general.d.ts

@@ -0,0 +1,84 @@
+import * as React from "react";
+import { GenericObject, ProjectedSummary } from "../types/generalTypes";
+import { ScaleLinear } from "d3-scale";
+export declare const curveHash: {
+    step: any;
+    stepbefore: any;
+    stepafter: any;
+    cardinal: any;
+    basis: any;
+    linear: any;
+    catmullrom: any;
+    monotone: any;
+    monotonex: any;
+    monotoney: any;
+    natural: any;
+};
+export declare function lineGeneratorDecorator({ generator, projectedCoordinateNames, defined, xScale, yScale, interpolator, simpleLine }: {
+    generator: any;
+    projectedCoordinateNames: any;
+    defined: any;
+    xScale: any;
+    yScale: any;
+    interpolator: any;
+    simpleLine: any;
+}): void;
+export declare function createPoints({ xScale, yScale, canvasDrawing, data, projectedCoordinateNames, customMark, canvasRender, styleFn, classFn, renderKeyFn, renderMode, baseMarkProps, showLinePoints: baseShowLinePoints }: {
+    xScale: any;
+    yScale: any;
+    canvasDrawing: any;
+    data: any;
+    projectedCoordinateNames: any;
+    customMark: any;
+    canvasRender: any;
+    styleFn: any;
+    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 }: {
+    xScale: any;
+    yScale: any;
+    canvasDrawing: any;
+    data: any;
+    projectedCoordinateNames: any;
+    customMark: any;
+    canvasRender: any;
+    styleFn: any;
+    classFn: any;
+    renderMode: any;
+    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 }: {
+    xScale: ScaleLinear<number, number>;
+    yScale: ScaleLinear<number, number>;
+    canvasDrawing?: object[];
+    data: ProjectedSummary[];
+    canvasRender?: Function;
+    styleFn?: Function;
+    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 }: {
+    tx?: number;
+    ty?: number;
+    d: GenericObject;
+    i: number;
+    markProps: GenericObject;
+    styleFn: Function;
+    renderFn: Function;
+    classFn: Function;
+    renderKeyFn: Function;
+    baseClass: string;
+    yi?: number;
+}): React.JSX.Element;

package/dist/constants/coordinateNames.d.ts

@@ -0,0 +1,8 @@
+export declare const projectedX = "x";
+export declare const projectedY = "y";
+export declare const projectedYMiddle = "yMiddle";
+export declare const projectedYTop = "yTop";
+export declare const projectedYBottom = "yBottom";
+export declare const projectedXMiddle = "xMiddle";
+export declare const projectedXTop = "xTop";
+export declare const projectedXBottom = "xBottom";

package/dist/constants/frame_props.d.ts

@@ -0,0 +1,4 @@
+export declare const xyFrameDataProps: string[];
+export declare const xyFrameChangeProps: string[];
+export declare const orFrameChangeProps: string[];
+export declare const networkFrameChangeProps: string[];

package/dist/constants/jsx.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+declare type FilterDefTypes = {
+    matte?: any;
+    key: string;
+    additionalDefs?: React.ReactNode;
+};
+export declare const filterDefs: ({ matte, key, additionalDefs }: FilterDefTypes) => React.JSX.Element;
+export declare const generateFinalDefs: ({ matte, size, margin, frameKey, additionalDefs, name }: {
+    matte: any;
+    size: any;
+    margin: any;
+    frameKey: any;
+    additionalDefs: any;
+    name: any;
+}) => {
+    defs: React.JSX.Element;
+    matte: any;
+};
+export {};