semiotic 2.0.3 → 3.0.0-beta.2

package/ai/dist/src/components/stream/NetworkPipelineStore.js

@@ -0,0 +1,498 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkPipelineStore = void 0;
+const d3_interpolate_1 = require("d3-interpolate");
+const ParticlePool_1 = require("./ParticlePool");
+const layouts_1 = require("./layouts");
+const networkTypes_1 = require("./networkTypes");
+const CURVATURE = 0.5;
+/**
+ * NetworkPipelineStore — stateful store for the StreamNetworkFrame.
+ *
+ * Absorbs TopologyStore's functionality (mutable Maps, tension tracking,
+ * bezier caching) and adds layout plugin dispatch and scene graph generation.
+ *
+ * For bounded data: ingests nodes/edges arrays, runs layout once, builds scene.
+ * For streaming data: ingests edge pushes, tracks tension, relayouts on threshold.
+ */
+class NetworkPipelineStore {
+    constructor(config) {
+        // ── Topology ──────────────────────────────────────────────────────────
+        this.nodes = new Map();
+        this.edges = new Map();
+        this.tension = 0;
+        this.layoutVersion = 0;
+        // ── Scene graph ───────────────────────────────────────────────────────
+        this.sceneNodes = [];
+        this.sceneEdges = [];
+        this.labels = [];
+        // ── Particles ─────────────────────────────────────────────────────────
+        this.particlePool = null;
+        // ── Transition animation ──────────────────────────────────────────────
+        this.transition = null;
+        this.config = config;
+        this.tensionConfig = {
+            ...networkTypes_1.DEFAULT_TENSION_CONFIG,
+            ...config.tensionConfig
+        };
+        // Lazy particle pool — only for sankey with particles
+        if (config.chartType === "sankey" && config.showParticles) {
+            this.particlePool = new ParticlePool_1.ParticlePool(2000);
+        }
+    }
+    // ── Config update ─────────────────────────────────────────────────────
+    updateConfig(config) {
+        this.config = config;
+        this.tensionConfig = {
+            ...networkTypes_1.DEFAULT_TENSION_CONFIG,
+            ...config.tensionConfig
+        };
+        // Create/destroy particle pool based on config
+        if (config.chartType === "sankey" && config.showParticles) {
+            if (!this.particlePool) {
+                this.particlePool = new ParticlePool_1.ParticlePool(2000);
+            }
+        }
+        else {
+            this.particlePool = null;
+        }
+    }
+    // ── Hierarchy data ingestion ──────────────────────────────────────────
+    /**
+     * Ingest hierarchy root data for tree/treemap/circlepack/partition layouts.
+     * The hierarchy root is passed to the layout plugin via config.__hierarchyRoot.
+     */
+    ingestHierarchy(rootData, size) {
+        this.nodes.clear();
+        this.edges.clear();
+        this.config.__hierarchyRoot = rootData;
+        // Run layout — the hierarchical plugin will populate nodes/edges
+        this.runLayout(size);
+    }
+    // ── Bounded data ingestion ────────────────────────────────────────────
+    /**
+     * Ingest bounded node/edge arrays (from props).
+     * Clears existing topology and rebuilds from scratch.
+     */
+    ingestBounded(rawNodes, rawEdges, size) {
+        const { nodeIDAccessor = "id", sourceAccessor = "source", targetAccessor = "target", valueAccessor = "value" } = this.config;
+        const getNodeId = typeof nodeIDAccessor === "function"
+            ? nodeIDAccessor
+            : (d) => d[nodeIDAccessor];
+        const getSource = typeof sourceAccessor === "function"
+            ? sourceAccessor
+            : (d) => d[sourceAccessor];
+        const getTarget = typeof targetAccessor === "function"
+            ? targetAccessor
+            : (d) => d[targetAccessor];
+        const getValue = typeof valueAccessor === "function"
+            ? valueAccessor
+            : (d) => d[valueAccessor] ?? 1;
+        this.nodes.clear();
+        this.edges.clear();
+        // Build node map
+        for (const raw of rawNodes) {
+            const id = String(getNodeId(raw));
+            this.nodes.set(id, {
+                ...createNode(id),
+                data: raw
+            });
+        }
+        // Build edge map (creating nodes if not provided)
+        for (const raw of rawEdges) {
+            const sourceId = String(getSource(raw));
+            const targetId = String(getTarget(raw));
+            const value = Number(getValue(raw)) || 1;
+            if (!this.nodes.has(sourceId)) {
+                this.nodes.set(sourceId, { ...createNode(sourceId), data: raw });
+            }
+            if (!this.nodes.has(targetId)) {
+                this.nodes.set(targetId, { ...createNode(targetId), data: raw });
+            }
+            const key = `${sourceId}\0${targetId}`;
+            this.edges.set(key, {
+                source: sourceId,
+                target: targetId,
+                value,
+                y0: 0,
+                y1: 0,
+                sankeyWidth: 0,
+                data: raw
+            });
+        }
+        // Run layout
+        this.runLayout(size);
+    }
+    // ── Streaming data ingestion ──────────────────────────────────────────
+    /**
+     * Unique key for an edge (same as TopologyStore).
+     */
+    edgeKey(source, target) {
+        return `${source}\0${target}`;
+    }
+    /**
+     * Ingest a pushed edge. Creates nodes/edges as needed and accumulates tension.
+     * Returns true if a relayout is needed.
+     */
+    ingestEdge(push) {
+        const { source, target, value } = push;
+        const isFirst = this.nodes.size === 0;
+        let topologyChanged = false;
+        if (!this.nodes.has(source)) {
+            this.nodes.set(source, createNode(source));
+            this.tension += this.tensionConfig.newNode;
+            topologyChanged = true;
+        }
+        if (!this.nodes.has(target)) {
+            this.nodes.set(target, createNode(target));
+            this.tension += this.tensionConfig.newNode;
+            topologyChanged = true;
+        }
+        const key = this.edgeKey(source, target);
+        const existing = this.edges.get(key);
+        if (existing) {
+            existing.value += value;
+            this.tension += this.tensionConfig.weightChange;
+        }
+        else {
+            this.edges.set(key, {
+                source,
+                target,
+                value,
+                y0: 0,
+                y1: 0,
+                sankeyWidth: 0
+            });
+            this.tension += this.tensionConfig.newEdge;
+            topologyChanged = true;
+        }
+        return isFirst || topologyChanged || this.tension >= this.tensionConfig.threshold;
+    }
+    // ── Layout execution ──────────────────────────────────────────────────
+    /**
+     * Run the layout algorithm via the appropriate plugin.
+     */
+    runLayout(size) {
+        const plugin = (0, layouts_1.getLayoutPlugin)(this.config.chartType);
+        if (!plugin)
+            return;
+        let nodesArr = Array.from(this.nodes.values());
+        let edgesArr = Array.from(this.edges.values());
+        // For hierarchical plugins the store's Maps are empty — the plugin
+        // populates the nodes/edges arrays itself from config.__hierarchyRoot.
+        // Skip the early exit so the plugin gets called.
+        if (nodesArr.length === 0 && !plugin.hierarchical)
+            return;
+        // Save previous positions for transition
+        this.prepareForRelayout();
+        // Execute layout — hierarchical plugins push into the arrays directly
+        plugin.computeLayout(nodesArr, edgesArr, this.config, size);
+        // After hierarchical layout, sync the populated arrays back into the
+        // store's Maps so buildScene and getLayoutData work correctly.
+        if (plugin.hierarchical && nodesArr.length > 0) {
+            this.nodes.clear();
+            this.edges.clear();
+            for (const node of nodesArr) {
+                this.nodes.set(node.id, node);
+            }
+            for (const edge of edgesArr) {
+                const srcId = typeof edge.source === "string" ? edge.source : edge.source.id;
+                const tgtId = typeof edge.target === "string" ? edge.target : edge.target.id;
+                this.edges.set(`${srcId}\0${tgtId}`, edge);
+            }
+        }
+        // Finalize — update derived properties and bezier caches
+        this.finalizeLayout();
+        // Save target positions for animation
+        this.saveTargetPositions();
+        // Check if we have meaningful previous positions to animate from
+        const hasOldPositions = nodesArr.some((n) => n._prevX0 !== undefined &&
+            (n._prevX0 !== 0 || n._prevX1 !== 0 || n._prevY0 !== 0 || n._prevY1 !== 0));
+        if (hasOldPositions && this.tensionConfig.transitionDuration > 0) {
+            // Reset to previous positions (animation starts from here)
+            this.restorePreviousPositions();
+            // Start transition
+            this.transition = {
+                startTime: performance.now(),
+                duration: this.tensionConfig.transitionDuration
+            };
+        }
+        this.layoutVersion++;
+    }
+    /**
+     * Build the scene graph from current layout positions.
+     */
+    buildScene(size) {
+        const plugin = (0, layouts_1.getLayoutPlugin)(this.config.chartType);
+        if (!plugin)
+            return;
+        const nodesArr = Array.from(this.nodes.values());
+        const edgesArr = Array.from(this.edges.values());
+        const { sceneNodes, sceneEdges, labels } = plugin.buildScene(nodesArr, edgesArr, this.config, size);
+        this.sceneNodes = sceneNodes;
+        this.sceneEdges = sceneEdges;
+        this.labels = labels;
+    }
+    // ── Transition animation ──────────────────────────────────────────────
+    /**
+     * Advance the transition animation. Returns true if still animating.
+     */
+    advanceTransition(now) {
+        if (!this.transition)
+            return false;
+        const elapsed = now - this.transition.startTime;
+        const rawT = Math.min(elapsed / this.transition.duration, 1);
+        // Ease-out cubic
+        const t = 1 - Math.pow(1 - rawT, 3);
+        for (const node of this.nodes.values()) {
+            if (node._targetX0 !== undefined &&
+                node._prevX0 !== undefined &&
+                (node._prevX0 !== 0 || node._prevX1 !== 0)) {
+                node.x0 = node._prevX0 + (node._targetX0 - node._prevX0) * t;
+                node.x1 = node._prevX1 + (node._targetX1 - node._prevX1) * t;
+                node.y0 = node._prevY0 + (node._targetY0 - node._prevY0) * t;
+                node.y1 = node._prevY1 + (node._targetY1 - node._prevY1) * t;
+            }
+        }
+        for (const edge of this.edges.values()) {
+            if (edge._targetY0 !== undefined &&
+                edge._prevY0 !== undefined &&
+                edge._prevSankeyWidth !== undefined &&
+                edge._prevSankeyWidth > 0) {
+                edge.y0 = edge._prevY0 + (edge._targetY0 - edge._prevY0) * t;
+                edge.y1 = edge._prevY1 + (edge._targetY1 - edge._prevY1) * t;
+                edge.sankeyWidth =
+                    edge._prevSankeyWidth + (edge._targetSankeyWidth - edge._prevSankeyWidth) * t;
+            }
+        }
+        // Rebuild beziers for new interpolated positions
+        this.rebuildAllBeziers();
+        if (rawT >= 1) {
+            // Snap to final target positions
+            this.snapToTargets();
+            this.transition = null;
+            return false;
+        }
+        return true;
+    }
+    // ── Topology helpers (ported from TopologyStore) ──────────────────────
+    prepareForRelayout() {
+        for (const node of this.nodes.values()) {
+            node._prevX0 = node.x0;
+            node._prevX1 = node.x1;
+            node._prevY0 = node.y0;
+            node._prevY1 = node.y1;
+        }
+        for (const edge of this.edges.values()) {
+            edge._prevY0 = edge.y0;
+            edge._prevY1 = edge.y1;
+            edge._prevSankeyWidth = edge.sankeyWidth;
+        }
+    }
+    finalizeLayout() {
+        const direction = this.config.orientation === "vertical" ? "down" : "right";
+        for (const node of this.nodes.values()) {
+            // Sankey/treemap/partition set x0/x1/y0/y1 — derive x/y from those.
+            // Force/chord set x/y directly — derive x0/x1 from x/y.
+            const hasBox = node.x0 !== 0 || node.x1 !== 0 || node.y0 !== 0 || node.y1 !== 0;
+            if (hasBox) {
+                node.width = node.x1 - node.x0;
+                node.height = node.y1 - node.y0;
+                node.x = node.x0 + node.width / 2;
+                node.y = node.y0 + node.height / 2;
+            }
+            else {
+                // x/y already set by layout (force, chord) — synthesize a bounding box
+                const r = 5;
+                node.x0 = node.x - r;
+                node.x1 = node.x + r;
+                node.y0 = node.y - r;
+                node.y1 = node.y + r;
+                node.width = r * 2;
+                node.height = r * 2;
+            }
+        }
+        for (const edge of this.edges.values()) {
+            edge.direction = direction;
+            this.updateEdgeBezier(edge);
+        }
+        this.tension = 0;
+    }
+    saveTargetPositions() {
+        for (const node of this.nodes.values()) {
+            node._targetX0 = node.x0;
+            node._targetX1 = node.x1;
+            node._targetY0 = node.y0;
+            node._targetY1 = node.y1;
+        }
+        for (const edge of this.edges.values()) {
+            edge._targetY0 = edge.y0;
+            edge._targetY1 = edge.y1;
+            edge._targetSankeyWidth = edge.sankeyWidth;
+        }
+    }
+    restorePreviousPositions() {
+        for (const node of this.nodes.values()) {
+            if (node._prevX0 !== undefined &&
+                (node._prevX0 !== 0 || node._prevX1 !== 0)) {
+                node.x0 = node._prevX0;
+                node.x1 = node._prevX1;
+                node.y0 = node._prevY0;
+                node.y1 = node._prevY1;
+            }
+        }
+        for (const edge of this.edges.values()) {
+            if (edge._prevY0 !== undefined &&
+                edge._prevSankeyWidth !== undefined &&
+                edge._prevSankeyWidth > 0) {
+                edge.y0 = edge._prevY0;
+                edge.y1 = edge._prevY1;
+                edge.sankeyWidth = edge._prevSankeyWidth;
+            }
+        }
+        this.rebuildAllBeziers();
+    }
+    snapToTargets() {
+        for (const node of this.nodes.values()) {
+            if (node._targetX0 !== undefined) {
+                node.x0 = node._targetX0;
+                node.x1 = node._targetX1;
+                node.y0 = node._targetY0;
+                node.y1 = node._targetY1;
+            }
+        }
+        for (const edge of this.edges.values()) {
+            if (edge._targetY0 !== undefined) {
+                edge.y0 = edge._targetY0;
+                edge.y1 = edge._targetY1;
+                edge.sankeyWidth = edge._targetSankeyWidth;
+            }
+        }
+        this.rebuildAllBeziers();
+    }
+    // ── Bezier caching (ported from TopologyStore) ────────────────────────
+    updateEdgeBezier(edge) {
+        const sourceNode = typeof edge.source === "string"
+            ? this.nodes.get(edge.source)
+            : edge.source;
+        const targetNode = typeof edge.target === "string"
+            ? this.nodes.get(edge.target)
+            : edge.target;
+        if (!sourceNode || !targetNode)
+            return;
+        if (edge.circular && edge.circularPathData) {
+            edge.bezier = this.buildCircularBezier(edge);
+        }
+        else {
+            edge.bezier = this.buildStandardBezier(edge, sourceNode, targetNode);
+        }
+    }
+    buildStandardBezier(edge, sourceNode, targetNode) {
+        const hw = (edge.sankeyWidth || 1) / 2;
+        if (edge.direction === "down") {
+            const y0 = sourceNode.y1;
+            const y1 = targetNode.y0;
+            const xi = (0, d3_interpolate_1.interpolateNumber)(y0, y1);
+            const p0 = { x: edge.y0, y: y0 };
+            const p1 = { x: edge.y0, y: xi(CURVATURE) };
+            const p2 = { x: edge.y1, y: xi(1 - CURVATURE) };
+            const p3 = { x: edge.y1, y: y1 };
+            return { circular: false, points: [p0, p1, p2, p3], halfWidth: hw };
+        }
+        // Horizontal (default)
+        const x0 = sourceNode.x1;
+        const x1 = targetNode.x0;
+        const xi = (0, d3_interpolate_1.interpolateNumber)(x0, x1);
+        const p0 = { x: x0, y: edge.y0 };
+        const p1 = { x: xi(CURVATURE), y: edge.y0 };
+        const p2 = { x: xi(1 - CURVATURE), y: edge.y1 };
+        const p3 = { x: x1, y: edge.y1 };
+        return { circular: false, points: [p0, p1, p2, p3], halfWidth: hw };
+    }
+    buildCircularBezier(edge) {
+        const hw = (edge.sankeyWidth || 1) / 2;
+        const cpd = edge.circularPathData;
+        let waypoints;
+        if (edge.direction === "down") {
+            waypoints = [
+                { x: cpd.sourceY, y: cpd.sourceX },
+                { x: cpd.sourceY, y: cpd.leftFullExtent },
+                { x: cpd.verticalFullExtent, y: cpd.leftFullExtent },
+                { x: cpd.verticalFullExtent, y: cpd.rightFullExtent },
+                { x: cpd.targetY, y: cpd.rightFullExtent },
+                { x: cpd.targetY, y: cpd.targetX }
+            ];
+        }
+        else {
+            waypoints = [
+                { x: cpd.sourceX, y: cpd.sourceY },
+                { x: cpd.leftFullExtent, y: cpd.sourceY },
+                { x: cpd.leftFullExtent, y: cpd.verticalFullExtent },
+                { x: cpd.rightFullExtent, y: cpd.verticalFullExtent },
+                { x: cpd.rightFullExtent, y: cpd.targetY },
+                { x: cpd.targetX, y: cpd.targetY }
+            ];
+        }
+        const segments = [];
+        for (let i = 0; i < waypoints.length - 1; i++) {
+            const a = waypoints[i];
+            const b = waypoints[i + 1];
+            const dx = b.x - a.x;
+            const dy = b.y - a.y;
+            segments.push([
+                a,
+                { x: a.x + dx / 3, y: a.y + dy / 3 },
+                { x: a.x + (2 * dx) / 3, y: a.y + (2 * dy) / 3 },
+                b
+            ]);
+        }
+        return { circular: true, segments, halfWidth: hw };
+    }
+    rebuildAllBeziers() {
+        for (const node of this.nodes.values()) {
+            node.width = node.x1 - node.x0;
+            node.height = node.y1 - node.y0;
+            node.x = node.x0 + node.width / 2;
+            node.y = node.y0 + node.height / 2;
+        }
+        for (const edge of this.edges.values()) {
+            this.updateEdgeBezier(edge);
+        }
+    }
+    // ── Public accessors ──────────────────────────────────────────────────
+    getLayoutData() {
+        return {
+            nodes: Array.from(this.nodes.values()),
+            edges: Array.from(this.edges.values())
+        };
+    }
+    clear() {
+        this.nodes.clear();
+        this.edges.clear();
+        this.tension = 0;
+        this.layoutVersion = 0;
+        this.sceneNodes = [];
+        this.sceneEdges = [];
+        this.labels = [];
+        this.transition = null;
+        if (this.particlePool) {
+            this.particlePool.clear();
+        }
+    }
+}
+exports.NetworkPipelineStore = NetworkPipelineStore;
+function createNode(id) {
+    return {
+        id,
+        x0: 0,
+        x1: 0,
+        y0: 0,
+        y1: 0,
+        x: 0,
+        y: 0,
+        width: 0,
+        height: 0,
+        value: 0,
+        createdByFrame: true
+    };
+}

