@grafloria/element 0.3.20 → 0.3.21

package/src/libs/renderer/src/svg/path-outline.d.ts

@@ -1,35 +0,0 @@
-import { type PathCmd, type Point } from '../canvas/path-geometry';
-/** Map every coordinate in a command list through `fn` (structure preserved). */
-export declare function mapPathCmds(cmds: PathCmd[], fn: (x: number, y: number) => Point): PathCmd[];
-/** Serialize a command list back into a compact `d` string. */
-export declare function serializePathCmds(cmds: PathCmd[]): string;
-/** The author's declared reference box for a STATIC path string. */
-export interface PathViewBox {
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-}
-/**
- * Rescale a parsed static path from its `viewBox` reference frame into a
- * `width × height` box anchored at the origin. Degenerate viewBox dimensions
- * fall back to 1 so a zero-width authoring box can't divide by zero.
- */
-export declare function fitCmdsToBox(cmds: PathCmd[], viewBox: PathViewBox, width: number, height: number): PathCmd[];
-/** Offset every coordinate by (dx, dy) — used for grow/shadow transforms. */
-export declare function translateCmds(cmds: PathCmd[], dx: number, dy: number): PathCmd[];
-/**
- * Sample a path's OUTLINE as a dense polygon of points.
- *
- * The path is flattened (curves → line segments) and the single richest subpath
- * — the shape's main silhouette — is returned as a vertex ring. Interior detail
- * subpaths (a UML component's tabs, a cube's inner edges) are intentionally
- * dropped: the boundary/anchor scanline treats its input as ONE closed ring, and
- * stitching several subpaths into one ring would invent phantom edges.
- *
- * Returns an empty array for an unparseable / empty `d` so callers fall back to
- * the bounding box.
- */
-export declare function sampleOutlinePoints(cmds: PathCmd[], steps?: number): Point[];
-/** Parse + sample a `d` string in one call. */
-export declare function sampleOutlineFromData(d: string, steps?: number): Point[];

package/src/libs/renderer/src/svg/path-outline.js

