flowfig 0.8.2 → 0.8.4

package/README.md

@@ -65,7 +65,7 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 22
-      - uses: iamalvisng/flowfig@v0.8.2
+      - uses: iamalvisng/flowfig@v0.8.4
         with:
           figures: 'docs/**/*.svg' # default **/*.svg
 ```
@@ -478,7 +478,7 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 22
-      - uses: iamalvisng/flowfig@v0.8.2
+      - uses: iamalvisng/flowfig@v0.8.4
         with:
           figures: 'docs/**/*.svg' # default **/*.svg
 ```

package/dist/code.d.ts

@@ -18,7 +18,7 @@ export declare function matchClose(code: string, open: number): number;
 export declare function pyBody(code: string, start: number): Extent;
 export declare function outside(root: string, path: string): boolean;
 export declare function codeFile(root: string, path: string, read?: Read, cache?: Map<string, CodeFile | null>): CodeFile | null;
-export declare function locate(file: CodeFile, symbol: string): {
+export declare const locate: (file: CodeFile, symbol: string) => {
     start: number;
     end: number;
 } | null;

package/dist/code.js

@@ -511,7 +511,7 @@ export function codeFile(root, path, read = readFile, cache = new Map()) {
     cache.set(full, file);
     return file;
 }
-export function locate(file, symbol) {
+function locateDefinition(file, symbol) {
     const { code, lang } = file;
     const parts = symbol.split('.');
     if (!parts.every((p) => /^[\p{L}_$][\p{L}\p{N}_$]*$/u.test(p)))
@@ -565,4 +565,33 @@ export function locate(file, symbol) {
     }
     return null;
 }
+function enumMember(file, symbol) {
+    const { code, lang } = file;
+    const [owner, name, ...rest] = symbol.split('.');
+    if (!name || rest.length || lang === 'go' || lang === 'py')
+        return null;
+    const head = new RegExp(`\\benum\\s+${esc(owner)}${E}[^;{}]*\\{`, 'u').exec(code);
+    if (!head)
+        return null;
+    const open = head.index + head[0].length - 1;
+    const close = matchClose(code, open);
+    let from = open + 1;
+    for (let i = from, d = 0; i <= close; i++) {
+        const c = code[i];
+        if ('{(['.includes(c))
+            d++;
+        else if (')]'.includes(c) || (c === '}' && i < close))
+            d--;
+        else if (d > 0 || (c !== ',' && c !== ';' && i < close))
+            continue;
+        const seg = code.slice(from, i).replace(/^(\s|@\w+(\([^)]*\))?|#\[[^\]]*\]|\[[^\]]*\])+/, '');
+        if (new RegExp(`^${esc(name)}${E}`, 'u').test(seg))
+            return { start: i - seg.length, end: i };
+        if (c === ';')
+            return null;
+        from = i + 1;
+    }
+    return null;
+}
+export const locate = (file, symbol) => locateDefinition(file, symbol) ?? enumMember(file, symbol);
 export const isDefined = (file, symbol) => locate(file, symbol) != null;

package/dist/geometry.js

@@ -1,4 +1,4 @@
-import { STUB } from './model.js';
+import { EDGE_ON, STUB } from './model.js';
 export const avoidOf = (boxes, extra, lanes) => [
     ...extra,
     ...boxes.map((r) => (lanes ? r : { ...r, box: true })),
@@ -78,6 +78,8 @@ export function route(edges, rects, tips = new Set(), avoid = [], area, lanes, p
         if (around && blocked(around, arc)) {
             const fits = Array.from({ length: ARC_STEPS + 1 }, (_, k) => [around, outward(around, k)]);
             arc = fits.find(([way, at]) => !blocked(way, at))?.[1] ?? arc;
+            if (blocked(around, arc))
+                around = undefined;
         }
         if (!around && !e.sides && !e.stub && !e.elbow && past.length) {
             const ways = stacked ? ['left', 'right'] : ['above', 'below'];
@@ -177,6 +179,7 @@ export function route(edges, rects, tips = new Set(), avoid = [], area, lanes, p
     const all = Object.values(rects);
     const [x0, y0] = [Math.min(...all.map((r) => r.x)), Math.min(...all.map((r) => r.y))];
     const [x1, y1] = [Math.max(...all.map((r) => r.x + r.w)), Math.max(...all.map((r) => r.y + r.h))];
+    const room = (d) => (d > 0 ? d + EDGE_ON / 2 : 0);
     const outside = (way, { x, y }) => (way === 'above' ? y0 - y : way === 'below' ? y - y1 : way === 'left' ? x0 - x : x - x1);
     const roomOf = (way, at, curve, labelW) => Math.max(ARC - 6, lanes || !labelW ? outside(way, { x: at, y: at }) - 6 : outside(way, bezier(curve, 0.5)) + (upright(way) ? labelW / 2 : 9));
     const one = (p) => {
@@ -335,21 +338,24 @@ export function route(edges, rects, tips = new Set(), avoid = [], area, lanes, p
             if (e.x - s.x < 16 && s.y === e.y) {
                 return { id: p.id, d: `M ${s.x} ${s.y} H ${e.x}`, mid: { x: (s.x + e.x) / 2, y: s.y }, curve: [s, s, e, e], elbow: [s, e] };
             }
+            const own = (r) => [p.a, p.b].some((q) => same(q, r));
+            const all = avoid.filter((r) => !own(r));
+            const boxes = all.filter((r) => r.box);
+            const vClear = (x, ya, yb, m = 2) => !all.some((r) => x > r.x - m && x < r.x + r.w + m && Math.max(ya, yb) > r.y && Math.min(ya, yb) < r.y + r.h);
+            const hClear = (y, xa, xb, list = boxes, m = 2) => !list.some((r) => y > r.y - m && y < r.y + r.h + m && Math.max(xa, xb) > r.x && Math.min(xa, xb) < r.x + r.w);
             if (e.x - s.x < 16) {
-                const mx = s.x + 8, ex = e.x - 8, my = (s.y + e.y) / 2;
+                const mx = s.x + 8, ex = e.x - 8, mid = (s.y + e.y) / 2;
+                const ys = Array.from({ length: Math.floor((y1 - y0 + 24) / 4) + 1 }, (_, i) => y0 - 12 + i * 4).sort((u, w) => Math.abs(u - mid) - Math.abs(w - mid));
+                const my = ys.find((y) => vClear(mx, s.y, y) && hClear(y, ex, mx, all) && vClear(ex, y, e.y)) ?? mid;
                 return {
                     id: p.id,
                     d: `M ${s.x} ${s.y} H ${mx} V ${my} H ${ex} V ${e.y} H ${e.x}`,
                     mid: { x: (mx + ex) / 2, y: my },
                     curve: [s, { x: mx, y: my }, { x: ex, y: my }, e],
                     elbow: [s, { x: mx, y: s.y }, { x: mx, y: my }, { x: ex, y: my }, { x: ex, y: e.y }, e],
+                    bleed: { above: room(y0 - my), below: room(my - y1) },
                 };
             }
-            const own = (r) => [p.a, p.b].some((q) => same(q, r));
-            const all = avoid.filter((r) => !own(r));
-            const boxes = all.filter((r) => r.box);
-            const vClear = (x, ya, yb, m = 2) => !all.some((r) => x > r.x - m && x < r.x + r.w + m && Math.max(ya, yb) > r.y && Math.min(ya, yb) < r.y + r.h);
-            const hClear = (y, xa, xb, list = boxes, m = 2) => !list.some((r) => y > r.y - m && y < r.y + r.h + m && Math.max(xa, xb) > r.x && Math.min(xa, xb) < r.x + r.w);
             const mid = (s.x + e.x) / 2;
             const gap = Array.from({ length: Math.floor((e.x - s.x - 16) / 4) + 1 }, (_, i) => s.x + 8 + i * 4).sort((u, w) => Math.abs(u - mid) - Math.abs(w - mid));
             const mx = [mid, e.x - 8, s.x + 8, ...gap].find((x) => vClear(x, s.y, e.y) && hClear(s.y, s.x, x) && hClear(e.y, x, e.x));
@@ -384,10 +390,10 @@ export function route(edges, rects, tips = new Set(), avoid = [], area, lanes, p
                         curve: [s, { x, y }, { x: ex, y }, e],
                         elbow: [s, { x, y: s.y }, { x, y }, { x: ex, y }, { x: ex, y: e.y }, e],
                         bleed: {
-                            left: Math.max(0, x0 - Math.min(x, ex)),
-                            right: Math.max(0, Math.max(x, ex) - x1),
-                            above: Math.max(0, y0 - y),
-                            below: Math.max(0, y - y1),
+                            left: room(x0 - Math.min(x, ex)),
+                            right: room(Math.max(x, ex) - x1),
+                            above: room(y0 - y),
+                            below: room(y - y1),
                         },
                     };
                 }
@@ -499,13 +505,16 @@ export function labelAlong(r, w, boxes, placed, fig, lines = []) {
             y: Math.max(fig.y + 9, Math.min(at.y, fig.y + fig.h - 9)),
         }
         : at;
-    const free = (at, strict) => {
+    const free = (at, strict, room = 1) => {
         const pill = { x: at.x - w / 2, y: at.y - 9, w, h: 18 };
         return (inFig(at) &&
-            !boxes.some((b) => overlaps(pill, b, 1)) &&
+            !boxes.some((b) => overlaps(pill, b, room)) &&
             !placed.some((b) => overlaps(pill, b, 1)) &&
             (!strict || !lines.some((q) => q.x > pill.x - 2 && q.x < pill.x + w + 2 && q.y > pill.y - 2 && q.y < pill.y + 20)));
     };
+    for (const at of spots)
+        if (free(at, true, 6))
+            return at;
     for (const strict of [true, false])
         for (const at of spots)
             if (free(at, strict))

package/dist/model.js

@@ -452,20 +452,21 @@ export const counts = (p) => {
     };
 };
 const idsIn = (c) => (isGroup(c) ? [...(c.id ? [c.id] : []), ...c.children.flatMap(idsIn)] : [c.id]);
+const LINE_CLEAR = 16;
 export function groupGap(g, edges) {
     const side = new Map();
     g.children.forEach((c, i) => idsIn(c).forEach((id) => side.set(id, i)));
     const spans = edges.filter((e) => e.label != null && side.has(e.from) && side.has(e.to) && side.get(e.from) !== side.get(e.to) && !(g.gap != null && e.around));
     if (g.gap != null && !spans.length)
         return g.gap;
-    const need = Math.max(0, ...spans.map((e) => labelPillW(str(e.label)) + 16));
+    const need = Math.max(0, ...spans.map((e) => labelPillW(str(e.label)) + 2 * LINE_CLEAR));
     if (g.gap != null && g.direction !== 'column')
-        return Math.max(g.gap, need - 16);
+        return Math.max(g.gap, need);
     let auto;
     if (g.direction === 'column') {
         const ends = spans.map((e) => [side.get(e.from), side.get(e.to)].sort((p, q) => p - q));
         const most = Math.max(0, ...g.children.map((_, k) => ends.filter(([lo, hi]) => lo <= k && k < hi).length));
-        auto = most > 1 ? Math.min(most, 3) * 22 + 16 : 28;
+        auto = most ? Math.min(most, 3) * 22 + 2 * LINE_CLEAR - 4 : 28;
     }
     else
         auto = Math.max(56, need);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.8.2";
+export declare const VERSION = "0.8.4";

package/dist/version.js

@@ -1,2 +1,2 @@
 // The release list bumps this with package.json.
-export const VERSION = '0.8.2';
+export const VERSION = '0.8.4';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowfig",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "Your coding agent draws animated diagrams from your code, and flowfig checks each box and arrow against that code. CI fails when a diagram drifts from the code. The output is one animated SVG with no script, for a README, PR or issue. Works with Claude Code, Cursor, GitHub Copilot, Codex, Gemini CLI, Windsurf and Kiro.",
   "license": "MIT",
   "repository": {