ts-prorm-orm 1.2.2 → 2.0.0

package/dist/diagrams/core/layout.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Layout primitives shared by every generator.
+ *
+ * Each generator previously carried its own text measurement, box drawing,
+ * arrow routing and footer code. These are the pieces that were duplicated,
+ * factored once so a change to how a panel or an edge looks lands everywhere.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureText = measureText;
+exports.truncate = truncate;
+exports.rect = rect;
+exports.line = line;
+exports.text = text;
+exports.panelSize = panelSize;
+exports.panel = panel;
+exports.defineArrowhead = defineArrowhead;
+exports.edge = edge;
+exports.gridPack = gridPack;
+exports.documentTitle = documentTitle;
+exports.footer = footer;
+const theme_1 = require("./theme");
+/**
+ * Approximate rendered width of a string.
+ *
+ * SVG has no text metrics without a layout engine, so this is the usual
+ * average-advance estimate. It is deliberately slightly generous: under-
+ * measuring clips text, over-measuring only adds whitespace.
+ */
+function measureText(text, size = theme_1.FONT.body, mono = false) {
+    const ratio = mono ? 0.6 : 0.55;
+    return Math.ceil(text.length * size * ratio);
+}
+/** Truncate to fit `maxWidth`, appending a single-character ellipsis. */
+function truncate(text, maxWidth, size = theme_1.FONT.body, mono = false) {
+    if (measureText(text, size, mono) <= maxWidth)
+        return text;
+    let out = text;
+    while (out.length > 1 && measureText(out + '...', size, mono) > maxWidth) {
+        out = out.slice(0, -1);
+    }
+    return out + '...';
+}
+/** Draw a plain hairline rectangle. */
+function rect(parent, box, fill = theme_1.INK.ground) {
+    return parent.child('rect', {
+        x: box.x,
+        y: box.y,
+        width: box.w,
+        height: box.h,
+        fill,
+        stroke: theme_1.INK.line,
+        'stroke-width': theme_1.STROKE.hair,
+    });
+}
+/** Draw a hairline between two points. */
+function line(parent, x1, y1, x2, y2, dashed = false) {
+    const el = parent.child('line', {
+        x1,
+        y1,
+        x2,
+        y2,
+        stroke: theme_1.INK.line,
+        'stroke-width': theme_1.STROKE.hair,
+    });
+    if (dashed)
+        el.attr('stroke-dasharray', '4 3');
+    return el;
+}
+/** Draw a run of text. */
+function text(parent, x, y, value, opts = {}) {
+    const el = parent
+        .child('text', {
+        x,
+        y,
+        'font-family': opts.mono ? theme_1.FONT.mono : theme_1.FONT.family,
+        'font-size': opts.size ?? theme_1.FONT.body,
+        fill: opts.fill ?? theme_1.INK.line,
+    })
+        .text(value);
+    if (opts.anchor && opts.anchor !== 'start')
+        el.attr('text-anchor', opts.anchor);
+    if (opts.weight === 'bold')
+        el.attr('font-weight', 'bold');
+    return el;
+}
+/** Compute a panel's size without drawing it, for layout passes. */
+function panelSize(opts) {
+    const rows = opts.rows ?? [];
+    const headerH = opts.subtitle ? theme_1.ROW_HEIGHT * 2 : theme_1.ROW_HEIGHT + theme_1.SPACE.sm;
+    let contentW = measureText(opts.title, theme_1.FONT.title) + theme_1.SPACE.lg;
+    if (opts.subtitle)
+        contentW = Math.max(contentW, measureText(opts.subtitle, theme_1.FONT.small) + theme_1.SPACE.lg);
+    for (const r of rows) {
+        const marker = r.marker ? measureText(r.marker, theme_1.FONT.small, true) + theme_1.SPACE.sm : 0;
+        const label = measureText(r.label, theme_1.FONT.body);
+        const detail = r.detail ? measureText(r.detail, theme_1.FONT.small, true) + theme_1.SPACE.lg : 0;
+        contentW = Math.max(contentW, marker + label + detail + theme_1.SPACE.lg * 2);
+    }
+    return {
+        w: Math.max(opts.minWidth ?? 0, contentW),
+        h: headerH + rows.length * theme_1.ROW_HEIGHT + (rows.length ? theme_1.SPACE.xs : 0),
+    };
+}
+/**
+ * Draw a titled panel at `x,y` and return the box it occupies.
+ *
+ * The header is a washed bar with a hairline under it; rows are plain text with
+ * the detail column right-aligned.
+ */
+function panel(parent, x, y, opts) {
+    const { w, h } = panelSize(opts);
+    const rows = opts.rows ?? [];
+    const headerH = opts.subtitle ? theme_1.ROW_HEIGHT * 2 : theme_1.ROW_HEIGHT + theme_1.SPACE.sm;
+    const box = { x, y, w, h };
+    const g = parent.child('g');
+    rect(g, box);
+    // Header bar
+    g.child('rect', {
+        x,
+        y,
+        width: w,
+        height: headerH,
+        fill: theme_1.INK.wash,
+        stroke: theme_1.INK.line,
+        'stroke-width': theme_1.STROKE.hair,
+    });
+    text(g, x + theme_1.SPACE.sm, y + theme_1.FONT.title + theme_1.SPACE.xs, opts.title, {
+        size: theme_1.FONT.title,
+        weight: 'bold',
+    });
+    if (opts.subtitle) {
+        text(g, x + theme_1.SPACE.sm, y + theme_1.ROW_HEIGHT + theme_1.FONT.small + theme_1.SPACE.xs, opts.subtitle, {
+            size: theme_1.FONT.small,
+            fill: theme_1.INK.muted,
+            mono: true,
+        });
+    }
+    rows.forEach((r, i) => {
+        const rowY = y + headerH + i * theme_1.ROW_HEIGHT;
+        const baseline = rowY + theme_1.ROW_HEIGHT - theme_1.SPACE.xs - 1;
+        if (r.rule)
+            line(g, x, rowY, x + w, rowY);
+        let cursor = x + theme_1.SPACE.sm;
+        if (r.marker) {
+            text(g, cursor, baseline, r.marker, { size: theme_1.FONT.small, mono: true, fill: theme_1.INK.muted });
+            cursor += measureText(r.marker, theme_1.FONT.small, true) + theme_1.SPACE.sm;
+        }
+        text(g, cursor, baseline, r.label, { size: theme_1.FONT.body });
+        if (r.detail) {
+            text(g, x + w - theme_1.SPACE.sm, baseline, r.detail, {
+                size: theme_1.FONT.small,
+                mono: true,
+                fill: theme_1.INK.muted,
+                anchor: 'end',
+            });
+        }
+    });
+    return box;
+}
+/** Register the single arrowhead marker. Call once per document. */
+function defineArrowhead(defs, id = 'arrow') {
+    defs
+        .child('marker', {
+        id,
+        viewBox: '0 0 10 10',
+        refX: 9,
+        refY: 5,
+        markerWidth: 6,
+        markerHeight: 6,
+        orient: 'auto-start-reverse',
+    })
+        .child('path', { d: 'M 0 0 L 10 5 L 0 10 z', fill: theme_1.INK.line });
+}
+/** Draw a straight edge, optionally arrowed and/or dashed, with a label. */
+function edge(parent, from, to, opts = {}) {
+    const el = line(parent, from.x, from.y, to.x, to.y, opts.dashed);
+    if (opts.arrow)
+        el.attr('marker-end', `url(#${opts.markerId ?? 'arrow'})`);
+    if (opts.label) {
+        text(parent, (from.x + to.x) / 2, (from.y + to.y) / 2 - theme_1.SPACE.xs, opts.label, {
+            size: theme_1.FONT.small,
+            fill: theme_1.INK.muted,
+            anchor: 'middle',
+        });
+    }
+    return el;
+}
+/** Pack boxes into a grid, returning positions and the total canvas size. */
+function gridPack(sizes, columns, gap = theme_1.SPACE.xl, origin = { x: theme_1.SPACE.xl, y: theme_1.SPACE.xl }) {
+    const cols = Math.max(1, columns);
+    const colWidth = sizes.length ? Math.max(...sizes.map((s) => s.w)) : 0;
+    const positions = [];
+    let rowTop = origin.y;
+    let rowHeight = 0;
+    sizes.forEach((s, i) => {
+        const col = i % cols;
+        if (col === 0 && i > 0) {
+            rowTop += rowHeight + gap;
+            rowHeight = 0;
+        }
+        positions.push({ x: origin.x + col * (colWidth + gap), y: rowTop });
+        rowHeight = Math.max(rowHeight, s.h);
+    });
+    const rows = Math.ceil(sizes.length / cols);
+    return {
+        positions,
+        width: origin.x * 2 + cols * colWidth + (cols - 1) * gap,
+        height: rowTop + rowHeight + origin.y,
+    };
+}
+/** Draw a title at the top of a document. Returns the y to continue from. */
+function documentTitle(parent, x, y, title) {
+    text(parent, x, y + theme_1.FONT.title, title, { size: theme_1.FONT.title + 3, weight: 'bold' });
+    return y + theme_1.FONT.title + theme_1.SPACE.md;
+}
+/** Draw a footer line. Plain text, no separators or glyphs. */
+function footer(parent, x, y, parts) {
+    return text(parent, x, y, parts.filter(Boolean).join('  '), {
+        size: theme_1.FONT.small,
+        fill: theme_1.INK.muted,
+    });
+}

