@grafloria/element 0.3.20 → 0.3.21

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

@@ -1,70 +0,0 @@
-/**
- * Type-aware placement for Mermaid imports — shared rank machinery.
- *
- * Closes the gap-analysis §3a item "no type-aware layout (ER tables by FK
- * dependency, class by inheritance depth, state by flow)". Each Mermaid type
- * chooses WHICH edges rank its graph (flowchart: every edge; ER: FK
- * dependency; class: inheritance/realization only; state: transitions from the
- * start pseudo-states) and hands them here. This module answers the two
- * questions the types share:
- *
- *   1. `assignRanks` — a rank per node by LONGEST PATH over the chosen edge
- *      subset. Cycles are broken at the back-edge (deterministic DFS in the
- *      caller's node order), so `Check -->|no| Start` ranks as a back-edge
- *      instead of dragging Start below Check.
- *   2. `placeByRank` — ranks become bands along the direction's flow axis
- *      (TD/TB/BT ⇒ y, LR/RL ⇒ x), size-aware; siblings spread on the cross
- *      axis, centered per band.
- *
- * SYNCHRONOUS and DETERMINISTIC on purpose: this runs at parse time inside the
- * builders/transformer (TextFormat constructs DSL with `autoLayout:false` and
- * must stay sync), so it cannot be the async ELK path and it must produce the
- * same picture for the same text, every time. No new dependencies.
- */
-export interface RankEdge {
-    from: string;
-    to: string;
-}
-/**
- * Longest-path ranks over the edge subset, back-edges dropped.
- *
- * Deterministic: DFS roots and neighbour order follow `ids` / `edges` order,
- * so the same text always breaks a cycle at the same edge. Nodes with no
- * ranking edges sit at rank 0.
- */
-export declare function assignRanks(ids: readonly string[], edges: readonly RankEdge[]): Map<string, number>;
-export interface PlaceByRankOptions {
-    /** TD / TB / BT rank down (or up) the page; LR / RL rank across it. Default TB. */
-    direction?: string;
-    /** Top-left corner of the laid-out block. */
-    start?: {
-        x: number;
-        y: number;
-    };
-    /** Gap between consecutive rank bands, along the flow axis. */
-    rankGap?: number;
-    /** Gap between siblings inside a band, across the flow axis. */
-    crossGap?: number;
-}
-export interface Placeable {
-    id: string;
-    size: {
-        width: number;
-        height: number;
-    };
-}
-/**
- * Rank-band placement. Bands are size-aware (a band is as deep as its deepest
- * node; each node centres within its band), siblings pack across the flow axis
- * and every band centres on the widest band — so a fork reads as a fork.
- * BT / RL simply reverse the band order, keeping coordinates positive.
- */
-export declare function placeByRank(nodes: readonly Placeable[], ranks: ReadonlyMap<string, number>, options?: PlaceByRankOptions): Map<string, {
-    x: number;
-    y: number;
-}>;
-/** The two steps together — the common case for the type builders. */
-export declare function rankLayout(nodes: readonly Placeable[], edges: readonly RankEdge[], options?: PlaceByRankOptions): Map<string, {
-    x: number;
-    y: number;
-}>;

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

