@grafloria/element 0.3.17 → 0.3.19

package/src/libs/element/src/lib/grafloria.d.ts

@@ -0,0 +1,72 @@
+import type { CreateDiagramOptions, DiagramInstance, EdgeSpec, NodeSpec, StaticRenderOptions, StaticRenderResult } from '@grafloria/renderer';
+import { defineGrafloriaFlow } from './grafloria-flow-element';
+import type { DashboardSpec } from './dashboard-kit';
+import { registerNodeType, registeredNodeTypes } from './node-type-registry';
+import type { NodeTypeRenderer } from './node-type-registry';
+/**
+ * `Grafloria` — the Mermaid-shaped top-level API.
+ *
+ * Mermaid's moat is not its renderer, it is `mermaid.render(id, text)`: one
+ * function, no build step, no framework. That is why it shows up in GitHub
+ * comments, in docs sites, in notebooks and in every CMS. This is the same
+ * surface for a diagram that is *interactive*:
+ *
+ * ```html
+ * <script type="module">
+ *   import { Grafloria } from 'https://esm.sh/@grafloria/element';
+ *
+ *   Grafloria.registerNodeType('card', (node, el) => {
+ *     el.innerHTML = `<div class="card">${node.data.title}</div>`;
+ *   });
+ *
+ *   const diagram = Grafloria.render(
+ *     { nodes: [...], edges: [...] },
+ *     document.getElementById('chart')
+ *   );
+ *   diagram.on('connect', ({ link }) => save(link));
+ * </script>
+ * ```
+ *
+ * `render()` returns the same `DiagramInstance` every wrapper binds to, so the
+ * "tiny API" is not a lesser one — it is the whole engine, addressed in one call.
+ */
+/** What `Grafloria.render()` accepts: an object spec, or the JSON string of one. */
+export interface DiagramSpec {
+    nodes?: NodeSpec[];
+    edges?: EdgeSpec[];
+}
+/**
+ * The structural shape every diagram kit emits (erDiagram, umlDiagram, …):
+ * nodes/edges as loose records plus the optional painter and finalize hook.
+ */
+export interface KitDiagramSpec {
+    nodes: Array<Record<string, unknown>>;
+    edges: Array<Record<string, unknown>>;
+    renderCustomNode?: (node: unknown, host: HTMLElement) => void;
+    finalize?: (api: unknown) => void;
+}
+export type RenderSpec = DiagramSpec | DashboardSpec | KitDiagramSpec | string;
+export type RenderOptions = Omit<CreateDiagramOptions, 'nodes' | 'edges'>;
+/**
+ * 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 declare function render(spec: RenderSpec, target: HTMLElement | string, options?: RenderOptions): DiagramInstance;
+/** Server-side render (Card 6). Re-exported so the tiny API is self-contained. */
+export declare function renderStatic(options?: StaticRenderOptions): StaticRenderResult;
+/** The namespace object, for `import { Grafloria }` and for `<script>` globals. */
+export declare const Grafloria: {
+    render: typeof render;
+    renderStatic: typeof renderStatic;
+    registerNodeType: typeof registerNodeType;
+    registeredNodeTypes: typeof registeredNodeTypes;
+    /** Register `<grafloria-flow>` (called for you when you import this package). */
+    define: typeof defineGrafloriaFlow;
+};
+export type { NodeTypeRenderer };

