@diagc/core 0.1.0

package/dist/view/tree.js

@@ -0,0 +1,147 @@
+export function buildViewTree(m, h, lod) {
+    const stateOf = (id) => (h.childrenOf.get(id) ?? []).length === 0 ? 'leaf' : (lod[id] ?? 'collapsed');
+    const visible = new Set();
+    const hostOf = new Map();
+    const promoted = new Set();
+    for (const r of h.roots) {
+        visible.add(r);
+        hostOf.set(r, null);
+    }
+    const absorbersOf = (id, memo) => {
+        const hit = memo.get(id);
+        if (hit)
+            return hit;
+        const acc = new Set();
+        memo.set(id, acc); // pre-set guards diamond re-entry (containment is a DAG)
+        for (const p of h.parentsOf.get(id) ?? []) {
+            if (visible.has(p))
+                acc.add(p);
+            else
+                for (const a of absorbersOf(p, memo))
+                    acc.add(a);
+        }
+        return acc;
+    };
+    const commonHost = (absorbers) => {
+        const chains = [...absorbers].map((a) => {
+            const chain = [];
+            let cur = hostOf.get(a) ?? null;
+            while (cur !== null) {
+                chain.push(cur);
+                cur = hostOf.get(cur) ?? null;
+            }
+            return chain;
+        });
+        const [first, ...rest] = chains;
+        for (const cand of first ?? []) {
+            if (rest.every((c) => c.includes(cand)))
+                return cand;
+        }
+        return null;
+    };
+    // Reveal children of visible expanded nodes; then promote hidden shared
+    // nodes spanning >=2 visible groups; repeat until stable. Within a round,
+    // only "membership-maximal" candidates promote: a candidate with a hidden
+    // ancestor that is itself a candidate waits — once the ancestor is visible,
+    // the descendant usually resolves to a single absorber (it lives inside the
+    // promoted container) instead of being wrongly promoted next to it.
+    for (;;) {
+        let placed = true;
+        while (placed) {
+            placed = false;
+            for (const n of m.nodes) {
+                if (visible.has(n.id))
+                    continue;
+                const host = (h.parentsOf.get(n.id) ?? []).find((p) => visible.has(p) && stateOf(p) === 'expanded');
+                if (host !== undefined) {
+                    visible.add(n.id);
+                    hostOf.set(n.id, host);
+                    placed = true;
+                }
+            }
+        }
+        const memo = new Map();
+        const candidates = m.nodes.filter((n) => !visible.has(n.id) && absorbersOf(n.id, memo).size >= 2);
+        if (candidates.length === 0)
+            break;
+        const candidateIds = new Set(candidates.map((n) => n.id));
+        const hasCandidateAncestor = (id) => {
+            const seen = new Set();
+            const stack = [...(h.parentsOf.get(id) ?? [])];
+            while (stack.length > 0) {
+                const p = stack.pop();
+                if (p === undefined || seen.has(p))
+                    continue;
+                seen.add(p);
+                if (candidateIds.has(p))
+                    return true;
+                if (!visible.has(p))
+                    stack.push(...(h.parentsOf.get(p) ?? []));
+            }
+            return false;
+        };
+        // A DAG always has a maximal candidate, so this round promotes >=1 node.
+        for (const n of candidates.filter((c) => !hasCandidateAncestor(c.id))) {
+            promoted.add(n.id);
+            visible.add(n.id);
+            hostOf.set(n.id, commonHost(absorbersOf(n.id, memo)));
+        }
+    }
+    // Anchors for hidden nodes (unique by construction: >=2 would have promoted).
+    const anchorOf = new Map();
+    const finalMemo = new Map();
+    for (const n of m.nodes) {
+        if (visible.has(n.id))
+            continue;
+        const [anchor] = absorbersOf(n.id, finalMemo);
+        if (anchor !== undefined)
+            anchorOf.set(n.id, anchor);
+    }
+    // Assemble ViewNodes in model order.
+    const byId = new Map();
+    for (const n of m.nodes) {
+        if (!visible.has(n.id))
+            continue;
+        byId.set(n.id, {
+            id: n.id,
+            node: n,
+            state: stateOf(n.id),
+            children: [],
+            promoted: promoted.has(n.id),
+            sharedMembers: [],
+        });
+    }
+    // Two passes so promoted nodes land AFTER normally-placed siblings within
+    // each roots/children list, each group internally in model order.
+    const roots = [];
+    const placeInto = (vn) => {
+        const host = hostOf.get(vn.id) ?? null;
+        if (host === null)
+            roots.push(vn);
+        else
+            byId.get(host)?.children.push(vn);
+    };
+    for (const n of m.nodes) {
+        const vn = byId.get(n.id);
+        if (vn && !promoted.has(n.id))
+            placeInto(vn);
+    }
+    for (const n of m.nodes) {
+        const vn = byId.get(n.id);
+        if (vn && promoted.has(n.id))
+            placeInto(vn);
+    }
+    // Shared markers: visible parents that are not the placement host.
+    for (const n of m.nodes) {
+        if (!byId.has(n.id))
+            continue;
+        const parents = h.parentsOf.get(n.id) ?? [];
+        if (parents.length < 2)
+            continue;
+        for (const p of parents) {
+            if (p !== hostOf.get(n.id) && byId.has(p))
+                byId.get(p)?.sharedMembers.push(n.id);
+        }
+    }
+    return { roots, byId, anchorOf, hostOf };
+}