package/dist/diagrams/{svg-dom.d.ts → core/svg.d.ts}

@@ -1,5 +1,5 @@
 /**
- * svg-dom — a small DOM-backed SVG builder shared by every diagram generator.
+ * A small DOM-backed SVG builder shared by every diagram generator.
  *
  * Diagrams are constructed against a real DOM document (via `@xmldom/xmldom`)
  * using `createElement`/`setAttribute`/`appendChild`, then serialized once with
@@ -7,9 +7,12 @@
  * values are escaped by the serializer, element nesting can't be malformed, and
  * every generator shares one construction API.
  *
- * The `El` wrapper is a thin fluent facade over a DOM `Element` — `.attr()`,
- * `.text()`, `.child()` — so generator code reads declaratively while the
- * underlying nodes remain inspectable/testable as real DOM.
+ * The `El` wrapper is a thin fluent facade over a DOM `Element` - `.attr()`,
+ * `.text()`, `.child()` - so generator code reads declaratively while the
+ * underlying nodes remain inspectable and testable as real DOM.
+ *
+ * The gradient helper was removed with the move to a monochrome theme; nothing
+ * in the redesigned generators emits a gradient.
  */
 export type AttrValue = string | number | undefined | null;
 export type Attrs = Record<string, AttrValue>;
