@grafloria/element 0.3.20 → 0.3.21

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

@@ -1,350 +0,0 @@
-"use strict";
-// Self-contained asset inlining (Card 1): make the file carry its own fonts and images.
-//
-// WHAT WAS ALREADY TRUE, and what was not
-// ---------------------------------------
-// Wave 4 flattened the THEME — every `var(--grafloria-*)` is resolved into a concrete
-// presentation attribute, so an exported SVG needs no stylesheet. That is most of
-// "self-contained", and it is done.
-//
-// Two real external references survived it:
-//
-//  1. FONTS were DECLARED, never embedded. The file says `font-family: Inter, …` and then
-//     depends on the machine that opens it to have Inter. On a machine that does not — a
-//     rasterizer, a Windows box, an email client — every label reflows in a fallback face,
-//     silently, and the picture is wrong in a way nobody notices until a customer prints it.
-//     `embedFontCss` existed as a seam, but it made the CALLER produce the base64 @font-face
-//     by hand. This builds it.
-//
-//  2. IMAGES. Panel nodes emit `<image href="https://…">` (an avatar, a logo, an ERD icon).
-//     That is a live network reference: it 404s on a server with no egress, it leaks a
-//     request to a third party every time the "self-contained" file is opened, and it simply
-//     does not render inside an email client. Those get inlined as `data:` URIs.
-//
-// THE SHAPE: a PURE substitution, and an ASYNC fetch that feeds it.
-// Fetching is I/O and cannot be pure, so it is kept strictly separate: `collectAssetUrls`
-// and `inlineAssets` are pure functions over the tree (fully testable, no network), and
-// `resolveAssets` is the thin async layer that goes and gets the bytes. A caller who already
-// has the bytes never touches the network at all.
-//
-// NOT DONE, deliberately: font SUBSETTING. Cutting a font down to the glyphs a diagram
-// actually uses needs a real font parser (a `glyf`/`loca`/`cmap` rewriter). Embedding a
-// whole woff2 is ~15-100KB; subsetting would typically get that under 5KB. That is a real
-// win and a real project, and it is not this card — the card asks for embedding.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fontFormatFromUrl = fontFormatFromUrl;
-exports.fontFaceCss = fontFaceCss;
-exports.isExternalUrl = isExternalUrl;
-exports.collectAssetUrls = collectAssetUrls;
-exports.inlineAssets = inlineAssets;
-exports.resolveAssets = resolveAssets;
-exports.fetchAssetsTiered = fetchAssetsTiered;
-exports.fetchFont = fetchFont;
-const tslib_1 = require("tslib");
-const round_trip_1 = require("./round-trip");
-const FONT_MIME = {
-    woff2: 'font/woff2',
-    woff: 'font/woff',
-    truetype: 'font/ttf',
-    opentype: 'font/otf',
-};
-/** `woff2` from a `.woff2` URL, etc. Defaults to woff2 — by far the most common on the web. */
-function fontFormatFromUrl(url) {
-    const clean = url.split('?')[0].split('#')[0].toLowerCase();
-    if (clean.endsWith('.woff'))
-        return 'woff';
-    if (clean.endsWith('.ttf'))
-        return 'truetype';
-    if (clean.endsWith('.otf'))
-        return 'opentype';
-    return 'woff2';
-}
-/**
- * Build the `@font-face` CSS that makes an export carry its own glyphs.
- *
- * PURE — bytes in, CSS out. Hand the result to `SvgExportOptions.embedFontCss` and the file
- * renders identically on a machine that has never heard of the typeface.
- *
- * The `format('…')` hint is not decoration: without it a renderer must sniff the bytes, and
- * some (notably older librsvg) simply decline and fall back.
- */
-function fontFaceCss(fonts) {
-    return fonts
-        .map(font => {
-        var _a, _b, _c;
-        const format = (_a = font.format) !== null && _a !== void 0 ? _a : 'woff2';
-        const mime = FONT_MIME[format];
-        const base64 = (0, round_trip_1.bytesToBase64)(font.data);
-        const declarations = [
-            `font-family: '${font.family.replace(/'/g, "\\'")}'`,
-            `font-style: ${(_b = font.style) !== null && _b !== void 0 ? _b : 'normal'}`,
-            `font-weight: ${(_c = font.weight) !== null && _c !== void 0 ? _c : 'normal'}`,
-            `src: url(data:${mime};base64,${base64}) format('${format}')`,
-        ];
-        if (font.unicodeRange)
-            declarations.push(`unicode-range: ${font.unicodeRange}`);
-        return `@font-face{${declarations.join(';')}}`;
-    })
-        .join('\n');
-}
-// ---------------------------------------------------------------------------
-// Images
-// ---------------------------------------------------------------------------
-/** The props an `<image>` can carry its source in. SVG 2 uses `href`; SVG 1.1 `xlink:href`. */
-const IMAGE_HREF_PROPS = ['href', 'xlinkHref', 'xlink:href'];
-/** Is this a reference that has to leave the document to resolve? */
-function isExternalUrl(value) {
-    if (typeof value !== 'string' || value === '')
-        return false;
-    // Already inline, or an intra-document reference — nothing to fetch.
-    if (value.startsWith('data:') || value.startsWith('#'))
-        return false;
-    return true;
-}
-/**
- * Every external asset URL the tree references. PURE.
- *
- * Deduplicated and returned in a STABLE order (first appearance), so a caller that fetches
- * them and re-inlines gets the same bytes for the same diagram every time — determinism runs
- * all the way through this module.
- */
-function collectAssetUrls(root) {
-    const urls = [];
-    const seen = new Set();
-    const visit = (vnode) => {
-        var _a, _b;
-        if (!vnode || typeof vnode !== 'object')
-            return;
-        const props = (_a = vnode.props) !== null && _a !== void 0 ? _a : {};
-        for (const key of IMAGE_HREF_PROPS) {
-            const value = props[key];
-            if (isExternalUrl(value) && !seen.has(value)) {
-                seen.add(value);
-                urls.push(value);
-            }
-        }
-        for (const child of (_b = vnode.children) !== null && _b !== void 0 ? _b : [])
-            visit(child);
-    };
-    visit(root);
-    return urls;
-}
-/**
- * Replace external asset URLs with the supplied `data:` URIs. PURE — returns a new tree.
- *
- * A URL with no entry in the map is LEFT ALONE rather than blanked: a broken-but-present
- * reference is debuggable, and an element silently stripped of its href is not. The async
- * layer reports those as warnings.
- */
-function inlineAssets(root, byUrl) {
-    const rewrite = (vnode) => {
-        var _a, _b;
-        if (!vnode || typeof vnode !== 'object')
-            return vnode;
-        let props = vnode.props;
-        for (const key of IMAGE_HREF_PROPS) {
-            const value = (_a = vnode.props) === null || _a === void 0 ? void 0 : _a[key];
-            if (isExternalUrl(value)) {
-                const inlined = byUrl.get(value);
-                if (inlined) {
-                    // Copy on first change only — an untouched subtree keeps its identity.
-                    if (props === vnode.props)
-                        props = Object.assign({}, vnode.props);
-                    props[key] = inlined;
-                }
-            }
-        }
-        const children = (_b = vnode.children) === null || _b === void 0 ? void 0 : _b.map(rewrite);
-        if (props === vnode.props && children === vnode.children)
-            return vnode;
-        return Object.assign(Object.assign({}, vnode), { props: props !== null && props !== void 0 ? props : {}, children });
-    };
-    return rewrite(root);
-}
-/**
- * Fetch every external asset the tree references and inline it as a `data:` URI.
- *
- * A FAILED ASSET IS A WARNING, NOT A THROW. One 404 avatar must not lose you the export of a
- * 200-node diagram — the reference is left as-is (still broken, but visible and debuggable)
- * and the caller is told. That is the same rule the batch exporter follows.
- */
-function resolveAssets(root_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (root, options = {}) {
-        var _a, _b;
-        const urls = collectAssetUrls(root);
-        const warnings = [];
-        if (urls.length === 0)
-            return { tree: root, inlined: 0, warnings };
-        const fetcher = (_a = options.fetcher) !== null && _a !== void 0 ? _a : defaultFetcher();
-        if (!fetcher) {
-            warnings.push(`[grafloria/export] ${urls.length} external image reference(s) could not be inlined: this environment ` +
-                `has no fetch. Pass options.fetcher. The exported file is NOT self-contained — it will try to ` +
-                `load those URLs when opened.`);
-            return { tree: root, inlined: 0, warnings };
-        }
-        const maxBytes = (_b = options.maxBytes) !== null && _b !== void 0 ? _b : 5 * 1024 * 1024;
-        const byUrl = new Map();
-        const results = yield Promise.all(urls.map((url) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            try {
-                const { data, mimeType } = yield fetcher(url);
-                if (data.length > maxBytes) {
-                    return { url, error: `asset is ${data.length} bytes, over the ${maxBytes}-byte cap` };
-                }
-                return { url, dataUri: `data:${mimeType};base64,${(0, round_trip_1.bytesToBase64)(data)}` };
-            }
-            catch (cause) {
-                return { url, error: cause.message };
-            }
-        })));
-        for (const result of results) {
-            if ('dataUri' in result && result.dataUri) {
-                byUrl.set(result.url, result.dataUri);
-            }
-            else {
-                warnings.push(`could not inline "${result.url}" (${result.error}) — the reference is left ` +
-                    `in the file, so the export is not fully self-contained.`);
-            }
-        }
-        return { tree: inlineAssets(root, byUrl), inlined: byUrl.size, warnings };
-    });
-}
-const DEFAULT_ASSET_MAX_BYTES = 5 * 1024 * 1024;
-const DEFAULT_ASSET_TIMEOUT = 5000;
-/**
- * Fetch every URL through the tiers above. Deduplicated: a URL is fetched once no
- * matter how many elements reference it. Resolves when the last URL settles; never
- * rejects.
- */
-function fetchAssetsTiered(urls_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (urls, options = {}) {
-        var _a, _b;
-        const byUrl = new Map();
-        const failures = new Map();
-        const unique = [...new Set(urls)];
-        if (unique.length === 0)
-            return { byUrl, failures };
-        const maxBytes = (_a = options.maxBytes) !== null && _a !== void 0 ? _a : DEFAULT_ASSET_MAX_BYTES;
-        const timeoutMs = (_b = options.timeoutMs) !== null && _b !== void 0 ? _b : DEFAULT_ASSET_TIMEOUT;
-        const browser = defaultFetcher();
-        yield Promise.all(unique.map((url) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            // -- tier 1: the environment's own fetch --------------------------------
-            let tier1Error;
-            if (browser) {
-                try {
-                    const asset = yield bounded(browser(url), timeoutMs);
-                    if (asset.data.length > maxBytes) {
-                        failures.set(url, overCap(asset.data.length, maxBytes));
-                        return; // terminal — a proxy returns the same bytes
-                    }
-                    byUrl.set(url, toDataUri(asset));
-                    return;
-                }
-                catch (cause) {
-                    tier1Error = errorMessage(cause);
-                }
-            }
-            else {
-                tier1Error = 'this environment has no fetch';
-            }
-            // -- tier 2: the caller's fetcher ---------------------------------------
-            if (options.fetcher) {
-                try {
-                    const asset = yield bounded(options.fetcher(url), timeoutMs);
-                    if (asset.data.length > maxBytes) {
-                        failures.set(url, overCap(asset.data.length, maxBytes));
-                        return;
-                    }
-                    byUrl.set(url, toDataUri(asset));
-                    return;
-                }
-                catch (cause) {
-                    failures.set(url, `fetch failed (${tier1Error}) and the assetFetcher also failed (${errorMessage(cause)})`);
-                    return;
-                }
-            }
-            // -- tier 3: honesty ----------------------------------------------------
-            failures.set(url, `fetch failed (${tier1Error}), which usually means the image's server does not allow ` +
-                `CORS — enable CORS on that server, or pass ExportOptions.assetFetcher to fetch it ` +
-                `through your own proxy`);
-        })));
-        return { byUrl, failures };
-    });
-}
-/** Race a fetch against a deadline; always clears the timer so a fast export exits fast. */
-function bounded(work, timeoutMs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        if (!(timeoutMs > 0) || !Number.isFinite(timeoutMs))
-            return work;
-        let timer;
-        const deadline = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error(`timed out after ${timeoutMs}ms`)), timeoutMs);
-        });
-        try {
-            return yield Promise.race([work, deadline]);
-        }
-        finally {
-            if (timer !== undefined)
-                clearTimeout(timer);
-        }
-    });
-}
-const overCap = (size, cap) => `asset is ${size} bytes, over the ${cap}-byte cap`;
-const errorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
-/**
- * Bytes → `data:` URI, trusting the MAGIC BYTES over the server's content-type. A CDN
- * that serves a PNG as `application/octet-stream` is common, and a data: URI that lies
- * about its media type makes the PDF writer (which trusts the URI) refuse a perfectly
- * good image.
- */
-function toDataUri(asset) {
-    var _a;
-    const sniffed = (_a = sniffImageMime(asset.data)) !== null && _a !== void 0 ? _a : asset.mimeType;
-    return `data:${sniffed};base64,${(0, round_trip_1.bytesToBase64)(asset.data)}`;
-}
-/** PNG / JPEG / GIF / WebP signatures — the formats an export can actually carry. */
-function sniffImageMime(data) {
-    if (data.length > 8 && data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47)
-        return 'image/png';
-    if (data.length > 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
-        return 'image/jpeg';
-    if (data.length > 6 && data[0] === 0x47 && data[1] === 0x49 && data[2] === 0x46)
-        return 'image/gif';
-    if (data.length > 12 &&
-        data[0] === 0x52 && data[1] === 0x49 && data[2] === 0x46 && data[3] === 0x46 &&
-        data[8] === 0x57 && data[9] === 0x45 && data[10] === 0x42 && data[11] === 0x50)
-        return 'image/webp';
-    return null;
-}
-/** `fetch` if this environment has one. */
-function defaultFetcher() {
-    const fetchImpl = globalThis.fetch;
-    if (typeof fetchImpl !== 'function')
-        return null;
-    return (url) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const response = yield fetchImpl(url);
-        if (!response.ok)
-            throw new Error(`HTTP ${response.status}`);
-        const buffer = yield response.arrayBuffer();
-        return {
-            data: new Uint8Array(buffer),
-            // Strip any `; charset=…` — a data: URI's media type must not carry one here.
-            mimeType: ((_a = response.headers.get('content-type')) !== null && _a !== void 0 ? _a : 'application/octet-stream').split(';')[0].trim(),
-        };
-    });
-}
-/**
- * Fetch a font and turn it into a {@link FontSource}, ready for {@link fontFaceCss}.
- */
-function fetchFont(url_1, descriptor_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (url, descriptor, options = {}) {
-        var _a, _b;
-        const fetcher = (_a = options.fetcher) !== null && _a !== void 0 ? _a : defaultFetcher();
-        if (!fetcher) {
-            throw new Error('[grafloria/export] fetchFont needs a fetch implementation — pass options.fetcher.');
-        }
-        const { data } = yield fetcher(url);
-        return Object.assign(Object.assign({}, descriptor), { data, format: (_b = descriptor.format) !== null && _b !== void 0 ? _b : fontFormatFromUrl(url) });
-    });
-}
-//# sourceMappingURL=assets.js.map