package/ai/dist/src/components/stream/NetworkSVGOverlay.js

@@ -0,0 +1,70 @@
+"use client";
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkSVGOverlay = NetworkSVGOverlay;
+const React = __importStar(require("react"));
+/**
+ * SVG overlay for network charts — renders labels, title, legend, annotations.
+ *
+ * Unlike XY/ordinal overlays, network charts don't have axes or grid lines.
+ * The overlay is positioned absolutely over the canvas.
+ */
+function NetworkSVGOverlay(props) {
+    const { width, height, totalWidth, totalHeight, margin, labels, title, legend, foregroundGraphics, annotations, svgAnnotationRules, annotationFrame } = props;
+    return (React.createElement("svg", { width: totalWidth, height: totalHeight, style: {
+            position: "absolute",
+            top: 0,
+            left: 0,
+            pointerEvents: "none"
+        } },
+        React.createElement("g", { transform: `translate(${margin.left},${margin.top})` },
+            labels.map((label, i) => (React.createElement("text", { key: `label-${i}`, x: label.x, y: label.y, textAnchor: label.anchor || "start", dominantBaseline: (label.baseline || "middle"), fontSize: label.fontSize || 11, fontWeight: label.fontWeight, fill: label.fill || "currentColor", stroke: label.stroke, strokeWidth: label.strokeWidth, paintOrder: label.paintOrder, style: { pointerEvents: "none" } }, label.text))),
+            annotations &&
+                svgAnnotationRules &&
+                annotations.map((annotation, i) => {
+                    const element = svgAnnotationRules(annotation, i, {
+                        width,
+                        height
+                    });
+                    return element ? (React.createElement(React.Fragment, { key: `annotation-${i}` }, element)) : null;
+                }),
+            foregroundGraphics),
+        title && typeof title === "string" ? (React.createElement("text", { x: totalWidth / 2, y: 16, textAnchor: "middle", fontSize: 14, fontWeight: 600, fill: "currentColor" }, title)) : title ? (React.createElement("foreignObject", { x: 0, y: 0, width: totalWidth, height: margin.top }, title)) : null,
+        legend && typeof legend === "object" && "legendGroups" in legend ? (React.createElement("g", { transform: `translate(${totalWidth - margin.right + 10},${margin.top})` }, legend.legendGroups.map((group, gi) => (React.createElement("g", { key: `legend-group-${gi}` }, group.items?.map((item, ii) => (React.createElement("g", { key: `legend-item-${ii}`, transform: `translate(0,${ii * 20})` },
+            React.createElement("rect", { x: 0, y: 0, width: 12, height: 12, fill: item.color, rx: 2 }),
+            React.createElement("text", { x: 18, y: 10, fontSize: 11, fill: "currentColor" }, item.label))))))))) : legend ? (React.createElement("g", { transform: `translate(${totalWidth - margin.right + 10},${margin.top})` }, legend)) : null));
+}
+NetworkSVGOverlay.displayName = "NetworkSVGOverlay";