@@ -38,25 +41,10 @@ export declare class SvgDocument {
     constructor(width: number, height: number, viewBox?: string);
     /** Create a standalone element not yet attached to the tree. */
     create(tag: string, attrs?: Attrs): El;
-    /**
-     * Embed a `<style>` block (inside <defs>) so browser renderers can resolve
-     * web fonts / CSS. Used by the Industry-styled generators to @import Barlow /
-     * Barlow Condensed / JetBrains Mono; non-browser renderers ignore it and fall
-     * back to the system fonts declared per family.
-     */
+    /** Embed a `<style>` block inside <defs>. */
     style(css: string): this;
     /** Get (creating on first use) the shared <defs> block. */
     defs(): El;
-    /**
-     * Convenience: add a linear gradient to <defs> and return its id.
-     * `stops` is a list of [offsetPercent, color] pairs.
-     */
-    linearGradient(id: string, stops: Array<[number, string]>, opts?: {
-        x1?: number;
-        y1?: number;
-        x2?: number;
-        y2?: number;
-    }): string;
     /** Serialize the whole document to an XML/SVG string (with XML prolog). */
     toString(comment?: string): string;
 }

package/dist/diagrams/{svg-dom.js → core/svg.js}

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * svg-dom — a small DOM-backed SVG builder shared by every diagram generator.
+ * A small DOM-backed SVG builder shared by every diagram generator.
  *
  * Diagrams are constructed against a real DOM document (via `@xmldom/xmldom`)
  * using `createElement`/`setAttribute`/`appendChild`, then serialized once with