package/dist/view/types.d.ts

@@ -0,0 +1,68 @@
+import type { DiagramNode, DiagramRelation, EdgeLabel, Polarity, RelationStyle } from '../types.js';
+export type NodeViewState = 'leaf' | 'expanded' | 'collapsed';
+/** Collapse decisions for container nodes only; leaves never appear. */
+export type LodState = Record<string, 'expanded' | 'collapsed'>;
+export interface ViewportState {
+    /** active plane id; absent = the model's first-declared plane (or the implicit one) */
+    plane?: string;
+    /** container ids the viewer is zoomed into (renderer-computed focus chain) */
+    focus?: string[];
+    pins?: Record<string, 'expanded' | 'collapsed'>;
+    /** layer ids to draw. ABSENT = the host has no opinion, so the active plane's
+     * `layers` presets apply; PRESENT = the host's own choice, which replaces the
+     * presets entirely — an empty array therefore means "no layers at all", not
+     * "presets only". A host with a layer switch seeds its state from the plane's
+     * `layers` (on load and on every plane change) and owns it from then on. */
+    activeLayers?: string[];
+    /** nested-zoom drill root: when set, the view is scoped to this node's INTERIOR
+     * — its children become the top-level content (the node itself isn't drawn) and
+     * everything outside its subtree disappears. Relations crossing the boundary are
+     * re-pointed to an external stub node (see ViewNode.external). */
+    root?: string;
+}
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface ViewNode {
+    id: string;
+    node: DiagramNode;
+    state: NodeViewState;
+    children: ViewNode[];
+    promoted: boolean;
+    /** Ids of shared nodes contained here but rendered elsewhere. */
+    sharedMembers: string[];
+    /** Set on a drill-view stub node: the id of the real (off-frame) node it stands
+     * in for — an edge to something outside the current drill root. Clicking it
+     * navigates into that node. */
+    external?: string;
+}
+export interface ViewEdge {
+    id: string;
+    from: string;
+    to: string;
+    kind: string;
+    label?: string;
+    /** the sole constituent's positioned labels; aggregated edges have none */
+    labels?: EdgeLabel[];
+    layer?: string;
+    tint?: string;
+    /** the sole constituent's per-relation style; aggregated edges have none */
+    style?: RelationStyle;
+    /** CLD polarity: a single constituent's sign, or an aggregate's shared sign when every constituent agrees; absent when constituents disagree or any lacks a sign */
+    polarity?: Polarity;
+    /** the sole constituent's CLD delay marker; aggregated edges have none */
+    delay?: boolean;
+    constituents: DiagramRelation[];
+}
+export interface CompiledView {
+    roots: ViewNode[];
+    /** the arrows to DRAW (filtered by active layers / plane) */
+    edges: ViewEdge[];
+    /** the arrows to LAYOUT BY (all layers + base) — stable across overlay
+     * toggles and structure-sharing planes, so boxes never jump */
+    layoutEdges: ViewEdge[];
+    lod: LodState;
+    /** drill view only: stub node id -> the real off-frame node it represents. */
+    externals?: Map<string, string>;
+}

package/dist/view/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@diagc/core",
+  "version": "0.1.0",
+  "description": "Diagram model, validator, and builder DSL for diagc — no React, no filesystem.",
+  "license": "AGPL-3.0-only",
+  "author": "Bogdan Frankovskyi",
+  "homepage": "https://github.com/Ferroman/diagc#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ferroman/diagc.git",
+    "directory": "packages/core"
+  },
+  "keywords": [
+    "diagram",
+    "architecture",
+    "c4",
+    "causal-loop",
+    "dsl"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {},
+  "types": "./dist/index.d.ts"
+}