@pptx-studio/validate 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @pptx-studio/validate
 
+## 0.3.0
+
+### Minor Changes
+
+- ae2e566: A table's style is the one PowerPoint draws. `BUILTIN_TABLE_STYLES` is PowerPoint's own Table
+  Styles gallery: 74 styles, each with its GUID, its name and the `a:tblStyle` PowerPoint writes for
+  it. `tableStyleOf(table)` returns the built-in a table's GUID names, in any case, or `null` for
+  PowerPoint's default 1-pt black grid; nothing in `ppt/tableStyles.xml` changes which. `builtinTableStyle`
+  and `parseTableStyle` read a `CT_TableStyle` into its thirteen parts. An inline `TableStyleRef` now
+  carries its `id`, a style GUID without braces or with padding throws `MODEL_TABLE_ATTR`, and
+  `MODEL_ERROR_CODES` lists every code, including the new `MODEL_TABLE_STYLE`.
+
+  validate adds `V032`, a warning on a table that names no built-in style, and `V033`, refusing the
+  table-style forms PowerPoint repairs.
+
+## 0.2.1
+
+### Patch Changes
+
+- b58dd19: Built with tsdown 0.23. The declarations take a new shape, and the API is unchanged.
+
+  - Every value is exported where it is declared (`export declare function …`), not in a trailing
+    `export { … }`.
+  - The types are exported in one `export type { … }`.
+  - The JavaScript is byte-for-byte what 0.22 emitted.
+  - In geometry, opc, validate and xml, the source maps name fewer symbols.
+
+- Updated dependencies [b58dd19]
+  - @pptx-studio/opc@0.1.3
+  - @pptx-studio/xml@0.1.2
+
 ## 0.2.0
 
 ### Minor Changes

package/NOTICE

@@ -27,14 +27,24 @@ Entries are added here at the moment the material lands, not at release time.
       presetShapeDefinitions.xml, 538970 bytes
       sha256 4a762444d8d85876881c02a5b1dedf6f73006fcd8acb7b4e393435615b37c780
 
+  * Microsoft PowerPoint output
+      Written by Microsoft PowerPoint, driven by this project's own scripts.
+
+    @pptx-studio/model contains PowerPoint's 74 built-in table styles: each is
+    the a:tblStyle element PowerPoint writes into ppt/tableStyles.xml, byte for
+    byte, enumerated through PowerPoint's Table Styles gallery and saved by
+    PowerPoint (LEGAL.md, ADR 0063). corpus/ground-truth/table-styles.json holds
+    the same 74.
+
+    The decks in corpus/authored are PowerPoint Blank Presentations, so each
+    carries the Microsoft-generated ppt/theme/theme1.xml and default layouts
+    PowerPoint writes into a new deck (ADR 0009).
+
 --------------------------------------------------------------------------------
 Attributions the plan commits us to, listed so the obligation is visible before
 the code arrives
 --------------------------------------------------------------------------------
 
-  * Pattern fill tiles (sub-phase 2.7) are generated from Mono libgdiplus.
-      libgdiplus - Copyright Novell, Inc. and contributors - MIT
-
   * Metric-compatible substitute fonts ship in a separate package,
     @pptx-studio/fonts-metric-compat, under SIL OFL 1.1 with its own
     OFL.txt and reserved-font-name handling. They are deliberately kept out

package/README.md

@@ -1,6 +1,6 @@
 # @pptx-studio/validate
 
-**The repair firewall.** Thirty-one rules a `.pptx` must not break, checked
+**The repair firewall.** Thirty-three rules a `.pptx` must not break, checked
 before any bytes are handed over, each finding carrying the part and the XPath.
 
 Apache-2.0 · browser and Web Worker only, no Node · part of
@@ -28,7 +28,7 @@ quietly lost something.
 So this is not a schema validator with a nice report. It is the only feedback
 loop that exists, and it runs on every export in development and in production.
 