@@ -8,9 +8,12 @@
  * values are escaped by the serializer, element nesting can't be malformed, and
  * every generator shares one construction API.
  *
- * The `El` wrapper is a thin fluent facade over a DOM `Element` — `.attr()`,
- * `.text()`, `.child()` — so generator code reads declaratively while the
- * underlying nodes remain inspectable/testable as real DOM.
+ * The `El` wrapper is a thin fluent facade over a DOM `Element` - `.attr()`,
+ * `.text()`, `.child()` - so generator code reads declaratively while the
+ * underlying nodes remain inspectable and testable as real DOM.
+ *
+ * The gradient helper was removed with the move to a monochrome theme; nothing
+ * in the redesigned generators emits a gradient.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SvgDocument = exports.El = void 0;
@@ -74,12 +77,7 @@ class SvgDocument {
             el.attrs(attrs);
         return el;
     }
-    /**
-     * Embed a `<style>` block (inside <defs>) so browser renderers can resolve
-     * web fonts / CSS. Used by the Industry-styled generators to @import Barlow /
-     * Barlow Condensed / JetBrains Mono; non-browser renderers ignore it and fall
-     * back to the system fonts declared per family.
-     */
+    /** Embed a `<style>` block inside <defs>. */
     style(css) {
         const s = this.defs().child('style', { type: 'text/css' });
         s.node.appendChild(this.doc.createTextNode(css));
@@ -94,29 +92,23 @@ class SvgDocument {
         }
         return this._defs;
     }
-    /**
-     * Convenience: add a linear gradient to <defs> and return its id.
-     * `stops` is a list of [offsetPercent, color] pairs.
-     */
-    linearGradient(id, stops, opts) {
-        const g = this.defs().child('linearGradient', {
-            id,
-            x1: opts?.x1 ?? 0,
-            y1: opts?.y1 ?? 0,
-            x2: opts?.x2 ?? 1,
-            y2: opts?.y2 ?? 1,
-            gradientUnits: 'objectBoundingBox',
-        });
-        for (const [offset, color] of stops) {
-            g.child('stop', { offset: `${offset}%`, 'stop-color': color });
-        }
-        return id;
-    }
     /** Serialize the whole document to an XML/SVG string (with XML prolog). */
     toString(comment) {
         const body = new xmldom_1.XMLSerializer().serializeToString(this.doc);
         const prolog = `<?xml version="1.0" encoding="UTF-8"?>`;
-        return comment ? `${prolog}\n<!-- ${comment} -->\n${body}` : `${prolog}\n${body}`;
+        if (!comment)
+            return `${prolog}\n${body}`;
+        // The comment is concatenated outside the serializer, so it has to be made
+        // safe here. Caller-supplied text (a model name) reaches this, and an
+        // unescaped `&` or an embedded `--` produces a document that is not
+        // well-formed XML - which some SVG consumers reject outright.
+        const safe = comment
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/-{2,}/g, '-')
+            .trim();
+        return `${prolog}\n<!-- ${safe} -->\n${body}`;
     }
 }
 exports.SvgDocument = SvgDocument;

package/dist/diagrams/core/theme.d.ts

