@grafloria/element 0.3.23 → 0.4.1

package/esm/src/lib/grafloria-flow-element.js

@@ -1,266 +0,0 @@
-import { createDiagram, DARK_THEME, LIGHT_THEME } from '@grafloria/renderer';
-import { getNodeType, renderFromTemplate } from './node-type-registry';
-/**
- * `<grafloria-flow>` — the universal embed.
- *
- * React Flow serves React. ngx-vflow serves Angular. Each is a wall around one
- * framework. A custom element has no wall: Vue, Svelte, Solid, Lit, Alpine,
- * plain HTML, a CMS block, a Jupyter/Observable cell and a static site all speak
- * "HTML element with attributes and events". This is the piece that lets Grafloria
- * reach the long tail those libraries cannot.
- *
- * ```html
- * <grafloria-flow theme="dark" fit-view
- *             nodes='[{"id":"a","position":{"x":0,"y":0},"label":"A"}]'
- *             edges='[{"source":"a","target":"b"}]'>
- *   <template data-node-type="card">
- *     <div class="card"><h4 data-field="title"></h4></div>
- *   </template>
- * </grafloria-flow>
- *
- * <script>
- *   document.querySelector('grafloria-flow')
- *     .addEventListener('grafloria-connect', e => console.log(e.detail.link));
- * </script>
- * ```
- *
- * Rich data goes in as PROPERTIES (`el.nodes = [...]`) and simple data as
- * ATTRIBUTES (JSON strings) — the standard custom-element contract that every
- * framework's template binding already targets:
- * `:nodes` in Vue, `nodes={...}` in Svelte/Solid, `[attr.nodes]` in Angular.
- *
- * Everything it does is delegation. There is no diagram logic in this file.
- */
-const THEMES = {
-    light: LIGHT_THEME,
-    dark: DARK_THEME,
-};
-/** Events emitted on the element. All bubble and cross shadow boundaries. */
-export const GRAFLORIA_EVENTS = {
-    ready: 'grafloria-ready',
-    nodesChange: 'grafloria-nodes-change',
-    edgesChange: 'grafloria-edges-change',
-    selectionChange: 'grafloria-selection-change',
-    connect: 'grafloria-connect',
-    nodeClick: 'grafloria-node-click',
-    edgeClick: 'grafloria-edge-click',
-    viewportChange: 'grafloria-viewport-change',
-};
-// wave11/gallery BUG FIX — worker-safe base class.
-//
-// `class GrafloriaFlowElement extends HTMLElement` evaluates `HTMLElement` at MODULE
-// LOAD, so merely IMPORTING this package threw `HTMLElement is not defined` in any
-// context without a DOM — a Web Worker, or Node. The package doc already promised
-// the import is "a no-op on the server", and `defineGrafloriaFlow()` guards
-// `customElements`; but the class declaration itself did not, so the promise was
-// only half true. It matters concretely: the off-thread-layout demo runs the
-// engine's `serveLayout` INSIDE a real Worker by importing this very bundle, which
-// is impossible if the top-level class reference throws. The element only ever
-// EXTENDS the real HTMLElement in a browser (a worker never instantiates it), so a
-// guarded base is behaviourally identical on the client and merely importable off it.
-const HTMLElementBase = typeof HTMLElement !== 'undefined'
-    ? HTMLElement
-    : class {
-    };
-export class GrafloriaFlowElement extends HTMLElementBase {
-    constructor() {
-        super(...arguments);
-        this.instance = null;
-        this.canvas = null;
-        this._nodes = [];
-        this._edges = [];
-        this.connected = false;
-    }
-    static get observedAttributes() {
-        return [
-            'nodes',
-            'edges',
-            'theme',
-            'fit-view',
-            'readonly',
-            'zoom',
-            'min-zoom',
-            'max-zoom',
-            'pan',
-            'wheel-zoom',
-        ];
-    }
-    // -- properties (the rich path) ---------------------------------------------
-    get nodes() {
-        return this._nodes;
-    }
-    set nodes(value) {
-        var _a;
-        this._nodes = value !== null && value !== void 0 ? value : [];
-        (_a = this.instance) === null || _a === void 0 ? void 0 : _a.setNodes(this._nodes);
-    }
-    get edges() {
-        return this._edges;
-    }
-    set edges(value) {
-        var _a;
-        this._edges = value !== null && value !== void 0 ? value : [];
-        (_a = this.instance) === null || _a === void 0 ? void 0 : _a.setEdges(this._edges);
-    }
-    /** The headless instance — the escape hatch to everything else. */
-    get diagram() {
-        return this.instance;
-    }
-    // -- lifecycle ---------------------------------------------------------------
-    connectedCallback() {
-        if (this.connected)
-            return;
-        this.connected = true;
-        // Attributes may have been parsed before we upgraded.
-        this.readAttributeModel();
-        // Light DOM, not shadow DOM: the diagram's stylesheet is injected into
-        // <head> and its CSS variables cascade — a shadow root would cut both off,
-        // and hosts routinely want to style nodes from their own stylesheet.
-        this.canvas = document.createElement('div');
-        this.canvas.className = 'grafloria-flow-canvas';
-        this.canvas.setAttribute('style', 'position:relative;width:100%;height:100%');
-        this.appendChild(this.canvas);
-        if (!this.style.display)
-            this.style.display = 'block';
-        this.instance = createDiagram(this.canvas, this.buildOptions());
-        this.wireEvents(this.instance);
-    }
-    disconnectedCallback() {
-        var _a, _b;
-        this.connected = false;
-        (_a = this.instance) === null || _a === void 0 ? void 0 : _a.dispose();
-        this.instance = null;
-        (_b = this.canvas) === null || _b === void 0 ? void 0 : _b.remove();
-        this.canvas = null;
-    }
-    attributeChangedCallback(name, previous, next) {
-        var _a, _b;
-        if (previous === next)
-            return;
-        switch (name) {
-            case 'nodes':
-                this._nodes = parseJsonAttribute(next, []);
-                (_a = this.instance) === null || _a === void 0 ? void 0 : _a.setNodes(this._nodes);
-                return;
-            case 'edges':
-                this._edges = parseJsonAttribute(next, []);
-                (_b = this.instance) === null || _b === void 0 ? void 0 : _b.setEdges(this._edges);
-                return;
-            case 'theme':
-                if (this.instance)
-                    this.instance.setTheme(this.resolveTheme());
-                return;
-            case 'fit-view':
-                if (this.instance && next !== null)
-                    this.instance.fitView();
-                return;
-            case 'zoom':
-                if (this.instance && next !== null)
-                    this.instance.viewport.setZoom(Number(next));
-                return;
-            default:
-                // pan / wheel-zoom / readonly / min-zoom / max-zoom are read at mount:
-                // they configure the event binder, which is created once. Changing them
-                // afterwards is rare enough that we do not tear the instance down.
-                return;
-        }
-    }
-    // -- API ---------------------------------------------------------------------
-    fitView(padding) {
-        var _a;
-        (_a = this.instance) === null || _a === void 0 ? void 0 : _a.fitView(padding);
-    }
-    // -- internals ---------------------------------------------------------------
-    buildOptions() {
-        return {
-            nodes: this._nodes,
-            edges: this._edges,
-            theme: this.resolveTheme(),
-            fitView: this.hasAttribute('fit-view'),
-            readonly: this.hasAttribute('readonly'),
-            enablePan: this.getAttribute('pan') !== 'false',
-            enableZoom: this.getAttribute('wheel-zoom') !== 'false',
-            zoom: this.hasAttribute('zoom') ? Number(this.getAttribute('zoom')) : undefined,
-            minZoom: this.hasAttribute('min-zoom')
-                ? Number(this.getAttribute('min-zoom'))
-                : undefined,
-            maxZoom: this.hasAttribute('max-zoom')
-                ? Number(this.getAttribute('max-zoom'))
-                : undefined,
-            renderCustomNode: (node, element) => this.renderCustomNode(node, element),
-        };
-    }
-    /**
-     * Custom nodes, two ways and no framework: a registered renderer
-     * (`Grafloria.registerNodeType`), or a slotted `<template data-node-type="…">`.
-     */
-    renderCustomNode(node, element) {
-        const renderer = getNodeType(node.type);
-        if (renderer) {
-            renderer(node, element);
-            return;
-        }
-        const template = this.querySelector(`template[data-node-type="${cssEscape(node.type)}"]`);
-        if (template) {
-            renderFromTemplate(template, node, element);
-            return;
-        }
-        // Nothing registered: leave the host empty rather than throwing inside a
-        // render. The node still exists, is selectable and is draggable.
-    }
-    resolveTheme() {
-        var _a, _b;
-        return (_b = THEMES[(_a = this.getAttribute('theme')) !== null && _a !== void 0 ? _a : 'light']) !== null && _b !== void 0 ? _b : LIGHT_THEME;
-    }
-    readAttributeModel() {
-        if (this._nodes.length === 0 && this.hasAttribute('nodes')) {
-            this._nodes = parseJsonAttribute(this.getAttribute('nodes'), []);
-        }
-        if (this._edges.length === 0 && this.hasAttribute('edges')) {
-            this._edges = parseJsonAttribute(this.getAttribute('edges'), []);
-        }
-    }
-    /** Instance events → DOM CustomEvents. `composed` so they escape a shadow root. */
-    wireEvents(instance) {
-        const forward = (type, detail) => {
-            this.dispatchEvent(new CustomEvent(type, { detail, bubbles: true, composed: true }));
-        };
-        instance.on('ready', () => forward(GRAFLORIA_EVENTS.ready, { diagram: instance }));
-        instance.on('nodes:change', (payload) => forward(GRAFLORIA_EVENTS.nodesChange, payload));
-        instance.on('edges:change', (payload) => forward(GRAFLORIA_EVENTS.edgesChange, payload));
-        instance.on('selection:change', (payload) => forward(GRAFLORIA_EVENTS.selectionChange, payload));
-        instance.on('connect', (payload) => forward(GRAFLORIA_EVENTS.connect, payload));
-        instance.on('node:click', (payload) => forward(GRAFLORIA_EVENTS.nodeClick, payload));
-        instance.on('edge:click', (payload) => forward(GRAFLORIA_EVENTS.edgeClick, payload));
-        instance.on('viewport:change', (payload) => forward(GRAFLORIA_EVENTS.viewportChange, payload));
-    }
-}
-/** JSON attribute → value. A malformed attribute must not take the page down. */
-function parseJsonAttribute(raw, fallback) {
-    if (!raw)
-        return fallback;
-    try {
-        return JSON.parse(raw);
-    }
-    catch (_a) {
-        console.warn('[grafloria-flow] ignoring malformed JSON attribute:', raw);
-        return fallback;
-    }
-}
-/** Minimal CSS.escape for the attribute selector (jsdom/older browsers lack it). */
-function cssEscape(value) {
-    return value.replace(/["\\]/g, '\\$&');
-}
-/**
- * Register the element. Idempotent, and safe to call on the server (where
- * `customElements` does not exist) — which is what lets a bundle be imported
- * from an SSR entry point without a `typeof window` dance at every call site.
- */
-export function defineGrafloriaFlow(tagName = 'grafloria-flow') {
-    if (typeof customElements === 'undefined')
-        return;
-    if (customElements.get(tagName))
-        return;
-    customElements.define(tagName, GrafloriaFlowElement);
-}
-//# sourceMappingURL=grafloria-flow-element.js.map

package/esm/src/lib/grafloria.js

@@ -1,69 +0,0 @@
-import { createDiagram, renderToStaticSVG } from '@grafloria/renderer';
-import { defineGrafloriaFlow } from './grafloria-flow-element';
-import { registerNodeType, registeredNodeTypes, getNodeType } from './node-type-registry';
-/**
- * Mount `spec` into `target` and return the live instance.
- *
- * `target` may be an element or a CSS selector. Custom nodes (`custom: true`)
- * are rendered by the types registered with {@link registerNodeType}.
- *
- * SCOPE, stated plainly: `spec` is data (an object or its JSON), not a Mermaid-
- * style text DSL. The engine does have a DSL, but wiring it in is a separate
- * card — `render()` is the embedding surface, not a parser.
- */
-export function render(spec, target, options = {}) {
-    var _a, _b, _c, _d;
-    const element = typeof target === 'string'
-        ? document.querySelector(target)
-        : target;
-    if (!element) {
-        throw new Error(`Grafloria.render: no element matched ${JSON.stringify(target)}`);
-    }
-    // Kit specs (dashboard()) carry looser node typing than DiagramSpec — both
-    // flow into createDiagram's NodeInput[] the same way.
-    const parsed = (typeof spec === 'string' ? parseSpec(spec) : spec);
-    const instance = createDiagram(element, Object.assign(Object.assign({}, options), { nodes: (_a = parsed.nodes) !== null && _a !== void 0 ? _a : [], edges: (_b = parsed.edges) !== null && _b !== void 0 ? _b : [], 
-        // Wire the global registry in, so `registerNodeType` works for the tiny API
-        // exactly as it does for `<grafloria-flow>` — unless the caller supplies their
-        // own. A KIT SPEC may also carry its own painter (dashboard() does: every
-        // widget is a custom HTML node), and it must be honoured — otherwise the
-        // documented one-liner `render(dashboard({…}), host)` mounts a board whose
-        // widgets never paint. Precedence: explicit option > spec > registry.
-        renderCustomNode: (_d = (_c = options.renderCustomNode) !== null && _c !== void 0 ? _c : parsed.renderCustomNode) !== null && _d !== void 0 ? _d : ((node, host) => { var _a; return (_a = getNodeType(node.type)) === null || _a === void 0 ? void 0 : _a(node, host); }) }));
-    // Diagram-kit specs (erDiagram/umlDiagram) carry a `finalize(api)` for the
-    // post-render wiring that needs the LIVE instance — row interactions,
-    // multiplicity chips. Auto-run it so a kit diagram is fully wired from one
-    // render() call; finalize is idempotent, so a caller may still call it too.
-    const maybeFinalize = spec.finalize;
-    if (typeof maybeFinalize === 'function') {
-        try {
-            maybeFinalize(instance);
-        }
-        catch (_e) {
-            /* a kit's finalize must never break the mount */
-        }
-    }
-    return instance;
-}
-/** Server-side render (Card 6). Re-exported so the tiny API is self-contained. */
-export function renderStatic(options = {}) {
-    return renderToStaticSVG(options);
-}
-function parseSpec(spec) {
-    try {
-        return JSON.parse(spec);
-    }
-    catch (error) {
-        throw new Error(`Grafloria.render: spec must be an object or a JSON string (${error.message})`);
-    }
-}
-/** The namespace object, for `import { Grafloria }` and for `<script>` globals. */
-export const Grafloria = {
-    render,
-    renderStatic,
-    registerNodeType,
-    registeredNodeTypes,
-    /** Register `<grafloria-flow>` (called for you when you import this package). */
-    define: defineGrafloriaFlow,
-};
-//# sourceMappingURL=grafloria.js.map

package/esm/src/lib/load.js

@@ -1,252 +0,0 @@
-/**
- * `fromDocument()` — the LOAD front door.
- *
- * ---------------------------------------------------------------------------
- * THE GAP THIS CLOSES
- * ---------------------------------------------------------------------------
- * Saving was never the problem. `DiagramSerializer.serialize()` already emits a
- * document that round-trips byte-identically, carrying nodes, links, ports,
- * groups and every scrap of kit metadata. LOADING was the problem, in three
- * layers:
- *
- *   1. THERE WAS NO FRONT DOOR. `CreateDiagramOptions` takes `nodes`/`edges`;
- *      nothing took a saved document. `deserialize()` handed back a
- *      `DiagramModel` that no entry point would render.
- *   2. THE KITS' POST-RENDER WIRING NEVER RAN. `erDiagram()`/`umlDiagram()` do
- *      their interaction wiring in `finalize(api)` — row selection, in-canvas
- *      editing, the suppressed resize handles. A document has no `finalize`, so
- *      a "successfully loaded" ERD was a PICTURE of an ERD: it looked right and
- *      did nothing.
- *   3. CUSTOM NODES HAD NO PAINTER. `renderCustomNode` is a function; functions
- *      do not serialize. A loaded dashboard mounted 14 widget hosts and painted
- *      into none of them.
- *
- * ---------------------------------------------------------------------------
- * WHY THE NODES GO BACK IN AS LIVE MODELS
- * ---------------------------------------------------------------------------
- * The obvious implementation projects every loaded `NodeModel` back down into a
- * `NodeSpec` and lets `buildNode()` rebuild it. That is a LOSSY detour, and it
- * loses exactly the things a saved diagram is made of: `toNodeSpec()` carries
- * id/position/size/data/label/shape and nothing else — no ports, no metadata,
- * no behavior. An ER card would come back with four default side ports instead
- * of its field ports, and every FK→PK edge would silently reroute.
- *
- * It is also unnecessary. `applyNodes()`/`applyEdges()` have always accepted a
- * live `NodeModel`/`LinkModel` and pass it through untouched — the documented
- * "mix data with your own model" seam. So the loaded models ARE the input, and
- * nothing is projected, converted or lost.
- *
- * ---------------------------------------------------------------------------
- * HOW PAINTERS COME BACK
- * ---------------------------------------------------------------------------
- * ER and UML need NOTHING: their card is `metadata.html`, a structured tree the
- * renderer paints itself, and metadata round-trips. Measured, not assumed — a
- * loaded ER document paints byte-identical cards with no painter in sight.
- *
- * Dashboard widgets are custom HTML nodes and do need one. The kit REBUILDS the
- * widget spec from the node's own metadata (`widgetKind` / `widgetSpec` /
- * `widgetTitle`) and hands it to the same `defaultWidgetRenderer` the authoring
- * path uses, so a loaded board is drawn by the identical code.
- *
- * Precedence, and why:
- *
- *   caller's `renderCustomNode`  — an explicit override outranks everything.
- *   caller's `renderWidget`      — the app's own chart painter; a board that was
- *                                  authored with one must be reloaded with it.
- *   the kit's own painter        — but ONLY for nodes the kit actually stamped.
- *   {@link getNodeType} registry — everything else, exactly as `render()` does.
- *
- * The kit claims a node by its METADATA, never by `type === 'widget'` alone.
- * Hijacking a type name would mean any unrelated diagram with a node called
- * "widget" got dashboard chrome painted over it; requiring the stamp the kit
- * itself wrote keeps the registry the general seam it is meant to be.
- */
-import { DiagramSerializer } from '@grafloria/engine';
-import { getNodeType } from './node-type-registry';
-import { bindRowInteractions } from './diagram-kit/rows';
-import { bindCardEditing } from './diagram-kit/editing';
-import { ensureDiagramKitStyles } from './diagram-kit/styles';
-import { bindDashboardGrid } from './dashboard-kit/grid-binder';
-import { ensureDashboardKitStyles } from './dashboard-kit/styles';
-import { defaultWidgetRenderer } from './dashboard-kit/widgets';
-import { createDashboardHandle, } from './dashboard-kit/dashboard';
-/** True when the node is an ER entity card or a UML class card. */
-function isDiagramKitCard(node) {
-    return node.getMetadata('kitEntity') !== undefined || node.getMetadata('kitClass') !== undefined;
-}
-/**
- * Rebuild the widget spec the kit's renderers eat, from the node's own metadata.
- * Returns null for a node the dashboard kit did not stamp — see the header on
- * why the type name alone is not enough.
- */
-function widgetSpecOf(node) {
-    var _a;
-    const kind = node.getMetadata('widgetKind');
-    if (kind === undefined)
-        return null;
-    const title = node.getMetadata('widgetTitle');
-    return Object.assign(Object.assign({ id: node.id, kind: kind }, (typeof title === 'string' ? { title } : {})), { data: ((_a = node.getMetadata('widgetSpec')) !== null && _a !== void 0 ? _a : {}), span: node.getMetadata('columnSpan'), rows: node.getMetadata('rowSpan') });
-}
-/**
- * Turn a saved document back into something `render()` can mount.
- *
- * ```ts
- * const json = JSON.stringify(new DiagramSerializer().serialize(api.getModel()));
- * // …later, in a fresh page:
- * render(fromDocument(json), host);
- * ```
- *
- * Accepts the flat serializer form, the portable envelope, or the JSON string
- * of either.
- */
-export function fromDocument(document, options = {}) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
-    const parsed = typeof document === 'string' ? parseDocument(document) : document;
-    const model = new DiagramSerializer().deserialize(parsed);
-    const nodes = model.getNodes();
-    const groups = model.getGroups();
-    const boards = new Map();
-    // The kits inject their stylesheet from their builder; a load never calls one,
-    // so an un-styled card would come back as unstyled divs. Only for documents
-    // that actually contain that kit's nodes.
-    if (nodes.some(isDiagramKitCard))
-        ensureDiagramKitStyles();
-    if (nodes.some((n) => widgetSpecOf(n) !== null))
-        ensureDashboardKitStyles();
-    const paintWidget = (_a = options.renderWidget) !== null && _a !== void 0 ? _a : defaultWidgetRenderer;
-    // -- reconstruct the dashboard handle's context from the loaded model -------
-    // Every board group carries `dashboardBoard` geometry; its widget members
-    // carry `widgetSpec`/title/span/rows — the canonical, lossless source for
-    // widgets (the load.ts principle that non-widget nodes go back as LIVE models
-    // is untouched; only widgets are rebuilt from metadata, exactly as the
-    // renderCustomNode painter already does). That is enough to build the SAME
-    // handle dashboard() does, through the SAME builder — no drifting twin.
-    const dashGroups = groups.filter((g) => g.getMetadata('dashboardBoard') !== undefined);
-    const specById = new Map();
-    const viewOfWidget = new Map();
-    const ctxViews = dashGroups.map((g) => {
-        var _a, _b, _c;
-        const board = g.getMetadata('dashboardBoard');
-        const widgets = [];
-        for (const memberId of (_a = g.members) !== null && _a !== void 0 ? _a : []) {
-            const node = model.getNode(memberId);
-            const ws = node ? widgetSpecOf(node) : null;
-            if (!ws)
-                continue; // non-widget members (e.g. a nested slab group) are not widgets
-            specById.set(ws.id, ws);
-            viewOfWidget.set(ws.id, g.id);
-            widgets.push(ws);
-        }
-        return { id: g.id, name: g.name, widgets, columns: board.columns, width: (_b = g.size) === null || _b === void 0 ? void 0 : _b.width, height: (_c = g.size) === null || _c === void 0 ? void 0 : _c.height };
-    });
-    const firstBoard = (_b = dashGroups[0]) === null || _b === void 0 ? void 0 : _b.getMetadata('dashboardBoard');
-    // The active view is the one the save left ON camera (x≈0); the others were
-    // parked far off-screen by showView. Falls back to the first board when
-    // positions are ambiguous (e.g. a single view, or positions not restored).
-    const activeGroup = (_c = dashGroups.find((g) => g.position.x > -1000)) !== null && _c !== void 0 ? _c : dashGroups[0];
-    const ctx = {
-        views: ctxViews,
-        groups: new Map(dashGroups.map((g) => [g.id, g])),
-        // The SAME map the LoadedDiagramSpec exposes as `boards` — derived, not a copy.
-        binders: boards,
-        specById,
-        viewOfWidget,
-        hosts: new Map(),
-        renderWidget: paintWidget,
-        columns: (_d = firstBoard === null || firstBoard === void 0 ? void 0 : firstBoard.columns) !== null && _d !== void 0 ? _d : 12,
-        gap: (_e = firstBoard === null || firstBoard === void 0 ? void 0 : firstBoard.gap) !== null && _e !== void 0 ? _e : 8,
-        rowHeight: (_f = firstBoard === null || firstBoard === void 0 ? void 0 : firstBoard.baseRowHeight) !== null && _f !== void 0 ? _f : 130,
-        boardW: (_j = (_h = (_g = dashGroups[0]) === null || _g === void 0 ? void 0 : _g.size) === null || _h === void 0 ? void 0 : _h.width) !== null && _j !== void 0 ? _j : 1180,
-        boardH: (_m = (_l = (_k = dashGroups[0]) === null || _k === void 0 ? void 0 : _k.size) === null || _l === void 0 ? void 0 : _l.height) !== null && _m !== void 0 ? _m : 660,
-        // responsive is NOT in the document (a runtime seam), so it is deliberately
-        // absent from the round-trip; width/height/columns/gap/sizing/float/rtl are.
-        optionsBase: firstBoard
-            ? {
-                columns: firstBoard.columns,
-                gap: firstBoard.gap,
-                rowHeight: firstBoard.baseRowHeight,
-                sizing: firstBoard.sizing,
-                float: firstBoard.float,
-                rtl: firstBoard.rtl,
-                width: (_p = (_o = dashGroups[0]) === null || _o === void 0 ? void 0 : _o.size) === null || _p === void 0 ? void 0 : _p.width,
-                height: (_r = (_q = dashGroups[0]) === null || _q === void 0 ? void 0 : _q.size) === null || _r === void 0 ? void 0 : _r.height,
-            }
-            : {},
-        active: (_s = activeGroup === null || activeGroup === void 0 ? void 0 : activeGroup.id) !== null && _s !== void 0 ? _s : 'main',
-        apiRef: null,
-    };
-    const handle = createDashboardHandle(ctx);
-    const renderCustomNode = (node, host) => {
-        var _a, _b;
-        if (options.renderCustomNode)
-            return options.renderCustomNode(node, host);
-        // Prefer the ctx spec object so a later handle.update()/repaint() mutates the
-        // SAME object this initial paint used; fall back to a fresh rebuild for a
-        // loose widget node that belongs to no reconstructed board.
-        const widget = (_a = specById.get(node.id)) !== null && _a !== void 0 ? _a : widgetSpecOf(node);
-        if (widget) {
-            ctx.hosts.set(node.id, host); // captured so update()/repaint() can find the host
-            return paintWidget(widget, host);
-        }
-        (_b = getNodeType(node.type)) === null || _b === void 0 ? void 0 : _b(node, host);
-    };
-    const finalize = (api) => {
-        var _a, _b, _c, _d;
-        const a = api;
-        if (!a)
-            return;
-        // -- groups ---------------------------------------------------------------
-        // Groups are not part of `nodes`/`edges`, so nothing else would carry them
-        // across. A dashboard without its view group is a set of loose widgets: no
-        // board frame, and nothing for the grid binder to bind to.
-        const live = (_a = a.getModel) === null || _a === void 0 ? void 0 : _a.call(a);
-        if (live) {
-            for (const group of groups) {
-                if (!((_b = live.getGroup) === null || _b === void 0 ? void 0 : _b.call(live, group.id)))
-                    (_c = live.addGroup) === null || _c === void 0 ? void 0 : _c.call(live, group);
-            }
-        }
-        if (options.interactive === false)
-            return;
-        // -- ER / UML -------------------------------------------------------------
-        const cards = nodes.filter(isDiagramKitCard);
-        if (cards.length > 0 && a.container) {
-            for (const node of cards) {
-                // The card draws its own selection ring; the node's resize handles would
-                // frame it a second time. `erDiagram().finalize` does this on the live
-                // model for the same reason — and behaviour is NOT in the document.
-                (_d = node.setBehavior) === null || _d === void 0 ? void 0 : _d.call(node, { resizable: false });
-            }
-            // `rowSelection: false` is recorded only when it is the non-default, so an
-            // ordinary document stays byte-identical to what it always was.
-            if (!cards.some((n) => n.getMetadata('kitRowSelection') === false)) {
-                bindRowInteractions(a);
-            }
-            if (cards.some((n) => n.getMetadata('kitEditable') === true)) {
-                bindCardEditing(a);
-            }
-        }
-        // -- dashboard boards -----------------------------------------------------
-        // Wire the render API into the handle's boxed cell, then bind each board.
-        // `bindDashboardGrid` sync()s on construction, so the handle's cellOf/toJSON
-        // work immediately — no camera move, no showView, so the paint is byte-for-
-        // byte what a boards-only load produced.
-        ctx.apiRef = a;
-        for (const group of groups) {
-            const board = group.getMetadata('dashboardBoard');
-            if (!board)
-                continue;
-            boards.set(group.id, bindDashboardGrid(a, group, Object.assign({}, board)));
-        }
-    };
-    return { nodes, edges: model.getLinks(), renderCustomNode, finalize, model, boards, handle };
-}
-function parseDocument(json) {
-    try {
-        return JSON.parse(json);
-    }
-    catch (error) {
-        throw new Error(`fromDocument: not a saved diagram (${error.message})`);
-    }
-}
-//# sourceMappingURL=load.js.map

package/esm/src/lib/node-type-registry.js

@@ -1,42 +0,0 @@
-const registry = new Map();
-/** Register (or replace) a node type globally. */
-export function registerNodeType(type, renderer) {
-    registry.set(type, renderer);
-}
-export function getNodeType(type) {
-    return registry.get(type);
-}
-export function hasNodeType(type) {
-    return registry.has(type);
-}
-/** Drop a registration (mostly for tests). */
-export function unregisterNodeType(type) {
-    registry.delete(type);
-}
-/** Every registered type name. */
-export function registeredNodeTypes() {
-    return [...registry.keys()];
-}
-/**
- * Render a node from a slotted `<template data-node-type="...">`.
- *
- * Clones the template's content into `element` and substitutes `node.data` into
- * every `[data-field="key"]` descendant's text. Values are written with
- * `textContent`, never `innerHTML`: a diagram's `data` is frequently
- * user-supplied, and a template engine that injected raw HTML here would be an
- * XSS vector in every host that embeds us.
- */
-export function renderFromTemplate(template, node, element) {
-    const fragment = template.content.cloneNode(true);
-    const fields = fragment.querySelectorAll('[data-field]');
-    for (const field of Array.from(fields)) {
-        const key = field.getAttribute('data-field');
-        if (!key)
-            continue;
-        const value = key === 'id' ? node.id : node.data[key];
-        field.textContent = value === undefined || value === null ? '' : String(value);
-    }
-    element.textContent = '';
-    element.appendChild(fragment);
-}
-//# sourceMappingURL=node-type-registry.js.map

package/esm/src/lib/stencil-kit/builders.js

@@ -1,18 +0,0 @@
-const builders = new Map();
-/** Register the builder for a master id. Last registration wins. */
-export function registerStencilBuilder(masterId, builder) {
-    builders.set(masterId, builder);
-}
-/** The builder for a master id, or undefined for the default template path. */
-export function getStencilBuilder(masterId) {
-    return builders.get(masterId);
-}
-/** Drop a registration (tests, or a host replacing a built-in). */
-export function unregisterStencilBuilder(masterId) {
-    return builders.delete(masterId);
-}
-/** Every master id that currently resolves to a card builder. */
-export function registeredStencilBuilders() {
-    return [...builders.keys()].sort();
-}
-//# sourceMappingURL=builders.js.map