@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/dsl/mermaid/MermaidState.js

@@ -1,613 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMermaidState = parseMermaidState;
-exports.stateModelToDiagram = stateModelToDiagram;
-exports.stateModelFromDiagram = stateModelFromDiagram;
-exports.generateMermaidState = generateMermaidState;
-exports.generateStateFromDiagram = generateStateFromDiagram;
-/**
- * Mermaid `stateDiagram` / `stateDiagram-v2` — parser, model builder and
- * generator (Phase 3, the third of the graph-family types).
- *
- * There was no parser at all before this: the header fell through to the
- * flowchart path and produced a node literally called `stateDiagram-v2`, which
- * Phase 0 then downgraded to an explicit "unsupported" signal. This is the
- * real thing.
- *
- * The one design decision worth recording is `[*]`. Mermaid writes BOTH the
- * start and the end pseudo-state with the same token, disambiguated only by
- * which side of the arrow it sits on — and it is scoped: a composite state has
- * its OWN start/end. So `[*]` becomes a generated pseudo-node per (scope,
- * role): `__start__` / `__end__` at the root, `Composite.__start__` inside.
- * Collapsing them into one node would silently merge a composite's entry with
- * the diagram's, which is a wrong diagram, not a lossy one.
- *
- * The second is CONCURRENCY. A `--` line inside a composite splits its body
- * into orthogonal regions that run at the same time. Ignoring the separator
- * merged them into one composite, which reads a concurrent machine as a
- * sequential one — and, because `[*]` is scoped, it also fused every region's
- * entry point into a single start node. Each region therefore becomes a
- * SYNTHETIC composite state of its own (`A.region1`, `A.region2`, …) that owns
- * that region's children, transitions and `[*]`. The regions are the composite's
- * children, so they nest as groups and the generator can put the `--` back.
- */
-const DiagramModel_1 = require("../../models/DiagramModel");
-const NodeModel_1 = require("../../models/NodeModel");
-const GroupModel_1 = require("../../models/GroupModel");
-const lines_1 = require("./lines");
-const layout_1 = require("./layout");
-/** Kinds written as a bracket token (`[*]`, `[H]`, `[H*]`), never as an id. */
-const PSEUDO_KINDS = new Set([
-    'start', 'end', 'history', 'deep-history',
-]);
-const ID = '[A-Za-z0-9_\\u00c0-\\uffff][A-Za-z0-9_\\-.\\u00c0-\\uffff]*';
-/** Mermaid allows exactly ONE `:::cssClass` suffix on a state reference. */
-const CSS = '(?::::[A-Za-z0-9_-]+)?';
-const CSS_SPLIT_RE = new RegExp(`^(${ID}):::([A-Za-z0-9_-]+)$`);
-const ENDPOINT = `(?:\\[\\*\\]|\\[H\\*?\\]|${ID}${CSS})`;
-const TRANSITION_RE = new RegExp(`^(${ENDPOINT})\\s*-{2,}>\\s*(${ENDPOINT})\\s*(?::\\s*(.*))?$`);
-// `state "long description" as s2`, optionally opening a composite body.
-const STATE_AS_RE = new RegExp(`^state\\s+"([^"]*)"\\s+as\\s+(${ID})\\s*(\\{?)\\s*$`);
-// `state name <<fork>>` / `state name {` / `state name` / `state name:::css`
-const STATE_DECL_RE = new RegExp(`^state\\s+(${ID}${CSS})\\s*(?:<<(fork|join|choice)>>)?\\s*(\\{?)\\s*$`);
-// `s2 : description`. The `(?!::)` keeps `A:::hot` out — that is a STYLE hook,
-// and reading it here made the state's label `::hot`.
-const DESCRIPTION_RE = new RegExp(`^(${ID})\\s*:(?!::)\\s*(.*)$`);
-/** A bare state reference on its own line, with or without its style hook. */
-const BARE_STATE_RE = new RegExp(`^${ID}${CSS}$`);
-const NOTE_RE = new RegExp(`^note\\s+(left of|right of|over)\\s+(${ID})\\s*(?::\\s*(.*))?$`);
-const DIRECTION_RE = /^direction\s+(TB|BT|LR|RL|TD)$/i;
-/**
- * The concurrency separator. Mermaid's lexer reads it as a repeated `--`, so
- * `--` and `----` are separators and `---` / `-----` are lexical ERRORS — hence
- * `(?:--)+` rather than `-{2,}`. (Confirmed against mermaid 11.16 directly.)
- */
-const REGION_SEPARATOR_RE = /^(?:--)+$/;
-const HISTORY_RE = /^\[H(\*)?\]$/;
-/** Does the composite body opening at `lines[open]` contain a `--` at ITS depth? */
-function hasConcurrentRegions(lines, open) {
-    let depth = 0;
-    for (let i = open + 1; i < lines.length; i++) {
-        const text = lines[i].text;
-        if (text === '}') {
-            if (depth === 0)
-                return false; // end of the composite we asked about
-            depth--;
-            continue;
-        }
-        if (depth === 0 && REGION_SEPARATOR_RE.test(text))
-            return true;
-        const decl = text.match(STATE_DECL_RE);
-        const as = text.match(STATE_AS_RE);
-        if ((decl === null || decl === void 0 ? void 0 : decl[3]) === '{' || (as === null || as === void 0 ? void 0 : as[3]) === '{')
-            depth++;
-    }
-    return false;
-}
-/**
- * Parse a state-diagram body. `stateDiagram` (v1) and `stateDiagram-v2` share
- * this grammar — v2 is a different LAYOUT engine in Mermaid, not a different
- * syntax, so refusing v1 would be arbitrary.
- */
-function parseMermaidState(text) {
-    var _a;
-    const lines = (0, lines_1.significantLines)(text, ['stateDiagram', 'stateDiagram-v2']);
-    const states = new Map();
-    const transitions = [];
-    const notes = [];
-    let direction;
-    const touch = (id, scope, kind = 'state') => {
-        const existing = states.get(id);
-        if (existing) {
-            if (kind !== 'state' && existing.kind === 'state')
-                existing.kind = kind;
-            return existing;
-        }
-        const node = Object.assign({ id, label: id, kind }, (scope ? { parent: scope } : {}));
-        states.set(id, node);
-        return node;
-    };
-    /**
-     * A bracket token resolves to a pseudo-state scoped to the enclosing body.
-     * `[*]`'s ROLE depends on which side of the arrow it sits on; `[H]`/`[H*]`
-     * carry their own. Before this, `[H]` matched no endpoint rule, so the whole
-     * transition line was dropped in silence.
-     */
-    const pseudo = (scope, role) => {
-        const slug = role === 'deep-history' ? '__deep_history__' : `__${role}__`;
-        const id = `${scope ? scope + '.' : ''}${slug}`;
-        touch(id, scope, role).label = '';
-        return id;
-    };
-    /** Touch a state written as `id` or `id:::cssClass`, keeping the hook. */
-    const touchStyled = (raw, kind = 'state') => {
-        const styled = raw.match(CSS_SPLIT_RE);
-        const node = touch(styled ? styled[1] : raw, scope(), kind);
-        if (styled)
-            node.cssClass = styled[2];
-        return node;
-    };
-    /** Resolve one side of a transition: bracket token or a real state id. */
-    const endpoint = (raw, side) => {
-        if (raw === '[*]')
-            return pseudo(scope(), side === 'from' ? 'start' : 'end');
-        const history = raw.match(HISTORY_RE);
-        if (history)
-            return pseudo(scope(), history[1] ? 'deep-history' : 'history');
-        return touchStyled(raw).id;
-    };
-    const frames = [];
-    const frame = () => frames[frames.length - 1];
-    const scope = () => {
-        var _a;
-        const f = frame();
-        return f ? ((_a = f.region) !== null && _a !== void 0 ? _a : f.id) : undefined;
-    };
-    /** Start the next orthogonal region of a concurrent composite. */
-    const openRegion = (f) => {
-        f.regions += 1;
-        const id = `${f.id}.region${f.regions}`;
-        const region = touch(id, f.id);
-        region.label = '';
-        region.composite = true;
-        region.region = true;
-        f.region = id;
-    };
-    /** Push a composite scope, pre-scanning its body for the `--` separator. */
-    const openComposite = (node, at) => {
-        node.composite = true;
-        const f = { id: node.id, concurrent: hasConcurrentRegions(lines, at), regions: 0 };
-        frames.push(f);
-        if (f.concurrent) {
-            node.concurrent = true;
-            openRegion(f);
-        }
-    };
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].text;
-        if (line === '}') {
-            frames.pop();
-            continue;
-        }
-        if (REGION_SEPARATOR_RE.test(line)) {
-            // Inside a concurrent composite this closes one region and opens the
-            // next. At the top level Mermaid rejects it outright, so we skip it —
-            // never let a run of dashes become a state.
-            const f = frame();
-            if (f === null || f === void 0 ? void 0 : f.concurrent)
-                openRegion(f);
-            continue;
-        }
-        const dir = line.match(DIRECTION_RE);
-        if (dir) {
-            // Scoped: `direction` inside a composite is the COMPOSITE's, not the
-            // diagram's. Hoisting it re-oriented the whole diagram on export.
-            const f = frame();
-            const owner = f ? states.get(f.id) : undefined;
-            if (owner)
-                owner.direction = dir[1].toUpperCase();
-            else
-                direction = dir[1].toUpperCase();
-            continue;
-        }
-        const note = line.match(NOTE_RE);
-        if (note) {
-            // Two spellings: `note right of A : text` (one line) and the BLOCK form,
-            // `note right of A` … `end note`. The block body must be consumed here —
-            // left to fall through, its prose lines match the bare-state rule and
-            // become STATES (`note right of A / hello / end note` used to mint a
-            // state called "hello"). That is precisely the Phase-0 garbage footgun.
-            if (note[3] !== undefined) {
-                notes.push({ position: note[1], target: note[2], text: note[3] });
-                continue;
-            }
-            const body = [];
-            let j = i + 1;
-            for (; j < lines.length && !/^end note$/.test(lines[j].text); j++)
-                body.push(lines[j].text);
-            notes.push({ position: note[1], target: note[2], text: body.join(' ') });
-            i = j; // skip the `end note` line too
-            continue;
-        }
-        if (/^end note$/.test(line))
-            continue;
-        const transition = line.match(TRANSITION_RE);
-        if (transition) {
-            const [, rawFrom, rawTo, label] = transition;
-            const from = endpoint(rawFrom, 'from');
-            const to = endpoint(rawTo, 'to');
-            transitions.push(Object.assign({ from, to }, (label && label.trim() ? { label: (0, lines_1.unquote)(label.trim()) } : {})));
-            continue;
-        }
-        const stateAs = line.match(STATE_AS_RE);
-        if (stateAs) {
-            // `state "desc" as X {` is valid Mermaid and used to match NOTHING: the
-            // composite was lost, its children leaked into the enclosing scope, and
-            // the orphaned `}` popped a scope it never pushed.
-            const node = touch(stateAs[2], scope());
-            node.label = stateAs[1];
-            if (stateAs[3] === '{')
-                openComposite(node, i);
-            continue;
-        }
-        const decl = line.match(STATE_DECL_RE);
-        if (decl) {
-            const [, id, pseudoKind, brace] = decl;
-            const node = touchStyled(id, (_a = pseudoKind) !== null && _a !== void 0 ? _a : 'state');
-            if (brace === '{')
-                openComposite(node, i);
-            continue;
-        }
-        const description = line.match(DESCRIPTION_RE);
-        if (description) {
-            touch(description[1], scope()).label = description[2].trim();
-            continue;
-        }
-        if (BARE_STATE_RE.test(line)) {
-            touchStyled(line);
-            continue;
-        }
-        // classDef / class / style / anything newer: ignored, never nodified.
-    }
-    return Object.assign({ states: [...states.values()], transitions, notes }, (direction ? { direction } : {}));
-}
-// ── Model building ─────────────────────────────────────────────────────────
-const PSEUDO_SIZE = 22;
-// ── Flow layout (gap-analysis §3a "state by flow") ─────────────────────────
-//
-// Replaces the naive 4-up grid with three type-aware rules:
-//   1. FLOW: within every body, states rank by transition flow — the start
-//      pseudo-state has no incoming transition, so it leads its scope.
-//   2. CONTAINMENT: a composite is SIZED to contain its laid-out children
-//      (bottom-up measure, then top-down commit into world coordinates).
-//   3. BANDING: a concurrent composite stacks its regions as horizontal
-//      bands — each region's children live in their own band, which is what
-//      draws the picture Mermaid divides with dashed lines. The un-banded
-//      picture is the defect the gap analysis names.
-const STATE_PAD = 18; // inner padding of a composite body
-const STATE_HEADER = 22; // title strip of a (non-region) composite
-const REGION_PAD = 14; // inner padding of one concurrent band
-const BAND_GAP = 10; // gap between stacked bands
-const RANK_GAP = 50;
-const CROSS_GAP = 40;
-/**
- * Lay every state out by flow, sizing composites to contain their children and
- * banding concurrent regions. Mutates the NodeModels' position/size in place.
- */
-function layoutStateModel(model, nodes, start) {
-    const byId = new Map(model.states.map((s) => [s.id, s]));
-    const childrenOf = (scope) => model.states.filter((s) => { var _a; return ((_a = s.parent) !== null && _a !== void 0 ? _a : undefined) === scope; });
-    /** The ancestor of `id` that is a DIRECT child of `scope` (else undefined). */
-    const liftTo = (id, scope) => {
-        var _a, _b;
-        let current = id;
-        while (current !== undefined) {
-            const parent = (_b = (_a = byId.get(current)) === null || _a === void 0 ? void 0 : _a.parent) !== null && _b !== void 0 ? _b : undefined;
-            if (parent === scope)
-                return current;
-            current = parent;
-        }
-        return undefined;
-    };
-    /** Transitions, lifted into `scope` — the edges that rank ITS children. */
-    const scopeEdges = (scope) => {
-        const edges = [];
-        for (const t of model.transitions) {
-            const from = liftTo(t.from, scope);
-            const to = liftTo(t.to, scope);
-            if (from !== undefined && to !== undefined && from !== to) {
-                edges.push({ from, to });
-            }
-        }
-        return edges;
-    };
-    // Bottom-up: measured outer size per state (leaves read their NodeModel).
-    const measured = new Map();
-    const arrangements = new Map(); // keyed by scope id ('' = root)
-    const measure = (state) => {
-        const cached = measured.get(state.id);
-        if (cached)
-            return cached;
-        let size;
-        if (!state.composite) {
-            const node = nodes.get(state.id);
-            size = { width: node.size.width, height: node.size.height };
-        }
-        else if (state.concurrent) {
-            // BANDING: measure each region, give every band the width of the widest
-            // (so the compartments align, as Mermaid draws them), stack them.
-            const regions = childrenOf(state.id).filter((s) => s.region);
-            const bands = regions.map((r) => measure(r));
-            const bandWidth = Math.max(...bands.map((b) => b.width), 0);
-            const stacked = bands.reduce((sum, b) => sum + b.height, 0) +
-                Math.max(0, bands.length - 1) * BAND_GAP;
-            size = {
-                width: bandWidth + 2 * STATE_PAD,
-                height: stacked + 2 * STATE_PAD + STATE_HEADER,
-            };
-        }
-        else {
-            const inner = arrange(state.id);
-            const pad = state.region ? REGION_PAD : STATE_PAD;
-            const header = state.region ? 0 : STATE_HEADER;
-            size = {
-                width: inner.width + 2 * pad,
-                height: inner.height + 2 * pad + header,
-            };
-        }
-        measured.set(state.id, size);
-        return size;
-    };
-    /** Rank-place the direct children of `scope` in local coordinates. */
-    const arrange = (scope) => {
-        var _a, _b, _c;
-        const key = scope !== null && scope !== void 0 ? scope : '';
-        const cached = arrangements.get(key);
-        if (cached)
-            return cached;
-        const children = childrenOf(scope);
-        const placeable = children.map((child) => ({ id: child.id, size: measure(child) }));
-        const direction = (_c = (_b = (scope !== undefined ? (_a = byId.get(scope)) === null || _a === void 0 ? void 0 : _a.direction : undefined)) !== null && _b !== void 0 ? _b : model.direction) !== null && _c !== void 0 ? _c : 'TB';
-        const positions = (0, layout_1.placeByRank)(placeable, (0, layout_1.assignRanks)(placeable.map((p) => p.id), scopeEdges(scope)), { direction, start: { x: 0, y: 0 }, rankGap: RANK_GAP, crossGap: CROSS_GAP });
-        let width = 0;
-        let height = 0;
-        for (const p of placeable) {
-            const at = positions.get(p.id);
-            width = Math.max(width, at.x + p.size.width);
-            height = Math.max(height, at.y + p.size.height);
-        }
-        const arrangement = { positions, width, height };
-        arrangements.set(key, arrangement);
-        return arrangement;
-    };
-    // Top-down: convert local placements to world coordinates and commit.
-    const commit = (state, x, y) => {
-        var _a, _b;
-        const node = nodes.get(state.id);
-        node.setPosition(x, y);
-        if (!state.composite)
-            return;
-        const size = measured.get(state.id);
-        node.setSize(size.width, size.height);
-        if (state.concurrent) {
-            const regions = childrenOf(state.id).filter((s) => s.region);
-            const bandWidth = size.width - 2 * STATE_PAD;
-            let bandY = y + STATE_PAD + STATE_HEADER;
-            for (const region of regions) {
-                const band = measured.get(region.id);
-                const regionNode = nodes.get(region.id);
-                regionNode.setPosition(x + STATE_PAD, bandY);
-                // Uniform width: every band spans the composite's content width.
-                regionNode.setSize(bandWidth, band.height);
-                const inner = (_a = arrangements.get(region.id)) !== null && _a !== void 0 ? _a : arrange(region.id);
-                for (const child of childrenOf(region.id)) {
-                    const local = inner.positions.get(child.id);
-                    commitChild(child, x + STATE_PAD + REGION_PAD + local.x, bandY + REGION_PAD + local.y);
-                }
-                bandY += band.height + BAND_GAP;
-            }
-        }
-        else {
-            const pad = state.region ? REGION_PAD : STATE_PAD;
-            const header = state.region ? 0 : STATE_HEADER;
-            const inner = (_b = arrangements.get(state.id)) !== null && _b !== void 0 ? _b : arrange(state.id);
-            for (const child of childrenOf(state.id)) {
-                const local = inner.positions.get(child.id);
-                commitChild(child, x + pad + local.x, y + pad + header + local.y);
-            }
-        }
-    };
-    const commitChild = commit; // alias for readability above
-    const root = arrange(undefined);
-    for (const child of childrenOf(undefined)) {
-        const local = root.positions.get(child.id);
-        commit(child, start.x + local.x, start.y + local.y);
-    }
-}
-function stateModelToDiagram(model) {
-    const diagram = new DiagramModel_1.DiagramModel('State Diagram');
-    diagram.setMetadata('diagramType', 'stateDiagram-v2');
-    if (model.direction)
-        diagram.setMetadata('direction', model.direction);
-    if (model.notes.length)
-        diagram.setMetadata('stateNotes', model.notes);
-    const nodes = new Map();
-    model.states.forEach((state) => {
-        const isPseudo = PSEUDO_KINDS.has(state.kind);
-        const node = new NodeModel_1.NodeModel({
-            id: state.id,
-            // A region is not a state the author wrote — give it its own type so a
-            // renderer can draw it as a compartment rather than a rounded box.
-            type: state.region ? 'state:region' : `state:${state.kind}`,
-            // Placeholder — layoutStateModel below assigns the real geometry.
-            position: { x: 0, y: 0 },
-            size: isPseudo
-                ? { width: PSEUDO_SIZE, height: PSEUDO_SIZE }
-                : { width: 140, height: 56 },
-        });
-        node.setLabel(state.label);
-        node.setMetadata('stateNode', state);
-        // Start/end/history are circles; a choice is a diamond; the rest are the
-        // familiar rounded state boxes.
-        const shape = isPseudo ? 'circle' : state.kind === 'choice' ? 'rhombus' : 'rounded-rectangle';
-        node.setMetadata('dslShape', shape);
-        node.setMetadata('shape', Object.assign({ type: isPseudo ? 'circle' : state.kind === 'choice' ? 'diamond' : 'rect', cornerRadius: isPseudo || state.kind === 'choice' ? 0 : 8 }, (state.kind === 'start' ? { fill: '#0f172a' } : {})));
-        diagram.addNode(node);
-        nodes.set(state.id, node);
-    });
-    // Flow layout BEFORE links exist, so createSmartLink below selects its ports
-    // against the real geometry (a link wired to the placeholder grid keeps the
-    // wrong sides). Composites are sized to contain their children; concurrent
-    // regions band. See layoutStateModel.
-    layoutStateModel(model, nodes, { x: 80, y: 60 });
-    // Composite states become groups whose members are their scoped children.
-    // Every group is created BEFORE membership is wired, because a nested
-    // composite is added to its parent by GROUP id and must already exist.
-    for (const state of model.states) {
-        if (!state.composite)
-            continue;
-        // A region has no name of its own — Mermaid draws it as an unlabelled
-        // compartment divided by a dashed line, not as a titled box.
-        diagram.addGroup(new GroupModel_1.GroupModel({ id: `group-${state.id}`, name: state.region ? '' : state.label || state.id }));
-    }
-    for (const state of model.states) {
-        if (!state.composite)
-            continue;
-        const group = diagram.getGroup(`group-${state.id}`);
-        if (!group)
-            continue;
-        for (const child of model.states) {
-            if (child.parent !== state.id)
-                continue;
-            // Nested composite → nest the GROUPS too, so the containment tree is
-            // real. Concurrent regions depend on this: `group-A` must own
-            // `group-A.region1` and `group-A.region2` or they float free.
-            if (child.composite && diagram.getGroup(`group-${child.id}`)) {
-                group.addMember(`group-${child.id}`, diagram);
-            }
-            if (diagram.getNode(child.id))
-                group.addMember(child.id, diagram);
-        }
-    }
-    for (const transition of model.transitions) {
-        const source = nodes.get(transition.from);
-        const target = nodes.get(transition.to);
-        if (!source || !target)
-            continue;
-        const link = diagram.createSmartLink(source, target, 'orthogonal');
-        if (!link)
-            continue;
-        if (transition.label)
-            link.setLabel(transition.label);
-        link.setMetadata('stateTransition', transition);
-    }
-    return diagram;
-}
-function stateModelFromDiagram(diagram) {
-    var _a, _b, _c, _d, _e;
-    const states = [];
-    for (const node of diagram.getNodes()) {
-        const stored = node.getMetadata('stateNode');
-        states.push(stored
-            ? Object.assign(Object.assign({}, stored), { id: node.id, label: (_b = (_a = node.getLabel) === null || _a === void 0 ? void 0 : _a.call(node)) !== null && _b !== void 0 ? _b : stored.label }) : { id: node.id, label: (_d = (_c = node.getLabel) === null || _c === void 0 ? void 0 : _c.call(node)) !== null && _d !== void 0 ? _d : node.id, kind: 'state' });
-    }
-    const transitions = [];
-    for (const link of diagram.getLinks()) {
-        const from = link.sourceNodeId;
-        const to = link.targetNodeId;
-        if (!from || !to)
-            continue;
-        const label = link.getMetadata('label');
-        transitions.push(Object.assign({ from, to }, (label ? { label } : {})));
-    }
-    const direction = diagram.getMetadata('direction');
-    const notes = (_e = diagram.getMetadata('stateNotes')) !== null && _e !== void 0 ? _e : [];
-    return Object.assign({ states, transitions, notes }, (direction ? { direction } : {}));
-}
-// ── Generation ─────────────────────────────────────────────────────────────
-/**
- * Emit a valid `stateDiagram-v2` body. The scoped pseudo-states are collapsed
- * back to `[*]`, which is the only spelling Mermaid accepts — writing
- * `__start__` would export a body that renders as a real state called
- * "__start__", i.e. a different diagram.
- */
-function generateMermaidState(model) {
-    const byId = new Map(model.states.map((s) => [s.id, s]));
-    /** Bracket tokens are the ONLY spelling Mermaid accepts for these. */
-    const ref = (id) => {
-        var _a;
-        switch ((_a = byId.get(id)) === null || _a === void 0 ? void 0 : _a.kind) {
-            case 'start':
-            case 'end': return '[*]';
-            case 'history': return '[H]';
-            case 'deep-history': return '[H*]';
-            default: return id;
-        }
-    };
-    const lines = ['stateDiagram-v2'];
-    if (model.direction)
-        lines.push(`    direction ${model.direction}`);
-    const children = (parent) => model.states.filter((s) => { var _a; return ((_a = s.parent) !== null && _a !== void 0 ? _a : undefined) === parent; });
-    // A transition belongs to exactly ONE body: the one that owns BOTH its ends.
-    // Matching on EITHER end (the previous rule) put a transition that crosses
-    // two composites into both of them — a duplicate edge on re-import — while
-    // one that crossed a composite boundary at the root was claimed by the
-    // composite and then skipped there, so it was written twice or not at all.
-    // Anything spanning two bodies belongs at the root, which Mermaid accepts and
-    // which is the only place that does not visually adopt the far state.
-    const emitted = new Set();
-    const emitTransitions = (owner, indent) => {
-        var _a, _b;
-        for (const t of model.transitions) {
-            if (emitted.has(t))
-                continue;
-            if (((_a = byId.get(t.from)) === null || _a === void 0 ? void 0 : _a.parent) !== owner || ((_b = byId.get(t.to)) === null || _b === void 0 ? void 0 : _b.parent) !== owner)
-                continue;
-            emitted.add(t);
-            lines.push(`${indent}${ref(t.from)} --> ${ref(t.to)}${t.label ? ` : ${t.label}` : ''}`);
-        }
-    };
-    /** The children + transitions of one body (a composite, or one region of one). */
-    const emitBody = (owner, indent) => {
-        for (const child of children(owner.id))
-            emitState(child, indent);
-        emitTransitions(owner.id, indent);
-    };
-    const emitState = (state, indent) => {
-        if (PSEUDO_KINDS.has(state.kind))
-            return; // written as [*] / [H] / [H*]
-        if (state.kind !== 'state') {
-            lines.push(`${indent}state ${state.id} <<${state.kind}>>`);
-            return;
-        }
-        if (state.composite) {
-            const head = state.label && state.label !== state.id
-                ? `state "${state.label}" as ${state.id}`
-                : `state ${state.id}`;
-            lines.push(`${indent}${head} {`);
-            if (state.direction)
-                lines.push(`${indent}    direction ${state.direction}`);
-            if (state.concurrent) {
-                // The regions are synthetic: they are NOT emitted as nested states,
-                // they are emitted as bodies separated by `--`. Writing them out as
-                // `state A.region1 { … }` would export a sequential machine.
-                const regions = children(state.id).filter((s) => s.region);
-                regions.forEach((region, index) => {
-                    if (index > 0)
-                        lines.push(`${indent}    --`);
-                    emitBody(region, indent + '    ');
-                });
-            }
-            else {
-                emitBody(state, indent + '    ');
-            }
-            lines.push(`${indent}}`);
-            return;
-        }
-        if (state.label && state.label !== state.id) {
-            lines.push(`${indent}state "${state.label}" as ${state.id}`);
-            return;
-        }
-        // An isolated state has no transition line to declare it — say it outright,
-        // or it disappears from the exported body.
-        const referenced = model.transitions.some((t) => t.from === state.id || t.to === state.id);
-        if (!referenced)
-            lines.push(`${indent}state ${state.id}`);
-    };
-    for (const state of children(undefined))
-        emitState(state, '    ');
-    for (const t of model.transitions) {
-        if (emitted.has(t))
-            continue;
-        emitted.add(t);
-        lines.push(`    ${ref(t.from)} --> ${ref(t.to)}${t.label ? ` : ${t.label}` : ''}`);
-    }
-    for (const note of model.notes) {
-        lines.push(`    note ${note.position} ${note.target} : ${note.text}`);
-    }
-    return lines.join('\n') + '\n';
-}
-function generateStateFromDiagram(diagram) {
-    return generateMermaidState(stateModelFromDiagram(diagram));
-}
-//# sourceMappingURL=MermaidState.js.map