@@ -0,0 +1,84 @@
+/**
+ * One theme, monochrome hairline.
+ *
+ * This replaces a 239-line palette module that carried nine accent palettes,
+ * three-stop gradient definitions, badge tint tables and a light/dark theme
+ * resolver. Diagrams are technical drawings: black on white, 1px rules, square
+ * corners, one font stack. They print, diff and embed predictably, and there is
+ * no colour to keep consistent across fifteen generators.
+ *
+ * The old `resolveAccent` / `resolveTheme` / `rotatedPalettes` entry points are
+ * kept as thin shims in ./legacy-palette so existing generators and callers
+ * keep compiling while they are converted.
+ */
+/** Ink, rules and fills. Every generator draws from these four values. */
+export declare const INK: {
+    /** Text, borders, arrowheads. */
+    readonly line: "#000000";
+    /** Page and shape fill. */
+    readonly ground: "#ffffff";
+    /** Secondary text: types, counts, footers. */
+    readonly muted: "#666666";
+    /** Fill for header bars and emphasis rows. */
+    readonly wash: "#f0f0f0";
+};
+/** Stroke widths. Hairline everywhere; `heavy` only for emphasis. */
+export declare const STROKE: {
+    readonly hair: 1;
+    readonly heavy: 2;
+};
+/**
+ * One font stack, three sizes. No web-font import: diagrams should render the
+ * same offline and in a PDF pipeline, which a Google Fonts `@import` cannot
+ * guarantee.
+ */
+export declare const FONT: {
+    readonly family: "ui-sans-serif, -apple-system, Segoe UI, Helvetica, Arial, sans-serif";
+    readonly mono: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace";
+    readonly title: 13;
+    readonly body: 11;
+    readonly small: 9;
+};
+/** Spacing scale. Multiples of 4 keep everything on a grid. */
+export declare const SPACE: {
+    readonly xs: 4;
+    readonly sm: 8;
+    readonly md: 12;
+    readonly lg: 16;
+    readonly xl: 24;
+};
+/** Row height for tabular content (field lists, columns, tasks). */
+export declare const ROW_HEIGHT = 18;
+/** The complete theme, for generators that prefer one object. */
+export declare const THEME: {
+    readonly ink: {
+        /** Text, borders, arrowheads. */
+        readonly line: "#000000";
+        /** Page and shape fill. */
+        readonly ground: "#ffffff";
+        /** Secondary text: types, counts, footers. */
+        readonly muted: "#666666";
+        /** Fill for header bars and emphasis rows. */
+        readonly wash: "#f0f0f0";
+    };
+    readonly stroke: {
+        readonly hair: 1;
+        readonly heavy: 2;
+    };
+    readonly font: {
+        readonly family: "ui-sans-serif, -apple-system, Segoe UI, Helvetica, Arial, sans-serif";
+        readonly mono: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace";
+        readonly title: 13;
+        readonly body: 11;
+        readonly small: 9;
+    };
+    readonly space: {
+        readonly xs: 4;
+        readonly sm: 8;
+        readonly md: 12;
+        readonly lg: 16;
+        readonly xl: 24;
+    };
+    readonly rowHeight: 18;
+};
+export type Theme = typeof THEME;

package/dist/diagrams/core/theme.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * One theme, monochrome hairline.
+ *
+ * This replaces a 239-line palette module that carried nine accent palettes,
+ * three-stop gradient definitions, badge tint tables and a light/dark theme
+ * resolver. Diagrams are technical drawings: black on white, 1px rules, square
+ * corners, one font stack. They print, diff and embed predictably, and there is
+ * no colour to keep consistent across fifteen generators.
+ *
+ * The old `resolveAccent` / `resolveTheme` / `rotatedPalettes` entry points are
+ * kept as thin shims in ./legacy-palette so existing generators and callers
+ * keep compiling while they are converted.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.THEME = exports.ROW_HEIGHT = exports.SPACE = exports.FONT = exports.STROKE = exports.INK = void 0;
+/** Ink, rules and fills. Every generator draws from these four values. */
+exports.INK = {
+    /** Text, borders, arrowheads. */
+    line: '#000000',
+    /** Page and shape fill. */
+    ground: '#ffffff',
+    /** Secondary text: types, counts, footers. */
+    muted: '#666666',
+    /** Fill for header bars and emphasis rows. */
+    wash: '#f0f0f0',
+};
+/** Stroke widths. Hairline everywhere; `heavy` only for emphasis. */
+exports.STROKE = {
+    hair: 1,
+    heavy: 2,
+};
+/**
+ * One font stack, three sizes. No web-font import: diagrams should render the
+ * same offline and in a PDF pipeline, which a Google Fonts `@import` cannot
+ * guarantee.
+ */
+exports.FONT = {
+    family: 'ui-sans-serif, -apple-system, Segoe UI, Helvetica, Arial, sans-serif',
+    mono: 'ui-monospace, SFMono-Regular, Menlo, Consolas, monospace',
+    title: 13,
+    body: 11,
+    small: 9,
+};
+/** Spacing scale. Multiples of 4 keep everything on a grid. */
+exports.SPACE = {
+    xs: 4,
+    sm: 8,
+    md: 12,
+    lg: 16,
+    xl: 24,
+};
+/** Row height for tabular content (field lists, columns, tasks). */
+exports.ROW_HEIGHT = 18;
+/** The complete theme, for generators that prefer one object. */
+exports.THEME = {
+    ink: exports.INK,
+    stroke: exports.STROKE,
+    font: exports.FONT,
+    space: exports.SPACE,
+    rowHeight: exports.ROW_HEIGHT,
+};