-## Thirty-one rules, in two halves
+## Thirty-three rules, in two halves
 
 Roughly half come from ECMA-376: content-type coverage, `xsd:sequence` child
 order, `minOccurs`, the four identifier ranges. Those are derivable, and one of
@@ -38,19 +38,23 @@ schemas and checked against 194 148 elements PowerPoint wrote.
 The other half cannot be derived from anything. Each is the record of a package
 built with **one** change in it, opened in PowerPoint 16.0.20326, and declined:
 
-|        |                                                                                                      |
-| ------ | ---------------------------------------------------------------------------------------------------- |
-| `V022` | a `p:ph type="hdr"` on a slide. The other seven content types all open.                              |
-| `V023` | a geometry guide referenced but never defined. `ST_GeomGuideName` is an unconstrained token.         |
-| `V024` | a `c:strLit` inside a series `c:tx`, two elements away from where the literal forms are legal.       |
-| `V025` | a `p:control`, in all eight forms tried. An empty `p:controls` is accepted.                          |
-| `V026` | a `cs:chartStyle` with thirty of its thirty-one entries. No chart style at all is fine.              |
-| `V019` | a master id colliding with a layout id. They are one number space and no schema says so.             |
-| `V020` | a `p:cNvPr/@id` between 2147483648 and 4294967294. 4294967295 opens; it is minus one.                |
-| `V009` | a slide without exactly one layout relationship; a `cx:chartSpace` with no `.rels`.                  |
-| `V004` | a percent-escape of an _unreserved_ character in a part name. `0x808D1005`.                          |
-| `V012` | an `a:ahXY` directly under `a:custGeom`, without its `a:ahLst` wrapper.                              |
-| `V031` | an `a:gridCol` without `@w`, an `a:tr` without `@h`, `gridSpan="2.0"`, `hMerge="on"`: a repair each. |
+|        |                                                                                                         |
+| ------ | ------------------------------------------------------------------------------------------------------- |
+| `V022` | a `p:ph type="hdr"` on a slide. The other seven content types all open.                                 |
+| `V023` | a geometry guide referenced but never defined. `ST_GeomGuideName` is an unconstrained token.            |
+| `V024` | a `c:strLit` inside a series `c:tx`, two elements away from where the literal forms are legal.          |
+| `V025` | a `p:control`, in all eight forms tried. An empty `p:controls` is accepted.                             |
+| `V026` | a `cs:chartStyle` with thirty of its thirty-one entries. No chart style at all is fine.                 |
+| `V019` | a master id colliding with a layout id. They are one number space and no schema says so.                |
+| `V020` | a `p:cNvPr/@id` between 2147483648 and 4294967294. 4294967295 opens; it is minus one.                   |
+| `V009` | a slide without exactly one layout relationship; a `cx:chartSpace` with no `.rels`.                     |
+| `V004` | a percent-escape of an _unreserved_ character in a part name. `0x808D1005`.                             |
+| `V012` | an `a:ahXY` directly under `a:custGeom`, without its `a:ahLst` wrapper.                                 |
+| `V031` | an `a:gridCol` without `@w`, an `a:tr` without `@h`, `gridSpan="2.0"`, `hMerge="on"`: a repair each.    |
+| `V033` | a table style id without braces or padded, a table-style part without `@def`, `b="yes"`: a repair each. |
+
+And one warning measured the same way: `V032`, a table naming none of PowerPoint's 74 built-in
+table styles, which PowerPoint draws as a 1-pt black grid whatever the package defines.
 
 Every rule carries a `why` recording what was tried and what opened, so whoever
 eventually contradicts one knows what they are contradicting.
@@ -86,7 +90,7 @@ the same reason.
 
 Two suites that check opposite things, and neither substitutes for the other.
 
-**It fires.** `validate.test.ts` breaks a minimal deck thirty-one ways, one per
+**It fires.** `validate.test.ts` breaks a minimal deck once per
 rule, and asserts each rule reports the right part and the right XPath.
 
 **It is quiet.** `tools/corpus/suites/validate.test.ts` runs all fifty-two committed

