semiotic 2.0.3 → 3.0.0-beta.2

package/ai/dist/src/components/stream/renderers/lineCanvasRenderer.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineCanvasRenderer = void 0;
+function resolveColor(value, thresholds, baseColor) {
+    let color = baseColor;
+    for (const t of thresholds) {
+        if (t.thresholdType === "lesser") {
+            if (value < t.value)
+                color = t.color;
+        }
+        else {
+            if (value > t.value)
+                color = t.color;
+        }
+    }
+    return color;
+}
+/**
+ * Canvas line renderer.
+ * Renders LineSceneNode paths using moveTo/lineTo.
+ * Supports threshold-based segment coloring when colorThresholds + rawValues
+ * are present on the node.
+ */
+const lineCanvasRenderer = (ctx, nodes, scales, layout) => {
+    const lineNodes = nodes.filter((n) => n.type === "line");
+    for (const node of lineNodes) {
+        if (node.path.length < 2)
+            continue;
+        const baseColor = node.style.stroke || "#007bff";
+        const lineWidth = node.style.strokeWidth || 2;
+        const thresholds = node.colorThresholds;
+        const rawValues = node.rawValues;
+        if (node.style.strokeDasharray) {
+            ctx.setLineDash(node.style.strokeDasharray.split(/[\s,]+/).map(Number));
+        }
+        else {
+            ctx.setLineDash([]);
+        }
+        if (node.style.opacity != null) {
+            ctx.globalAlpha = node.style.opacity;
+        }
+        ctx.lineWidth = lineWidth;
+        // Fast path: no color thresholds — single-path draw
+        if (!thresholds || thresholds.length === 0 || !rawValues || rawValues.length !== node.path.length) {
+            ctx.beginPath();
+            ctx.strokeStyle = baseColor;
+            const [startX, startY] = node.path[0];
+            ctx.moveTo(startX, startY);
+            for (let i = 1; i < node.path.length; i++) {
+                ctx.lineTo(node.path[i][0], node.path[i][1]);
+            }
+            ctx.stroke();
+        }
+        else {
+            // Threshold mode: segment-based drawing with interpolated crossings
+            let prevX = null;
+            let prevY = null;
+            let prevValue = null;
+            let prevColor = null;
+            let pathStarted = false;
+            function startSegment(color, x, y) {
+                ctx.beginPath();
+                ctx.strokeStyle = color;
+                ctx.moveTo(x, y);
+                pathStarted = true;
+            }
+            function endSegment() {
+                if (pathStarted) {
+                    ctx.stroke();
+                    pathStarted = false;
+                }
+            }
+            for (let i = 0; i < node.path.length; i++) {
+                const [x, y] = node.path[i];
+                const v = rawValues[i];
+                const currColor = resolveColor(v, thresholds, baseColor);
+                if (prevX === null || prevColor === null || prevValue === null) {
+                    startSegment(currColor, x, y);
+                    prevX = x;
+                    prevY = y;
+                    prevValue = v;
+                    prevColor = currColor;
+                    continue;
+                }
+                if (currColor === prevColor) {
+                    ctx.lineTo(x, y);
+                }
+                else {
+                    // Find threshold crossings between prevValue and v
+                    const crossings = [];
+                    for (const threshold of thresholds) {
+                        const tv = threshold.value;
+                        if ((prevValue <= tv && v >= tv) || (prevValue >= tv && v <= tv)) {
+                            if (prevValue !== tv && v !== tv) {
+                                const interpT = (tv - prevValue) / (v - prevValue);
+                                crossings.push({ t: interpT });
+                            }
+                        }
+                    }
+                    crossings.sort((a, b) => a.t - b.t);
+                    for (const crossing of crossings) {
+                        const midX = prevX + (x - prevX) * crossing.t;
+                        const midY = prevY + (y - prevY) * crossing.t;
+                        const nudgedValue = prevValue + (v - prevValue) * Math.min(crossing.t + 0.0001, 1);
+                        const nextColor = resolveColor(nudgedValue, thresholds, baseColor);
+                        ctx.lineTo(midX, midY);
+                        endSegment();
+                        startSegment(nextColor, midX, midY);
+                    }
+                    ctx.lineTo(x, y);
+                }
+                prevX = x;
+                prevY = y;
+                prevValue = v;
+                prevColor = currColor;
+            }
+            endSegment();
+        }
+        // Fill area under line if fillOpacity is set
+        if (node.style.fill && node.style.fillOpacity && node.style.fillOpacity > 0) {
+            ctx.beginPath();
+            ctx.globalAlpha = node.style.fillOpacity;
+            ctx.fillStyle = node.style.fill;
+            const [startX, startY] = node.path[0];
+            ctx.moveTo(startX, startY);
+            for (let i = 1; i < node.path.length; i++) {
+                ctx.lineTo(node.path[i][0], node.path[i][1]);
+            }
+            const lastX = node.path[node.path.length - 1][0];
+            const firstX = node.path[0][0];
+            ctx.lineTo(lastX, layout.height);
+            ctx.lineTo(firstX, layout.height);
+            ctx.closePath();
+            ctx.fill();
+        }
+        ctx.globalAlpha = 1;
+        ctx.setLineDash([]);
+    }
+};
+exports.lineCanvasRenderer = lineCanvasRenderer;