@@ -1,162 +0,0 @@
-"use strict";
-/**
- * Type-aware placement for Mermaid imports — shared rank machinery.
- *
- * Closes the gap-analysis §3a item "no type-aware layout (ER tables by FK
- * dependency, class by inheritance depth, state by flow)". Each Mermaid type
- * chooses WHICH edges rank its graph (flowchart: every edge; ER: FK
- * dependency; class: inheritance/realization only; state: transitions from the
- * start pseudo-states) and hands them here. This module answers the two
- * questions the types share:
- *
- *   1. `assignRanks` — a rank per node by LONGEST PATH over the chosen edge
- *      subset. Cycles are broken at the back-edge (deterministic DFS in the
- *      caller's node order), so `Check -->|no| Start` ranks as a back-edge
- *      instead of dragging Start below Check.
- *   2. `placeByRank` — ranks become bands along the direction's flow axis
- *      (TD/TB/BT ⇒ y, LR/RL ⇒ x), size-aware; siblings spread on the cross
- *      axis, centered per band.
- *
- * SYNCHRONOUS and DETERMINISTIC on purpose: this runs at parse time inside the
- * builders/transformer (TextFormat constructs DSL with `autoLayout:false` and
- * must stay sync), so it cannot be the async ELK path and it must produce the
- * same picture for the same text, every time. No new dependencies.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assignRanks = assignRanks;
-exports.placeByRank = placeByRank;
-exports.rankLayout = rankLayout;
-/**
- * Longest-path ranks over the edge subset, back-edges dropped.
- *
- * Deterministic: DFS roots and neighbour order follow `ids` / `edges` order,
- * so the same text always breaks a cycle at the same edge. Nodes with no
- * ranking edges sit at rank 0.
- */
-function assignRanks(ids, edges) {
-    var _a;
-    const idSet = new Set(ids);
-    const out = new Map();
-    for (const id of ids)
-        out.set(id, []);
-    for (const edge of edges) {
-        if (!idSet.has(edge.from) || !idSet.has(edge.to))
-            continue;
-        if (edge.from === edge.to)
-            continue; // self-loop: never a ranking edge
-        out.get(edge.from).push(edge);
-    }
-    // Back-edge detection: iterative DFS, colouring nodes white→grey→black. An
-    // edge into a GREY node closes a cycle and is dropped from ranking.
-    const GREY = 1;
-    const BLACK = 2;
-    const colour = new Map();
-    const forward = new Map();
-    for (const id of ids)
-        forward.set(id, []);
-    for (const root of ids) {
-        if (colour.has(root))
-            continue;
-        const stack = [{ id: root, next: 0 }];
-        colour.set(root, GREY);
-        while (stack.length > 0) {
-            const frame = stack[stack.length - 1];
-            const outgoing = out.get(frame.id);
-            if (frame.next < outgoing.length) {
-                const edge = outgoing[frame.next++];
-                const state = colour.get(edge.to);
-                if (state === GREY)
-                    continue; // back-edge — drop
-                forward.get(frame.id).push(edge);
-                if (state === undefined) {
-                    colour.set(edge.to, GREY);
-                    stack.push({ id: edge.to, next: 0 });
-                }
-            }
-            else {
-                colour.set(frame.id, BLACK);
-                stack.pop();
-            }
-        }
-    }
-    // Longest-path over the acyclic subset (Kahn order, then relax).
-    const incoming = new Map();
-    for (const id of ids)
-        incoming.set(id, 0);
-    for (const bucket of forward.values()) {
-        for (const edge of bucket)
-            incoming.set(edge.to, incoming.get(edge.to) + 1);
-    }
-    const ranks = new Map();
-    const queue = ids.filter((id) => incoming.get(id) === 0);
-    for (const id of queue)
-        ranks.set(id, 0);
-    for (let head = 0; head < queue.length; head++) {
-        const id = queue[head];
-        const rank = ranks.get(id);
-        for (const edge of forward.get(id)) {
-            const proposed = rank + 1;
-            if (((_a = ranks.get(edge.to)) !== null && _a !== void 0 ? _a : -1) < proposed)
-                ranks.set(edge.to, proposed);
-            const remaining = incoming.get(edge.to) - 1;
-            incoming.set(edge.to, remaining);
-            if (remaining === 0)
-                queue.push(edge.to);
-        }
-    }
-    for (const id of ids)
-        if (!ranks.has(id))
-            ranks.set(id, 0);
-    return ranks;
-}
-/**
- * Rank-band placement. Bands are size-aware (a band is as deep as its deepest
- * node; each node centres within its band), siblings pack across the flow axis
- * and every band centres on the widest band — so a fork reads as a fork.
- * BT / RL simply reverse the band order, keeping coordinates positive.
- */
-function placeByRank(nodes, ranks, options = {}) {
-    var _a, _b, _c, _d, _e, _f;
-    if (nodes.length === 0)
-        return new Map();
-    const direction = ((_a = options.direction) !== null && _a !== void 0 ? _a : 'TB').toUpperCase();
-    const vertical = direction !== 'LR' && direction !== 'RL';
-    const reversed = direction === 'BT' || direction === 'RL';
-    const start = (_b = options.start) !== null && _b !== void 0 ? _b : { x: 100, y: 100 };
-    const rankGap = (_c = options.rankGap) !== null && _c !== void 0 ? _c : 70;
-    const crossGap = (_d = options.crossGap) !== null && _d !== void 0 ? _d : 50;
-    const along = (n) => (vertical ? n.size.height : n.size.width);
-    const across = (n) => (vertical ? n.size.width : n.size.height);
-    // Bands in rank order, preserving the caller's node order inside a band.
-    const bands = new Map();
-    for (const node of nodes) {
-        const rank = (_e = ranks.get(node.id)) !== null && _e !== void 0 ? _e : 0;
-        const band = (_f = bands.get(rank)) !== null && _f !== void 0 ? _f : [];
-        band.push(node);
-        bands.set(rank, band);
-    }
-    let order = [...bands.keys()].sort((a, b) => a - b);
-    if (reversed)
-        order = order.reverse();
-    const crossTotal = (band) => band.reduce((sum, n) => sum + across(n), 0) + (band.length - 1) * crossGap;
-    const widest = Math.max(...order.map((r) => crossTotal(bands.get(r))));
-    const positions = new Map();
-    let alongCursor = vertical ? start.y : start.x;
-    for (const rank of order) {
-        const band = bands.get(rank);
-        const bandDepth = Math.max(...band.map(along));
-        let crossCursor = (vertical ? start.x : start.y) + (widest - crossTotal(band)) / 2;
-        for (const node of band) {
-            const alongPos = alongCursor + (bandDepth - along(node)) / 2;
-            positions.set(node.id, vertical ? { x: crossCursor, y: alongPos } : { x: alongPos, y: crossCursor });
-            crossCursor += across(node) + crossGap;
-        }
-        alongCursor += bandDepth + rankGap;
-    }
-    return positions;
-}
-/** The two steps together — the common case for the type builders. */
-function rankLayout(nodes, edges, options = {}) {
-    return placeByRank(nodes, assignRanks(nodes.map((n) => n.id), edges), options);
-}
-//# sourceMappingURL=layout.js.map

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