package/ai/dist/src/components/stream/NetworkSceneGraph.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCircleNode = buildCircleNode;
+exports.buildRectNode = buildRectNode;
+exports.buildArcNode = buildArcNode;
+exports.buildLineEdge = buildLineEdge;
+exports.buildBezierEdge = buildBezierEdge;
+exports.buildRibbonEdge = buildRibbonEdge;
+exports.buildCurvedEdge = buildCurvedEdge;
+exports.buildLabel = buildLabel;
+/**
+ * Builder functions for network scene nodes.
+ * Used by layout plugins to construct the scene graph.
+ */
+function buildCircleNode(cx, cy, r, style, datum, id, label, depth) {
+    return { type: "circle", cx, cy, r, style, datum, id, label, depth };
+}
+function buildRectNode(x, y, w, h, style, datum, id, label, depth) {
+    return { type: "rect", x, y, w, h, style, datum, id, label, depth };
+}
+function buildArcNode(cx, cy, innerR, outerR, startAngle, endAngle, style, datum, id, label) {
+    return { type: "arc", cx, cy, innerR, outerR, startAngle, endAngle, style, datum, id, label };
+}
+function buildLineEdge(x1, y1, x2, y2, style, datum) {
+    return { type: "line", x1, y1, x2, y2, style, datum };
+}
+function buildBezierEdge(pathD, style, datum, bezierCache) {
+    return { type: "bezier", pathD, bezierCache, style, datum };
+}
+function buildRibbonEdge(pathD, style, datum) {
+    return { type: "ribbon", pathD, style, datum };
+}
+function buildCurvedEdge(pathD, style, datum) {
+    return { type: "curved", pathD, style, datum };
+}
+function buildLabel(x, y, text, options) {
+    return { x, y, text, ...options };
+}