@@ -1,134 +0,0 @@
-"use strict";
-// Path-outline sampling (Wave 5 / Nodes & shapes — Card 2)
-//
-// Card 2 makes arbitrary SVG-path geometry a FIRST-CLASS, userland shape: a
-// caller registers a `'path'`/`'custom'` shape with either a static `d` string
-// or a parametric generator `(w, h) => d`, and the registry derives everything
-// else — the smart-connection boundary (`edgeIntersect`) and the per-side port
-// anchors — by SAMPLING the path's real outline instead of falling back to the
-// bounding box. That is what lets a hand-authored star / gauge / chevron attach
-// links to its true silhouette the same way the built-in diamond/hexagon do.
-//
-// This module owns the pure geometry that makes that possible. It leans on the
-// canvas backend's path parser/flattener (`../canvas/path-geometry`), which is a
-// dependency-FREE leaf module (parses `d`, converts arcs → cubics, flattens
-// curves to polylines). Reusing it means Card 2's sampler and the Canvas hit
-// tester cannot disagree about what a path's outline is.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapPathCmds = mapPathCmds;
-exports.serializePathCmds = serializePathCmds;
-exports.fitCmdsToBox = fitCmdsToBox;
-exports.translateCmds = translateCmds;
-exports.sampleOutlinePoints = sampleOutlinePoints;
-exports.sampleOutlineFromData = sampleOutlineFromData;
-const path_geometry_1 = require("../canvas/path-geometry");
-/** Round to 3dp so serialized path strings stay compact and diff-stable. */
-function round3(n) {
-    return Math.round(n * 1000) / 1000;
-}
-/** Map every coordinate in a command list through `fn` (structure preserved). */
-function mapPathCmds(cmds, fn) {
-    return cmds.map((cmd) => {
-        switch (cmd.op) {
-            case 'M':
-            case 'L': {
-                const p = fn(cmd.x, cmd.y);
-                return { op: cmd.op, x: p.x, y: p.y };
-            }
-            case 'C': {
-                const c1 = fn(cmd.x1, cmd.y1);
-                const c2 = fn(cmd.x2, cmd.y2);
-                const p = fn(cmd.x, cmd.y);
-                return { op: 'C', x1: c1.x, y1: c1.y, x2: c2.x, y2: c2.y, x: p.x, y: p.y };
-            }
-            case 'Q': {
-                const c1 = fn(cmd.x1, cmd.y1);
-                const p = fn(cmd.x, cmd.y);
-                return { op: 'Q', x1: c1.x, y1: c1.y, x: p.x, y: p.y };
-            }
-            case 'Z':
-                return cmd;
-        }
-    });
-}
-/** Serialize a command list back into a compact `d` string. */
-function serializePathCmds(cmds) {
-    const parts = [];
-    for (const cmd of cmds) {
-        switch (cmd.op) {
-            case 'M':
-                parts.push(`M ${round3(cmd.x)},${round3(cmd.y)}`);
-                break;
-            case 'L':
-                parts.push(`L ${round3(cmd.x)},${round3(cmd.y)}`);
-                break;
-            case 'C':
-                parts.push(`C ${round3(cmd.x1)},${round3(cmd.y1)} ${round3(cmd.x2)},${round3(cmd.y2)} ${round3(cmd.x)},${round3(cmd.y)}`);
-                break;
-            case 'Q':
-                parts.push(`Q ${round3(cmd.x1)},${round3(cmd.y1)} ${round3(cmd.x)},${round3(cmd.y)}`);
-                break;
-            case 'Z':
-                parts.push('Z');
-                break;
-        }
-    }
-    return parts.join(' ');
-}
-/**
- * Rescale a parsed static path from its `viewBox` reference frame into a
- * `width × height` box anchored at the origin. Degenerate viewBox dimensions
- * fall back to 1 so a zero-width authoring box can't divide by zero.
- */
-function fitCmdsToBox(cmds, viewBox, width, height) {
-    const sx = viewBox.w !== 0 ? width / viewBox.w : 1;
-    const sy = viewBox.h !== 0 ? height / viewBox.h : 1;
-    return mapPathCmds(cmds, (x, y) => ({
-        x: (x - viewBox.x) * sx,
-        y: (y - viewBox.y) * sy,
-    }));
-}
-/** Offset every coordinate by (dx, dy) — used for grow/shadow transforms. */
-function translateCmds(cmds, dx, dy) {
-    if (dx === 0 && dy === 0)
-        return cmds;
-    return mapPathCmds(cmds, (x, y) => ({ x: x + dx, y: y + dy }));
-}
-/**
- * Sample a path's OUTLINE as a dense polygon of points.
- *
- * The path is flattened (curves → line segments) and the single richest subpath
- * — the shape's main silhouette — is returned as a vertex ring. Interior detail
- * subpaths (a UML component's tabs, a cube's inner edges) are intentionally
- * dropped: the boundary/anchor scanline treats its input as ONE closed ring, and
- * stitching several subpaths into one ring would invent phantom edges.
- *
- * Returns an empty array for an unparseable / empty `d` so callers fall back to
- * the bounding box.
- */
-function sampleOutlinePoints(cmds, steps = 24) {
-    const subs = (0, path_geometry_1.flattenPath)(cmds, steps);
-    if (subs.length === 0)
-        return [];
-    // Richest subpath = the main silhouette.
-    let best = subs[0];
-    for (const sub of subs) {
-        if (sub.points.length > best.points.length)
-            best = sub;
-    }
-    // Drop a duplicated closing vertex (flattenPath echoes the start point on Z).
-    const pts = best.points;
-    if (pts.length > 1) {
-        const first = pts[0];
-        const last = pts[pts.length - 1];
-        if (Math.abs(first.x - last.x) < 1e-6 && Math.abs(first.y - last.y) < 1e-6) {
-            return pts.slice(0, -1);
-        }
-    }
-    return pts;
-}
-/** Parse + sample a `d` string in one call. */
-function sampleOutlineFromData(d, steps = 24) {
-    return sampleOutlinePoints((0, path_geometry_1.parsePath)(d), steps);
-}
-//# sourceMappingURL=path-outline.js.map