package/src/libs/engine/src/dsl/mermaid/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Mermaid graph-family diagram types beyond the flowchart (Phase 3).
- *
- * Each type is a matched TRIPLE — parser, model builder, generator — because a
- * type that parses but cannot re-emit itself loses everything the grammar
- * cannot say on the first save (gap-analysis §7).
- */
-export { parseMermaidEr, erModelToDiagram, erModelFromDiagram, generateMermaidEr, generateErFromDiagram, erSpecFrom, erMarkers, type MermaidErModel, type MermaidErEntity, type MermaidErAttribute, type MermaidErRelationship, type ErCardinalityMarker, type ErSpec, } from './MermaidER';
-export { parseMermaidClass, classModelToDiagram, classModelFromDiagram, generateMermaidClass, generateClassFromDiagram, umlSpecFrom, umlRelationKind, type MermaidClassModel, type MermaidClassDef, type MermaidClassMember, type MermaidClassRelationship, type UmlOperator, type UmlLeftMarker, type UmlRightMarker, type UmlLineType, type UmlKind, type UmlSpec, } from './MermaidClass';
-export { parseMermaidState, stateModelToDiagram, stateModelFromDiagram, generateMermaidState, generateStateFromDiagram, type MermaidStateModel, type MermaidStateNode, type MermaidStateTransition, type StateKind, } from './MermaidState';

