@synergenius/flow-weaver 0.2.0

package/dist/diagram/index.d.ts

@@ -0,0 +1,16 @@
+import type { TWorkflowAST } from '../ast/types.js';
+import type { DiagramOptions } from './types.js';
+export type { DiagramOptions } from './types.js';
+/**
+ * Render a workflow AST to an SVG string.
+ */
+export declare function workflowToSVG(ast: TWorkflowAST, options?: DiagramOptions): string;
+/**
+ * Parse TypeScript source code and render the first (or named) workflow to SVG.
+ */
+export declare function sourceToSVG(code: string, options?: DiagramOptions): string;
+/**
+ * Parse a workflow file (resolves imports) and render the first (or named) workflow to SVG.
+ */
+export declare function fileToSVG(filePath: string, options?: DiagramOptions): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/diagram/index.js

@@ -0,0 +1,42 @@
+import { parser } from '../parser.js';
+import { buildDiagramGraph } from './geometry.js';
+import { renderSVG } from './renderer.js';
+/**
+ * Render a workflow AST to an SVG string.
+ */
+export function workflowToSVG(ast, options = {}) {
+    const graph = buildDiagramGraph(ast, options);
+    return renderSVG(graph, options);
+}
+/**
+ * Parse TypeScript source code and render the first (or named) workflow to SVG.
+ */
+export function sourceToSVG(code, options = {}) {
+    const result = parser.parseFromString(code);
+    return pickAndRender(result.workflows, options);
+}
+/**
+ * Parse a workflow file (resolves imports) and render the first (or named) workflow to SVG.
+ */
+export function fileToSVG(filePath, options = {}) {
+    const result = parser.parse(filePath);
+    return pickAndRender(result.workflows, options);
+}
+function pickAndRender(workflows, options) {
+    if (workflows.length === 0) {
+        throw new Error('No workflows found in source code');
+    }
+    let workflow;
+    if (options.workflowName) {
+        const found = workflows.find(w => w.name === options.workflowName);
+        if (!found) {
+            throw new Error(`Workflow "${options.workflowName}" not found. Available: ${workflows.map(w => w.name).join(', ')}`);
+        }
+        workflow = found;
+    }
+    else {
+        workflow = workflows[0];
+    }
+    return workflowToSVG(workflow, options);
+}
+//# sourceMappingURL=index.js.map

package/dist/diagram/layout.d.ts

@@ -0,0 +1,11 @@
+import type { TWorkflowAST } from '../ast/types.js';
+export interface LayoutResult {
+    layers: string[][];
+    nodeLayer: Map<string, number>;
+}
+/**
+ * Layered graph layout using Kahn's longest-path BFS + barycenter crossing minimization.
+ * Filters out scoped connections and scoped child nodes.
+ */
+export declare function layoutWorkflow(ast: TWorkflowAST): LayoutResult;
+//# sourceMappingURL=layout.d.ts.map

package/dist/diagram/layout.js