package/src/libs/renderer/src/svg/port-glyph.d.ts

@@ -1,27 +0,0 @@
-import type { PortShapeSpec } from '@grafloria/engine';
-import type { VNode } from '../types/vnode.types';
-export interface PortGlyphInput {
-    /** Node-local anchor: the port's position. The glyph is CENTRED on it. */
-    x: number;
-    y: number;
-    /** Resolved glyph spec. Undefined → a circle of `radius` (the legacy glyph). */
-    shape?: PortShapeSpec;
-    /** The circle radius the interaction config asks for, and the size fallback. */
-    radius: number;
-    /** Presentation attributes (fill/stroke/…) already merged from theme+group+port. */
-    props: Record<string, unknown>;
-}
-/** Half-extents of the glyph box, honouring size/width/height with `radius` fallback. */
-export declare function glyphHalfExtents(shape: PortShapeSpec | undefined, radius: number): {
-    hw: number;
-    hh: number;
-};
-/**
- * Build the port's glyph VNode.
- *
- * BYTE-STABILITY CONTRACT: with `shape` undefined this returns exactly the
- * `<circle cx cy r>` the renderer emitted before wave 6 — same element, same
- * prop set, same order, no rotation attribute. Every existing diagram's port
- * VNodes are unchanged.
- */
-export declare function renderPortGlyph(input: PortGlyphInput): VNode;

package/src/libs/renderer/src/svg/port-glyph.js

@@ -1,97 +0,0 @@
-"use strict";
-// port-glyph.ts — Wave 6 (Ports & connections), Card 0.
-//
-// The port's rendered marker. Before wave 6 every port in Grafloria was a `<circle>`
-// — hardcoded in `SVGRenderer.renderPort` — while THREE separate config surfaces
-// claimed otherwise and were all dead:
-//
-//   * `PortModel.style`  — serialized, deserialized, read by nobody.
-//   * `PortModel.visible` — same: round-tripped faithfully, never consulted.
-//   * `PortRenderingConfig.svg.{shape,fill,stroke,strokeWidth}` and `.size` —
-//     declared in the template system with shape: 'circle' | 'rect' | 'custom',
-//     of which only `.mode` and `.visibility` were ever read.
-//
-// This module is where a port's glyph is actually decided. PURE: spec in, VNode
-// in node-local coordinates out.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.glyphHalfExtents = glyphHalfExtents;
-exports.renderPortGlyph = renderPortGlyph;
-/** Half-extents of the glyph box, honouring size/width/height with `radius` fallback. */
-function glyphHalfExtents(shape, radius) {
-    var _a, _b, _c, _d;
-    const size = shape === null || shape === void 0 ? void 0 : shape.size;
-    const width = (_b = (_a = shape === null || shape === void 0 ? void 0 : shape.width) !== null && _a !== void 0 ? _a : size) !== null && _b !== void 0 ? _b : radius * 2;
-    const height = (_d = (_c = shape === null || shape === void 0 ? void 0 : shape.height) !== null && _c !== void 0 ? _c : size) !== null && _d !== void 0 ? _d : radius * 2;
-    return { hw: width / 2, hh: height / 2 };
-}
-/** `rotate(deg cx cy)` — omitted entirely when the glyph isn't rotated. */
-function rotationTransform(shape, x, y) {
-    const degrees = shape === null || shape === void 0 ? void 0 : shape.rotation;
-    if (!degrees)
-        return undefined;
-    return `rotate(${degrees} ${x} ${y})`;
-}
-/**
- * Build the port's glyph VNode.
- *
- * BYTE-STABILITY CONTRACT: with `shape` undefined this returns exactly the
- * `<circle cx cy r>` the renderer emitted before wave 6 — same element, same
- * prop set, same order, no rotation attribute. Every existing diagram's port
- * VNodes are unchanged.
- */
-function renderPortGlyph(input) {
-    var _a;
-    const { x, y, shape, radius, props } = input;
-    const kind = (_a = shape === null || shape === void 0 ? void 0 : shape.shape) !== null && _a !== void 0 ? _a : 'circle';
-    const transform = rotationTransform(shape, x, y);
-    const extra = transform ? { transform } : {};
-    switch (kind) {
-        case 'square': {
-            const { hw, hh } = glyphHalfExtents(shape, radius);
-            return {
-                type: 'rect',
-                props: Object.assign(Object.assign({ x: x - hw, y: y - hh, width: hw * 2, height: hh * 2 }, props), extra),
-            };
-        }
-        case 'diamond': {
-            const { hw, hh } = glyphHalfExtents(shape, radius);
-            return {
-                type: 'polygon',
-                props: Object.assign(Object.assign({ points: `${x},${y - hh} ${x + hw},${y} ${x},${y + hh} ${x - hw},${y}` }, props), extra),
-            };
-        }
-        case 'triangle': {
-            // Apex UP by default; `rotation` aims it anywhere (a 90° triangle is the
-            // classic "signal flows this way" port of a node editor).
-            const { hw, hh } = glyphHalfExtents(shape, radius);
-            return {
-                type: 'polygon',
-                props: Object.assign(Object.assign({ points: `${x},${y - hh} ${x + hw},${y + hh} ${x - hw},${y + hh}` }, props), extra),
-            };
-        }
-        case 'path': {
-            // Author-supplied `d`, drawn in a box centred on (0,0) and translated onto
-            // the anchor. A path glyph with no `d` degrades to the default circle
-            // rather than emitting an empty <path> that hit-tests as nothing.
-            if (!(shape === null || shape === void 0 ? void 0 : shape.path))
-                break;
-            const translate = `translate(${x} ${y})`;
-            return {
-                type: 'path',
-                props: Object.assign(Object.assign({ d: shape.path }, props), { transform: transform ? `${translate} rotate(${shape.rotation} 0 0)` : translate }),
-            };
-        }
-        case 'circle':
-        default:
-            break;
-    }
-    // The legacy glyph. `r` honours an explicit size (size is a DIAMETER) but
-    // falls back to the interaction config's radius — so an unconfigured port is
-    // byte-for-byte what it always was.
-    const r = (shape === null || shape === void 0 ? void 0 : shape.size) !== undefined ? shape.size / 2 : radius;
-    return {
-        type: 'circle',
-        props: Object.assign(Object.assign({ cx: x, cy: y, r }, props), extra),
-    };
-}
-//# sourceMappingURL=port-glyph.js.map