package/ai/dist/src/components/stream/renderers/networkArcRenderer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networkArcRenderer = networkArcRenderer;
+/**
+ * Canvas painter for NetworkArcNode (chord diagram arc segments).
+ */
+function networkArcRenderer(ctx, nodes) {
+    for (const node of nodes) {
+        if (node.type !== "arc")
+            continue;
+        const a = node;
+        ctx.save();
+        if (a.style.opacity !== undefined) {
+            ctx.globalAlpha = a.style.opacity;
+        }
+        // Draw arc segment (annular sector)
+        ctx.beginPath();
+        ctx.arc(a.cx, a.cy, a.outerR, a.startAngle, a.endAngle);
+        ctx.arc(a.cx, a.cy, a.innerR, a.endAngle, a.startAngle, true);
+        ctx.closePath();
+        // Fill
+        if (a.style.fill) {
+            ctx.fillStyle = a.style.fill;
+            if (a.style.fillOpacity !== undefined) {
+                ctx.globalAlpha = (a.style.opacity ?? 1) * a.style.fillOpacity;
+            }
+            ctx.fill();
+        }
+        // Stroke
+        if (a.style.stroke && a.style.stroke !== "none") {
+            ctx.strokeStyle = a.style.stroke;
+            ctx.lineWidth = a.style.strokeWidth ?? 1;
+            ctx.globalAlpha = a.style.opacity ?? 1;
+            ctx.stroke();
+        }
+        ctx.restore();
+    }
+}

package/ai/dist/src/components/stream/renderers/networkCircleRenderer.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networkCircleRenderer = networkCircleRenderer;
+/**
+ * Canvas painter for NetworkCircleNode (force nodes, tree nodes, circlepack).
+ */
+function networkCircleRenderer(ctx, nodes) {
+    for (const node of nodes) {
+        if (node.type !== "circle")
+            continue;
+        const c = node;
+        if (c.r <= 0)
+            continue;
+        ctx.save();
+        if (c.style.opacity !== undefined) {
+            ctx.globalAlpha = c.style.opacity;
+        }
+        ctx.beginPath();
+        ctx.arc(c.cx, c.cy, c.r, 0, Math.PI * 2);
+        // Fill
+        if (c.style.fill) {
+            ctx.fillStyle = c.style.fill;
+            if (c.style.fillOpacity !== undefined) {
+                ctx.globalAlpha = (c.style.opacity ?? 1) * c.style.fillOpacity;
+            }
+            ctx.fill();
+        }
+        // Stroke
+        if (c.style.stroke && c.style.stroke !== "none") {
+            ctx.strokeStyle = c.style.stroke;
+            ctx.lineWidth = c.style.strokeWidth ?? 1;
+            ctx.globalAlpha = c.style.opacity ?? 1;
+            ctx.stroke();
+        }
+        ctx.restore();
+    }
+}