@@ -0,0 +1,143 @@
+import { isExitNode } from '../constants.js';
+/**
+ * Layered graph layout using Kahn's longest-path BFS + barycenter crossing minimization.
+ * Filters out scoped connections and scoped child nodes.
+ */
+export function layoutWorkflow(ast) {
+    // Collect all node IDs (Start, Exit, and non-scoped instances)
+    const nodeIds = new Set();
+    nodeIds.add('Start');
+    nodeIds.add('Exit');
+    // Track scoped child nodes to exclude
+    const scopedChildren = new Set();
+    if (ast.scopes) {
+        for (const children of Object.values(ast.scopes)) {
+            for (const child of children) {
+                scopedChildren.add(child);
+            }
+        }
+    }
+    for (const inst of ast.instances) {
+        if (!scopedChildren.has(inst.id)) {
+            nodeIds.add(inst.id);
+        }
+    }
+    // Build adjacency (filter scoped connections)
+    const forward = new Map();
+    const backward = new Map();
+    for (const id of nodeIds) {
+        forward.set(id, new Set());
+        backward.set(id, new Set());
+    }
+    for (const conn of ast.connections) {
+        // Skip scoped connections
+        if (conn.from.scope || conn.to.scope)
+            continue;
+        const from = conn.from.node;
+        const to = conn.to.node;
+        if (!nodeIds.has(from) || !nodeIds.has(to))
+            continue;
+        forward.get(from).add(to);
+        backward.get(to).add(from);
+    }
+    // Kahn's longest-path layer assignment (BFS from Start)
+    const nodeLayer = new Map();
+    const inDegree = new Map();
+    for (const id of nodeIds) {
+        inDegree.set(id, backward.get(id).size);
+    }
+    const queue = [];
+    for (const id of nodeIds) {
+        if (inDegree.get(id) === 0) {
+            queue.push(id);
+            nodeLayer.set(id, 0);
+        }
+    }
+    // Force Start at layer 0 even if it has incoming edges (shouldn't, but be safe)
+    if (!nodeLayer.has('Start')) {
+        nodeLayer.set('Start', 0);
+        queue.push('Start');
+    }
+    let head = 0;
+    while (head < queue.length) {
+        const node = queue[head++];
+        const layer = nodeLayer.get(node);
+        for (const next of forward.get(node)) {
+            const candidate = layer + 1;
+            if (!nodeLayer.has(next) || nodeLayer.get(next) < candidate) {
+                nodeLayer.set(next, candidate);
+            }
+            inDegree.set(next, inDegree.get(next) - 1);
+            if (inDegree.get(next) === 0) {
+                queue.push(next);
+            }
+        }
+    }
+    // Handle disconnected nodes - assign to layer 1 (after Start)
+    for (const id of nodeIds) {
+        if (!nodeLayer.has(id)) {
+            nodeLayer.set(id, 1);
+        }
+    }
+    // Force Exit to last layer
+    let maxLayer = 0;
+    for (const [id, layer] of nodeLayer) {
+        if (!isExitNode(id) && layer > maxLayer) {
+            maxLayer = layer;
+        }
+    }
+    nodeLayer.set('Exit', maxLayer + 1);
+    // Build layers array
+    const layerCount = nodeLayer.get('Exit') + 1;
+    const layers = Array.from({ length: layerCount }, () => []);
+    for (const [id, layer] of nodeLayer) {
+        layers[layer].push(id);
+    }
+    // Barycenter heuristic for crossing minimization (4 sweeps)
+    for (let sweep = 0; sweep < 4; sweep++) {
+        if (sweep % 2 === 0) {
+            // Forward sweep
+            for (let l = 1; l < layerCount; l++) {
+                sortLayerByBarycenter(layers[l], layers[l - 1], backward, forward);
+            }
+        }
+        else {
+            // Backward sweep
+            for (let l = layerCount - 2; l >= 0; l--) {
+                sortLayerByBarycenter(layers[l], layers[l + 1], forward, backward);
+            }
+        }
+    }
+    return { layers, nodeLayer };
+}
+function sortLayerByBarycenter(layer, referenceLayer, _adjacencyToRef, _adjacencyFromRef) {
+    const refPositions = new Map();
+    referenceLayer.forEach((id, i) => refPositions.set(id, i));
+    const barycenters = new Map();
+    for (const nodeId of layer) {
+        // Get neighbors in the reference layer
+        const neighbors = [];
+        const fwd = _adjacencyToRef.get(nodeId);
+        const bwd = _adjacencyFromRef.get(nodeId);
+        if (fwd) {
+            for (const n of fwd) {
+                if (refPositions.has(n))
+                    neighbors.push(refPositions.get(n));
+            }
+        }
+        if (bwd) {
+            for (const n of bwd) {
+                if (refPositions.has(n))
+                    neighbors.push(refPositions.get(n));
+            }
+        }
+        if (neighbors.length > 0) {
+            barycenters.set(nodeId, neighbors.reduce((a, b) => a + b, 0) / neighbors.length);
+        }
+        else {
+            barycenters.set(nodeId, Infinity);
+        }
+    }
+    layer.sort((a, b) => barycenters.get(a) - barycenters.get(b));
+}
+//# sourceMappingURL=layout.js.map