package/src/libs/renderer/src/svg/port-label.d.ts

@@ -1,74 +0,0 @@
-import type { PortLabelSpec } from '@grafloria/engine';
-import type { VNode } from '../types/vnode.types';
-export interface PortLabelInput {
-    spec: PortLabelSpec;
-    /** Node-local anchor of the port's glyph. */
-    x: number;
-    y: number;
-    /** Half-extents of the glyph box — the label clears the glyph, not its centre. */
-    hw: number;
-    hh: number;
-    /** The port's side: the outward normal. */
-    side: 'left' | 'right' | 'top' | 'bottom';
-    /** Node box, for the `radial` layout's centre and for `inside` clamping. */
-    width: number;
-    height: number;
-    /** Vertical nudge applied by collision resolution (see `nudgePortLabels`). */
-    nudge?: number;
-    fontSize: number;
-    fontFamily?: string;
-    color?: string;
-    className?: string;
-}
-export interface PortLabelGeometry {
-    x: number;
-    y: number;
-    /** Total rotation in degrees (0 when the label is horizontal). */
-    rotation: number;
-    align: 'start' | 'middle' | 'end';
-    valign: 'top' | 'middle' | 'bottom';
-}
-/**
- * Where does the label go, which way does it point, and how does it hang off its
- * anchor?
- *
- * The `align`/`valign` choice matters as much as the position: a label to the
- * LEFT of a port must be right-aligned (`end`), or it grows away from the port
- * and collides with the node.
- */
-export declare function portLabelGeometry(input: PortLabelInput): PortLabelGeometry;
-/**
- * Total label rotation, with keep-upright auto-flip.
- *
- * `angle` rotates the label. `keepUpright` (default ON) then adds 180° to any
- * label that would end up reading upside-down — the standard trick, and the
- * reason a `radial` label on the LEFT half of a circle still reads
- * left-to-right instead of mirror-written.
- */
-export declare function resolveRotation(spec: PortLabelSpec, direction: {
-    x: number;
-    y: number;
-}): number;
-/**
- * Collision-aware nudging: when several port labels crowd, push them apart along
- * the axis they stack on.
- *
- * Deliberately a ONE-AXIS resolver over labels that share a side. That is the
- * shape the crowding actually has — a column of inputs down the left edge whose
- * labels overlap vertically — and a general 2-D label-placement solver would be
- * both slower and less predictable (labels would visibly hop sideways as you
- * dragged a node). Returns a per-label nudge, so the caller can decide whether
- * to apply it.
- *
- * `heights` are the labels' rendered heights, `centres` their unnudged centre
- * coordinates on the stacking axis, both in the SAME order.
- */
-export declare function nudgePortLabels(centres: number[], heights: number[], gap?: number): number[];
-/** The label's rendered width, using the shared text engine's estimator. */
-export declare function portLabelWidth(spec: PortLabelSpec, fontSize: number): number;
-/**
- * Render the port's label as a `<text>` (or a `<g>` when it is rotated — a
- * rotation needs a transform, and putting it on the text itself would fight the
- * `x`/`y` the text-block engine emits for its tspans).
- */
-export declare function renderPortLabel(input: PortLabelInput): VNode;