package/ai/dist/src/components/stream/renderers/networkEdgeRenderer.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networkEdgeRenderer = networkEdgeRenderer;
+/**
+ * Canvas painter for all network edge types.
+ *
+ * - bezier: Sankey flow bands (Path2D from SVG path string)
+ * - line: Force-directed straight edges
+ * - ribbon: Chord diagram ribbons
+ * - curved: Tree/cluster curved edges
+ */
+function networkEdgeRenderer(ctx, edges) {
+    for (const edge of edges) {
+        switch (edge.type) {
+            case "bezier":
+                renderBezierEdge(ctx, edge);
+                break;
+            case "line":
+                renderLineEdge(ctx, edge);
+                break;
+            case "ribbon":
+                renderRibbonEdge(ctx, edge);
+                break;
+            case "curved":
+                renderCurvedEdge(ctx, edge);
+                break;
+        }
+    }
+}
+function renderBezierEdge(ctx, edge) {
+    if (!edge.pathD)
+        return;
+    ctx.save();
+    const path = new Path2D(edge.pathD);
+    // Fill the band
+    if (edge.style.fill && edge.style.fill !== "none") {
+        ctx.fillStyle = edge.style.fill;
+        ctx.globalAlpha = edge.style.fillOpacity ?? edge.style.opacity ?? 0.5;
+        ctx.fill(path);
+    }
+    // Stroke the band outline
+    if (edge.style.stroke && edge.style.stroke !== "none") {
+        ctx.strokeStyle = edge.style.stroke;
+        ctx.lineWidth = edge.style.strokeWidth ?? 0.5;
+        ctx.globalAlpha = (edge.style.opacity ?? 1) * 0.5;
+        ctx.stroke(path);
+    }
+    ctx.restore();
+}
+function renderLineEdge(ctx, edge) {
+    ctx.save();
+    ctx.strokeStyle = edge.style.stroke || "#999";
+    ctx.lineWidth = edge.style.strokeWidth ?? 1;
+    if (edge.style.opacity !== undefined) {
+        ctx.globalAlpha = edge.style.opacity;
+    }
+    if (edge.style.strokeDasharray) {
+        ctx.setLineDash(edge.style.strokeDasharray.split(/[\s,]+/).map(Number));
+    }
+    ctx.beginPath();
+    ctx.moveTo(edge.x1, edge.y1);
+    ctx.lineTo(edge.x2, edge.y2);
+    ctx.stroke();
+    ctx.restore();
+}
+function renderRibbonEdge(ctx, edge) {
+    if (!edge.pathD)
+        return;
+    ctx.save();
+    const path = new Path2D(edge.pathD);
+    if (edge.style.fill && edge.style.fill !== "none") {
+        ctx.fillStyle = edge.style.fill;
+        ctx.globalAlpha = edge.style.fillOpacity ?? edge.style.opacity ?? 0.5;
+        ctx.fill(path);
+    }
+    if (edge.style.stroke && edge.style.stroke !== "none") {
+        ctx.strokeStyle = edge.style.stroke;
+        ctx.lineWidth = edge.style.strokeWidth ?? 0.5;
+        ctx.globalAlpha = (edge.style.opacity ?? 1) * 0.3;
+        ctx.stroke(path);
+    }
+    ctx.restore();
+}
+function renderCurvedEdge(ctx, edge) {
+    if (!edge.pathD)
+        return;
+    ctx.save();
+    const path = new Path2D(edge.pathD);
+    ctx.strokeStyle = edge.style.stroke || "#999";
+    ctx.lineWidth = edge.style.strokeWidth ?? 1;
+    if (edge.style.opacity !== undefined) {
+        ctx.globalAlpha = edge.style.opacity;
+    }
+    ctx.stroke(path);
+    // Fill if specified (usually not for tree edges)
+    if (edge.style.fill && edge.style.fill !== "none") {
+        ctx.fillStyle = edge.style.fill;
+        ctx.globalAlpha = edge.style.fillOpacity ?? 0.1;
+        ctx.fill(path);
+    }
+    ctx.restore();
+}