package/dist/diagram/orthogonal-router.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Orthogonal connection router for SVG diagram rendering.
+ *
+ * Ported from the original React-based editor's orthogonalRouter.ts.
+ * Removed gl-matrix dependency — uses plain [number, number] tuples.
+ *
+ * Features:
+ * - L-shape and S-shape routing with rounded corners
+ * - Node collision avoidance via inflated bounding boxes
+ * - Track allocator prevents parallel connections from overlapping
+ * - Crossing minimization (evaluates up to 11 candidates per allocation)
+ * - Per-port-index stub spacing
+ * - Waypoint simplification (collinear removal, jog collapse)
+ * - Backward/self connection escape routing
+ */
+export interface NodeBox {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface OrthogonalRouteOptions {
+    cornerRadius?: number;
+    padding?: number;
+    stubLength?: number;
+    stubSpacing?: number;
+    maxStubLength?: number;
+    fromPortIndex?: number;
+    toPortIndex?: number;
+}
+type Vec2 = [number, number];
+type InflatedBox = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+export declare class TrackAllocator {
+    private claims;
+    private verticalClaims;
+    /** Check if a Y value is too close to any claimed segment whose X range overlaps. */
+    private isOccupied;
+    /** Check if an X value is too close to any claimed vertical segment whose Y range overlaps. */
+    private isOccupiedVertical;
+    /** Check if a horizontal segment at Y passes through any inflated node box. */
+    private isBlockedByNode;
+    /** Check if a vertical segment at X passes through any inflated node box. */
+    private isBlockedByNodeVertical;
+    /** Count claimed vertical segments that a horizontal segment at Y would cross. */
+    countHorizontalCrossings(xMin: number, xMax: number, y: number): number;
+    /** Count claimed horizontal segments that a vertical segment at X would cross. */
+    countVerticalCrossings(yMin: number, yMax: number, x: number): number;
+    /**
+     * Find the nearest free Y to candidateY in the given X range, preferring fewer crossings.
+     * When nodeBoxes is provided, candidates inside inflated node boxes are rejected (hard constraint).
+     */
+    findFreeY(xMin: number, xMax: number, candidateY: number, nodeBoxes?: InflatedBox[]): number;
+    /**
+     * Find the nearest free X to candidateX in the given Y range, preferring fewer crossings.
+     * When nodeBoxes is provided, candidates inside inflated node boxes are rejected (hard constraint).
+     */
+    findFreeX(yMin: number, yMax: number, candidateX: number, nodeBoxes?: InflatedBox[]): number;
+    /** Claim a horizontal segment so later connections avoid it. */
+    claim(xMin: number, xMax: number, y: number): void;
+    /** Claim a vertical segment so later connections avoid it. */
+    claimVertical(yMin: number, yMax: number, x: number): void;
+}
+/**
+ * Calculate an orthogonal SVG path between two ports.
+ * Returns null if the path should fall back to bezier (e.g. nearly aligned ports).
+ */
+export declare function calculateOrthogonalPath(from: Vec2, to: Vec2, nodeBoxes: NodeBox[], sourceNodeId: string, targetNodeId: string, options?: OrthogonalRouteOptions, allocator?: TrackAllocator): string | null;
+/**
+ * Safe wrapper — returns null if routing fails, caller falls back to bezier.
+ */
+export declare function calculateOrthogonalPathSafe(from: Vec2, to: Vec2, nodeBoxes: NodeBox[], sourceNodeId: string, targetNodeId: string, options?: OrthogonalRouteOptions, allocator?: TrackAllocator): string | null;
+export {};
+//# sourceMappingURL=orthogonal-router.d.ts.map