@pptx-studio/validate 0.2.1 → 0.4.0

package/dist/index.js

@@ -295,6 +295,30 @@ const RULES = [
 		evidence: "both",
 		title: "`a:gridCol/@w`, `a:tr/@h`, and typed `gridSpan`, `rowSpan`, `hMerge`, `vMerge`",
 		why: "`CT_TableCol/@w` and `CT_TableRow/@h` are required `ST_Coordinate`s, the spans are `xsd:int` and the flags `xsd:boolean`. C7 measured each: a `gridCol` without `@w`, a `tr` without `@h`, `gridSpan=\"2.0\"` and `hMerge=\"on\"` are a repair prompt apiece; PowerPoint saves the column at its minimum width, the row at zero, the span gone and the flag as \"1\". `w=\"108pt\"`, the universal-measure spelling, opens clean and is not this rule."
+	},
+	{
+		id: "V032",
+		category: "ids",
+		severity: "warning",
+		evidence: "measured",
+		title: "a table names one of PowerPoint's 74 built-in table styles, or none",
+		why: "C8 drew 84 probe packages in three themes. A table whose `a:tableStyleId`, or inline `a:tableStyle`, names one of the 74 built-ins draws that built-in, in any case, whatever `ppt/tableStyles.xml` says about it; any other id - defined in the part or not - draws a 1-pt black grid with no fill, and an id nothing defines is dropped on the next save. The deck opens without a word, which is why this is a warning: the file names one style and PowerPoint draws another."
+	},
+	{
+		id: "V033",
+		category: "required",
+		severity: "fatal",
+		evidence: "both",
+		title: "a table style id is a braced GUID, and the table-style part is one PowerPoint keeps",
+		why: "`ST_Guid` is a GUID in braces, `CT_TableStyleList/@def` and `CT_TableStyle/@styleId` are required, `b` and `i` are `ST_OnOffStyleType` and a border or fill must hold one. C8 measured each as a repair prompt: an id without braces or with padding, a `tblPr` naming its style twice, a part whose root is not `a:tblStyleLst`, a list without `@def`, a style without `@styleId`, `b=\"yes\"`, an edge with neither `a:ln` nor `a:lnRef`, and an empty `a:fill`. PowerPoint writes the all-zero GUID for the id and empties the part."
+	},
+	{
+		id: "V034",
+		category: "required",
+		severity: "warning",
+		evidence: "measured",
+		title: "a border a cell writes is the one PowerPoint draws on that edge",
+		why: "A grid edge belongs to two cells, and each may write a line for it. C9 drew direct borders, on plain and merged cells, under seven built-ins and the default grid: PowerPoint draws an edge from the cell above or to the left - its `a:lnB` or `a:lnR`, or the style where it writes none - where that cell, merged or not, has its anchor level with the edge. Otherwise the cell below or to the right draws its own `a:lnT` or `a:lnL` where its anchor is level with the edge, and elsewhere the cell above or to the left keeps it. When PowerPoint sets a border itself it writes every side alike. The deck opens without a word, which is why this is a warning: the file says one border and PowerPoint draws another."
 	}
 ];
 const BY_ID = new Map(RULES.map((rule) => [rule.id, rule]));
@@ -645,14 +669,7 @@ function readRelsParts(ctx) {
 	return parts;
 }
 /**
-* Memoised above, because five of the thirty-one rules want this list and each
-* would otherwise re-walk every `.rels` part in the package. The parsed trees
-* are already cached on the context; what is saved here is the element scan and
-* the allocation, which on a three-hundred-slide deck is five passes over a
-* thousand relationship parts for one answer that cannot have changed.
-*
-* Keyed by context rather than by store, so nothing survives one validation run
-* into the next.
+* Memoised per context: several rules want every relationship part, and this walks them once.
 */
 function scanRelsParts(ctx) {
 	const out = [];
@@ -1169,16 +1186,8 @@ function forEachElement$1(ctx, visit) {
 //#endregion
 //#region src/rules/required.ts
 /**
-* `V013` … `V017`, `V030` and `V031`: children and attributes that are not optional.
-*
-* Every one of these is a `minOccurs` the schema states plainly, and every one
-* is broken the same way: by an editor deleting the last of something. The last
-* paragraph goes and a `p:txBody` is left with no `a:p`; a shape is dragged out
-* of a group and the group's `p:grpSpPr` is dropped with it. That is why these
-* are separate rules from the ordering ones even though a missing child and a
-* misplaced child are both "the sequence is wrong": the messages have to say
-* *add this*, not *move this*, and they have to fire on the parent rather than
-* on a child that is not there to point at.
+* `V013` … `V017`, `V030`, `V031`, `V033` and `V034`: children and attributes that are not optional,
+* and tables PowerPoint reads otherwise than they say.
 */
 /** The twelve attributes of `CT_ColorMapping`. All required, no defaults. */
 const CLR_MAP_ATTRIBUTES = [
@@ -1288,6 +1297,82 @@ function v031TableAttributes(ctx) {
 		}
 	});
 }