package/ai/dist/src/components/stream/renderers/networkParticleRenderer.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderNetworkParticles = renderNetworkParticles;
+exports.spawnNetworkParticles = spawnNetworkParticles;
+const networkTypes_1 = require("../networkTypes");
+/**
+ * Canvas particle renderer for sankey — ported directly from realtime-network.
+ * Called each rAF frame.
+ */
+function renderNetworkParticles(ctx, pool, edges, style, edgeColorFn) {
+    const radius = style.radius ?? networkTypes_1.DEFAULT_PARTICLE_STYLE.radius;
+    const opacity = style.opacity ?? networkTypes_1.DEFAULT_PARTICLE_STYLE.opacity;
+    ctx.globalAlpha = opacity;
+    for (let i = 0; i < pool.particles.length; i++) {
+        const p = pool.particles[i];
+        if (!p.active)
+            continue;
+        const edge = edges[p.edgeIndex];
+        if (!edge)
+            continue;
+        // Resolve color
+        if (typeof style.color === "function") {
+            const sourceNode = typeof edge.source === "object" ? edge.source : null;
+            ctx.fillStyle = sourceNode ? style.color(edge, sourceNode) : "#666";
+        }
+        else if (style.color && style.color !== "inherit") {
+            ctx.fillStyle = style.color;
+        }
+        else {
+            ctx.fillStyle = edgeColorFn(edge);
+        }
+        ctx.beginPath();
+        ctx.arc(p.x, p.y, radius, 0, Math.PI * 2);
+        ctx.fill();
+    }
+    ctx.globalAlpha = 1;
+}
+/**
+ * Spawn particles for all edges proportional to their value.
+ */
+function spawnNetworkParticles(pool, edges, deltaTime, style) {
+    const spawnRate = style.spawnRate ?? networkTypes_1.DEFAULT_PARTICLE_STYLE.spawnRate;
+    const maxPerEdge = style.maxPerEdge ?? networkTypes_1.DEFAULT_PARTICLE_STYLE.maxPerEdge;
+    for (let i = 0; i < edges.length; i++) {
+        const edge = edges[i];
+        if (!edge.bezier)
+            continue;
+        const currentCount = pool.countForEdge(i);
+        if (currentCount >= maxPerEdge)
+            continue;
+        const rate = edge.value * spawnRate * deltaTime;
+        const whole = Math.floor(rate);
+        const frac = rate - whole;
+        let toSpawn = whole;
+        if (Math.random() < frac)
+            toSpawn++;
+        for (let j = 0; j < toSpawn; j++) {
+            if (pool.countForEdge(i) >= maxPerEdge)
+                break;
+            pool.spawn(i);
+        }
+    }
+}

package/ai/dist/src/components/stream/renderers/networkRectRenderer.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networkRectRenderer = networkRectRenderer;
+/**
+ * Canvas painter for NetworkRectNode (sankey nodes, treemap cells, partition blocks).
+ */
+function networkRectRenderer(ctx, nodes) {
+    for (const node of nodes) {
+        if (node.type !== "rect")
+            continue;
+        const r = node;
+        if (r.w <= 0 || r.h <= 0)
+            continue;
+        ctx.save();
+        if (r.style.opacity !== undefined) {
+            ctx.globalAlpha = r.style.opacity;
+        }
+        // Fill
+        if (r.style.fill) {
+            ctx.fillStyle = r.style.fill;
+            if (r.style.fillOpacity !== undefined) {
+                ctx.globalAlpha = (r.style.opacity ?? 1) * r.style.fillOpacity;
+            }
+            ctx.fillRect(r.x, r.y, r.w, r.h);
+        }
+        // Stroke
+        if (r.style.stroke && r.style.stroke !== "none") {
+            ctx.strokeStyle = r.style.stroke;
+            ctx.lineWidth = r.style.strokeWidth ?? 1;
+            ctx.globalAlpha = r.style.opacity ?? 1;
+            ctx.strokeRect(r.x, r.y, r.w, r.h);
+        }
+        ctx.restore();
+    }
+}