@@ -1,25 +0,0 @@
-/**
- * Shared line pre-pass for the Mermaid graph-family parsers (ER, class, state).
- *
- * Every Mermaid body carries the same non-content furniture: `---` YAML
- * frontmatter, `%%{init: …}%%` config directives, `%%` comments (own-line and
- * trailing) and the type header itself. Stripping it in ONE place is what keeps
- * the three parsers honest about the rest — a directive we do not understand
- * must be SKIPPED, never turned into an entity (gap-analysis §5, invariant #1).
- */
-export interface SignificantLine {
-    /** The line with comments and surrounding whitespace removed. */
-    text: string;
-    /** 1-based line number in the original text (for diagnostics). */
-    line: number;
-}
-/**
- * Content lines of a Mermaid body: frontmatter, init directives, comments and
- * blank lines removed. The header line (`erDiagram`, `classDiagram`, …) is
- * dropped when `header` matches its first word, case-insensitively.
- */
-export declare function significantLines(text: string, header: string | string[]): SignificantLine[];
-/** Unwrap a `"quoted"` token; returns the raw token otherwise. */
-export declare function unquote(token: string): string;
-/** Quote a Mermaid label when it is not a bare word (spaces, punctuation, empty). */
-export declare function quoteIfNeeded(label: string): string;

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

@@ -1,74 +0,0 @@
-"use strict";
-/**
- * Shared line pre-pass for the Mermaid graph-family parsers (ER, class, state).
- *
- * Every Mermaid body carries the same non-content furniture: `---` YAML
- * frontmatter, `%%{init: …}%%` config directives, `%%` comments (own-line and
- * trailing) and the type header itself. Stripping it in ONE place is what keeps
- * the three parsers honest about the rest — a directive we do not understand
- * must be SKIPPED, never turned into an entity (gap-analysis §5, invariant #1).
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.significantLines = significantLines;
-exports.unquote = unquote;
-exports.quoteIfNeeded = quoteIfNeeded;
-/** A `%%`-comment stripper that does not eat `%%` inside a quoted string. */
-function stripTrailingComment(raw) {
-    let inQuote = false;
-    for (let i = 0; i < raw.length; i++) {
-        const ch = raw[i];
-        if (ch === '"')
-            inQuote = !inQuote;
-        if (!inQuote && ch === '%' && raw[i + 1] === '%')
-            return raw.slice(0, i);
-    }
-    return raw;
-}
-/**
- * Content lines of a Mermaid body: frontmatter, init directives, comments and
- * blank lines removed. The header line (`erDiagram`, `classDiagram`, …) is
- * dropped when `header` matches its first word, case-insensitively.
- */
-function significantLines(text, header) {
-    const headers = (Array.isArray(header) ? header : [header]).map((h) => h.toLowerCase());
-    const out = [];
-    let inFrontmatter = false;
-    let headerSeen = false;
-    const lines = text.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-        const raw = lines[i];
-        const trimmedRaw = raw.trim();
-        if (trimmedRaw === '---') {
-            // Only the LEADING `---` block is frontmatter; a stray one later is not.
-            if (!headerSeen)
-                inFrontmatter = !inFrontmatter;
-            continue;
-        }
-        if (inFrontmatter)
-            continue;
-        const text2 = stripTrailingComment(raw).trim();
-        if (!text2)
-            continue;
-        if (!headerSeen) {
-            const first = text2.split(/[\s:]/)[0].toLowerCase();
-            if (headers.includes(first)) {
-                headerSeen = true;
-                continue;
-            }
-        }
-        out.push({ text: text2, line: i + 1 });
-    }
-    return out;
-}
-/** Unwrap a `"quoted"` token; returns the raw token otherwise. */
-function unquote(token) {
-    const t = token.trim();
-    if (t.length >= 2 && t.startsWith('"') && t.endsWith('"'))
-        return t.slice(1, -1);
-    return t;
-}
-/** Quote a Mermaid label when it is not a bare word (spaces, punctuation, empty). */
-function quoteIfNeeded(label) {
-    return /^[A-Za-z0-9_-]+$/.test(label) ? label : `"${label.replace(/"/g, "'")}"`;
-}
-//# sourceMappingURL=lines.js.map