+/** `ST_Guid`, in any case: C8 measured lower case opening clean. */
+const TABLE_STYLE_GUID$1 = /^\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\}$/i;
+const ON_OFF_STYLES = /* @__PURE__ */ new Set([
+	"on",
+	"off",
+	"def"
+]);
+const TABLE_STYLE_EDGES = /* @__PURE__ */ new Set([
+	"left",
+	"right",
+	"top",
+	"bottom",
+	"insideH",
+	"insideV",
+	"tl2br",
+	"tr2bl"
+]);
+const FILL_PROPERTIES = /* @__PURE__ */ new Set([
+	"noFill",
+	"solidFill",
+	"gradFill",
+	"blipFill",
+	"pattFill",
+	"grpFill"
+]);
+const drawingChildren = (element, local) => childElements(element).filter((child) => child.local === local && namespaceOf(child) === NS.a);
+/** A table-style id is a braced GUID, and a table style has the parts C8 measured as required. */
+function v033TableStyles(ctx) {
+	for (const part of ctx.parts()) {
+		if (ctx.contentType(part) !== CONTENT_TYPE.tableStyles) continue;
+		const root = ctx.document(part)?.root;
+		if (root === void 0 || root.local === "tblStyleLst" && namespaceOf(root) === NS.a) continue;
+		ctx.add("V033", elementLocation(part, root), `The table-style part's root is <${root.qname}>, not <a:tblStyleLst>. C8 measured this as a repair prompt.`);
+	}
+	forEachElement(ctx, (part, element) => {
+		if (namespaceOf(element) !== NS.a) return;
+		const report = (at, what) => {
+			ctx.add("V033", elementLocation(part, at), what + " C8 measured this as a repair prompt.");
+		};
+		if (element.local === "tblPr" && drawingChildren(element, "tableStyleId").length > 0 && drawingChildren(element, "tableStyle").length > 0) report(element, "<a:tblPr> names its style twice, by <a:tableStyleId> and <a:tableStyle>.");
+		const guid = (raw, what) => {
+			if (!TABLE_STYLE_GUID$1.test(raw)) report(element, `${what} is "${raw}", which is not a GUID in braces.`);
+		};
+		switch (element.local) {
+			case "tableStyleId":
+				guid(textContent(element), "<a:tableStyleId>");
+				return;
+			case "tableStyle":
+			case "tblStyle": {
+				const id = attributeValue(element, "styleId");
+				if (id === void 0) report(element, `<a:${element.local}> has no @styleId.`);
+				else guid(id, `<a:${element.local}>/@styleId`);
+				return;
+			}
+			case "tblStyleLst":
+				if (attributeValue(element, "def") === void 0) report(element, "<a:tblStyleLst> has no @def.");
+				return;
+			case "tcTxStyle":
+				for (const name of ["b", "i"]) {
+					const raw = attributeValue(element, name);
+					if (raw !== void 0 && !ON_OFF_STYLES.has(raw)) report(element, `<a:tcTxStyle>/@${name} is "${raw}", not on, off or def.`);
+				}
+				return;
+			case "tcBdr":
+				for (const edge of childElements(element)) {
+					if (!TABLE_STYLE_EDGES.has(edge.local) || namespaceOf(edge) !== NS.a) continue;
+					if (drawingChildren(edge, "ln").length + drawingChildren(edge, "lnRef").length === 0) report(edge, `<a:${edge.local}> has neither <a:ln> nor <a:lnRef>.`);
+				}
+				return;
+			case "tcStyle":
+			case "tblBg":
+				for (const fill of drawingChildren(element, "fill")) if (!childElements(fill).some((child) => FILL_PROPERTIES.has(child.local))) report(fill, "<a:fill> holds no fill.");
+				return;
+		}
+	});
+}
 /** Zero is one and a negative runs to the edge: C7's span-zero and span-negative. */
 function spanOf(raw) {
 	if (raw === void 0) return 1;
@@ -1376,6 +1461,104 @@ function v030TableGrid(ctx) {
 		});
 	});
 }