package/src/libs/renderer/src/svg/port-label.js

@@ -1,201 +0,0 @@
-"use strict";
-// port-label.ts — Wave 6 (Ports & connections), Card 1.
-//
-// A text label per port, laid out relative to the glyph.
-//
-// This does NOT contain a text renderer. Line-breaking, wrapping, multi-line
-// `tspan` emission, ellipsis truncation and vertical alignment all belong to
-// `text-block.ts`, the engine that node labels and link labels (LabelRenderer)
-// already share — so a port label wraps by exactly the same rules as every other
-// piece of text in the diagram, and there is still exactly ONE place that knows
-// how to break a line. What lives here is only the part that is genuinely about
-// PORTS: where the label sits relative to the glyph, which way it faces, and what
-// to do when a column of them crowds together.
-//
-// PURE GEOMETRY + one call into the shared text engine. No models, no DOM.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.portLabelGeometry = portLabelGeometry;
-exports.resolveRotation = resolveRotation;
-exports.nudgePortLabels = nudgePortLabels;
-exports.portLabelWidth = portLabelWidth;
-exports.renderPortLabel = renderPortLabel;
-const engine_1 = require("@grafloria/engine");
-const text_block_1 = require("./text-block");
-/** The unit outward normal of a side. */
-function outwardNormal(side) {
-    switch (side) {
-        case 'left':
-            return { x: -1, y: 0 };
-        case 'right':
-            return { x: 1, y: 0 };
-        case 'top':
-            return { x: 0, y: -1 };
-        case 'bottom':
-            return { x: 0, y: 1 };
-    }
-}
-/** The glyph half-extent along a direction — how far the label must clear. */
-function clearance(direction, hw, hh) {
-    return Math.abs(direction.x) * hw + Math.abs(direction.y) * hh;
-}
-/**
- * Where does the label go, which way does it point, and how does it hang off its
- * anchor?
- *
- * The `align`/`valign` choice matters as much as the position: a label to the
- * LEFT of a port must be right-aligned (`end`), or it grows away from the port
- * and collides with the node.
- */
-function portLabelGeometry(input) {
-    var _a, _b, _c;
-    const { spec, x, y, hw, hh, side, width, height } = input;
-    const layout = (_a = spec.layout) !== null && _a !== void 0 ? _a : 'outside';
-    const offset = (_b = spec.offset) !== null && _b !== void 0 ? _b : engine_1.DEFAULT_PORT_LABEL_OFFSET;
-    const nudge = (_c = input.nudge) !== null && _c !== void 0 ? _c : 0;
-    const normal = outwardNormal(side);
-    let direction;
-    switch (layout) {
-        case 'inside':
-            direction = { x: -normal.x, y: -normal.y };
-            break;
-        case 'orthogonal': {
-            // Perpendicular to the outward normal: the label reads ALONG the edge.
-            // Pick the perpendicular that points into the node's long axis so the text
-            // runs down a side-port column rather than off the top of it.
-            direction = { x: -normal.y, y: normal.x };
-            break;
-        }
-        case 'radial': {
-            // Along the ray from the node's centre through the port. On a circle or an
-            // ellipse this is the ONLY layout that reads right — `outside` would push
-            // every label along its side's normal and stack the diagonal ones.
-            const dx = x - width / 2;
-            const dy = y - height / 2;
-            const length = Math.hypot(dx, dy);
-            direction = length < 1e-6 ? normal : { x: dx / length, y: dy / length };
-            break;
-        }
-        case 'outside':
-        default:
-            direction = normal;
-            break;
-    }
-    const distance = clearance(direction, hw, hh) + offset;
-    const px = x + direction.x * distance;
-    const py = y + direction.y * distance + nudge;
-    // Anchor the text so it GROWS AWAY from the port, never back over it.
-    let align = 'middle';
-    if (direction.x > 0.3)
-        align = 'start';
-    else if (direction.x < -0.3)
-        align = 'end';
-    let valign = 'middle';
-    if (Math.abs(direction.x) <= 0.3) {
-        valign = direction.y > 0 ? 'top' : 'bottom';
-    }
-    // `inside` on a side port must not run out of the node: flip the anchor so the
-    // text reads back toward the body.
-    const rotation = resolveRotation(spec, direction);
-    return { x: px, y: py, rotation, align, valign };
-}
-/**
- * Total label rotation, with keep-upright auto-flip.
- *
- * `angle` rotates the label. `keepUpright` (default ON) then adds 180° to any
- * label that would end up reading upside-down — the standard trick, and the
- * reason a `radial` label on the LEFT half of a circle still reads
- * left-to-right instead of mirror-written.
- */
-function resolveRotation(spec, direction) {
-    var _a;
-    const explicit = (_a = spec.angle) !== null && _a !== void 0 ? _a : 0;
-    if (explicit === 0)
-        return 0;
-    let total = explicit;
-    if (spec.keepUpright !== false) {
-        // Normalise to (-180, 180] and flip the upside-down half.
-        total = ((total % 360) + 540) % 360 - 180;
-        if (total > 90 || total < -90) {
-            total += total > 0 ? -180 : 180;
-        }
-    }
-    return total;
-}
-/**
- * Collision-aware nudging: when several port labels crowd, push them apart along
- * the axis they stack on.
- *
- * Deliberately a ONE-AXIS resolver over labels that share a side. That is the
- * shape the crowding actually has — a column of inputs down the left edge whose
- * labels overlap vertically — and a general 2-D label-placement solver would be
- * both slower and less predictable (labels would visibly hop sideways as you
- * dragged a node). Returns a per-label nudge, so the caller can decide whether
- * to apply it.
- *
- * `heights` are the labels' rendered heights, `centres` their unnudged centre
- * coordinates on the stacking axis, both in the SAME order.
- */
-function nudgePortLabels(centres, heights, gap = 2) {
-    var _a;
-    const count = centres.length;
-    const nudges = new Array(count).fill(0);
-    if (count < 2)
-        return nudges;
-    // Resolve in visual order, not declaration order.
-    const order = centres.map((c, i) => i).sort((a, b) => centres[a] - centres[b]);
-    let previousBottom = -Infinity;
-    for (const i of order) {
-        const half = ((_a = heights[i]) !== null && _a !== void 0 ? _a : 0) / 2;
-        const wanted = centres[i];
-        const top = wanted - half;
-        if (top < previousBottom + gap) {
-            // Overlaps the label above: push it down just enough to clear.
-            nudges[i] = previousBottom + gap - top;
-        }
-        previousBottom = wanted + nudges[i] + half;
-    }
-    // Re-centre the whole stack on its original centroid, so a crowded column
-    // spreads symmetrically instead of drifting downward off the node.
-    const mean = nudges.reduce((sum, n) => sum + n, 0) / count;
-    return nudges.map((n) => n - mean);
-}
-/** The label's rendered width, using the shared text engine's estimator. */
-function portLabelWidth(spec, fontSize) {
-    var _a;
-    return (0, text_block_1.estimateTextWidth)(spec.text, (_a = spec.fontSize) !== null && _a !== void 0 ? _a : fontSize);
-}
-/**
- * Render the port's label as a `<text>` (or a `<g>` when it is rotated — a
- * rotation needs a transform, and putting it on the text itself would fight the
- * `x`/`y` the text-block engine emits for its tspans).
- */
-function renderPortLabel(input) {
-    var _a, _b, _c, _d;
-    const { spec } = input;
-    const fontSize = (_a = spec.fontSize) !== null && _a !== void 0 ? _a : input.fontSize;
-    const geometry = portLabelGeometry(input);
-    const text = (0, text_block_1.renderTextBlock)({
-        text: spec.text,
-        x: geometry.x,
-        y: geometry.y,
-        align: geometry.align,
-        valign: geometry.valign,
-        fontSize,
-        fontFamily: (_b = spec.fontFamily) !== null && _b !== void 0 ? _b : input.fontFamily,
-        fontWeight: spec.fontWeight,
-        color: (_c = spec.color) !== null && _c !== void 0 ? _c : input.color,
-        maxWidth: spec.maxWidth,
-        className: (_d = spec.className) !== null && _d !== void 0 ? _d : input.className,
-        // A label must never eat the port's pointer events — the port under it is
-        // the whole point of the drag.
-        nonInteractive: true,
-    });
-    if (!geometry.rotation)
-        return text;
-    return {
-        type: 'g',
-        props: { transform: `rotate(${geometry.rotation} ${geometry.x} ${geometry.y})` },
-        children: [text],
-    };
-}
-//# sourceMappingURL=port-label.js.map