package/src/libs/engine/src/dsl/parser/Parser.d.ts

@@ -1,131 +0,0 @@
-/**
- * DSL Parser - Converts token stream into Abstract Syntax Tree
- *
- * Parses Mermaid-compatible diagram syntax into structured AST
- */
-import { Token } from '../types/Token';
-import { DiagramNode } from '../types/ASTNode';
-export declare class ParseError extends Error {
-    token: Token;
-    line: number;
-    column: number;
-    constructor(message: string, token: Token, line: number, column: number);
-}
-export declare class Parser {
-    private tokens;
-    private current;
-    /**
-     * Parse tokens into an AST
-     */
-    parse(tokens: Token[]): DiagramNode;
-    /**
-     * Parse diagram root
-     */
-    private parseDiagram;
-    /**
-     * Parse a statement
-     */
-    private parseStatement;
-    /**
-     * A single node reference: an id, then an optional shape (`[A]`, `([A])`, …)
-     * or a v11 metadata block (`@{ shape: rect, label: "Hi" }`).
-     */
-    private parseNodeRef;
-    /** One or more node refs joined by `&` (Mermaid multi-node syntax). */
-    private parseNodeGroup;
-    /** ClassApplication statements for any refs carrying an inline `:::class`. */
-    private classApps;
-    /**
-     * An edge chain: node-group (link [label] node-group)+. Each link produces the
-     * FULL CROSS PRODUCT of the previous group and the next (so `a & b --> c & d`
-     * is four edges), and the chain continues so `a --> b --> c` is two.
-     */
-    private parseEdgeChain;
-    /**
-     * v11 node metadata block: `@{ shape: rect, label: "Hi", icon: … }`. We read
-     * the keys we model (shape, label) and ignore the rest for forward-compat.
-     * `{`/`}` lex as RHOMBUS_OPEN/CLOSE.
-     */
-    private parseNodeMetadata;
-    /**
-     * Parse subgraph
-     */
-    private parseSubgraph;
-    /**
-     * Parse style definition: style A fill:#f9f,stroke:#333
-     */
-    private parseStyle;
-    /**
-     * Parse class definition: classDef className fill:#f9f
-     */
-    private parseClassDef;
-    /**
-     * Parse `class a,b hot` — bind an existing classDef to one or more nodes.
-     */
-    private parseClassApplication;
-    /**
-     * Parse `linkStyle 0,2 stroke:#f00` — style links by index (or `default`).
-     */
-    private parseLinkStyle;
-    /**
-     * Parse `click a "https://…" "tooltip"` — a node's navigation target. The
-     * `href` keyword form and `call`/callback forms are intentionally not modeled
-     * (a callback name is not a document fact); those lines are still skipped.
-     */
-    private parseClick;
-    /**
-     * Parse a Tier-2 extension comment into a GrafloriaDirective:
-     *   %%grafloria:node <id> <k>:<v>[,<k>:<v>]*
-     *   %%grafloria:edge <source> <target> <k>:<v>...
-     * Returns null for anything that is not a well-formed grafloria directive (a
-     * malformed one is simply ignored, never garbage).
-     */
-    private parseGrafloriaComment;
-    /**
-     * Parse style properties: fill:#f9f,stroke:#333,stroke-width:2
-     */
-    private parseStyleProperties;
-    /**
-     * Parse node ID
-     */
-    private parseNodeId;
-    /**
-     * Parse node shape and extract label
-     */
-    private parseNodeShape;
-    /**
-     * Parse text until a specific token type
-     */
-    private parseTextUntil;
-    /**
-     * Get link type from token type
-     */
-    private getLinkType;
-    /**
-     * Check if current token is a link token
-     */
-    private isLinkToken;
-    /**
-     * Check if current token starts a node shape
-     */
-    private isNodeShapeStart;
-    /**
-     * Token stream helpers
-     */
-    private match;
-    private check;
-    private checkSequence;
-    private advance;
-    private isAtEnd;
-    private peek;
-    private previous;
-    private currentToken;
-    private consume;
-    private consumeNewlines;
-    /** Consume everything up to (not including) the next newline. */
-    private skipLine;
-    /**
-     * Get source location from start and end tokens
-     */
-    private getLocation;
-}