package/src/libs/renderer/src/export/batch.d.ts

@@ -1,49 +0,0 @@
-import type { DiagramDocumentEnvelope, SerializedDiagramData } from '@grafloria/engine';
-import type { ExportFormat, ExportOptions, SVGRendererConfig } from '../types/renderer.interface';
-import type { Theme } from '../types/theme.types';
-/** A document to export: the engine's envelope, or the flat serialized form. */
-export type BatchDocument = SerializedDiagramData | DiagramDocumentEnvelope;
-export interface BatchJob {
-    /** Echoed back on the result, so a caller can correlate without relying on order. */
-    id: string;
-    document: BatchDocument;
-    /** Default `'svg'` — the only format that needs no rasterizer at all. */
-    format?: ExportFormat;
-    /** Merged over the batch-wide options. */
-    options?: ExportOptions;
-}
-export interface BatchResult {
-    id: string;
-    format: ExportFormat;
-    /** The artifact: an SVG string, or a `data:` URL for a raster. Absent when `error` is set. */
-    output?: string;
-    /** Fidelity caveats (foreignObject, unresolved theme vars, a clamped size). */
-    warnings: string[];
-    /** Set when THIS job failed. The rest of the batch still ran. */
-    error?: Error;
-}
-export interface BatchOptions {
-    /** Applied to every job; a job's own `options` win. */
-    options?: ExportOptions;
-    /** Theme for every job. */
-    theme?: Theme;
-    /** Renderer config for every job. */
-    rendererConfig?: SVGRendererConfig;
-    /**
-     * How many jobs run at once. Default 4.
-     *
-     * Not unbounded: a rasterized 4000×4000 RGBA frame is ~64MB, so a few hundred in
-     * flight is an OOM, not a speedup.
-     */
-    concurrency?: number;
-    /** Called as each job settles — for a progress bar or a log line. */
-    onProgress?: (done: number, total: number, result: BatchResult) => void;
-}
-/**
- * Export many documents. Never throws for a job-level failure — a failed job comes back
- * with `error` set and the batch keeps going.
- *
- * Results are returned IN INPUT ORDER regardless of the order they finish in, because a
- * caller zipping results back onto its own list should not have to think about the pool.
- */
-export declare function exportBatch(jobs: BatchJob[], options?: BatchOptions): Promise<BatchResult[]>;

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