package/ai/dist/src/components/stream/renderers/pointCanvasRenderer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointCanvasRenderer = void 0;
+/**
+ * Canvas point renderer.
+ * Renders PointSceneNode as circles. Used for Scatterplot, BubbleChart, and SwarmChart.
+ * Supports pulse glow effect via _pulseIntensity/_pulseColor fields.
+ */
+const pointCanvasRenderer = (ctx, nodes, scales, layout) => {
+    const pointNodes = nodes.filter((n) => n.type === "point");
+    for (const node of pointNodes) {
+        ctx.beginPath();
+        ctx.arc(node.x, node.y, node.r, 0, Math.PI * 2);
+        const alpha = node.style.opacity ?? node.style.fillOpacity;
+        if (alpha != null) {
+            ctx.globalAlpha = alpha;
+        }
+        ctx.fillStyle = node.style.fill || "#4e79a7";
+        ctx.fill();
+        if (node.style.stroke) {
+            ctx.strokeStyle = node.style.stroke;
+            ctx.lineWidth = node.style.strokeWidth || 1;
+            ctx.stroke();
+        }
+        // Pulse glow ring
+        if (node._pulseIntensity && node._pulseIntensity > 0) {
+            const glowRadius = 4;
+            ctx.beginPath();
+            ctx.arc(node.x, node.y, node.r + glowRadius * node._pulseIntensity, 0, Math.PI * 2);
+            ctx.strokeStyle = node._pulseColor || "rgba(255,255,255,0.6)";
+            ctx.lineWidth = 2 * node._pulseIntensity;
+            ctx.globalAlpha = node._pulseIntensity * 0.5;
+            ctx.stroke();
+        }
+        ctx.globalAlpha = 1;
+    }
+};
+exports.pointCanvasRenderer = pointCanvasRenderer;

package/ai/dist/src/components/stream/renderers/swarmCanvasRenderer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swarmCanvasRenderer = void 0;
+const pointCanvasRenderer_1 = require("./pointCanvasRenderer");
+/**
+ * Canvas swarm renderer.
+ * Identical to point renderer — swarm data points are pre-computed as PointSceneNodes.
+ * Separated for semantic clarity and potential future swarm-specific logic.
+ */
+exports.swarmCanvasRenderer = pointCanvasRenderer_1.pointCanvasRenderer;

package/ai/dist/src/components/stream/renderers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/stream/renderers/violinCanvasRenderer.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.violinCanvasRenderer = void 0;
+const violinCanvasRenderer = (ctx, nodes, _scales, _layout) => {
+    const violinNodes = nodes.filter((n) => n.type === "violin");
+    for (const node of violinNodes) {
+        ctx.save();
+        if (node.translateX || node.translateY) {
+            ctx.translate(node.translateX, node.translateY);
+        }
+        // Draw the violin shape
+        const path = new Path2D(node.pathString);
+        ctx.globalAlpha = node.style.fillOpacity ?? node.style.opacity ?? 0.6;
+        ctx.fillStyle = node.style.fill || "#007bff";
+        ctx.fill(path);
+        ctx.globalAlpha = 1;
+        if (node.style.stroke && node.style.stroke !== "none") {
+            ctx.strokeStyle = node.style.stroke;
+            ctx.lineWidth = node.style.strokeWidth || 1;
+            ctx.stroke(path);
+        }
+        // IQR overlay lines
+        if (node.iqrLine) {
+            ctx.strokeStyle = "#333";
+            ctx.lineWidth = 2;
+            ctx.globalAlpha = 0.8;
+            // Q1 to Q3 line
+            ctx.beginPath();
+            // Determine if this is a vertical violin by checking path characteristics
+            // IQR positions are already in pixel space from rScale
+            ctx.moveTo(0, node.iqrLine.q1Pos);
+            ctx.lineTo(0, node.iqrLine.q3Pos);
+            ctx.stroke();
+            // Median dot
+            ctx.beginPath();
+            ctx.arc(0, node.iqrLine.medianPos, 3, 0, Math.PI * 2);
+            ctx.fillStyle = "#fff";
+            ctx.fill();
+            ctx.strokeStyle = "#333";
+            ctx.lineWidth = 1;
+            ctx.stroke();
+            ctx.globalAlpha = 1;
+        }
+        ctx.restore();
+    }
+};
+exports.violinCanvasRenderer = violinCanvasRenderer;