package/dist/diagrams/dependency-diagram.d.ts

@@ -1,22 +1,19 @@
 /**
- * DependencyDiagram — renders a directed dependency graph of models/tables.
+ * DependencyDiagram - renders a directed dependency graph of models/tables.
  *
- * Nodes are models/tables; a directed edge `from → to` means "from depends on
+ * Nodes are models/tables; a directed edge `from -> to` means "from depends on
  * to" (e.g. table `from` holds a foreign key into table `to`). The generator:
  *
  *  - Computes a layered / topological layout: each node's layer is the longest
  *    dependency path to a leaf. Nodes with no dependencies sit in layer 0;
  *    their dependents fan out into higher layers.
  *  - Detects cycles (back edges) with a DFS colouring pass and visually flags
- *    the cyclic edges in red. The layering pass carries its own visited guard
- *    so a cycle can never send it into an infinite loop.
- *  - Draws each node as a labelled rounded box sized to its label, with arrows
+ *    the cyclic edges with a heavier dashed stroke. The layering pass carries
+ *    its own visited guard so a cycle can never send it into an infinite loop.
+ *  - Draws each node as a labelled box sized to its label, with arrows
  *    between dependent boxes.
  *
- * Accent colour (`color`) drives the node fills / arrowheads; the theme
- * (`light` | `dark`) drives the canvas + text colours. Both genuinely change
- * real fill/stroke values in the emitted SVG. The viewBox auto-sizes to the
- * computed layout.
+ * The viewBox auto-sizes to the computed layout.
  *
  * Usage:
  *   const d = new DependencyDiagram({ nodes, edges, title: 'Schema deps' });
@@ -36,8 +33,12 @@ export interface DependencyDiagramOptions {
     nodes: DepNode[];
     edges: DepEdge[];
     title?: string;
+    /**
+     * Accepted for backward compatibility and ignored: diagrams render in a
+     * single monochrome theme.
+     */
     theme?: 'light' | 'dark';
-    /** Named palette or hex accent colour */
+    /** Accepted for backward compatibility and ignored. */
     color?: string;
     direction?: 'horizontal' | 'vertical';
 }
@@ -51,9 +52,8 @@ export declare class DependencyDiagram {
     private static readonly MIN_NODE_W;
     private static readonly LAYER_GAP;
     private static readonly NODE_GAP;
-    private static readonly R;
     constructor(options: DependencyDiagramOptions);
-    /** Adjacency: node → the nodes it depends on (its outgoing edge targets). */
+    /** Adjacency: node -> the nodes it depends on (its outgoing edge targets). */
     private buildAdjacency;
     /**
      * Assign each node a layer = longest dependency path length (0 for nodes with
@@ -62,16 +62,17 @@ export declare class DependencyDiagram {
      */
     private computeLayers;
     /**
-     * Detect cyclic edges via DFS colouring. Returns a set of "from→to" keys that
+     * Detect cyclic edges via DFS colouring. Returns a set of "from-to" keys that
      * are back edges (participate in a cycle).
      */
     private detectCyclicEdges;
     private nodeWidth;
     /**
      * Point on the boundary of a rectangle along the line from the rect centre
-     * toward an external point — used so arrowheads land on the box edge.
+     * toward an external point - used so arrowheads land on the box edge.
      */
     private edgePoint;
+    private build;
     generate(): string;
     private place;
     private defineArrow;