+/** Two elements alike but for their own names: the same attributes and the same children. */
+function sameMarkup(a, b) {
+	const attrs = (e) => [...e.attributes].map((x) => `${x.qname}=${x.value}`).sort().join(" ");
+	const ka = childElements(a);
+	const kb = childElements(b);
+	return attrs(a) === attrs(b) && textContent(a).trim() === textContent(b).trim() && ka.length === kb.length && ka.every((child, i) => child.qname === kb[i]?.qname && sameMarkup(child, kb[i]));
+}
+/** Whether a line draws nothing: an `a:noFill`, or no fill at all (C9). */
+function drawsNothing(line) {
+	const fills = childElements(line).filter((c) => [
+		"noFill",
+		"solidFill",
+		"gradFill",
+		"pattFill"
+	].includes(c.local));
+	return fills.length === 0 || fills.some((c) => c.local === "noFill");
+}
+/** Two lines that draw alike: both draw nothing, or they are the same markup. */
+function alike(a, b) {
+	return drawsNothing(a) && drawsNothing(b) || sameMarkup(a, b);
+}
+/** A cell's own `a:tcPr` line, by its local name. */
+function lineOf(cell, local) {
+	const tcPr = childElements(cell).find((child) => child.local === "tcPr");
+	return tcPr === void 0 ? void 0 : childElements(tcPr).find((child) => child.local === local);
+}
+/** The grid position across segment `k` of a cell's `side`, the cell anchored at (r, c). */
+function acrossOf(side, r, c, owner, k) {
+	if (side === "lnT") return [r - 1, c + k];
+	if (side === "lnL") return [r + k, c - 1];
+	if (side === "lnB") return [r + owner.rows, c + k];
+	return [r + k, c + owner.cols];
+}
+/** Each side a cell writes, the side facing it across the edge, and how a segment of it is named. */
+const SIDES = [
+	{
+		side: "lnT",
+		facing: "lnB",
+		across: "cols",
+		after: true,
+		where: "above column"
+	},
+	{
+		side: "lnL",
+		facing: "lnR",
+		across: "rows",
+		after: true,
+		where: "left of row"
+	},
+	{
+		side: "lnB",
+		facing: "lnT",
+		across: "cols",
+		after: false,
+		where: "below column"
+	},
+	{
+		side: "lnR",
+		facing: "lnL",
+		across: "rows",
+		after: false,
+		where: "right of row"
+	}
+];
+/**
+* A border a cell writes that PowerPoint draws from the cell across the edge: the cell before owns a
+* segment where its anchor is level with it, else the cell after where its is, else the cell before
+* (C9, ADR 0064). PowerPoint's own writer writes every side alike, so this never fires on its output.
+*/
+function v034TableBorders(ctx) {
+	forEachElement(ctx, (part, element) => {
+		if (element.local !== "tbl" || namespaceOf(element) !== NS.a) return;
+		const tblGrid = childElements(element).find((child) => child.local === "tblGrid");
+		const cols = tblGrid === void 0 ? 0 : childElements(tblGrid).filter((c) => c.local === "gridCol").length;
+		const cells = childElements(element).filter((child) => child.local === "tr").map((row) => childElements(row).filter((child) => child.local === "tc"));
+		const grid = owners(cells, cols);
+		for (const [r, line] of cells.entries()) for (const [c, cell] of line.entries()) {
+			const owner = grid[r]?.[c];
+			if (owner?.row !== r || owner.col !== c) continue;
+			for (const s of SIDES) {
+				const written = lineOf(cell, s.side);
+				if (written === void 0) continue;
+				const reach = s.across === "cols" ? owner.cols : owner.rows;
+				for (let k = 0; k < reach; k++) {
+					const [nr, nc] = acrossOf(s.side, r, c, owner, k);
+					const other = grid[nr]?.[nc];
+					if (other === null || other === void 0) continue;
+					const otherLevel = s.across === "cols" ? other.col === nc : other.row === nr;
+					if (!(s.after ? otherLevel || k > 0 : k > 0 && otherLevel)) continue;
+					const drawn = lineOf(cells[other.row][other.col], s.facing);
+					if (drawn !== void 0 && alike(drawn, written)) continue;
+					ctx.add("V034", elementLocation(part, written), `cell (${String(r + 1)}, ${String(c + 1)}) writes <a:${s.side}>, but ${s.where} ${String((s.across === "cols" ? nc : nr) + 1)} PowerPoint draws the <a:${s.facing}> of cell (${String(other.row + 1)}, ${String(other.col + 1)}), which writes ${drawn === void 0 ? "none" : "a different one"} - measured in C9.`);
+					break;
+				}
+			}
+		}
+	});
+}
 /**
 * Presentation-family parts only.
 *
@@ -1404,22 +1587,93 @@ function forEachElement(ctx, visit) {
 	}
 }
 //#endregion
+//#region src/rules/table-style-ids.ts
+/**
+* The GUIDs of PowerPoint's 74 built-in table styles, in its gallery's order.
+* GENERATED by tools/ground-truth/model/tables/styles/write-tables.ts from
+* corpus/ground-truth/table-styles.json. Do not edit: rules.test.ts re-derives it.
+*/
+const BUILTIN_TABLE_STYLE_IDS = [
+	"{2D5ABB26-0587-4C30-8999-92F81FD0307C}",
+	"{3C2FFA5D-87B4-456A-9821-1D502468CF0F}",
+	"{284E427A-3D55-4303-BF80-6455036E1DE7}",
+	"{69C7853C-536D-4A76-A0AE-DD22124D55A5}",
+	"{775DCB02-9BB8-47FD-8907-85C794F793BA}",
+	"{35758FB7-9AC5-4552-8A53-C91805E547FA}",
+	"{08FB837D-C827-4EFA-A057-4D05807E0F7C}",
+	"{5940675A-B579-460E-94D1-54222C63F5DA}",
+	"{D113A9D2-9D6B-4929-AA2D-F23B5EE8CBE7}",
+	"{18603FDC-E32A-4AB5-989C-0864C3EAD2B8}",
+	"{306799F8-075E-4A3A-A7F6-7FBC6576F1A4}",
+	"{E269D01E-BC32-4049-B463-5C60D7B0CCD2}",
+	"{327F97BB-C833-4FB7-BDE5-3F7075034690}",
+	"{638B1855-1B75-4FBE-930C-398BA8C253C6}",
+	"{9D7B26C5-4107-4FEC-AEDC-1716B250A1EF}",
+	"{3B4B98B0-60AC-42C2-AFA5-B58CD77FA1E5}",
+	"{0E3FDE45-AF77-4B5C-9715-49D594BDF05E}",
+	"{C083E6E3-FA7D-4D7B-A595-EF9225AFEA82}",
+	"{D27102A9-8310-4765-A935-A1911B00CA55}",
+	"{5FD0F851-EC5A-4D38-B0AD-8093EC10F338}",
+	"{68D230F3-CF80-4859-8CE7-A43EE81993B5}",
+	"{7E9639D4-E3E2-4D34-9284-5A2195B3D0D7}",
+	"{69012ECD-51FC-41F1-AA8D-1B2483CD663E}",
+	"{72833802-FEF1-4C79-8D5D-14CF1EAF98D9}",
+	"{F2DE63D5-997A-4646-A377-4702673A728D}",
+	"{17292A2E-F333-43FB-9621-5CBBE7FDCDCB}",
+	"{5A111915-BE36-4E01-A7E5-04B1672EAD32}",
+	"{912C8C85-51F0-491E-9774-3900AFEF0FD7}",
+	"{616DA210-FB5B-4158-B5E0-FEB733F419BA}",
+	"{BC89EF96-8CEA-46FF-86C4-4CE0E7609802}",
+	"{5DA37D80-6434-44D0-A028-1B22A696006F}",
+	"{8799B23B-EC83-4686-B30A-512413B5E67A}",
+	"{ED083AE6-46FA-4A59-8FB0-9F97EB10719F}",
+	"{BDBED569-4797-4DF1-A0F4-6AAB3CD982D8}",
+	"{E8B1032C-EA38-4F05-BA0D-38AFFFC7BED3}",
+	"{793D81CF-94F2-401A-BA57-92F5A7B2D0C5}",
+	"{B301B821-A1FF-4177-AEE7-76D212191A09}",
+	"{9DCAF9ED-07DC-4A11-8D7F-57B35C25682E}",
+	"{1FECB4D8-DB02-4DC6-A0A2-4F2EBAE1DC90}",
+	"{1E171933-4619-4E11-9A3F-F7608DF75F80}",
+	"{FABFCF23-3B69-468F-B69F-88F6DE6A72F2}",
+	"{10A1B5D5-9B99-4C35-A422-299274C87663}",
+	"{073A0DAA-6AF3-43AB-8588-CEC1D06C72B9}",
+	"{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}",
+	"{21E4AEA4-8DFA-4A89-87EB-49C32662AFE0}",
+	"{F5AB1C69-6EDB-4FF4-983F-18BD219EF322}",
+	"{00A15C55-8517-42AA-B614-E9B94910E393}",
+	"{7DF18680-E054-41AD-8BC1-D1AEF772440D}",
+	"{93296810-A885-4BE3-A3E7-6D5BEEA58F35}",
+	"{8EC20E35-A176-4012-BC5E-935CFFF8708E}",
+	"{6E25E649-3F16-4E02-A733-19D2CDBF48F0}",
+	"{85BE263C-DBD7-4A20-BB59-AAB30ACAA65A}",
+	"{EB344D84-9AFB-497E-A393-DC336BA19D2E}",
+	"{EB9631B5-78F2-41C9-869B-9F39066F8104}",
+	"{74C1A8A3-306A-4EB7-A6B1-4F7E0EB9C5D6}",
+	"{2A488322-F2BA-4B5B-9748-0D474271808F}",
+	"{D7AC3CCA-C797-4891-BE02-D94E43425B78}",
+	"{69CF1AB2-1976-4502-BF36-3FF5EA218861}",
+	"{8A107856-5554-42FB-B03E-39F5DBC370BA}",
+	"{0505E3EF-67EA-436B-97B2-0124C06EBD24}",
+	"{C4B1156A-380E-4F78-BDF5-A606A8083BF9}",
+	"{22838BEF-8BB2-4498-84A7-C5851F593DF1}",
+	"{16D9F66E-5EB9-4882-86FB-DCBF35E3C3E4}",
+	"{E8034E78-7F5D-4C2E-B375-FC64B27BC917}",
+	"{125E5076-3810-47DD-B79F-674D7AD40C01}",
+	"{37CE84F3-28C3-443E-9E96-99CF82512B78}",
+	"{D03447BB-5D67-496B-8E87-E561075AD55C}",
+	"{E929F9F4-4A8F-4326-A1B4-22849713DDAB}",
+	"{8FD4443E-F989-4FC4-A0C8-D5A2AF1F390B}",
+	"{AF606853-7671-496A-8E4F-DF71F8EC918B}",
+	"{5202B0CA-FC54-4496-8BCA-5EF66A818D29}",
+	"{0660B408-B3CF-4A94-85FC-2B1E0A45F4A2}",
+	"{91EBBBCC-DAD2-459C-BE2E-F6DE35CF9A28}",
+	"{46F890A9-2807-4EBB-B81D-B2AA78EC7F39}"
+];
+//#endregion
 //#region src/rules/id.ts
 /**
-* `V018` … `V021`: four identifier spaces, and never one allocator.
-*
-* A presentation has four kinds of id and they do not share a rule between
-* them. Slide ids start at 256 and stop at 2147483647. Master and layout ids
-* start at 2147483648, and - the part no schema says - come out of **one**
-* counter shared between them. Shape ids are unique inside a part and free to
-* repeat across parts. Placeholder indices are not identifiers at all; they are
-* a join key against another part.
-*
-* Every one of those is a way to break a file that looks like a way to be
-* tidy. Renumbering shape ids to be unique across the deck is the obvious
-* example: it is more consistent, it is what a database would do, and it
-* detaches every `p:custDataLst`, VML `@spid` and animation target that names
-* the old number.
+* `V018` … `V021` and `V032`: identifier spaces and the ids that name into them. Slide, sheet and
+* shape ids never share an allocator, and a table style id names one of PowerPoint's built-ins.
 */
 const SLIDE_ID_MIN = 256;
 const SLIDE_ID_MAX = 2147483647;
