semiotic 2.0.3 → 3.0.0-beta.1

package/dist/processing/network.d.ts

@@ -1,12 +1,10 @@
 import * as React from "react";
 import { TitleType } from "../svg/frameFunctions";
+import { NetworkPipelineCache } from "../data/networkPipelineCache";
 import { NetworkFrameProps, NetworkFrameState, NetworkSettingsType, NodeType } from "../types/networkTypes";
-import { GenericObject } from "../types/generalTypes";
-export declare const nodesEdgesFromHierarchy: (baseRootNode: any, idAccessor?: (d: any) => any) => {
-    edges: any[];
-    nodes: any[];
-};
-export declare const calculateNetworkFrame: (currentProps: NetworkFrameProps, prevState: NetworkFrameState) => {
+import { NetworkLayoutMap } from "./layouts/types";
+export { nodesEdgesFromHierarchy } from "./hierarchyUtils";
+export declare const calculateNetworkFrame: (currentProps: NetworkFrameProps, prevState: NetworkFrameState, cache: NetworkPipelineCache, layoutMap?: NetworkLayoutMap) => {
     adjustedPosition: number[];
     adjustedSize: number[];
     backgroundGraphics: Function | React.ReactNode;
@@ -17,24 +15,24 @@ export declare const calculateNetworkFrame: (currentProps: NetworkFrameProps, pr
     projectedEdges: import("../types/networkTypes").EdgeType[];
     projectedXYPoints: any;
     overlay: any[];
-    nodeIDAccessor: (d?: GenericObject, i?: number) => string;
-    sourceAccessor: (d?: GenericObject, i?: number) => string | GenericObject;
-    targetAccessor: (d?: GenericObject, i?: number) => string | GenericObject;
-    nodeSizeAccessor: (args?: GenericObject) => number;
-    edgeWidthAccessor: (d?: GenericObject, i?: number) => number;
-    margin: import("../types/generalTypes").MarginType;
+    nodeIDAccessor: (d?: Record<string, any>, i?: number) => string;
+    sourceAccessor: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+    targetAccessor: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+    nodeSizeAccessor: (args?: Record<string, any>) => number;
+    edgeWidthAccessor: (d?: Record<string, any>, i?: number) => number;
+    margin: import("../semiotic-network").MarginType;
     legendSettings: any;
     networkFrameRender: {
         edges: {
             accessibleTransform: (data: any, i: any) => any;
             data: import("../types/networkTypes").EdgeType[];
-            styleFn: (d?: GenericObject, i?: number) => GenericObject;
-            classFn: (d?: GenericObject, i?: number) => string;
-            renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
-            canvasRenderFn: (d?: GenericObject, i?: number) => boolean;
+            styleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+            classFn: (d?: Record<string, any>, i?: number) => string;
+            renderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+            canvasRenderFn: (d?: Record<string, any>, i?: number) => boolean;
             renderKeyFn: (d: any) => any;
             behavior: (settings: any) => any[];
-            projection: "horizontal" | "vertical" | "radial";
+            projection: "horizontal" | "radial" | "vertical";
             type: string | Function;
             customMark: any;
             networkSettings: NetworkSettingsType;
@@ -44,12 +42,12 @@ export declare const calculateNetworkFrame: (currentProps: NetworkFrameProps, pr
         nodes: {
             accessibleTransform: (data: any, i: any) => any;
             data: NodeType[];
-            styleFn: (d?: GenericObject, i?: number) => GenericObject;
-            classFn: (d?: GenericObject, i?: number) => string;
-            renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
-            canvasRenderFn: (d?: GenericObject, i?: number) => boolean;
+            styleFn: (d?: Record<string, any>, i?: number) => Record<string, any>;
+            classFn: (d?: Record<string, any>, i?: number) => string;
+            renderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+            canvasRenderFn: (d?: Record<string, any>, i?: number) => boolean;
             customMark: any;
-            behavior: ({ data, renderKeyFn, customMark, styleFn, classFn, renderMode, canvasDrawing, canvasRenderFn, baseMarkProps, networkSettings }: {
+            behavior: ({ data, renderKeyFn, customMark, styleFn, classFn, renderMode, canvasDrawing, canvasRenderFn, networkSettings }: {
                 data: any;
                 renderKeyFn: any;
                 customMark: any;
@@ -58,10 +56,9 @@ export declare const calculateNetworkFrame: (currentProps: NetworkFrameProps, pr
                 renderMode: any;
                 canvasDrawing: any;
                 canvasRenderFn: any;
-                baseMarkProps: any;
                 networkSettings: any;
             }) => any[];
-            renderKeyFn: (args: GenericObject) => string;
+            renderKeyFn: (args: Record<string, any>) => string;
             networkSettings: NetworkSettingsType;
         };
     };
@@ -80,7 +77,7 @@ export declare const calculateNetworkFrame: (currentProps: NetworkFrameProps, pr
         iterations?: number;
         width?: number;
         height?: number;
-        projection?: "horizontal" | "vertical" | "radial";
+        projection?: "horizontal" | "radial" | "vertical";
         customSankey?: Function;
         groupWidth?: number;
         padAngle?: number;
@@ -97,12 +94,12 @@ export declare const calculateNetworkFrame: (currentProps: NetworkFrameProps, pr
         edgeStrength?: number;
         distanceMax?: number;
         edgeDistance?: number;
-        forceManyBody?: number | Function;
+        forceManyBody?: Function | number;
         hierarchicalNetwork: boolean;
         graphSettings: import("../types/networkTypes").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: import("../types/networkTypes").EdgeType[], size: number[]) => void);
         fixExistingNodes?: boolean | Function;
         showArrows?: boolean;
@@ -110,5 +107,5 @@ export declare const calculateNetworkFrame: (currentProps: NetworkFrameProps, pr
         edgeHash: Map<any, import("../types/networkTypes").EdgeType>;
         filterRenderedNodes?: Function;
     };
-    props: NetworkFrameProps;
+    props: NetworkFrameProps<Record<string, any>, Record<string, any>>;
 };

package/dist/processing/networkDefaults.d.ts

@@ -0,0 +1,36 @@
+export declare const emptyArray: any[];
+export declare const baseNodeProps: {
+    id: any;
+    degree: number;
+    inDegree: number;
+    outDegree: number;
+    x: number;
+    y: number;
+    x1: number;
+    x0: number;
+    y1: number;
+    y0: number;
+    height: number;
+    width: number;
+    radius: number;
+    r: number;
+    direction: any;
+    textHeight: number;
+    textWidth: number;
+    fontSize: number;
+    scale: number;
+    nodeSize: number;
+    component: number;
+    shapeNode: boolean;
+};
+export declare const baseNetworkSettings: {
+    hierarchicalNetwork: boolean;
+};
+export declare const baseGraphSettings: {
+    nodeHash: Map<any, any>;
+    edgeHash: Map<any, any>;
+    nodes: any[];
+    edges: any[];
+    hierarchicalNetwork: boolean;
+    type: string;
+};

package/dist/processing/networkLayoutHelpers.d.ts

@@ -0,0 +1,54 @@
+export { hierarchicalTypeHash } from "./layouts/hierarchyLayout";
+export { sankeyOrientHash } from "./layouts/sankeyLayout";
+export declare function determineNodeIcon(baseCustomNodeIcon: any, networkSettings: any, size: any, nodes: any): any;
+export declare function determineEdgeIcon({ baseCustomEdgeIcon, networkSettings, size, graph, nodes }: {
+    baseCustomEdgeIcon: any;
+    networkSettings: any;
+    size: any;
+    graph: any;
+    nodes: any;
+}): any;
+export declare const basicMiddle: (d: any) => {
+    edge: any;
+    x: number;
+    y: number;
+};
+export declare const edgePointHash: {
+    sankey: (d: any) => {
+        edge: any;
+        x: number;
+        y: any;
+    };
+    force: (d: any) => {
+        edge: any;
+        x: number;
+        y: number;
+    };
+    tree: (d: any) => {
+        edge: any;
+        x: number;
+        y: number;
+    };
+    cluster: (d: any) => {
+        edge: any;
+        x: number;
+        y: number;
+    };
+    matrix: (d: any) => {
+        edge: any;
+        x: any;
+        y: any;
+    };
+};
+export declare const hierarchicalProjectable: {
+    partition: boolean;
+    cluster: boolean;
+    tree: boolean;
+    dendrogram: boolean;
+};
+export declare const radialProjectable: {
+    partition: boolean;
+    cluster: boolean;
+    tree: boolean;
+    dendrogram: boolean;
+};

package/dist/processing/ordinal.d.ts

@@ -1,64 +1,62 @@
 import * as React from "react";
-import { orFrameConnectionRenderer } from "../svg/frameFunctions";
+import { OrdinalPipelineCache } from "../data/ordinalPipelineCache";
 import { OrdinalFrameProps, OrdinalFrameState, PieceTypeSettings } from "../types/ordinalTypes";
 import { AxisProps } from "../types/annotationTypes";
-import { GenericObject } from "../types/generalTypes";
-import { ScaleBand } from "d3-scale";
+import { ScaleBand, ScaleLinear } from "d3-scale";
+export { layoutHash, midMod, zeroFunction, twoPI, naturalLanguageTypes } from "./ordinalConstants";
+export { generateColumnOverlays } from "./ordinalOverlays";
+export type { GenerateColumnOverlaysArgs } from "./ordinalOverlays";
+export { assembleRenderPipeline } from "./ordinalRenderPipeline";
+export type { AssembleRenderPipelineArgs } from "./ordinalRenderPipeline";
 export declare const calculateMappedMiddles: (oScale: ScaleBand<string>, middleMax: number, padding: number) => {};
-export declare const calculateOrdinalFrame: (currentProps: OrdinalFrameProps, currentState: OrdinalFrameState) => {
-    pieceDataXY: any;
+export declare const calculateOrdinalFrame: (currentProps: OrdinalFrameProps, currentState: OrdinalFrameState, cache: OrdinalPipelineCache) => {
     adjustedPosition: number[];
     adjustedSize: number[];
     backgroundGraphics: Function | React.ReactNode;
     foregroundGraphics: Function | React.ReactNode;
     axisData: AxisProps[];
-    axes: JSX.Element[];
-    axesTickLines: Object[];
+    axes: React.ReactNode[];
+    axesTickLines: object[];
     oLabels: {
-        labels: any;
+        labels: React.ReactNode;
     };
     title: object;
-    columnOverlays: any;
+    columnOverlays: Record<string, any>[];
     renderNumber: number;
-    oAccessor: ((arg?: GenericObject, index?: number) => string | number)[];
-    rAccessor: ((arg?: GenericObject, index?: number) => number)[];
-    oScaleType: any;
-    rScaleType: any;
+    oScaleType: ScaleBand<string>;
+    rScaleType: ScaleLinear<number, number, never>;
     oExtent: string[];
     rExtent: number[];
-    oScale: any;
-    rScale: any;
+    oScale: ScaleBand<string>;
+    rScale: ScaleLinear<number, number, never>;
     calculatedOExtent: string[];
     calculatedRExtent: number[];
-    projectedColumns: {};
+    projectedColumns: {
+        [key: string]: Record<string, any>;
+    };
     margin: import("../types/generalTypes").MarginType;
     legendSettings: any;
     orFrameRender: {
         connectors: {
             accessibleTransform: (data: any, i: any) => any;
-            projection: import("../types/generalTypes").ProjectionTypes;
-            data: {
-                keyedData: any;
-                oExtent: string[];
-            };
-            styleFn: (d?: GenericObject, i?: number) => GenericObject;
-            classFn: (d?: GenericObject, i?: number) => string;
-            renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
-            canvasRender: (d?: GenericObject, i?: number) => boolean;
-            behavior: typeof orFrameConnectionRenderer;
-            type: {
-                type?: string | Function;
-            };
-            eventListenersGenerator: () => {};
+            projection: string;
+            data: object[];
+            styleFn: Function;
+            classFn: Function;
+            renderMode: Function;
+            canvasRender: Function;
+            behavior: typeof import("../svg/frameFunctions").orFrameConnectionRenderer;
+            type: Record<string, any>;
+            eventListenersGenerator: () => Record<string, never>;
             pieceType: PieceTypeSettings;
         };
         summaries: {
             accessibleTransform: (data: any, i: any) => {
                 type: string;
-                column: any;
+                column: Record<string, any>;
                 pieces: any;
                 summary: any;
-                oAccessor: ((arg?: GenericObject, index?: number) => string | number)[];
+                oAccessor: Function[];
             };
             data: object[];
             behavior: ({ data, canvasRender, canvasDrawing }: {
@@ -66,37 +64,39 @@ export declare const calculateOrdinalFrame: (currentProps: OrdinalFrameProps, cu
                 canvasRender: any;
                 canvasDrawing: any;
             }) => JSX.Element[];
-            canvasRender: (d?: GenericObject, i?: number) => boolean;
-            styleFn: (d?: GenericObject, i?: number) => GenericObject;
-            classFn: (d?: GenericObject, i?: number) => string;
+            canvasRender: Function;
+            styleFn: Function;
+            classFn: Function;
         };
         pieces: {
             accessibleTransform: (data: any, i: any) => any;
             shouldRender: boolean;
-            data: any[];
-            behavior: ({ data, shouldRender, canvasRender, canvasDrawing, styleFn, classFn, baseMarkProps, renderKeyFn, ariaLabel, axis }: {
+            data: Record<string, any>[];
+            behavior: ({ data, shouldRender, canvasRender, canvasDrawing, styleFn, classFn, renderKeyFn, ariaLabel, axis }: {
                 data: any;
                 shouldRender: any;
                 canvasRender: any;
                 canvasDrawing: any;
                 styleFn: any;
                 classFn: any;
-                baseMarkProps: any;
                 renderKeyFn: any;
                 ariaLabel: any;
                 axis: any;
             }) => any[];
-            canvasRender: (d?: GenericObject, i?: number) => boolean;
-            styleFn: (d?: GenericObject, i?: number) => GenericObject;
-            classFn: (d?: GenericObject, i?: number) => string;
+            canvasRender: Function;
+            styleFn: Function;
+            classFn: Function;
             axis: AxisProps[];
             ariaLabel: any;
         };
     };
+    pieceIDAccessor: import("../types/generalTypes").GenericAccessor<string>;
+    props: OrdinalFrameProps<Record<string, any>>;
+    pieceDataXY: any;
+    oAccessor: ((arg?: Record<string, any>, index?: number) => string | number)[];
+    rAccessor: ((arg?: Record<string, any>, index?: number) => number)[];
     summaryType: {
         type?: string | Function;
     };
     type: PieceTypeSettings;
-    pieceIDAccessor: (d?: GenericObject, i?: number) => string;
-    props: OrdinalFrameProps;
 };

package/dist/processing/ordinalConstants.d.ts

@@ -0,0 +1,33 @@
+import { clusterBarLayout, barLayout, pointLayout, swarmLayout, timelineLayout } from "../svg/pieceLayouts";
+export declare const layoutHash: {
+    clusterbar: typeof clusterBarLayout;
+    bar: typeof barLayout;
+    point: typeof pointLayout;
+    swarm: typeof swarmLayout;
+    timeline: typeof timelineLayout;
+};
+export declare const midMod: (d: any) => any;
+export declare const zeroFunction: () => any;
+export declare const twoPI: number;
+export declare const naturalLanguageTypes: {
+    bar: {
+        items: string;
+        chart: string;
+    };
+    clusterbar: {
+        items: string;
+        chart: string;
+    };
+    swarm: {
+        items: string;
+        chart: string;
+    };
+    point: {
+        items: string;
+        chart: string;
+    };
+    timeline: {
+        items: string;
+        chart: string;
+    };
+};

package/dist/processing/ordinalOverlays.d.ts

@@ -0,0 +1,33 @@
+import { ProjectionTypes } from "../types/generalTypes";
+interface PieArc {
+    markD: string;
+    centroid: number[];
+    translate: number[];
+    midAngle: number;
+}
+interface ProjectedColumn {
+    width: number;
+    x: number;
+    middle: number;
+    y: number;
+    pieceData: Record<string, any>[];
+    pieArc?: PieArc;
+    [key: string]: unknown;
+}
+export interface GenerateColumnOverlaysArgs {
+    oExtent: string[];
+    projectedColumns: {
+        [key: string]: ProjectedColumn;
+    };
+    rScale: {
+        range: () => number[];
+    };
+    pieArcs: PieArc[];
+    padding: number;
+    projection: ProjectionTypes;
+    customDoubleClickBehavior?: Function;
+    customClickBehavior?: Function;
+    customHoverBehavior?: Function;
+}
+export declare function generateColumnOverlays({ oExtent, projectedColumns, rScale, pieArcs, padding, projection, customDoubleClickBehavior, customClickBehavior, customHoverBehavior }: GenerateColumnOverlaysArgs): Record<string, any>[];
+export {};

package/dist/processing/ordinalRenderPipeline.d.ts

@@ -0,0 +1,148 @@
+import * as React from "react";
+import { orFrameConnectionRenderer } from "../svg/frameFunctions";
+import { OrdinalFrameProps, OrdinalFrameState, PieceTypeSettings, ProjectedOrdinalSummary } from "../types/ordinalTypes";
+import { AxisProps } from "../types/annotationTypes";
+import { MarginType, GenericAccessor } from "../types/generalTypes";
+import { ScaleBand, ScaleLinear } from "d3-scale";
+export interface AssembleRenderPipelineArgs {
+    usesPieceOverlays: boolean;
+    shouldRecalculateOverlay: boolean;
+    calculatedPieceData: Record<string, any>[];
+    projection: string;
+    customClickBehavior?: Function;
+    customDoubleClickBehavior?: Function;
+    customHoverBehavior?: Function;
+    currentState: OrdinalFrameState;
+    connectorStyle: Function;
+    connectorClass: Function;
+    connectorRenderMode: Function;
+    connectorCanvasRender: Function;
+    summaryCanvasRender: Function;
+    pieceCanvasRender: Function;
+    connectorType: Record<string, any>;
+    eventListenersGenerator: () => Record<string, never>;
+    pieceType: PieceTypeSettings;
+    summaryStyle: Function;
+    summaryClass: Function;
+    pieceStyle: Function;
+    pieceClass: Function;
+    keyedData: {
+        [key: string]: Record<string, any>[];
+    };
+    oExtent: string[];
+    projectedColumns: {
+        [key: string]: Record<string, any>;
+    };
+    calculatedSummaries: ProjectedOrdinalSummary;
+    oAccessor: Function[];
+    rScale: ScaleLinear<number, number>;
+    calculatedRExtent: number[];
+    calculatedOExtent: string[];
+    rExtentSettings: Record<string, any>;
+    oExtentSettings: {
+        extent?: string[];
+        onChange?: Function;
+    };
+    adjustedPosition: number[];
+    adjustedSize: number[];
+    margin: MarginType;
+    backgroundGraphics?: React.ReactNode | Function;
+    foregroundGraphics?: React.ReactNode | Function;
+    arrayWrappedAxis?: AxisProps[];
+    axis: React.ReactNode[];
+    axesTickLines: object[];
+    oLabels: React.ReactNode;
+    title: object;
+    columnOverlays: Record<string, any>[];
+    oScaleType: ScaleBand<string>;
+    instantiatedRScaleType: ScaleLinear<number, number>;
+    oScale: ScaleBand<string>;
+    rExtent: number[];
+    legend?: object | boolean;
+    pieceIDAccessor: GenericAccessor<string>;
+    currentProps: OrdinalFrameProps;
+}
+export declare function assembleRenderPipeline(args: AssembleRenderPipelineArgs): {
+    adjustedPosition: number[];
+    adjustedSize: number[];
+    backgroundGraphics: Function | React.ReactNode;
+    foregroundGraphics: Function | React.ReactNode;
+    axisData: AxisProps[];
+    axes: React.ReactNode[];
+    axesTickLines: object[];
+    oLabels: {
+        labels: React.ReactNode;
+    };
+    title: object;
+    columnOverlays: Record<string, any>[];
+    renderNumber: number;
+    oScaleType: ScaleBand<string>;
+    rScaleType: ScaleLinear<number, number, never>;
+    oExtent: string[];
+    rExtent: number[];
+    oScale: ScaleBand<string>;
+    rScale: ScaleLinear<number, number, never>;
+    calculatedOExtent: string[];
+    calculatedRExtent: number[];
+    projectedColumns: {
+        [key: string]: Record<string, any>;
+    };
+    margin: MarginType;
+    legendSettings: any;
+    orFrameRender: {
+        connectors: {
+            accessibleTransform: (data: any, i: any) => any;
+            projection: string;
+            data: object[];
+            styleFn: Function;
+            classFn: Function;
+            renderMode: Function;
+            canvasRender: Function;
+            behavior: typeof orFrameConnectionRenderer;
+            type: Record<string, any>;
+            eventListenersGenerator: () => Record<string, never>;
+            pieceType: PieceTypeSettings;
+        };
+        summaries: {
+            accessibleTransform: (data: any, i: any) => {
+                type: string;
+                column: Record<string, any>;
+                pieces: any;
+                summary: any;
+                oAccessor: Function[];
+            };
+            data: object[];
+            behavior: ({ data, canvasRender, canvasDrawing }: {
+                data: any;
+                canvasRender: any;
+                canvasDrawing: any;
+            }) => JSX.Element[];
+            canvasRender: Function;
+            styleFn: Function;
+            classFn: Function;
+        };
+        pieces: {
+            accessibleTransform: (data: any, i: any) => any;
+            shouldRender: boolean;
+            data: Record<string, any>[];
+            behavior: ({ 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[];
+            canvasRender: Function;
+            styleFn: Function;
+            classFn: Function;
+            axis: AxisProps[];
+            ariaLabel: any;
+        };
+    };
+    pieceIDAccessor: GenericAccessor<string>;
+    props: OrdinalFrameProps<Record<string, any>>;
+};