semiotic 3.0.0-beta.2 → 3.0.0-beta.4

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

@@ -1,498 +0,0 @@
-"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

@@ -1,70 +0,0 @@
-"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

@@ -1,38 +0,0 @@
-"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 };
-}