package/ai/dist/src/components/stream/renderers/waterfallCanvasRenderer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waterfallCanvasRenderer = void 0;
+const barCanvasRenderer_1 = require("./barCanvasRenderer");
+/**
+ * Canvas waterfall renderer.
+ * Waterfall bars are pre-computed as RectSceneNodes by PipelineStore,
+ * so the rendering is identical to the bar renderer.
+ * Connector lines between bars are handled separately if needed.
+ */
+const waterfallCanvasRenderer = (ctx, nodes, scales, layout) => {
+    // Render the bar segments
+    (0, barCanvasRenderer_1.barCanvasRenderer)(ctx, nodes, scales, layout);
+    // Draw connector lines between consecutive waterfall bars
+    const rects = nodes.filter(n => n.type === "rect");
+    if (rects.length < 2)
+        return;
+    ctx.save();
+    ctx.strokeStyle = "#999";
+    ctx.lineWidth = 1;
+    ctx.setLineDash([]);
+    for (let i = 0; i < rects.length - 1; i++) {
+        const curr = rects[i];
+        const next = rects[i + 1];
+        if (!curr.datum?.cumEnd || !next.datum?.baseline)
+            continue;
+        // Connect from end of current bar to start of next bar at cumEnd level
+        const yConn = scales.y(curr.datum.cumEnd);
+        const x1 = curr.x + curr.w;
+        const x2 = next.x;
+        ctx.beginPath();
+        ctx.moveTo(x1, yConn);
+        ctx.lineTo(x2, yConn);
+        ctx.stroke();
+    }
+    ctx.restore();
+};
+exports.waterfallCanvasRenderer = waterfallCanvasRenderer;

package/ai/dist/src/components/stream/renderers/wedgeCanvasRenderer.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wedgeCanvasRenderer = void 0;
+const wedgeCanvasRenderer = (ctx, nodes, _scales, _layout) => {
+    const wedgeNodes = nodes.filter((n) => n.type === "wedge");
+    for (const node of wedgeNodes) {
+        ctx.beginPath();
+        if (node.innerRadius > 0) {
+            // Donut: outer arc forward, inner arc backward
+            ctx.arc(node.cx, node.cy, node.outerRadius, node.startAngle, node.endAngle);
+            ctx.arc(node.cx, node.cy, node.innerRadius, node.endAngle, node.startAngle, true);
+        }
+        else {
+            // Pie: move to center, arc, close
+            ctx.moveTo(node.cx, node.cy);
+            ctx.arc(node.cx, node.cy, node.outerRadius, node.startAngle, node.endAngle);
+        }
+        ctx.closePath();
+        if (node.style.opacity != null)
+            ctx.globalAlpha = node.style.opacity;
+        if (node.style.fillOpacity != null)
+            ctx.globalAlpha = node.style.fillOpacity;
+        ctx.fillStyle = node.style.fill || "#007bff";
+        ctx.fill();
+        if (node.style.stroke && node.style.stroke !== "none") {
+            ctx.strokeStyle = node.style.stroke;
+            ctx.lineWidth = node.style.strokeWidth || 1;
+            ctx.stroke();
+        }
+        ctx.globalAlpha = 1;
+    }
+};
+exports.wedgeCanvasRenderer = wedgeCanvasRenderer;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/types/annotationTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/types/canvasTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/types/generalTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/types/interactionTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/types/legendTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/types/networkTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/types/ordinalTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/types/xyTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/ai/dist/src/components/useBoundingRect.js

@@ -0,0 +1,24 @@
+"use client";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBoundingRect = useBoundingRect;
+const react_1 = require("react");
+function useBoundingRect(ref) {
+    const [rect, setRect] = (0, react_1.useState)(null);
+    (0, react_1.useLayoutEffect)(() => {
+        const element = ref.current;
+        if (element != null) {
+            setRect(element.getBoundingClientRect());
+            // TypeScript 3.9 does not know about resize observer
+            // @ts-ignore
+            const observer = new ResizeObserver((entries) => {
+                if (entries.length > 0) {
+                    setRect(entries[0].contentRect);
+                }
+            });
+            observer.observe(element);
+            return () => observer.disconnect();
+        }
+    }, []);
+    return rect;
+}