package/src/libs/element/src/lib/grafloria.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Grafloria = void 0;
+exports.render = render;
+exports.renderStatic = renderStatic;
+const renderer_1 = require("@grafloria/renderer");
+const grafloria_flow_element_1 = require("./grafloria-flow-element");
+const node_type_registry_1 = require("./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.
+ */
+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 = (0, renderer_1.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 = (0, node_type_registry_1.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. */
+function renderStatic(options = {}) {
+    return (0, renderer_1.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. */
+exports.Grafloria = {
+    render,
+    renderStatic,
+    registerNodeType: node_type_registry_1.registerNodeType,
+    registeredNodeTypes: node_type_registry_1.registeredNodeTypes,
+    /** Register `<grafloria-flow>` (called for you when you import this package). */
+    define: grafloria_flow_element_1.defineGrafloriaFlow,
+};
+//# sourceMappingURL=grafloria.js.map

package/src/libs/element/src/lib/grafloria.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"grafloria.js","sourceRoot":"","sources":["../../../../lib/grafloria.ts"],"names":[],"mappings":";;;AA2EA,wBAgDC;AAGD,oCAEC;AAhID,kDAAuE;AASvE,qEAA+D;AAE/D,6DAA0F;AAsD1F;;;;;;;;;GASG;AACH,SAAgB,MAAM,CACpB,IAAgB,EAChB,MAA4B,EAC5B,UAAyB,EAAE;;IAE3B,MAAM,OAAO,GACX,OAAO,MAAM,KAAK,QAAQ;QACxB,CAAC,CAAE,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAwB;QACxD,CAAC,CAAC,MAAM,CAAC;IAEb,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CAAC,wCAAwC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACpF,CAAC;IAED,2EAA2E;IAC3E,sDAAsD;IACtD,MAAM,MAAM,GAAG,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAgB,CAAC;IAElF,MAAM,QAAQ,GAAG,IAAA,wBAAa,EAAC,OAAO,kCACjC,OAAO,KACV,KAAK,EAAE,MAAA,MAAM,CAAC,KAAK,mCAAI,EAAE,EACzB,KAAK,EAAE,MAAA,MAAM,CAAC,KAAK,mCAAI,EAAE;QACzB,4EAA4E;QAC5E,+EAA+E;QAC/E,0EAA0E;QAC1E,yEAAyE;QACzE,2EAA2E;QAC3E,sEAAsE;QACtE,gBAAgB,EACd,MAAA,MAAA,OAAO,CAAC,gBAAgB,mCACvB,MAAmE,CAAC,gBAAgB,mCACrF,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,WAAC,OAAA,MAAA,IAAA,gCAAW,EAAC,IAAI,CAAC,IAAI,CAAC,0CAAG,IAAI,EAAE,IAAI,CAAC,CAAA,EAAA,CAAC,IACxD,CAAC;IAEH,2EAA2E;IAC3E,sEAAsE;IACtE,2EAA2E;IAC3E,4EAA4E;IAC5E,MAAM,aAAa,GAAI,IAA8C,CAAC,QAAQ,CAAC;IAC/E,IAAI,OAAO,aAAa,KAAK,UAAU,EAAE,CAAC;QACxC,IAAI,CAAC;YACH,aAAa,CAAC,QAAQ,CAAC,CAAC;QAC1B,CAAC;QAAC,WAAM,CAAC;YACP,iDAAiD;QACnD,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,kFAAkF;AAClF,SAAgB,YAAY,CAAC,UAA+B,EAAE;IAC5D,OAAO,IAAA,4BAAiB,EAAC,OAAO,CAAC,CAAC;AACpC,CAAC;AAED,SAAS,SAAS,CAAC,IAAY;IAC7B,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAgB,CAAC;IACzC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,8DAA+D,KAAe,CAAC,OAAO,GAAG,CAC1F,CAAC;IACJ,CAAC;AACH,CAAC;AAED,mFAAmF;AACtE,QAAA,SAAS,GAAG;IACvB,MAAM;IACN,YAAY;IACZ,gBAAgB,EAAhB,qCAAgB;IAChB,mBAAmB,EAAnB,wCAAmB;IACnB,iFAAiF;IACjF,MAAM,EAAE,4CAAmB;CAC5B,CAAC"}

package/src/libs/element/src/lib/load.d.ts

@@ -0,0 +1,72 @@
+import type { DiagramDocumentEnvelope, DiagramModel, LinkModel, NodeModel, SerializedDiagramData } from '@grafloria/engine';
+import { type DashboardGridHandle } from './dashboard-kit/grid-binder';
+import { type WidgetRenderer } from './dashboard-kit/widgets';
+import { type DashboardHandle } from './dashboard-kit/dashboard';
+/** Anything `DiagramSerializer.deserialize()` accepts, or the JSON string of it. */
+export type SavedDiagram = SerializedDiagramData | DiagramDocumentEnvelope | Record<string, unknown> | string;
+export interface FromDocumentOptions {
+    /**
+     * The app's own widget painter — the same function it passed to
+     * `dashboard({ renderWidget })`. A board authored with a custom painter must
+     * be RELOADED with it, or the reload silently drops the app's chrome.
+     */
+    renderWidget?: WidgetRenderer;
+    /** Full override of the custom-node painter. Outranks everything. */
+    renderCustomNode?: (node: NodeModel, host: HTMLElement) => void;
+    /**
+     * Re-attach kit interaction wiring (row selection, in-canvas editing, the
+     * dashboard grid binder). Default true — a loaded diagram should behave like
+     * the one that was saved. Pass false for a read-only viewer.
+     */
+    interactive?: boolean;
+}
+/** What {@link fromDocument} returns: a `render()` spec, plus the way back in. */
+export interface LoadedDiagramSpec {
+    nodes: NodeModel[];
+    edges: LinkModel[];
+    renderCustomNode: (node: NodeModel, host: HTMLElement) => void;
+    finalize: (api: unknown) => void;
+    /** The deserialized model — the escape hatch, available before any render. */
+    readonly model: DiagramModel;
+    /**
+     * Live grid binders for the boards `finalize()` re-attached, keyed by group
+     * id. Empty for a document that is not a dashboard.
+     *
+     * This is the SAME Map instance the handle drives (`handle.binderOf` returns
+     * from it), so the two can never disagree — `boards` is now derived from the
+     * handle's own binders rather than a parallel copy.
+     */
+    readonly boards: Map<string, DashboardGridHandle>;
+    /**
+     * The dashboard toolbar handle over the reloaded board(s) — the SAME
+     * `DashboardHandle` `dashboard()` returns, built by the one shared builder so
+     * it cannot drift from the authoring surface: addWidget/showView/setSizing/
+     * setColumns/toJSON/exportIds and the widget handles, all live on the reload.
+     *
+     * INERT (empty `views`, every op a no-op) for a document that is not a
+     * dashboard — an ER/UML load carries no board, so an honest empty handle
+     * beats one that pretends a class card is a widget.
+     *
+     * Two carried limits, both because the datum is not in the document:
+     *  - `responsive` is a runtime seam, never serialised, so a reloaded board is
+     *    fixed at its saved column count until `setColumns`/`responsive` is
+     *    re-supplied; `toJSON()` therefore omits it.
+     *  - `renderWidget`/`onLayoutChange` are functions and cannot serialise —
+     *    pass `renderWidget` to `fromDocument({ renderWidget })` to reattach the
+     *    app's own painter, exactly as `dashboard({ renderWidget })` did.
+     */
+    readonly handle: DashboardHandle;
+}
+/**
+ * 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 declare function fromDocument(document: SavedDiagram, options?: FromDocumentOptions): LoadedDiagramSpec;

package/src/libs/element/src/lib/load.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromDocument = fromDocument;
+/**
+ * `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.
+ */
+const engine_1 = require("@grafloria/engine");
+const node_type_registry_1 = require("./node-type-registry");
+const rows_1 = require("./diagram-kit/rows");
+const editing_1 = require("./diagram-kit/editing");
+const styles_1 = require("./diagram-kit/styles");
+const grid_binder_1 = require("./dashboard-kit/grid-binder");
+const styles_2 = require("./dashboard-kit/styles");
+const widgets_1 = require("./dashboard-kit/widgets");
+const dashboard_1 = require("./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.
+ */
+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 engine_1.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))
+        (0, styles_1.ensureDiagramKitStyles)();
+    if (nodes.some((n) => widgetSpecOf(n) !== null))
+        (0, styles_2.ensureDashboardKitStyles)();
+    const paintWidget = (_a = options.renderWidget) !== null && _a !== void 0 ? _a : widgets_1.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 = (0, dashboard_1.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 = (0, node_type_registry_1.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)) {
+                (0, rows_1.bindRowInteractions)(a);
+            }
+            if (cards.some((n) => n.getMetadata('kitEditable') === true)) {
+                (0, editing_1.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, (0, grid_binder_1.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/src/libs/element/src/lib/load.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.js","sourceRoot":"","sources":["../../../../lib/load.ts"],"names":[],"mappings":"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"}

package/src/libs/element/src/lib/node-type-registry.d.ts

@@ -0,0 +1,39 @@
+import type { NodeModel } from '@grafloria/engine';
+/**
+ * The framework-free custom-node registry behind `<grafloria-flow>` and
+ * `Grafloria.registerNodeType()`.
+ *
+ * A "node type" is just a function that fills a host element the core handed us:
+ *
+ * ```ts
+ * Grafloria.registerNodeType('card', (node, el) => {
+ *   el.innerHTML = `<div class="card">${node.data.title}</div>`;
+ * });
+ * ```
+ *
+ * There is a second, zero-JavaScript path: a `<template data-node-type="card">`
+ * slotted inside the `<grafloria-flow>` element. The template is cloned per node and
+ * `[data-field="title"]` elements are filled from `node.data` — which is what
+ * lets a CMS, a notebook or a plain HTML page ship a custom node with no build
+ * step at all.
+ */
+/** Fills `element` with the visual for `node`. Called once per mounted node. */
+export type NodeTypeRenderer = (node: NodeModel, element: HTMLElement) => void;
+/** Register (or replace) a node type globally. */
+export declare function registerNodeType(type: string, renderer: NodeTypeRenderer): void;
+export declare function getNodeType(type: string): NodeTypeRenderer | undefined;
+export declare function hasNodeType(type: string): boolean;
+/** Drop a registration (mostly for tests). */
+export declare function unregisterNodeType(type: string): void;
+/** Every registered type name. */
+export declare function registeredNodeTypes(): string[];
+/**
+ * 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 declare function renderFromTemplate(template: HTMLTemplateElement, node: NodeModel, element: HTMLElement): void;

package/src/libs/element/src/lib/node-type-registry.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNodeType = registerNodeType;
+exports.getNodeType = getNodeType;
+exports.hasNodeType = hasNodeType;
+exports.unregisterNodeType = unregisterNodeType;
+exports.registeredNodeTypes = registeredNodeTypes;
+exports.renderFromTemplate = renderFromTemplate;
+const registry = new Map();
+/** Register (or replace) a node type globally. */
+function registerNodeType(type, renderer) {
+    registry.set(type, renderer);
+}
+function getNodeType(type) {
+    return registry.get(type);
+}
+function hasNodeType(type) {
+    return registry.has(type);
+}
+/** Drop a registration (mostly for tests). */
+function unregisterNodeType(type) {
+    registry.delete(type);
+}
+/** Every registered type name. */
+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.
+ */
+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/src/libs/element/src/lib/node-type-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-type-registry.js","sourceRoot":"","sources":["../../../../lib/node-type-registry.ts"],"names":[],"mappings":";;AA2BA,4CAEC;AAED,kCAEC;AAED,kCAEC;AAGD,gDAEC;AAGD,kDAEC;AAWD,gDAiBC;AAnDD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA4B,CAAC;AAErD,kDAAkD;AAClD,SAAgB,gBAAgB,CAAC,IAAY,EAAE,QAA0B;IACvE,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AAC/B,CAAC;AAED,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC5B,CAAC;AAED,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC5B,CAAC;AAED,8CAA8C;AAC9C,SAAgB,kBAAkB,CAAC,IAAY;IAC7C,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AACxB,CAAC;AAED,kCAAkC;AAClC,SAAgB,mBAAmB;IACjC,OAAO,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,kBAAkB,CAChC,QAA6B,EAC7B,IAAe,EACf,OAAoB;IAEpB,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAqB,CAAC;IAEtE,MAAM,MAAM,GAAG,QAAQ,CAAC,gBAAgB,CAAc,cAAc,CAAC,CAAC;IACtE,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QACvC,MAAM,GAAG,GAAG,KAAK,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;QAC7C,IAAI,CAAC,GAAG;YAAE,SAAS;QACnB,MAAM,KAAK,GAAG,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAE,IAAI,CAAC,IAAgC,CAAC,GAAG,CAAC,CAAC;QACnF,KAAK,CAAC,WAAW,GAAG,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACjF,CAAC;IAED,OAAO,CAAC,WAAW,GAAG,EAAE,CAAC;IACzB,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;AAChC,CAAC"}

package/src/libs/element/src/lib/stencil-kit/builders.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Stencil BUILDERS — how a dropped master becomes node(s).
+ *
+ * Most masters are a silhouette plus a label, and `NodeFactory` builds those
+ * perfectly well. A few are not shapes at all: an ER entity or a UML class is a
+ * CARD with rows you select, rename and add to. The diagram kits already build
+ * exactly those cards, with inline editing, row-selection events and an undoable
+ * update funnel — and the palette had no way to reach them, so dropping "Entity"
+ * produced a rectangle.
+ *
+ * Rather than special-case ids inside the palette (which would hardcode ER/UML
+ * knowledge into a module that should not have it, and would lock a host's own
+ * stencils out of the same capability), a master resolves to a REGISTERED
+ * builder. The default builder is the template path; the ER and UML kits
+ * register card builders; anyone can register their own.
+ *
+ *     registerStencilBuilder('erd-entity', myBuilder);
+ */
+import type { NodeTemplate } from '@grafloria/engine';
+/** What a builder is handed. */
+export interface StencilBuildContext {
+    /** The live diagram instance (engine + model + container). */
+    api: any;
+    /** The master being placed. */
+    master: NodeTemplate;
+    /** World position for the node's TOP-LEFT (the palette centres before calling). */
+    at: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Build the node(s) for a master. Return the created root node — the palette
+ * takes it from there (undo entry, membership, onPlace). Return `null` to fall
+ * through to the default template path.
+ */
+export type StencilBuilder = (ctx: StencilBuildContext) => any | null;
+/** Register the builder for a master id. Last registration wins. */
+export declare function registerStencilBuilder(masterId: string, builder: StencilBuilder): void;
+/** The builder for a master id, or undefined for the default template path. */
+export declare function getStencilBuilder(masterId: string): StencilBuilder | undefined;
+/** Drop a registration (tests, or a host replacing a built-in). */
+export declare function unregisterStencilBuilder(masterId: string): boolean;
+/** Every master id that currently resolves to a card builder. */
+export declare function registeredStencilBuilders(): string[];