@@ -1,95 +0,0 @@
-"use strict";
-// Batch / server export (Card 6).
-//
-// The whole pipeline as a framework-agnostic function: persisted documents in, exported
-// artifacts out, in plain Node, with no browser and no Chromium. This is what a
-// thumbnail worker, a nightly "render every diagram in the workspace" job, or a
-// `POST /export` endpoint actually calls.
-//
-// It leans on a property the renderer already had and wave 4 proved: `render()` is pure
-// VNode production with no DOM, and the serializer turns that tree into a file. So the
-// SAME code that draws the live canvas draws the server's PNG — there is no second
-// rendering path to drift.
-//
-// THREE THINGS A BATCH MUST GET RIGHT, and does here:
-//
-//  1. ONE BAD DOCUMENT DOES NOT KILL THE RUN. A batch of 500 diagrams where #237 has a
-//     corrupt link must return 499 artifacts and one error, not throw on the way past
-//     #237 and lose the work. Failures are per-job values, not exceptions.
-//  2. BOUNDED CONCURRENCY. Rasterizing is memory-hungry (a 4000×4000 RGBA buffer is
-//     64MB); firing 500 at once is how a worker gets OOM-killed. Default 4.
-//  3. NO LEAKS. Every job builds an engine + renderer and disposes them, whatever
-//     happens — otherwise a long-running worker's listeners accumulate until it dies.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportBatch = exportBatch;
-const tslib_1 = require("tslib");
-const engine_1 = require("@grafloria/engine");
-const svg_renderer_1 = require("../svg/svg-renderer");
-/**
- * Export many documents. Never throws for a job-level failure — a failed job comes back
- * with `error` set and the batch keeps going.
- *
- * Results are returned IN INPUT ORDER regardless of the order they finish in, because a
- * caller zipping results back onto its own list should not have to think about the pool.
- */
-function exportBatch(jobs_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (jobs, options = {}) {
-        var _a;
-        const results = new Array(jobs.length);
-        const concurrency = Math.max(1, (_a = options.concurrency) !== null && _a !== void 0 ? _a : 4);
-        let cursor = 0;
-        let done = 0;
-        const worker = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a;
-            for (;;) {
-                const index = cursor++;
-                if (index >= jobs.length)
-                    return;
-                const result = yield runJob(jobs[index], options);
-                results[index] = result;
-                (_a = options.onProgress) === null || _a === void 0 ? void 0 : _a.call(options, ++done, jobs.length, result);
-            }
-        });
-        yield Promise.all(Array.from({ length: Math.min(concurrency, jobs.length) }, worker));
-        return results;
-    });
-}
-/** One document → one artifact. Every failure is caught and returned, not thrown. */
-function runJob(job, batch) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const format = (_a = job.format) !== null && _a !== void 0 ? _a : 'svg';
-        let engine;
-        let renderer;
-        try {
-            const diagram = new engine_1.DiagramSerializer().deserialize(job.document);
-            engine = new engine_1.DiagramEngine();
-            engine.setDiagram(diagram);
-            renderer = new svg_renderer_1.SVGRenderer(engine, (_b = batch.rendererConfig) !== null && _b !== void 0 ? _b : {});
-            if (batch.theme)
-                renderer.setTheme(batch.theme);
-            const merged = Object.assign(Object.assign({}, batch.options), job.options);
-            // Take the warnings from the SVG pass — `IRenderer.export` returns a bare string and
-            // has nowhere to put them, and silently dropping "your foreignObject is not in this
-            // file" is exactly the kind of quiet fidelity loss a server batch must not do.
-            const warnings = renderer.exportSvgString(merged).warnings;
-            const output = yield renderer.export(format, merged);
-            return { id: job.id, format, output, warnings };
-        }
-        catch (cause) {
-            return {
-                id: job.id,
-                format,
-                warnings: [],
-                error: cause instanceof Error ? cause : new Error(String(cause)),
-            };
-        }
-        finally {
-            // Whatever happened: give the listeners back. A worker that leaks one engine per
-            // document dies a few thousand documents in.
-            renderer === null || renderer === void 0 ? void 0 : renderer.dispose();
-            engine === null || engine === void 0 ? void 0 : engine.destroy();
-        }
-    });
-}
-//# sourceMappingURL=batch.js.map