@@ -1641,6 +1895,19 @@ function v021PlaceholderIndices(ctx) {
 		}
 	}
 }
+const BUILTIN_TABLE_STYLES = new Set(BUILTIN_TABLE_STYLE_IDS);
+/** A well-formed id; V033 reports the rest. */
+const TABLE_STYLE_GUID = /^\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\}$/i;
+/** A table's `a:tableStyleId`, or its inline `a:tableStyle/@styleId`, names a built-in (C8). */
+function v032TableStyleIds(ctx) {
+	forEachElement(ctx, (part, element) => {
+		if (namespaceOf(element) !== NS.a) return;
+		const named = element.local === "tableStyleId" ? textContent(element) : element.local === "tableStyle" ? attributeValue(element, "styleId") : void 0;
+		if (named === void 0 || !TABLE_STYLE_GUID.test(named)) return;
+		if (BUILTIN_TABLE_STYLES.has(named.toUpperCase())) return;
+		ctx.add("V032", elementLocation(part, element), `<a:${element.local}> names ${named}, none of PowerPoint's 74 built-in table styles. PowerPoint draws a 1-pt black grid instead, whatever ppt/tableStyles.xml defines (C8).`);
+	});
+}
 //#endregion
 //#region src/rules/refusal.ts
 /**
@@ -2109,12 +2376,7 @@ function v029TextAndFieldIdentity(ctx) {
 //#endregion
 //#region src/validate.ts
 /**
-* The thirty-one, wired to their implementations.
-*
-* A plain table, so that "is every rule reachable" is a thing a test can ask
-* rather than a thing a reader has to believe. `rules.test.ts` asserts that the
-* keys here are exactly `RULE_IDS` - a rule with a definition and no function
-* would otherwise sit in the table looking enforced.
+* Every rule wired to its implementation; `rules.test.ts` holds the keys to `RULE_IDS`.
 */
 const IMPLEMENTATIONS = {
 	V001: v001ContentTypeCoverage,
@@ -2147,7 +2409,10 @@ const IMPLEMENTATIONS = {
 	V028: v028OpaqueContainersUnchanged,
 	V029: v029TextAndFieldIdentity,
 	V030: v030TableGrid,
-	V031: v031TableAttributes
+	V031: v031TableAttributes,
+	V032: v032TableStyleIds,
+	V033: v033TableStyles,
+	V034: v034TableBorders
 };
 /** Rules that cannot run without the archive bytes. See `Context.archive`. */
 const ARCHIVE_RULES = ["V003"];
@@ -2220,20 +2485,9 @@ function run(ctx, rules) {
 	for (const id of rules) IMPLEMENTATIONS[id](ctx);
 }
 /**
-* Decide, for each finding, whether we introduced it.
-*
-* The second pass is the whole of it: run the same rules against the package as
-* it was opened and difference the two sets. A finding in both was already
-* there. See `report.ts` for why that question is the one that decides whether
-* an export is refused, and why answering it by differencing beats answering it
-* per rule.
-*
-* Three properties make it cheap enough to be unconditional in the only case
-* that matters. It runs **only when something fatal was found**, so a clean
-* export - which is nearly all of them - pays nothing. It runs **only the rules
-* that fired**, not all twenty-nine. And it skips the preservation rules, which
-* would be comparing the baseline against itself and would find nothing by
-* construction.
+* Which findings were already in the package as it was opened: the fired rules run again on
+* the baseline and the two sets are differenced. Only when something fatal was found, only the
+* rules that fired, and never the preservation rules. `report.ts` has why.
 */
 function attributeOrigins(ctx, options, running) {
 	const baseline = options.baseline;