code.js

"use strict";
/// <reference types="@figma/plugin-typings" />
/* ────────────────────────────────────────────────────────────────
   Raised-Intersection  •  headless plugin
   Works on Vectors *and* Lines, regardless of nesting
   © 2025 – feel free to MIT this!
──────────────────────────────────────────────────────────────── */
function run() {
    /* ═════ helpers ══════════════════════════════════════════════ */
    var _a, _b;
    /** Convert Paint → “#rrggbb” */
    const paintToHex = (paint) => {
        const { r, g, b } = paint.color;
        return ("#" +
            [r, g, b]
                .map(v => Math.round(v * 255).toString(16).padStart(2, "0"))
                .join(""));
    };
    /** Convert “#rrggbb” → RGB 0-1 */
    const hexToRgb = (hex) => {
        const n = parseInt(hex.replace(/^#/, ""), 16);
        return {
            r: ((n >> 16) & 0xff) / 255,
            g: ((n >> 8) & 0xff) / 255,
            b: (n & 0xff) / 255
        };
    };
    const apply = (m, p) => ({
        x: m[0][0] * p.x + m[0][1] * p.y + m[0][2],
        y: m[1][0] * p.x + m[1][1] * p.y + m[1][2],
    });
    /** Local-geometry pt → page pt (honours vectorTransform) */
    const toAbsolute = (node, p) => {
        var _a;
        const vt = (_a = node.vectorTransform) !== null && _a !== void 0 ? _a : [[1, 0, 0], [0, 1, 0]]; // identity if undefined
        return apply(node.absoluteTransform, apply(vt, p));
    };
    // /** Local pt → absolute (page) pt */
    // const toAbsolute = (node: SceneNode, pt: Vector): Vector => {
    //   const m = node.absoluteTransform;
    //   return {
    //     x: m[0][0] * pt.x + m[0][1] * pt.y + m[0][2],
    //     y: m[1][0] * pt.x + m[1][1] * pt.y + m[1][2]
    //   };
    // };
    /** Magnitude + unit direction */
    const dirLen = (p1, p2) => {
        const dx = p2.x - p1.x, dy = p2.y - p1.y;
        const len = Math.hypot(dx, dy);
        return { dir: { x: dx / len, y: dy / len }, len };
    };
    /** Intersection of two infinite lines p+tv and q+sw */
    const intersect = (p, v, q, w) => {
        const denom = v.x * w.y - v.y * w.x;
        if (Math.abs(denom) < 1e-4)
            return null; // parallel
        const t = ((q.x - p.x) * w.y - (q.y - p.y) * w.x) / denom;
        return { x: p.x + t * v.x, y: p.y + t * v.y };
    };
    /** Build an upward-bulging semicircle using 2 cubic Béziers */
    const makeArc = (center, radius, stroke, weight, rotationDeg) => {
        const k = 0.5522847498; // circle constant (4*(√2-1)/3)
        const d = [
            `M ${-radius} 0`,
            `C ${-radius} ${-k * radius} ${-k * radius} ${-radius} 0 ${-radius}`,
            `C ${k * radius} ${-radius} ${radius} ${-k * radius} ${radius} 0`
        ].join(" ");
        const v = figma.createVector();
        v.vectorPaths = [{ windingRule: "NONZERO", data: d }];
        v.strokes = [stroke];
        v.strokeCap = "ROUND";
        v.strokeWeight = weight;
        // Node’s own geometry spans from –r…+r horizontally and –r…0 vertically,
        // so its top-left corner is (center.x − r, center.y − r).
        v.x = center.x - radius;
        v.y = center.y - radius;
        v.rotation = rotationDeg;
        return v;
    };
    const isHorizontal = (v) => Math.abs(v.x) >= Math.abs(v.y);
    /** Recursively collect single-segment vectors/lines inside any selection */
    function collectLines(nodes) {
        const found = [];
        for (const n of nodes) {
            if (n.type === "VECTOR") {
                if (n.vectorNetwork.segments.length === 1)
                    found.push(n);
            }
            else if (n.type === "LINE") {
                found.push(n);
            }
            else if ("children" in n) {
                found.push(...collectLines(n.children));
            }
        }
        return found;
    }
    /* ═════ main flow ═════════════════════════════════════════════ */
    const lines = collectLines(figma.currentPage.selection);
    if (lines.length !== 2) {
        figma.notify("Select exactly two straight vector strokes 🙏");
        figma.closePlugin();
        return;
    }
    /* Extract absolute endpoints for each line / vector */
    const endpoints = lines.map(line => {
        if (line.type === "VECTOR") {
            const v = line.vectorNetwork.vertices;
            return [
                toAbsolute(line, { x: v[0].x, y: v[0].y }),
                toAbsolute(line, { x: v[1].x, y: v[1].y })
            ];
        }
        else { // LINE node
            // Geometry for a Line is the segment (0,0) → (1,0) in local space.
            return [
                toAbsolute(line, { x: 0, y: 0 }),
                toAbsolute(line, { x: 1, y: 0 })
            ];
        }
    });
    const [p1, p2] = endpoints[0];
    const [q1, q2] = endpoints[1];
    const { dir: vDir } = dirLen(p1, p2);
    const { dir: wDir } = dirLen(q1, q2);
    const ip = intersect(p1, vDir, q1, wDir);
    if (!ip) {
        figma.notify("Those two lines don’t intersect 🤷‍♂️");
        figma.closePlugin();
        return;
    }
    /* Decide which stroke “jumps” */
    const jumper = isHorizontal(vDir) ? lines[0] : lines[1];
    const jumperStroke = (_b = (_a = jumper.strokes) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : {
        type: "SOLID",
        color: { r: 1, g: 0, b: 0 }
    };
    const weight = typeof jumper.strokeWeight === "number" ? jumper.strokeWeight : 2;
    const radius = weight * 2;
    const jumperDir = isHorizontal(vDir) ? vDir : wDir;
    const rotation = (Math.atan2(jumperDir.y, jumperDir.x) * 180) / Math.PI;
    const arc = makeArc(ip, radius, jumperStroke, weight, rotation);
    figma.currentPage.appendChild(arc);
    figma.notify("✨ Jump-over added!");
    figma.closePlugin();
}
run(); // boot it