package/src/libs/renderer/src/export/bounds.d.ts

@@ -1,81 +0,0 @@
-import type { VNode } from '../types/vnode.types';
-import type { Rectangle } from '../types/geometry.types';
-/**
- * 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.
- */
-export declare const AVG_CHAR_WIDTH_EM = 0.6;
-export interface BoundsOptions {
-    /**
-     * Only union elements whose subtree is one of these diagram ids (node ids / link
-     * ids). This is what makes a SELECTION export tight around the selection.
-     */
-    includeIds?: Set<string>;
-}
-/**
- * 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.
- */
-export { selectionKeys as scopeKeysFor } from './scope';
-/**
- * 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.
- */
-export declare function vnodeBounds(root: VNode, options?: BoundsOptions): Rectangle | null;
-/**
- * WHAT rectangle of the world an export covers.
- *
- *   'content'   the whole diagram, tight around everything drawn (the default —
- *               a thumbnail of "whatever the user happened to be scrolled to" is
- *               almost never what anyone means)
- *   'viewport'  exactly what is on screen right now
- *   'selection' tight around the selected nodes/links alone
- */
-export type ExportScope = 'content' | 'viewport' | 'selection';
-/** The default cap on an exported raster's pixel size, per side. */
-export declare const DEFAULT_MAX_OUTPUT_SIZE = 4000;
-export interface ClampResult {
-    /** The scale that actually gets used (≤ the requested one). */
-    scale: number;
-    width: number;
-    height: number;
-    /** Set when the requested scale had to be reduced. */
-    warning?: string;
-}
-/**
- * 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.
- */
-export declare function clampOutputSize(width: number, height: number, requestedScale: number, maxSize?: number, minSize?: number): ClampResult;
-/** Grow a rectangle by `padding` on every side. */
-export declare function padRect(rect: Rectangle, padding: number): Rectangle;