reamkit 1.23.0 → 1.24.0

package/dist/esm/core/drawingml/diagram/data-model.js

@@ -0,0 +1,119 @@
+import { poAttr, poChildren, poIs, poText } from "../../po-helpers.js";
+//#region src/core/drawingml/diagram/data-model.ts
+/**
+* The data part as the layout engine asks about it: the point tree recovered
+* from the connection list, plus the transition points that go with each edge.
+*/
+var DiagramData = class {
+	byId = /* @__PURE__ */ new Map();
+	kids = /* @__PURE__ */ new Map();
+	/** The document point every layout starts from. */
+	root;
+	/** §21.4.2.4 `dgm:bg` — the fill painted behind the whole diagram. */
+	background;
+	constructor(tree) {
+		const model = findDescendant(tree, "dgm:dataModel");
+		this.background = model ? poChildren(model).find((c) => poIs(c, "dgm:bg")) : void 0;
+		const ptLst = model ? poChildren(model).find((c) => poIs(c, "dgm:ptLst")) : void 0;
+		for (const pt of ptLst ? poChildren(ptLst) : []) {
+			if (!poIs(pt, "dgm:pt")) continue;
+			const id = poAttr(pt, "modelId");
+			if (id === void 0) continue;
+			const kids = poChildren(pt);
+			this.byId.set(id, {
+				id,
+				type: poAttr(pt, "type") ?? "node",
+				...pick(kids, "dgm:t", "text"),
+				...pick(kids, "dgm:spPr", "spPr"),
+				...pick(kids, "dgm:prSet", "prSet")
+			});
+		}
+		const cxnLst = model ? poChildren(model).find((c) => poIs(c, "dgm:cxnLst")) : void 0;
+		for (const cxn of cxnLst ? poChildren(cxnLst) : []) {
+			if (!poIs(cxn, "dgm:cxn")) continue;
+			if ((poAttr(cxn, "type") ?? "parOf") !== "parOf") continue;
+			const parent = poAttr(cxn, "srcId");
+			const child = poAttr(cxn, "destId");
+			if (parent === void 0 || child === void 0) continue;
+			const list = this.kids.get(parent) ?? [];
+			list.push({
+				parent,
+				child,
+				ord: Number(poAttr(cxn, "srcOrd") ?? "0"),
+				...opt("sibTransId", poAttr(cxn, "sibTransId")),
+				...opt("parTransId", poAttr(cxn, "parTransId"))
+			});
+			this.kids.set(parent, list);
+		}
+		for (const list of this.kids.values()) list.sort((a, b) => a.ord - b.ord);
+		this.root = [...this.byId.values()].find((p) => p.type === "doc");
+	}
+	/** The point with this id, if the model holds one. */
+	point(id) {
+		return this.byId.get(id);
+	}
+	/**
+	* The children of a point, in the order the connections give them.
+	*
+	* @param id       The parent's model id.
+	* @param ptType   Which kind of child to return — `node` skips the
+	*                 transitions, `sibTrans` returns them instead.
+	*/
+	children(id, ptType = "node") {
+		const out = [];
+		for (const edge of this.kids.get(id) ?? []) {
+			const wanted = ptType === "node" ? edge.child : ptType === "sibTrans" ? edge.sibTransId : edge.parTransId;
+			const pt = wanted === void 0 ? void 0 : this.byId.get(wanted);
+			if (pt && (ptType !== "node" || pt.type !== "parTrans" && pt.type !== "sibTrans")) out.push(pt);
+		}
+		return out;
+	}
+	/**
+	* How many generations of `node` points the model holds below its root.
+	*
+	* §21.4.3.3 — a layout branches on this (`func="maxDepth" op="gte" val="2"`):
+	* the same part lays a chevron out as one box when the nodes have no
+	* children and as a labelled box over a body when they do.
+	*/
+	get depth() {
+		const walk = (id, seen) => {
+			if (seen.has(id)) return 0;
+			seen.add(id);
+			let best = 0;
+			for (const kid of this.children(id, "node")) best = Math.max(best, walk(kid.id, seen));
+			return best + 1;
+		};
+		return this.root ? walk(this.root.id, /* @__PURE__ */ new Set()) - 1 : 0;
+	}
+	/** The plain text of a point's `dgm:t`, paragraphs joined by newlines. */
+	static textOf(pt) {
+		if (!pt?.text) return "";
+		const lines = [];
+		for (const p of poChildren(pt.text)) {
+			if (!poIs(p, "a:p")) continue;
+			let line = "";
+			for (const r of poChildren(p)) if (poIs(r, "a:br")) {
+				lines.push(line);
+				line = "";
+			} else if (poIs(r, "a:r")) line += poText(poChildren(r).find((c) => poIs(c, "a:t")));
+			lines.push(line);
+		}
+		return lines.join("\n");
+	}
+};
+function pick(kids, tag, as) {
+	const found = kids.find((c) => poIs(c, tag));
+	return found ? { [as]: found } : {};
+}
+function opt(name, v) {
+	return v === void 0 || v === "" ? {} : { [name]: v };
+}
+function findDescendant(tree, tag) {
+	for (const node of tree) {
+		if (poIs(node, tag)) return node;
+		const found = findDescendant(poChildren(node), tag);
+		if (found) return found;
+	}
+}
+//#endregion
+export { DiagramData };

package/dist/esm/core/drawingml/diagram/layout-engine.d.ts

@@ -0,0 +1,46 @@
+import { PoNode } from '../../po-helpers.js';
+import { DiagramData, DiagramPoint } from './data-model.js';
+/** One box the engine laid out, in the diagram's own frame (EMU). */
+export interface LaidNode {
+    readonly point: DiagramPoint;
+    readonly shapeType: string;
+    /** The layout node's `styleLbl` — which run of colours the box takes. */
+    readonly styleLbl?: string;
+    /** The box's place among its siblings, which is where in that run it is. */
+    readonly index: number;
+    /** The point size the layout states for the box's text, when it states one. */
+    readonly fontSizePt?: number;
+    /** Whether the `tx` algorithm asks for the text to be bulleted. */
+    readonly bulleted?: boolean;
+    /**
+     * §21.4.3.9 `dgm:shape@hideGeom` — the box reserves its room but its outline
+     * is never drawn. The picture lists put an invisible spacer above each node.
+     */
+    readonly hideGeom?: boolean;
+    /** §21.4.3.2 `txAnchorVert` — where in its box the `tx` algorithm sits text. */
+    readonly anchor?: string;
+    /** §21.4.3.2 `parTxLTRAlign` — how the layout ranges a node's own label. */
+    readonly align?: string;
+    /**
+     * §21.4.3.5 `dgm:shape@rot` — how far the box's geometry is turned, in
+     * 60 000ths of a degree clockwise. The cycle-matrix layout builds its disc
+     * out of one quarter-wedge stated four times at 0°, 90°, 180° and 270°.
+     */
+    readonly rotation60k?: number;
+    readonly x: number;
+    readonly y: number;
+    readonly cx: number;
+    readonly cy: number;
+}
+/**
+ * Lay a diagram out from its data and layout parts.
+ *
+ * @param layout The parsed `layout1.xml` tree.
+ * @param data   The parsed data part.
+ * @param cx     The frame's width in EMU, as the drawing states it.
+ * @param cy     The frame's height in EMU.
+ * @returns The boxes to draw, or an empty list when the layout uses an
+ *          algorithm this slice does not run — the caller then reports the
+ *          diagram as a loss exactly as before.
+ */
+export declare function layoutDiagram(layout: ReadonlyArray<PoNode>, data: DiagramData, cx: number, cy: number): Array<LaidNode>;