package/src/libs/engine/src/dsl/mermaid/index.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStateFromDiagram = exports.generateMermaidState = exports.stateModelFromDiagram = exports.stateModelToDiagram = exports.parseMermaidState = exports.umlRelationKind = exports.umlSpecFrom = exports.generateClassFromDiagram = exports.generateMermaidClass = exports.classModelFromDiagram = exports.classModelToDiagram = exports.parseMermaidClass = exports.erMarkers = exports.erSpecFrom = exports.generateErFromDiagram = exports.generateMermaidEr = exports.erModelFromDiagram = exports.erModelToDiagram = exports.parseMermaidEr = void 0;
-/**
- * Mermaid graph-family diagram types beyond the flowchart (Phase 3).
- *
- * Each type is a matched TRIPLE — parser, model builder, generator — because a
- * type that parses but cannot re-emit itself loses everything the grammar
- * cannot say on the first save (gap-analysis §7).
- */
-var MermaidER_1 = require("./MermaidER");
-Object.defineProperty(exports, "parseMermaidEr", { enumerable: true, get: function () { return MermaidER_1.parseMermaidEr; } });
-Object.defineProperty(exports, "erModelToDiagram", { enumerable: true, get: function () { return MermaidER_1.erModelToDiagram; } });
-Object.defineProperty(exports, "erModelFromDiagram", { enumerable: true, get: function () { return MermaidER_1.erModelFromDiagram; } });
-Object.defineProperty(exports, "generateMermaidEr", { enumerable: true, get: function () { return MermaidER_1.generateMermaidEr; } });
-Object.defineProperty(exports, "generateErFromDiagram", { enumerable: true, get: function () { return MermaidER_1.generateErFromDiagram; } });
-Object.defineProperty(exports, "erSpecFrom", { enumerable: true, get: function () { return MermaidER_1.erSpecFrom; } });
-Object.defineProperty(exports, "erMarkers", { enumerable: true, get: function () { return MermaidER_1.erMarkers; } });
-var MermaidClass_1 = require("./MermaidClass");
-Object.defineProperty(exports, "parseMermaidClass", { enumerable: true, get: function () { return MermaidClass_1.parseMermaidClass; } });
-Object.defineProperty(exports, "classModelToDiagram", { enumerable: true, get: function () { return MermaidClass_1.classModelToDiagram; } });
-Object.defineProperty(exports, "classModelFromDiagram", { enumerable: true, get: function () { return MermaidClass_1.classModelFromDiagram; } });
-Object.defineProperty(exports, "generateMermaidClass", { enumerable: true, get: function () { return MermaidClass_1.generateMermaidClass; } });
-Object.defineProperty(exports, "generateClassFromDiagram", { enumerable: true, get: function () { return MermaidClass_1.generateClassFromDiagram; } });
-Object.defineProperty(exports, "umlSpecFrom", { enumerable: true, get: function () { return MermaidClass_1.umlSpecFrom; } });
-Object.defineProperty(exports, "umlRelationKind", { enumerable: true, get: function () { return MermaidClass_1.umlRelationKind; } });
-var MermaidState_1 = require("./MermaidState");
-Object.defineProperty(exports, "parseMermaidState", { enumerable: true, get: function () { return MermaidState_1.parseMermaidState; } });
-Object.defineProperty(exports, "stateModelToDiagram", { enumerable: true, get: function () { return MermaidState_1.stateModelToDiagram; } });
-Object.defineProperty(exports, "stateModelFromDiagram", { enumerable: true, get: function () { return MermaidState_1.stateModelFromDiagram; } });
-Object.defineProperty(exports, "generateMermaidState", { enumerable: true, get: function () { return MermaidState_1.generateMermaidState; } });
-Object.defineProperty(exports, "generateStateFromDiagram", { enumerable: true, get: function () { return MermaidState_1.generateStateFromDiagram; } });
-//# sourceMappingURL=index.js.map