@grafloria/element 0.3.20 → 0.3.22

package/src/libs/renderer/src/export/bounds.js

@@ -1,367 +0,0 @@
-"use strict";
-// Content-tight bounds, export scope, and output-size clamping.
-//
-// WHY A VNODE WALK AND NOT A MODEL WALK
-// -------------------------------------
-// The renderer already had a content bbox (`SVGRenderer.contentViewport`), and it
-// unioned the MODEL: node position/size + routed link points. That is most of the
-// picture — but it is not the picture. What the model does not know:
-//
-//   • link LABELS, which hang off the path at a midpoint + offset and routinely
-//     stick out past every node and every routed point;
-//   • node labels placed OUTSIDE the node box;
-//   • ports, which sit ON the node border and (with an outward offset) past it;
-//   • arrowheads, which extend beyond the last path point;
-//   • the node SHADOW's blur radius.
-//
-// Export with a model-derived bbox and all of those get clipped at the edge of the
-// file. So the bbox is taken from the thing that is actually drawn: the VNode tree.
-// One walk, every drawable, transforms applied — if the renderer draws it, it is in
-// the box.
-//
-// TEXT is the one estimate. There is no font engine here (that is the whole point
-// of a headless exporter), so a `<text>` is measured with the SAME 0.6em-per-char
-// approximation `LabelRenderer.estimateTextWidth` already uses to size its own
-// label backgrounds. Sharing the estimator means the box we reserve and the box the
-// renderer reserved cannot disagree; both are approximations of the same thing.
-//
-// Every other shape is EXACT: paths go through the shared `parsePath` + `pathBounds`,
-// which flatten the curves rather than guessing from control points.
-//
-// Everything here is pure: no DOM, no clock, no randomness.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_MAX_OUTPUT_SIZE = exports.scopeKeysFor = exports.AVG_CHAR_WIDTH_EM = void 0;
-exports.vnodeBounds = vnodeBounds;
-exports.clampOutputSize = clampOutputSize;
-exports.padRect = padRect;
-const scope_1 = require("./scope");
-// THE geometry module for this codebase. `canvas/path-geometry.ts` already owns the SVG
-// geometry model — matrices, `parseTransform`, `parsePath` (every command, relative forms,
-// the S/T reflection, and A→cubics), the primitive builders, and `pathBounds`, which
-// FLATTENS curves rather than approximating them by their control points. The canvas
-// renderer draws through it and it has its own suite. Re-deriving any of it here would be a
-// second copy of some very fiddly maths, drifting, with only one copy tested.
-const path_geometry_1 = require("../canvas/path-geometry");
-/** A growable min/max box. `null`-ish until the first point lands in it. */
-class BoxAccumulator {
-    constructor() {
-        this.minX = Infinity;
-        this.minY = Infinity;
-        this.maxX = -Infinity;
-        this.maxY = -Infinity;
-    }
-    addPoint(m, x, y) {
-        if (!Number.isFinite(x) || !Number.isFinite(y))
-            return;
-        const p = (0, path_geometry_1.applyMatrix)(m, { x, y });
-        if (!Number.isFinite(p.x) || !Number.isFinite(p.y))
-            return;
-        this.minX = Math.min(this.minX, p.x);
-        this.minY = Math.min(this.minY, p.y);
-        this.maxX = Math.max(this.maxX, p.x);
-        this.maxY = Math.max(this.maxY, p.y);
-    }
-    /** Add an axis-aligned box by its four CORNERS — under rotation the corners move. */
-    addBox(m, x, y, width, height) {
-        this.addPoint(m, x, y);
-        this.addPoint(m, x + width, y);
-        this.addPoint(m, x, y + height);
-        this.addPoint(m, x + width, y + height);
-    }
-    get empty() {
-        return !Number.isFinite(this.minX) || !Number.isFinite(this.minY);
-    }
-    toRect() {
-        if (this.empty)
-            return null;
-        return {
-            x: this.minX,
-            y: this.minY,
-            width: this.maxX - this.minX,
-            height: this.maxY - this.minY,
-        };
-    }
-}
-/**
- * The average glyph advance, as a fraction of font-size.
- *
- * THE SAME CONSTANT `LabelRenderer.estimateTextWidth` uses. It is a rough mean for
- * proportional Latin text — and it being rough is fine, because the renderer sizes
- * label backgrounds with it too. What matters is that the two AGREE: a bbox derived
- * from a different estimate than the one that placed the text would crop labels the
- * renderer thought it had left room for.
- */
-exports.AVG_CHAR_WIDTH_EM = 0.6;
-const DEFAULT_FONT_SIZE = 12;
-/** Elements that paint nothing and whose children are references, not drawings. */
-const NON_PAINTING = new Set(['defs', 'title', 'desc', 'metadata', 'linearGradient', 'radialGradient', 'stop', 'filter', 'marker', 'clipPath', 'mask', 'pattern', 'style']);
-function num(value, fallback = 0) {
-    const n = Number(value);
-    return Number.isFinite(n) ? n : fallback;
-}
-/** `"10,20 30,40"` / `"10 20 30 40"` → [[10,20],[30,40]] */
-function parsePoints(points) {
-    if (typeof points !== 'string')
-        return [];
-    const nums = points
-        .trim()
-        .split(/[\s,]+/)
-        .map(Number)
-        .filter(n => Number.isFinite(n));
-    const out = [];
-    for (let i = 0; i + 1 < nums.length; i += 2)
-        out.push([nums[i], nums[i + 1]]);
-    return out;
-}
-/**
- * Estimate a `<text>` element's ink box.
- *
- * Honours `text-anchor` (start/middle/end) and treats `y` as the BASELINE, which is
- * what SVG does — so the box runs from roughly one ascent above y to one descent
- * below it. Ascent ≈ 0.8em, descent ≈ 0.2em is the usual rule of thumb and is well
- * within the error of the width estimate it sits next to.
- */
-function textBox(vnode) {
-    var _a, _b, _c, _d;
-    const props = (_a = vnode.props) !== null && _a !== void 0 ? _a : {};
-    const content = textContentOf(vnode);
-    if (!content)
-        return null;
-    const fontSize = num((_b = props['fontSize']) !== null && _b !== void 0 ? _b : props['font-size'], DEFAULT_FONT_SIZE);
-    // Multi-line labels render as <tspan> children; the widest line sets the width.
-    const lines = content.split('\n');
-    const longest = lines.reduce((max, line) => Math.max(max, line.length), 0);
-    const width = longest * fontSize * exports.AVG_CHAR_WIDTH_EM;
-    const height = fontSize * lines.length;
-    const x = num(props['x']);
-    const y = num(props['y']);
-    const anchor = String((_d = (_c = props['textAnchor']) !== null && _c !== void 0 ? _c : props['text-anchor']) !== null && _d !== void 0 ? _d : 'start');
-    const left = anchor === 'middle' ? x - width / 2 : anchor === 'end' ? x - width : x;
-    return { x: left, y: y - fontSize * 0.8, width, height };
-}
-/** The text a `<text>` will actually paint — its own prop, or its tspans'. */
-function textContentOf(vnode) {
-    var _a, _b;
-    const own = (_a = vnode.props) === null || _a === void 0 ? void 0 : _a['textContent'];
-    if (typeof own === 'string' && own !== '')
-        return own;
-    const lines = [];
-    for (const child of (_b = vnode.children) !== null && _b !== void 0 ? _b : []) {
-        if (!child || typeof child !== 'object') {
-            if (typeof child === 'string')
-                lines.push(child);
-            continue;
-        }
-        const nested = textContentOf(child);
-        if (nested)
-            lines.push(nested);
-    }
-    return lines.join('\n');
-}
-/**
- * The VNode `key` is the diagram's identity in the tree: the renderer stamps every
- * node group with `node-<id>` and every link group with `link-<id>`.
- *
- * We match on the KEY and not on a `data-*` prop because the key is the only
- * identifier that is actually universal. `data-link-id` is present on some link
- * variants and absent on others, and `data-node-id` DOES NOT EXIST — a selection
- * filter written against it would have matched nothing and silently exported an
- * empty box, which is precisely the "config declared but never consumed" failure
- * this codebase keeps producing.
- *
- * ONE definition of the key shapes, shared with the tree prune in `scope.ts`: if the
- * box and the prune ever disagreed about what a selection IS, an export would crop
- * to a different set of elements than it contains.
- */
-var scope_2 = require("./scope");
-Object.defineProperty(exports, "scopeKeysFor", { enumerable: true, get: function () { return scope_2.selectionKeys; } });
-/**
- * The union box of everything a VNode tree paints, in the tree's own user space.
- *
- * Returns `null` for a tree that paints nothing (an empty diagram) — the caller
- * decides what an empty document should be, because "nothing" is not a rectangle.
- */
-function vnodeBounds(root, options = {}) {
-    const box = new BoxAccumulator();
-    const scopeKeys = options.includeIds ? (0, scope_1.selectionKeys)(options.includeIds) : undefined;
-    // With no filter every element is in scope from the root down.
-    walk(root, path_geometry_1.IDENTITY, box, scopeKeys, scopeKeys === undefined);
-    return box.toRect();
-}
-/**
- * @param selected has an ancestor already matched `includeIds`? Once a subtree is
- *        in scope, everything under it is in scope — a node's label and ports are
- *        part of the node, and they are not separately id-tagged.
- */
-function walk(vnode, parent, box, scopeKeys, selected) {
-    var _a, _b;
-    if (!vnode || typeof vnode !== 'object' || typeof vnode.type !== 'string')
-        return;
-    const props = (_a = vnode.props) !== null && _a !== void 0 ? _a : {};
-    // A hidden element paints nothing, so it must not enlarge the box. (`display:
-    // none` on a culled node used to be the sneaky way an off-screen element still
-    // widened an export.)
-    if (props['display'] === 'none')
-        return;
-    // <defs> and friends: their children are REFERENCED, never drawn in place.
-    if (NON_PAINTING.has(vnode.type))
-        return;
-    const here = (0, path_geometry_1.multiply)(parent, (0, path_geometry_1.parseTransform)(props['transform']));
-    // Scope gate. Once a subtree is in scope everything under it is too — a node's
-    // label and ports are PART of the node and carry no id of their own.
-    const inScope = selected || (scopeKeys !== undefined && vnode.key !== undefined && scopeKeys.has(vnode.key));
-    if (inScope) {
-        addGeometry(vnode, here, box);
-    }
-    for (const child of (_b = vnode.children) !== null && _b !== void 0 ? _b : []) {
-        if (child && typeof child === 'object')
-            walk(child, here, box, scopeKeys, inScope);
-    }
-}
-/** `blur(4px)` → 4. The renderer's node shadow declares its blur this way. */
-function blurRadius(filter) {
-    if (typeof filter !== 'string')
-        return 0;
-    const match = /blur\(\s*([\d.]+)/.exec(filter);
-    return match ? Number(match[1]) : 0;
-}
-/** Union THIS element's own geometry (not its children's) into the box. */
-function addGeometry(vnode, m, box) {
-    var _a, _b, _c;
-    const props = (_a = vnode.props) !== null && _a !== void 0 ? _a : {};
-    // A stroke straddles the path: half of it lies outside the geometry. Ignoring it
-    // shaves half a stroke off every edge of the export.
-    const strokeWidth = props['stroke'] && props['stroke'] !== 'none' ? num((_b = props['strokeWidth']) !== null && _b !== void 0 ? _b : props['stroke-width'], 0) : 0;
-    // A BLUR paints outside its geometry — that is what a blur is. The node shadow is
-    // `filter: blur(4px)` on an offset rect, so a tight crop that ignored the blur
-    // would shave the soft edge off the shadow on the right and bottom of the diagram.
-    // Expanding by the radius is a slight over-estimate (the visible tail is shorter),
-    // which is the safe direction for an export box.
-    // The blur may arrive as the SVG attribute OR inside the style object — the
-    // renderer moved the node shadow to `style.filter` (the attribute form never
-    // actually blurred in browsers; only url(#…) applies there).
-    const styleFilter = (_c = props['style']) === null || _c === void 0 ? void 0 : _c['filter'];
-    const pad = strokeWidth / 2 + Math.max(blurRadius(props['filter']), blurRadius(styleFilter));
-    switch (vnode.type) {
-        case 'rect': {
-            const x = num(props['x']);
-            const y = num(props['y']);
-            box.addBox(m, x - pad, y - pad, num(props['width']) + pad * 2, num(props['height']) + pad * 2);
-            break;
-        }
-        case 'circle': {
-            const cx = num(props['cx']);
-            const cy = num(props['cy']);
-            const r = num(props['r']) + pad;
-            box.addBox(m, cx - r, cy - r, r * 2, r * 2);
-            break;
-        }
-        case 'ellipse': {
-            const cx = num(props['cx']);
-            const cy = num(props['cy']);
-            const rx = num(props['rx']) + pad;
-            const ry = num(props['ry']) + pad;
-            box.addBox(m, cx - rx, cy - ry, rx * 2, ry * 2);
-            break;
-        }
-        case 'line': {
-            box.addBox(m, Math.min(num(props['x1']), num(props['x2'])) - pad, Math.min(num(props['y1']), num(props['y2'])) - pad, Math.abs(num(props['x2']) - num(props['x1'])) + pad * 2, Math.abs(num(props['y2']) - num(props['y1'])) + pad * 2);
-            break;
-        }
-        case 'polyline':
-        case 'polygon': {
-            for (const [x, y] of parsePoints(props['points'])) {
-                box.addBox(m, x - pad, y - pad, pad * 2, pad * 2);
-            }
-            break;
-        }
-        case 'path': {
-            const d = props['d'];
-            if (typeof d !== 'string' || d.trim() === '')
-                break;
-            // parsePath turns arcs into cubics and resolves the smooth shorthands; pathBounds
-            // then FLATTENS the curves, so this is the true ink box — not a control-point
-            // over-approximation. (An arc's `large`/`sweep` flags are 0/1, and a naive pairwise
-            // scan of `d` reads them as the point (1,0) and drags the box to the origin. Using
-            // the real parser is what makes that class of bug impossible here.)
-            const bounds = (0, path_geometry_1.pathBounds)((0, path_geometry_1.transformCmds)((0, path_geometry_1.parsePath)(d), m));
-            if (bounds) {
-                box.addPoint(path_geometry_1.IDENTITY, bounds.minX - pad, bounds.minY - pad);
-                box.addPoint(path_geometry_1.IDENTITY, bounds.maxX + pad, bounds.maxY + pad);
-            }
-            break;
-        }
-        case 'text': {
-            const t = textBox(vnode);
-            if (t)
-                box.addBox(m, t.x, t.y, t.width, t.height);
-            break;
-        }
-        case 'image':
-        case 'foreignObject': {
-            box.addBox(m, num(props['x']), num(props['y']), num(props['width']), num(props['height']));
-            break;
-        }
-        // 'g', 'svg', 'tspan' and anything else: no geometry of its own. `tspan`
-        // positions are already covered by the parent <text>'s multi-line estimate.
-        default:
-            break;
-    }
-}
-/** The default cap on an exported raster's pixel size, per side. */
-exports.DEFAULT_MAX_OUTPUT_SIZE = 4000;
-/**
- * Clamp an export's PIXEL size.
- *
- * A 3x export of a big diagram is how you ask a browser for a 30000 × 20000 canvas
- * and get back a blank image — canvas has a hard area/side limit (~16k on most
- * engines, less on Safari/mobile), and it fails SILENTLY: `toDataURL` hands you a
- * blank or throws deep inside the driver. So we cap the output and REDUCE THE SCALE
- * to fit, rather than emitting a request we know will fail.
- *
- * Reducing scale (not cropping) is the right lever: it keeps the whole picture and
- * only spends fewer pixels on it, which is exactly the trade a caller who asked for
- * "3x, and it must fit" wants.
- *
- * `minSize` floors the result so a tiny diagram still yields a usable image rather
- * than a 12 × 8 sliver.
- */
-function clampOutputSize(width, height, requestedScale, maxSize = exports.DEFAULT_MAX_OUTPUT_SIZE, minSize = 1) {
-    const scale = requestedScale > 0 ? requestedScale : 1;
-    const safeMax = maxSize > 0 ? maxSize : exports.DEFAULT_MAX_OUTPUT_SIZE;
-    let outWidth = width * scale;
-    let outHeight = height * scale;
-    // Scale UP a sliver to the floor, keeping the aspect ratio.
-    let effective = scale;
-    const longestMin = Math.max(outWidth, outHeight);
-    if (longestMin > 0 && minSize > 1 && longestMin < minSize) {
-        const up = minSize / longestMin;
-        effective *= up;
-        outWidth *= up;
-        outHeight *= up;
-    }
-    const longest = Math.max(outWidth, outHeight);
-    if (longest <= safeMax) {
-        return { scale: effective, width: outWidth, height: outHeight };
-    }
-    const shrink = safeMax / longest;
-    const clamped = effective * shrink;
-    return {
-        scale: clamped,
-        width: outWidth * shrink,
-        height: outHeight * shrink,
-        warning: `export size ${Math.round(outWidth)}×${Math.round(outHeight)}px exceeds the ${safeMax}px cap — ` +
-            `scale reduced ${effective.toFixed(2)} → ${clamped.toFixed(2)}. Raise options.maxSize to override ` +
-            `(note: browsers refuse very large canvases, often silently).`,
-    };
-}
-/** Grow a rectangle by `padding` on every side. */
-function padRect(rect, padding) {
-    return {
-        x: rect.x - padding,
-        y: rect.y - padding,
-        width: rect.width + padding * 2,
-        height: rect.height + padding * 2,
-    };
-}
-//# sourceMappingURL=bounds.js.map

package/src/libs/renderer/src/export/capture-host.d.ts

@@ -1,39 +0,0 @@
-import type { Rectangle } from '../types/geometry.types';
-import type { CustomNodeCapture } from './custom-nodes';
-export interface CaptureHostOptions {
-    /**
-     * The camera zoom the html layer is transformed by. Client rects are SCREEN space,
-     * so they are divided by this to get the host-local layout coordinates the export
-     * needs. Defaults to being inferred from the host itself, which is more reliable
-     * than trusting a caller to remember.
-     */
-    scale?: number;
-    /** Safety valve for a pathologically deep host. Default 4000 elements. */
-    maxElements?: number;
-}
-/**
- * Capture ONE custom node's host into plain data.
- *
- * Never throws: an export must not be taken down by a host in a state we did not
- * anticipate. A failed capture degrades to `fidelity: 'empty'`, which the pure layer
- * turns into a marked box and a warning — the whole point being that a blank is never
- * silent.
- */
-export declare function captureCustomNodeHost(id: string, rect: Rectangle, host: unknown, options?: CaptureHostOptions): CustomNodeCapture;
-/**
- * The capture-time verdict on an external image, EXPORTED because the async export path
- * revises it: `await export(…)` fetches external URLs (environment fetch, then
- * `ExportOptions.assetFetcher`) and STRIPS this warning from any capture whose images it
- * embedded — see `stripResolvedImageWarnings`. The synchronous entry points cannot fetch,
- * so for them this text is the whole truth, and it names the way out.
- */
-export declare const IMAGE_PDF_WARNING: string;
-/** Companion caveat from `resolveImageHref` — same lifecycle as {@link IMAGE_PDF_WARNING}. */
-export declare const IMAGE_NOT_INLINED_WARNING: string;
-/**
- * Remove the two external-image caveats from a capture's warning — called by the async
- * export AFTER it embedded every external image the capture held, at which point both
- * sentences assert a problem that no longer exists (the same defect, mirrored, as
- * staying silent about one that does). Returns undefined when nothing else remains.
- */
-export declare function stripResolvedImageWarnings(warning: string | undefined): string | undefined;