package/src/libs/renderer/src/svg/port-layout.d.ts

@@ -1,50 +0,0 @@
-import type { NodeModel, PortModel, PortLayoutArgs, PortLayoutSpec } from '@grafloria/engine';
-export interface PortLayoutInput {
-    /** Node-local box the ports live in. */
-    width: number;
-    height: number;
-    /** The port's side (after group inheritance). */
-    side: 'left' | 'right' | 'top' | 'bottom';
-    /** This port's rank among the ports sharing its LAYOUT SCOPE, and the scope size. */
-    rank: number;
-    count: number;
-    /** The node's shape type — the `shape` strategy needs it. */
-    shapeType: string;
-    /** The node's rotation in degrees (for `compensateRotation`). */
-    rotation?: number;
-}
-export type PortLayoutStrategy = (input: PortLayoutInput, args: PortLayoutArgs) => {
-    x: number;
-    y: number;
-};
-/** Register a custom strategy. Hosts can add their own; the built-ins are just entries. */
-export declare function registerPortLayout(name: string, strategy: PortLayoutStrategy): void;
-export declare function getPortLayout(name: string | undefined): PortLayoutStrategy;
-export declare function hasPortLayout(name: string): boolean;
-/** For tests / tooling. */
-export declare function portLayoutNames(): string[];
-/**
- * Rotate `point` about the node's centre by `-degrees`, so a port on a rotated
- * node keeps its WORLD-space arrangement (a `compensateRotation` group on a node
- * spun 90° still shows its inputs on the left of the screen).
- *
- * Node-local in, node-local out: the node's own transform then rotates it BACK,
- * and the two cancel.
- */
-export declare function compensateForRotation(point: {
-    x: number;
-    y: number;
-}, width: number, height: number, degrees: number): {
-    x: number;
-    y: number;
-};
-/**
- * Run a port's layout: pick the strategy, apply it, then the shared `dx`/`dy`
- * nudge and optional rotation compensation.
- */
-export declare function runPortLayout(spec: PortLayoutSpec | undefined, input: PortLayoutInput): {
-    x: number;
-    y: number;
-};
-/** Re-exported so `port-positioning` and the tests agree on the type. */
-export type { PortLayoutSpec, PortLayoutArgs, NodeModel, PortModel };