reamkit 1.23.0 → 1.25.0

package/dist/esm/core/drawingml/chart-geometry.js

@@ -875,9 +875,10 @@ function buildPieScene(chart, wPt, hPt, measure) {
 		});
 		const mid = ang + sweep / 2;
 		const pct = Math.round(v / total * 100);
+		const own = chart.showValues ? fmtDataLabel(chart, v) : `${pct}%`;
 		const custom = series.pointLabels?.find((l) => l.idx === i)?.text;
-		if (custom !== void 0 || pct >= 5) labels.push({
-			text: custom ?? `${pct}%`,
+		if (custom !== void 0 || chart.showValues || pct >= 5) labels.push({
+			text: custom ?? own,
 			x: cx + Math.cos(mid) * labelR,
 			y: cy + Math.sin(mid) * labelR - 9 / 3,
 			sizePt: 9,

package/dist/esm/core/drawingml/diagram/colors.d.ts

@@ -0,0 +1,52 @@
+import { PoNode } from '../../po-helpers.js';
+/** The colours part, as the drawing writer asks it. */
+export declare class DiagramColors {
+    private readonly byLabel;
+    constructor(tree: ReadonlyArray<PoNode>);
+    /**
+     * The `a:solidFill` for a box, or undefined when the part states none.
+     *
+     * @param label The layout node's `styleLbl`.
+     * @param index The box's place in the run of siblings.
+     */
+    fill(label: string | undefined, index: number): string | undefined;
+    /**
+     * Whether the part states this label at all.
+     *
+     * A label it names but gives no fill — `revTx`, the reversed text of a
+     * process arrow — is a box with NO fill, which is not the same as a file
+     * that ships no colours and falls back to one accent for everything.
+     */
+    knows(label: string | undefined): boolean;
+    /**
+     * The `a:ln` for a box's OUTLINE, where the part states one.
+     *
+     * A follower box is often a near-white wash with the node's own accent drawn
+     * round it (`conFgAcc1` is `lt1` at 90% inside an `accent1` line): without the
+     * line it is a white rectangle on a white slide and reads as nothing at all.
+     *
+     * @param label The layout node's `styleLbl`.
+     * @param index The box's place in the run of siblings.
+     */
+    line(label: string | undefined, index: number): string | undefined;
+    /** The `a:solidFill` for a box's TEXT, where the part overrides the style. */
+    textFill(label: string | undefined, index: number): string | undefined;
+    private pick;
+}
+/**
+ * §21.4.2.20 `dgm:pt/dgm:spPr` — the formatting the AUTHOR set on one point,
+ * which beats whatever the colours part gives that point's style label.
+ *
+ * A cycle-matrix whose second quarter was recoloured by hand states it here and
+ * nowhere else: read only from the colours part, all four quarters came out the
+ * one accent the label names, and the orange quarter and the orange outline
+ * round its callout both vanished.
+ *
+ * @param spPr The point's `dgm:spPr`, when it has one.
+ * @returns The fill and the outline it overrides, each as DrawingML, when it
+ *          overrides them.
+ */
+export declare function pointPaint(spPr: PoNode | undefined): {
+    fill?: string;
+    line?: string;
+};

package/dist/esm/core/drawingml/diagram/colors.js

@@ -0,0 +1,125 @@
+import { poAttr, poChildren, poIs, poTag } from "../../po-helpers.js";
+//#region src/core/drawingml/diagram/colors.ts
+/** The colours part, as the drawing writer asks it. */
+var DiagramColors = class {
+	byLabel = /* @__PURE__ */ new Map();
+	constructor(tree) {
+		const def = findDescendant(tree, "dgm:colorsDef");
+		for (const lbl of def ? poChildren(def) : []) {
+			if (!poIs(lbl, "dgm:styleLbl")) continue;
+			const name = poAttr(lbl, "name");
+			if (name === void 0) continue;
+			const kids = poChildren(lbl);
+			this.byLabel.set(name, {
+				...run(kids, "dgm:fillClrLst", "fill"),
+				...run(kids, "dgm:linClrLst", "line"),
+				...run(kids, "dgm:txFillClrLst", "txFill")
+			});
+		}
+	}
+	/**
+	* The `a:solidFill` for a box, or undefined when the part states none.
+	*
+	* @param label The layout node's `styleLbl`.
+	* @param index The box's place in the run of siblings.
+	*/
+	fill(label, index) {
+		return solid(this.pick(label, "fill", index));
+	}
+	/**
+	* Whether the part states this label at all.
+	*
+	* A label it names but gives no fill — `revTx`, the reversed text of a
+	* process arrow — is a box with NO fill, which is not the same as a file
+	* that ships no colours and falls back to one accent for everything.
+	*/
+	knows(label) {
+		return label !== void 0 && this.byLabel.has(label);
+	}
+	/**
+	* The `a:ln` for a box's OUTLINE, where the part states one.
+	*
+	* A follower box is often a near-white wash with the node's own accent drawn
+	* round it (`conFgAcc1` is `lt1` at 90% inside an `accent1` line): without the
+	* line it is a white rectangle on a white slide and reads as nothing at all.
+	*
+	* @param label The layout node's `styleLbl`.
+	* @param index The box's place in the run of siblings.
+	*/
+	line(label, index) {
+		const fill = solid(this.pick(label, "line", index));
+		return fill === void 0 ? void 0 : `<a:ln>${fill}</a:ln>`;
+	}
+	/** The `a:solidFill` for a box's TEXT, where the part overrides the style. */
+	textFill(label, index) {
+		return solid(this.pick(label, "txFill", index));
+	}
+	pick(label, which, index) {
+		const colors = (label === void 0 ? void 0 : this.byLabel.get(label)?.[which])?.colors ?? [];
+		if (colors.length === 0) return void 0;
+		return colors[(index % colors.length + colors.length) % colors.length];
+	}
+};
+function run(kids, tag, as) {
+	const list = kids.find((c) => poIs(c, tag));
+	const colors = list ? poChildren(list).filter((c) => poTag(c)?.endsWith("Clr") === true) : [];
+	if (colors.length === 0) return {};
+	return { [as]: {
+		meth: poAttr(list, "meth") ?? "repeat",
+		colors
+	} };
+}
+/**
+* §21.4.2.20 `dgm:pt/dgm:spPr` — the formatting the AUTHOR set on one point,
+* which beats whatever the colours part gives that point's style label.
+*
+* A cycle-matrix whose second quarter was recoloured by hand states it here and
+* nowhere else: read only from the colours part, all four quarters came out the
+* one accent the label names, and the orange quarter and the orange outline
+* round its callout both vanished.
+*
+* @param spPr The point's `dgm:spPr`, when it has one.
+* @returns The fill and the outline it overrides, each as DrawingML, when it
+*          overrides them.
+*/
+function pointPaint(spPr) {
+	const kids = poChildren(spPr);
+	const fillNode = kids.find((c) => poIs(c, "a:solidFill") || poIs(c, "a:noFill") || poIs(c, "a:gradFill"));
+	const colorIn = (node) => poChildren(node).find((c) => poTag(c)?.endsWith("Clr") === true);
+	const fill = poIs(fillNode, "a:noFill") ? "<a:noFill/>" : poIs(fillNode, "a:solidFill") ? solid(colorIn(fillNode)) : void 0;
+	const ln = kids.find((c) => poIs(c, "a:ln"));
+	const lnColor = solid(colorIn(ln ? poChildren(ln).find((c) => poIs(c, "a:solidFill")) : void 0));
+	const w = poAttr(ln, "w");
+	const line = ln === void 0 ? void 0 : `<a:ln${w !== void 0 ? ` w="${esc(w)}"` : ""}>${lnColor ?? ""}</a:ln>`;
+	return {
+		...fill !== void 0 ? { fill } : {},
+		...line !== void 0 ? { line } : {}
+	};
+}
+function solid(color) {
+	const xml = color === void 0 ? "" : colorXml(color);
+	return xml === "" ? void 0 : `<a:solidFill>${xml}</a:solidFill>`;
+}
+function colorXml(color) {
+	const tag = poTag(color);
+	if (tag === void 0) return "";
+	const val = poAttr(color, "val");
+	const mods = poChildren(color).map((m) => {
+		const t = poTag(m);
+		const v = poAttr(m, "val");
+		return t === void 0 || v === void 0 ? "" : `<${t} val="${esc(v)}"/>`;
+	}).join("");
+	return `${val === void 0 ? `<${tag}>` : `<${tag} val="${esc(val)}">`}${mods}</${tag}>`;
+}
+function esc(s) {
+	return s.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/"/gu, "&quot;");
+}
+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 { DiagramColors, pointPaint };

package/dist/esm/core/drawingml/diagram/data-model.d.ts

@@ -0,0 +1,47 @@
+import { PoNode } from '../../po-helpers.js';
+/** §21.4.2.27 `dgm:pt@type` — what a point is in the model. */
+export type PointType = 'doc' | 'node' | 'asst' | 'parTrans' | 'sibTrans' | 'pres';
+/** One point of the data model. */
+export interface DiagramPoint {
+    readonly id: string;
+    readonly type: PointType;
+    /** `dgm:t` — the point's text, as the `a:txBody` every other reader takes. */
+    readonly text?: PoNode;
+    /** `dgm:spPr` — the formatting the user overrode on this node. */
+    readonly spPr?: PoNode;
+    /** `dgm:prSet` — presentation properties (placeholder text, custom sizes). */
+    readonly prSet?: PoNode;
+}
+/**
+ * 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.
+ */
+export declare class DiagramData {
+    private readonly byId;
+    private readonly kids;
+    /** The document point every layout starts from. */
+    readonly root: DiagramPoint | undefined;
+    /** §21.4.2.4 `dgm:bg` — the fill painted behind the whole diagram. */
+    readonly background: PoNode | undefined;
+    constructor(tree: ReadonlyArray<PoNode>);
+    /** The point with this id, if the model holds one. */
+    point(id: string): DiagramPoint | undefined;
+    /**
+     * 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: string, ptType?: 'node' | 'sibTrans' | 'parTrans'): Array<DiagramPoint>;
+    /**
+     * 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(): number;
+    /** The plain text of a point's `dgm:t`, paragraphs joined by newlines. */
+    static textOf(pt: DiagramPoint | undefined): string;
+}

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>;