@openpresentation/opf-pptx 0.13.1 → 0.14.0

package/dist/timeline-provenance.js

@@ -1,8 +1,9 @@
 import {XMLParser} from 'fast-xml-parser';
-import {validatePresentation} from '@openpresentation/opf';
+import {isValidFormat} from './format-check.js';
 import {attachTextTags,decodeTextTag} from './code-provenance.js';
 import {sourceLineParagraphs} from './text-provenance.js';
 
+const STATUSES=['done','current','planned'];
 const TAG='OPF_TIMELINE_V1',REL='http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags';
 const parser=new XMLParser({ignoreAttributes:false,attributeNamePrefix:'',parseTagValue:false,trimValues:false});
 const decoder=new TextDecoder('utf-8',{fatal:true}),array=value=>value===undefined?[]:Array.isArray(value)?value:[value];
@@ -49,16 +50,22 @@ export function importTimelineGroups(shapes,paragraphs,relationships,entries,rep
   for(const group of groups.values())try{
     const anchors=group.filter(item=>item.data.anchor!==undefined);if(anchors.length!==1)throw Error('Missing or duplicated timeline anchor.');
     const anchor=anchors[0],manifest=anchor.data.anchor,count=validateManifest(manifest);
-    const total=count+manifest.eventCount+1;
+    // A current event's ring is a second native ellipse with its own tag, so the group has one more shape per ring.
+    const total=count+manifest.eventCount+1+group.filter(item=>item.data.role==='ring').length;
     if(anchor.data.role!=='text'||anchor.data.part!==0||anchor.data.line!==0||group.length!==total||new Set(group.map(item=>item.shape)).size!==total)throw Error('Incomplete or duplicated timeline elements.');
-    const ordered=manifest.parts.map(part=>Array(part.lines)),markers=new Set();let connectors=0;
+    const ordered=manifest.parts.map(part=>Array(part.lines)),markers=new Set(),rings=new Set(),statuses=new Map();let connectors=0;
     for(const item of group){
       if(item.ambiguous)throw Error('Multiple source identities on one timeline shape.');
-      if(item.data.role==='connector'||item.data.role==='marker'){
+      if(item.data.role==='connector'||item.data.role==='marker'||item.data.role==='ring'){
         const expected=item.data.role==='connector'?'line':'ellipse';
         if(item.shape['p:spPr']?.['a:prstGeom']?.prst!==expected||(paragraphs[item.index]??[]).some(paragraph=>paragraph.text||paragraph.bullet))throw Error('Timeline graphic now contains different geometry or native text.');
         if(item.data.role==='connector'){if(++connectors>1)throw Error('Duplicated timeline connector.');}
-        else{const index=item.data.eventIndex;if(!Number.isSafeInteger(index)||index<0||index>=manifest.eventCount||markers.has(index))throw Error('Ambiguous timeline marker.');markers.add(index);}
+        else{
+          const index=item.data.eventIndex,known=item.data.role==='marker'?markers:rings;
+          if(!Number.isSafeInteger(index)||index<0||index>=manifest.eventCount||known.has(index))throw Error('Ambiguous timeline marker.');
+          known.add(index);
+          if(item.data.role==='marker'&&item.data.status!==undefined){if(!STATUSES.includes(item.data.status))throw Error('Invalid timeline event status.');statuses.set(index,item.data.status);}
+        }
         continue;
       }
       const {part,line}=item.data;
@@ -66,13 +73,17 @@ export function importTimelineGroups(shapes,paragraphs,relationships,entries,rep
       ordered[part][line]=item;
     }
     if(connectors!==1||markers.size!==manifest.eventCount)throw Error('Incomplete timeline graphics.');
+    // Only a current event has a ring, and every current event has one.
+    for(const index of rings)if(statuses.get(index)!=='current')throw Error('Timeline ring without a current event.');
+    for(const [index,status] of statuses)if(status==='current'&&!rings.has(index))throw Error('Current timeline event without its ring.');
     const result={events:Array.from({length:manifest.eventCount},()=>({}))};
     for(const [index,part]of manifest.parts.entries()){
       const text=sourceLineParagraphs(ordered[index],paragraphs)[0].text;
       if(part.eventIndex===undefined)result[part.field]=text;else result.events[part.eventIndex][part.field]=text;
     }
+    for(const [index,status] of statuses)result.events[index].status=status;
     const timeline=manifest.shorthand?result.events:result;
-    if(!validatePresentation({slides:[{timeline}]}).valid)throw Error('Current native text does not form a valid timeline.');
+    if(!isValidFormat({slides:[{timeline}]}))throw Error('Current native text does not form a valid timeline.');
     for(const item of group)consumed.add(item.shape);
     items.push({shapes:group.map(item=>item.shape),payload:{type:'timeline',timeline}});
     report({code:'timeline-import-reflow',message:'Timeline field order, source boundaries and current native text were recovered. Native formatting, positions, marker styling and font theme are not reconstructed; review the reflowed timeline.'});

package/dist/typeface-inventory.js

@@ -7,7 +7,7 @@ import {unzipSync} from 'fflate';
 // DrawingML `typeface` attributes (latin, ea, cs, sym, buFont, theme script
 // supplements, embedded-font lists), SpreadsheetML font names (styles `name`,
 // rich-text `rFont`) and the docProps/app.xml "Fonts Used" list.
-// checkPptxTypefaces() then applies the owner font policy: a package names only
+// checkTypefaces() then applies the owner font policy: a package names only
 // the fonts its author chose, plus theme references that resolve to them, empty
 // theme script slots when no script font was selected (as in Office's themes; FF-49 checks a selected slot through options.themeScripts) and the documented theme script supplements.
 
@@ -33,7 +33,7 @@ export const THEME_SCRIPT_SUPPLEMENTS = Object.freeze({
   minor: supplement(`Jpan=游ゴシック|Hans=等线|Arab=Arial|Hebr=Arial|Thai=Cordia New|Khmr=DaunPenh|Viet=Arial|${SHARED_SCRIPTS}`)
 });
 
-export function inventoryPptxTypefaces(input, options = {}) {
+export function inventoryTypefaces(input, options = {}) {
   const typefaces = [];
   const themes = {};
   // Every theme part's fonts, and the theme each part of the presentation package resolves its references against.
@@ -90,15 +90,15 @@ export function packageFontsUsed(inventory) {
   return [...used].sort(compareFontNames);
 }
 
-export function checkPptxTypefaces(input, options = {}) {
-  if (!Array.isArray(options.fonts) || options.fonts.some(font => typeof font !== 'string' || !font)) {
-    throw new TypeError('checkPptxTypefaces requires options.fonts, the non-empty family names the author chose.');
+export function checkTypefaces(input, options = {}) {
+  if (!Array.isArray(options.families) || options.families.some(family => typeof family !== 'string' || !family)) {
+    throw new TypeError('checkTypefaces requires options.families, the non-empty family names the author chose.');
   }
-  const chosen = new Set(options.fonts);
+  const chosen = new Set(options.families);
   const monospace = new Set(options.monospace ?? []);
   const allowEmpty = options.allowEmptyThemeScripts ?? true;
   const supplements = options.scriptSupplements ?? THEME_SCRIPT_SUPPLEMENTS;
-  const inventory = inventoryPptxTypefaces(input);
+  const inventory = inventoryTypefaces(input);
   const violations = [];
   const fail = (entry, reason, details = {}) => violations.push({reason, part: entry.part, element: entry.element, typeface: entry.typeface, ...details});
   const emptyAllowed = entry => allowEmpty && entry.theme && (entry.element === 'ea' || entry.element === 'cs');

package/dist/watermark-provenance.js

@@ -19,6 +19,8 @@ const canonical = value => JSON.stringify(value, (_key, item) => item && typeof
   ? Object.fromEntries(Object.keys(item).sort().filter(key => !(key === '#text' && typeof item[key] === 'string' && !item[key].trim())).map(key => [key, item[key]])) : item);
 
 export const watermarkName = () => 'OPF watermark';
+// FA-13: a text watermark is one native text box (a p:sp), not a picture.
+export const watermarkTextName = () => 'OPF watermark text';
 
 // The preview's frame: x/y at 30% and a 40% by 40% box, in the slide's units.
 export const watermarkBox = (width, height) => ({x: width * .3, y: height * .3, w: width * .4, h: height * .4});
@@ -80,6 +82,7 @@ function attachTags(entries, manifests) {
   const NS = 'http://schemas.openxmlformats.org/presentationml/2006/main', types = [];
   let count = 0;
   for (const [part, manifest] of manifests) {
+    const element = manifest.kind === 'text' ? 'sp' : 'pic', name = manifest.kind === 'text' ? watermarkTextName() : watermarkName();
     const relPath = part.replace('/slides/', '/slides/_rels/') + '.rels';
     const rels = decoder.decode(entries[relPath]);
     const ids = new Set([...rels.matchAll(/\bId="([^"]+)"/g)].map(match => match[1]));
@@ -90,11 +93,11 @@ function attachTags(entries, manifests) {
     types.push(`<Override PartName="/${tagPart}" ContentType="application/vnd.openxmlformats-officedocument.presentationml.tags+xml"/>`);
     entries[relPath] = encoder.encode(rels.replace('</Relationships>', `<Relationship Id="${id}" Type="${REL}" Target="../tags/opfWatermark${count}.xml"/></Relationships>`));
     let attached = false;
-    const xml = decoder.decode(entries[part]).replace(/<p:pic>[\s\S]*?<\/p:pic>/g, picture => {
-      if (attached || picture.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1] !== watermarkName()) return picture;
+    const xml = decoder.decode(entries[part]).replace(new RegExp(`<p:${element}>[\\s\\S]*?</p:${element}>`, 'g'), picture => {
+      if (attached || picture.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1] !== name) return picture;
       attached = true;
       picture = picture.replace(/<p:nvPr\s*\/>/, '<p:nvPr></p:nvPr>');
-      if (!picture.includes('</p:nvPr>')) throw new Error('Generated watermark picture has no native application properties.');
+      if (!picture.includes('</p:nvPr>')) throw new Error('Generated watermark shape has no native application properties.');
       return picture.replace('</p:nvPr>', `<p:custDataLst><p:tags r:id="${id}"/></p:custDataLst></p:nvPr>`);
     });
     entries[part] = encoder.encode(xml);
@@ -102,6 +105,28 @@ function attachTags(entries, manifests) {
   entries['[Content_Types].xml'] = encoder.encode(decoder.decode(entries['[Content_Types].xml']).replace('</Types>', types.join('') + '</Types>'));
 }
 
+/**
+ * Bind each generated text watermark box to its manifest with a native tag.
+ * marks: Map<slidePart, {slide, text, opacity}>. The manifest records the text and the exact native geometry
+ * (position, size and rotation), so an unchanged box imports back as design.watermark.
+ */
+export function tagTextWatermarks(entries, marks) {
+  if (!marks.size) return;
+  const manifests = new Map();
+  for (const part of Object.keys(entries).filter(path => /^ppt\/slides\/slide\d+\.xml$/.test(path))) {
+    const mark = marks.get(part);
+    if (!mark) continue;
+    let found = 0;
+    for (const shape of decoder.decode(entries[part]).match(/<p:sp>[\s\S]*?<\/p:sp>/g) ?? []) {
+      if (shape.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1] !== watermarkTextName()) continue;
+      found++;
+      manifests.set(part, {v: 1, kind: 'text', slide: mark.slide, text: mark.text, opacity: mark.opacity, properties: parser.parse(shape)['p:sp']['p:spPr']});
+    }
+    if (found !== 1) throw new Error('Missing generated watermark text box.');
+  }
+  attachTags(entries, manifests);
+}
+
 function readTags(container, relationships, entries) {
   const tags = [];
   let unreadable = false;
@@ -113,6 +138,43 @@ function readTags(container, relationships, entries) {
   return {tags, unreadable};
 }
 
+/**
+ * Recover a text design.watermark from an unchanged tagged text box. paragraphs[index] are the native paragraphs of
+ * shapes[index]. Returns the consumed shape indexes and the slide design fields to restore. A box whose text, position,
+ * size or rotation changed stays an ordinary text box and is reported.
+ */
+export function importTextWatermark(shapes, paragraphs, relationships, entries, slideIndex, report) {
+  const consumed = new Set(), found = [];
+  for (const [index, shape] of shapes.entries()) {
+    const {tags, unreadable} = readTags(shape['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst'], relationships, entries);
+    const own = tags.filter(tag => tag.name?.toUpperCase() === TAG);
+    if (!own.length) continue;
+    // The picture watermark has the same tag name; a picture's manifest has no kind and is read by importWatermark.
+    let kind;
+    try { kind = decodeTextTag(own[0].val)?.kind; } catch { kind = undefined; }
+    if (kind !== 'text') continue;
+    found.push({index, shape, own, unreadable, others: tags.some(tag => /^OPF_/i.test(tag.name) && tag.name.toUpperCase() !== TAG)});
+  }
+  if (!found.length) return {consumed};
+  const invalid = () => report({code: 'invalid-watermark-provenance', message: 'An edited, ambiguous or invalid tagged OPF watermark was imported as ordinary text. It is not reconstructed as design.watermark.'});
+  if (found.length > 1) { invalid(); return {consumed}; }
+  const [{index, shape, own, unreadable, others}] = found;
+  try {
+    if (unreadable || others || own.length !== 1) throw Error('Ambiguous watermark identity.');
+    const manifest = decodeTextTag(own[0].val);
+    if (manifest?.v !== 1 || manifest.kind !== 'text' || manifest.slide !== `slides.${slideIndex}` || typeof manifest.text !== 'string' || !manifest.text
+      || typeof manifest.opacity !== 'number' || !(manifest.opacity >= 0 && manifest.opacity <= 1)) throw Error('Invalid watermark manifest.');
+    if (shape['p:nvSpPr']?.['p:cNvPr']?.name !== watermarkTextName()) throw Error('Watermark identity changed.');
+    if (canonical(shape['p:spPr']) !== canonical(manifest.properties)) throw Error('Watermark geometry changed.');
+    if ((paragraphs[index] ?? []).map(paragraph => paragraph.text).join('\n') !== manifest.text) throw Error('Watermark text changed.');
+    consumed.add(index);
+    return {consumed, design: {watermark: {text: manifest.text, opacity: manifest.opacity}}};
+  } catch {
+    invalid();
+    return {consumed};
+  }
+}
+
 /**
  * Recover design.watermark from an unchanged tagged picture. Returns the
  * consumed picture indexes and the slide design fields to restore.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -65,15 +65,15 @@
   },
   "dependencies": {
     "@node-projects/jszip": "4.3.0",
-    "@openpresentation/opf": "^0.13.0",
+    "@openpresentation/opf": "^0.14.0",
     "@rgrove/parse-xml": "4.2.3",
     "fast-xml-parser": "^5.8.0",
     "fflate": "^0.8.3",
     "pako": "3.0.2",
-    "sharp": "0.35.4"
+    "sharp": "0.35.5"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.13.0"
+    "@openpresentation/opf-render": "^0.14.0"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -82,7 +82,7 @@
   },
   "devDependencies": {
     "@expo-google-fonts/carlito": "0.4.1",
-    "@openpresentation/opf-render": "0.13.0",
+    "@openpresentation/opf-render": "0.14.0",
     "esbuild": "0.28.2",
     "playwright": "1.63.0"
   },