package/dist/index.d.ts

@@ -24,7 +24,7 @@ import { PartName, PartStore, ReadZipOptions, ZipArchive } from "@pptx-studio/op
  *
  * Deliberately few. Almost everything this package has to say is a finding.
  */
-declare const VALIDATE_ERROR_CODES: readonly ["ERR_VALIDATION_FAILED", "ERR_UNVALIDATABLE", "ERR_UNKNOWN_RULE"];
+export declare const VALIDATE_ERROR_CODES: readonly ["ERR_VALIDATION_FAILED", "ERR_UNVALIDATABLE", "ERR_UNKNOWN_RULE"];
 type ValidateErrorCode = (typeof VALIDATE_ERROR_CODES)[number];
 interface ValidateErrorDetail {
   /** The part the failure is about, if it is about one. */
@@ -40,55 +40,18 @@ interface ValidateErrorDetail {
    */
   readonly report?: unknown;
 }
-declare class ValidateError extends Error {
+export declare class ValidateError extends Error {
   readonly code: ValidateErrorCode;
   readonly detail: ValidateErrorDetail;
   constructor(code: ValidateErrorCode, message: string, detail?: ValidateErrorDetail);
 }
-declare function isValidateError(value: unknown): value is ValidateError;
+export declare function isValidateError(value: unknown): value is ValidateError;
 //#endregion
 //#region src/rules/rules.d.ts
 /**
- * The thirty-one rules, and the evidence for each.
- *
- * ## Why a table and not thirty-one functions
- *
- * The functions are in the files beside this one. What lives here is the part a
- * person reads: what each rule claims, how sure we are, and *how we know*. A
- * validator whose rules exist only as code is a validator nobody can audit, and
- * this one has to be audited, because roughly half of it enforces things no
- * schema says.
- *
- * That is the fact that shapes the whole package. ECMA-376 is a description of
- * a file format; PowerPoint is an implementation that refuses files the
- * description permits. Sub-phase 0.7 and the corpus bisections in
- * `tools/corpus/ROSTER.md` found nineteen such refusals by building a package
- * with one change in it and watching PowerPoint decline to open it - no
- * diagnostic, no log, no part named, just "PowerPoint could not open the file"
- * or `0x80070570`. Every rule below whose `evidence` says `measured` came from
- * that loop and from nowhere else.
- *
- * So each rule carries three things beyond its check:
- *
- * - `evidence` - `schema` (ECMA-376 says so), `measured` (we watched PowerPoint
- *   refuse it), or `both`.
- * - `why` - the sentence that justifies the rule to somebody who is about to
- *   delete it because it fired on their file.
- * - `severity` - `fatal` refuses an export; `warning` is reported and does not.
- *
- * ## On being wrong in the safe direction
- *
- * A false positive here blocks an export a user wanted. A false negative hands
- * them a file PowerPoint will not open, with no way to find out why. Those are
- * not symmetric, but the first is not free either - a validator that fires on
- * good files gets turned off, and then it catches nothing.
- *
- * The resolution is `origin`, which lives on the finding rather than here: a
- * fatal a caller *introduced* refuses the export, and the identical fatal that
- * was already in the file when it was opened is reported and does not. That is
- * the same split `PartStore.write` already makes for dangling relationships,
- * and for the same reason - refusing to re-export a file we did not break makes
- * the file unopenable in this editor and does not fix anything.
+ * The rules, and the evidence for each: `schema`, `measured` (PowerPoint refused or repaired it),
+ * or `both`. A fatal a caller introduced refuses an export; the same fatal inherited from the
+ * opened file is reported and does not. The README lists every rule.
  */
 type RuleCategory = 'package' | 'relationships' | 'order' | 'required' | 'ids' | 'refused' | 'preservation';
 type Severity = 'fatal' | 'warning';
@@ -104,17 +67,12 @@ interface Rule {
   /** Why the rule exists, for whoever is about to argue with it. */
   readonly why: string;
   /**
-   * True when the rule needs the package as it was opened as well as the
-   * package about to be written.
-   *
-   * Six rules do. They are skipped rather than passed when no baseline is
-   * given, and the report says so - a preservation rule that silently reports
-   * nothing because it had nothing to compare against is worse than one that
-   * did not run, because it looks like a pass.
+   * True when the rule needs the package as it was opened; without a baseline it is reported as
+   * skipped, never as passed.
    */
   readonly needsBaseline?: true;
 }
-declare const RULES: readonly [{
+export declare const RULES: readonly [{
   readonly id: "V001";
   readonly category: "package";
   readonly severity: "fatal";
@@ -334,12 +292,26 @@ declare const RULES: readonly [{
   readonly evidence: "both";
   readonly title: "`a:gridCol/@w`, `a:tr/@h`, and typed `gridSpan`, `rowSpan`, `hMerge`, `vMerge`";
   readonly why: string;
+}, {
+  readonly id: "V032";
+  readonly category: "ids";
+  readonly severity: "warning";
+  readonly evidence: "measured";
+  readonly title: "a table names one of PowerPoint's 74 built-in table styles, or none";
+  readonly why: string;
+}, {
+  readonly id: "V033";
+  readonly category: "required";
+  readonly severity: "fatal";
+  readonly evidence: "both";
+  readonly title: "a table style id is a braced GUID, and the table-style part is one PowerPoint keeps";
+  readonly why: string;
 }];
 type RuleId = (typeof RULES)[number]['id'];
-declare function ruleById(id: string): Rule | undefined;
-declare const RULE_IDS: readonly RuleId[];
+export declare function ruleById(id: string): Rule | undefined;
+export declare const RULE_IDS: readonly RuleId[];
 /** Rules that need the package as it was opened. See `Rule.needsBaseline`. */
-declare const BASELINE_RULES: readonly RuleId[];
+export declare const BASELINE_RULES: readonly RuleId[];
 //#endregion
 //#region src/report/location.d.ts
 /**
@@ -397,9 +369,9 @@ interface Location {
   readonly offset: number | null;
 }
 /** A location that names a part and nothing inside it. */
-declare function partLocation(part: string): Location;
+export declare function partLocation(part: string): Location;
 /** The location of the package itself: the archive, the content types, the graph. */
-declare const PACKAGE_LOCATION: Location;
+export declare const PACKAGE_LOCATION: Location;
 /**
  * The XPath of an element, from the document root.
  *
@@ -408,11 +380,11 @@ declare const PACKAGE_LOCATION: Location;
  * finding built from a node the caller synthesised is degraded rather than
  * lost.
  */
-declare function xpathOf(element: XElement): string;
+export declare function xpathOf(element: XElement): string;
 /** The XPath of an attribute: its owner's path, then `/@qname`. */
-declare function xpathOfAttribute(owner: XElement, attr: XAttribute | string): string;
+export declare function xpathOfAttribute(owner: XElement, attr: XAttribute | string): string;
 /** A location for an element inside a named part. */
-declare function elementLocation(part: string, element: XElement): Location;
+export declare function elementLocation(part: string, element: XElement): Location;
 /**
  * A location for one attribute of an element.
  *
@@ -420,7 +392,7 @@ declare function elementLocation(part: string, element: XElement): Location;
  * element's start when it does not - which is the case that matters, because a
  * *missing* required attribute is a finding and it has to point somewhere.
  */
-declare function attributeLocation(part: string, element: XElement, qname: string): Location;
+export declare function attributeLocation(part: string, element: XElement, qname: string): Location;
 /**
  * `line:column` for an offset, 1-based, or `null`.
  *
@@ -429,44 +401,20 @@ declare function attributeLocation(part: string, element: XElement, qname: strin
  * hundred times. Callers that render a report for a human ask for it once, at
  * the point of rendering, for the findings they are about to show.
  */
-declare function lineColumn(source: string, offset: number): {
+export declare function lineColumn(source: string, offset: number): {
   line: number;
   column: number;
 };
 /** Document order, for sorting findings within a part. */
-declare function inDocumentOrder(a: XNode, b: XNode): number;
+export declare function inDocumentOrder(a: XNode, b: XNode): number;
 /** The root element's qname, for the handful of rules that dispatch on it. */
-declare function rootName(document: XDocument): string;
+export declare function rootName(document: XDocument): string;
 //#endregion
 //#region src/report/report.d.ts
 /**
- * What validation produces.
- *
- * ## Origin, and why it is computed rather than guessed
- *
- * The hardest question this package has to answer is not "is this file valid".
- * It is **"did we break it"**, and those are different questions with different
- * consequences. A fatal finding in a deck the user imported ten seconds ago is
- * information; the same finding in a deck they just edited is a bug in us, and
- * handing over the bytes would give them a repair prompt with no explanation.
- *
- * Refusing both would be the strict-looking choice and it is the wrong one. It
- * would mean that a deck with one pre-existing defect - a dangling image
- * relationship, say, which PowerPoint tolerates and which is common in files
- * that have been through three other tools - could be opened in this editor and
- * never saved again. The editor would be refusing to give the user back their
- * own file over a problem it did not cause and cannot fix. `PartStore.write`
- * already made exactly this call for dangling relationships, and this is the
- * same call generalised to all thirty-one rules.
- *
- * So `origin` is not a per-rule judgement call. It is computed by running the
- * rules a second time against the package **as it was opened** and differencing
- * the two reports: a finding that is in both is `inherited`, one that is only in
- * the new report is `introduced`. That is exact, it needs no rule to reason
- * about history, and it cannot drift from what the rules actually do.
- *
- * The second pass only happens when the first found something fatal, so a clean
- * export - the overwhelmingly common case - pays nothing for it.
+ * A finding is `inherited` when the package as it was opened already had it, `introduced` when it
+ * did not, computed by running the rules on both and differencing. Only an introduced fatal refuses
+ * an export, so a deck with a defect it arrived with can still be saved.
  */
 type Origin =
 /** The finding is in the package we are about to write and was not in the original. */
@@ -528,14 +476,14 @@ interface Report {
  * the same place with different values are different findings, and treating
  * them as one would let an introduced defect hide behind an inherited one.
  */
-declare function findingKey(finding: Finding): string;
-declare function buildReport(input: {
+export declare function findingKey(finding: Finding): string;
+export declare function buildReport(input: {
   readonly findings: readonly Finding[];
   readonly checked: readonly RuleId[];
   readonly skipped: readonly SkippedRule[];
   readonly problems: readonly ReadProblem[];
 }): Report;
-declare function isReport(value: unknown): value is Report;
+export declare function isReport(value: unknown): value is Report;
 interface FormatOptions {
   /** Include `inherited` findings. Default true. */
   readonly inherited?: boolean;
@@ -551,32 +499,13 @@ interface FormatOptions {
  * "what is wrong with this file", and a file is a set of parts. Grouping by
  * rule is the right shape for the corpus gate and the wrong one here.
  */
-declare function formatReport(report: Report, options?: FormatOptions): string;
+export declare function formatReport(report: Report, options?: FormatOptions): string;
 //#endregion
 //#region src/context.d.ts
 /**
- * The state a rule reads, and the one method it writes.
- *
- * Every rule is `(ctx: Context) => void`. That is a deliberately small
- * interface, and it is the same shape `checkLayering({manifests, catalog})` and
- * `checkCorpus({manifests, files, ...})` already have in this repository, for
- * the same reason: a rule that takes a context and returns nothing is a rule
- * that can be run against a package assembled in a test, with no temporary
- * directory, no archive on disk and no other twenty-eight rules running beside
- * it obscuring which one fired.
- *
- * ## Everything is lazy, and everything is cached
- *
- * Twelve of the rules want the parsed tree of every XML part. Parsing each part
- * once per rule would be twelve passes over a deck that can be two hundred
- * megabytes. Parsing all of them up front would be one pass too many for the
- * package-level rules, which need no trees at all.
- *
- * So `document()` parses on first ask and remembers. A part that is not XML
- * returns `null` and is not asked again. A part that will not *parse* also
- * returns `null` - and records a `ReadProblem`, because a rule that silently
- * saw nothing is indistinguishable from a rule that found nothing, and those
- * are opposite answers.
+ * The state a rule reads, and the one method it writes. Every rule is `(ctx: Context) => void`,
+ * so one runs alone against a package built in a test. Trees parse on first ask and are cached;
+ * a part that will not parse returns `null` and records a `ReadProblem`.
  */
 interface Context {
   /** The package about to be handed over, or the one being inspected. */
@@ -665,7 +594,7 @@ declare class RuntimeContext implements Context {
   add(rule: RuleId, where: Location, message: string): void;
   problem(part: string, message: string): void;
 }
-declare function createContext(input: ContextInput): RuntimeContext;
+export declare function createContext(input: ContextInput): RuntimeContext;
 //#endregion
 //#region src/validate.d.ts
 interface ValidateOptions {
@@ -688,11 +617,11 @@ interface ValidateOptions {
    * those are skipped and the report says so.
    */
   readonly bytes?: Uint8Array;
-  /** The package as it was opened. The six preservation rules need it. */
+  /** The package as it was opened. The preservation rules need it. */
   readonly baseline?: PartStore;
   /** The baseline's archive, so an inherited `V003` can be recognised as inherited. */
   readonly baselineBytes?: Uint8Array;
-  /** A subset to run. Defaults to all twenty-nine. */
+  /** A subset to run. Defaults to every rule. */
   readonly rules?: readonly RuleId[];
   /** Passed to `readZip` when `bytes` are given. */
   readonly zip?: ReadZipOptions;
@@ -704,7 +633,7 @@ interface ValidateOptions {
  * findings in it, which is the shape a caller can render. It throws only when
  * it was handed something it cannot open at all.
  */
-declare function validatePackage(options: ValidateOptions): Report;
+export declare function validatePackage(options: ValidateOptions): Report;
 /**
  * Validate, and refuse to go on if we broke something.
  *
@@ -715,7 +644,7 @@ declare function validatePackage(options: ValidateOptions): Report;
  * feedback loop that exists, and a caller who forgot to check a return value
  * would have removed it.
  */
-declare function assertValid(options: ValidateOptions): Report;
+export declare function assertValid(options: ValidateOptions): Report;
 //#endregion
-export { BASELINE_RULES, type Context, type ContextInput, type Evidence, type Finding, type FormatOptions, type Location, type Origin, PACKAGE_LOCATION, RULES, RULE_IDS, type ReadProblem, type Report, type Rule, type RuleCategory, type RuleId, type Severity, type SkippedRule, VALIDATE_ERROR_CODES, ValidateError, type ValidateErrorCode, type ValidateErrorDetail, type ValidateOptions, assertValid, attributeLocation, buildReport, createContext, elementLocation, findingKey, formatReport, inDocumentOrder, isReport, isValidateError, lineColumn, partLocation, rootName, ruleById, validatePackage, xpathOf, xpathOfAttribute };
+export type { Context, ContextInput, Evidence, Finding, FormatOptions, Location, Origin, ReadProblem, Report, Rule, RuleCategory, RuleId, Severity, SkippedRule, ValidateErrorCode, ValidateErrorDetail, ValidateOptions };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/errors.ts","../src/rules/rules.ts","../src/report/location.ts","../src/report/report.ts","../src/context.ts","../src/validate.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/errors.ts","../src/rules/rules.ts","../src/report/location.ts","../src/report/report.ts","../src/context.ts","../src/validate.ts"],"mappings":"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"}