semiotic 2.0.3 → 3.0.0-beta.2

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

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNearestOrdinalNode = findNearestOrdinalNode;
+function findNearestOrdinalNode(scene, px, py, maxDistance = 30) {
+    let best = null;
+    for (const node of scene) {
+        let result = null;
+        switch (node.type) {
+            case "rect":
+                result = hitTestRect(node, px, py);
+                break;
+            case "point":
+                result = hitTestPoint(node, px, py);
+                break;
+            case "wedge":
+                result = hitTestWedge(node, px, py);
+                break;
+            case "boxplot":
+                result = hitTestBoxplot(node, px, py);
+                break;
+            case "violin":
+                result = hitTestViolin(node, px, py);
+                break;
+        }
+        if (result && result.distance < maxDistance) {
+            if (!best || result.distance < best.distance) {
+                best = result;
+            }
+        }
+    }
+    return best;
+}
+function hitTestRect(node, px, py) {
+    if (px >= node.x && px <= node.x + node.w && py >= node.y && py <= node.y + node.h) {
+        return {
+            datum: node.datum,
+            x: node.x + node.w / 2,
+            y: node.y,
+            distance: 0,
+            category: node.group
+        };
+    }
+    return null;
+}
+function hitTestPoint(node, px, py) {
+    const dx = px - node.x;
+    const dy = py - node.y;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    const hitR = Math.max(node.r, 5); // minimum hit target
+    if (dist <= hitR) {
+        return {
+            datum: node.datum,
+            x: node.x,
+            y: node.y,
+            distance: dist
+        };
+    }
+    return null;
+}
+function hitTestWedge(node, px, py) {
+    // Convert to polar coordinates relative to center
+    const dx = px - node.cx;
+    const dy = py - node.cy;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    // Check radius bounds
+    if (dist < node.innerRadius || dist > node.outerRadius)
+        return null;
+    // Check angle bounds
+    // atan2 returns [-π, π], normalize to [0, 2π]
+    let angle = Math.atan2(dy, dx);
+    if (angle < 0)
+        angle += Math.PI * 2;
+    // Normalize start/end angles to [0, 2π]
+    let start = node.startAngle % (Math.PI * 2);
+    let end = node.endAngle % (Math.PI * 2);
+    if (start < 0)
+        start += Math.PI * 2;
+    if (end < 0)
+        end += Math.PI * 2;
+    // Check if angle is within the arc
+    const inArc = start <= end
+        ? angle >= start && angle <= end
+        : angle >= start || angle <= end;
+    if (!inArc)
+        return null;
+    // Return centroid position for tooltip
+    const midAngle = (node.startAngle + node.endAngle) / 2;
+    const midRadius = (node.innerRadius + node.outerRadius) / 2;
+    return {
+        datum: node.datum,
+        x: node.cx + Math.cos(midAngle) * midRadius,
+        y: node.cy + Math.sin(midAngle) * midRadius,
+        distance: 0,
+        category: node.category
+    };
+}
+function hitTestBoxplot(node, px, py) {
+    const halfWidth = node.columnWidth / 2;
+    if (node.projection === "vertical") {
+        const left = node.x - halfWidth;
+        const right = node.x + halfWidth;
+        const top = Math.min(node.minPos, node.maxPos);
+        const bottom = Math.max(node.minPos, node.maxPos);
+        if (px >= left && px <= right && py >= top && py <= bottom) {
+            return {
+                datum: node.datum,
+                x: node.x,
+                y: node.medianPos,
+                distance: 0,
+                category: node.category
+            };
+        }
+    }
+    else {
+        const top = node.y - halfWidth;
+        const bottom = node.y + halfWidth;
+        const left = Math.min(node.minPos, node.maxPos);
+        const right = Math.max(node.minPos, node.maxPos);
+        if (px >= left && px <= right && py >= top && py <= bottom) {
+            return {
+                datum: node.datum,
+                x: node.medianPos,
+                y: node.y,
+                distance: 0,
+                category: node.category
+            };
+        }
+    }
+    return null;
+}
+function hitTestViolin(node, px, py) {
+    if (!node.bounds)
+        return null;
+    const { x, y, width, height } = node.bounds;
+    if (px >= x && px <= x + width && py >= y && py <= y + height) {
+        // Return center of bounds for tooltip positioning
+        return {
+            datum: node.datum,
+            x: x + width / 2,
+            y: y + height / 2,
+            distance: 0,
+            category: node.category
+        };
+    }
+    return null;
+}