@openpresentation/opf 0.10.1 → 0.11.0

package/dist/{chunk-ZIL7MGZU.js → chunk-CHKJ4QHQ.js}

@@ -1,9 +1,89 @@
-import { MAX_COMPOSITION_DEPTH, tableGrid } from './chunk-PQJRDNA6.js';
-import { schemas, schemaEntries } from './chunk-D3GQIREP.js';
-import { catalogSchemaNames } from './chunk-TU7I3KSB.js';
+import { MAX_COMPOSITION_DEPTH, tableGrid } from './chunk-FTWNWFIV.js';
+import { schemas, schemaEntries } from './chunk-GN52EE3P.js';
+import { catalogSchemaNames } from './chunk-6FU2KICU.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
 
+// src/content-walk.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pathFor(parentPath, key) {
+  return parentPath === "/" ? `/${key}` : `${parentPath}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`;
+}
+var bareIdPattern = /^[a-z0-9][a-z0-9-]*$/;
+var promotedRegionKeys = [
+  "left",
+  "center",
+  "right",
+  "left+center",
+  "center+right",
+  "left+center+right",
+  "top",
+  "middle",
+  "bottom",
+  "top+middle",
+  "middle+bottom",
+  "top+middle+bottom",
+  "top:left",
+  "top:center",
+  "top:right",
+  "top:left+center",
+  "top:center+right",
+  "top:left+center+right",
+  "middle:left",
+  "middle:center",
+  "middle:right",
+  "middle:left+center",
+  "middle:center+right",
+  "middle:left+center+right",
+  "bottom:left",
+  "bottom:center",
+  "bottom:right",
+  "bottom:left+center",
+  "bottom:center+right",
+  "bottom:left+center+right",
+  "top+middle:left",
+  "top+middle:center",
+  "top+middle:right",
+  "top+middle:left+center",
+  "top+middle:center+right",
+  "top+middle:left+center+right",
+  "middle+bottom:left",
+  "middle+bottom:center",
+  "middle+bottom:right",
+  "middle+bottom:left+center",
+  "middle+bottom:center+right",
+  "middle+bottom:left+center+right",
+  "top+middle+bottom:left",
+  "top+middle+bottom:center",
+  "top+middle+bottom:right",
+  "top+middle+bottom:left+center",
+  "top+middle+bottom:center+right",
+  "top+middle+bottom:left+center+right"
+];
+function visitContentPayloads(slide, slidePath, visit) {
+  const walk = (payload, path, depth, ancestors) => {
+    visit(payload, path);
+    if (!Array.isArray(payload.blocks) || depth >= MAX_COMPOSITION_DEPTH || ancestors.includes(payload)) return;
+    const nested = [...ancestors, payload];
+    const blocksPath = pathFor(path, "blocks");
+    payload.blocks.forEach((block, index) => {
+      if (isRecord(block)) walk(block, `${blocksPath}/${index}`, depth + 1, nested);
+    });
+  };
+  if (Array.isArray(slide.blocks)) {
+    const blocksPath = pathFor(slidePath, "blocks");
+    slide.blocks.forEach((block, index) => {
+      if (isRecord(block)) walk(block, `${blocksPath}/${index}`, 0, []);
+    });
+  }
+  for (const key of promotedRegionKeys) {
+    const region = slide[key];
+    if (isRecord(region)) walk(region, pathFor(slidePath, key), 0, []);
+  }
+}
+
 // src/generated/catalog-ids.ts
 var catalogIds = {
   audiences: [
@@ -466,56 +546,6 @@ var OPFValidationError = class extends Error {
 var schemaNameByCatalogKind = catalogSchemaNames;
 var ajv;
 var dynamicSchemaCache = /* @__PURE__ */ new WeakMap();
-var promotedRegionKeys = [
-  "left",
-  "center",
-  "right",
-  "left+center",
-  "center+right",
-  "left+center+right",
-  "top",
-  "middle",
-  "bottom",
-  "top+middle",
-  "middle+bottom",
-  "top+middle+bottom",
-  "top:left",
-  "top:center",
-  "top:right",
-  "top:left+center",
-  "top:center+right",
-  "top:left+center+right",
-  "middle:left",
-  "middle:center",
-  "middle:right",
-  "middle:left+center",
-  "middle:center+right",
-  "middle:left+center+right",
-  "bottom:left",
-  "bottom:center",
-  "bottom:right",
-  "bottom:left+center",
-  "bottom:center+right",
-  "bottom:left+center+right",
-  "top+middle:left",
-  "top+middle:center",
-  "top+middle:right",
-  "top+middle:left+center",
-  "top+middle:center+right",
-  "top+middle:left+center+right",
-  "middle+bottom:left",
-  "middle+bottom:center",
-  "middle+bottom:right",
-  "middle+bottom:left+center",
-  "middle+bottom:center+right",
-  "middle+bottom:left+center+right",
-  "top+middle+bottom:left",
-  "top+middle+bottom:center",
-  "top+middle+bottom:right",
-  "top+middle+bottom:left+center",
-  "top+middle+bottom:center+right",
-  "top+middle+bottom:left+center+right"
-];
 var promotedRegionKeySet = new Set(promotedRegionKeys);
 var rootPayloadFields = [
   "type",
@@ -655,18 +685,12 @@ function semanticIssue(path, message, params = {}) {
     params
   };
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function hasOwn(value, key) {
   return Object.hasOwn(value, key);
 }
 function isEnUkTag(value) {
   return typeof value === "string" && value.toLowerCase() === "en-uk";
 }
-function pathFor(parentPath, key) {
-  return parentPath === "/" ? `/${key}` : `${parentPath}/${key.replaceAll("~", "~0").replaceAll("/", "~1")}`;
-}
 function presentFields(value, fields) {
   return fields.filter((field) => hasOwn(value, field));
 }
@@ -839,27 +863,32 @@ function validatePresentationSemantics(value) {
       replacement: "en-GB"
     }));
   }
-  const slideIds = /* @__PURE__ */ new Set();
+  const documentIds = /* @__PURE__ */ new Map();
   value.slides.forEach((slide, index) => {
     if (isRecord(slide)) {
+      const slidePath = `/slides/${index}`;
       if (typeof slide.id === "string") {
-        if (slideIds.has(slide.id)) issues.push(semanticIssue(`/slides/${index}/id`, "slide ids must be unique within a presentation", { id: slide.id }));
-        slideIds.add(slide.id);
+        const seen = documentIds.get(slide.id);
+        if (seen === "slide") issues.push(semanticIssue(`${slidePath}/id`, "slide ids must be unique within a presentation", { id: slide.id }));
+        else if (seen === "payload") issues.push(semanticIssue(`${slidePath}/id`, "slide id duplicates a content payload id; ids must be unique among slide and payload ids within a presentation", { id: slide.id }));
+        else documentIds.set(slide.id, "slide");
       }
-      issues.push(...validateSlideRegions(slide, `/slides/${index}`));
-      const visitTables = (node, path) => {
-        if (isRecord(node.table)) for (const issue of tableGrid(node.table).issues) issues.push(semanticIssue(pathFor(path, "table") + issue.path.slice(5).replaceAll(".", "/"), issue.message));
-        if (Array.isArray(node.blocks)) node.blocks.forEach((block, i) => {
-          if (isRecord(block)) visitTables(block, `${path}/blocks/${i}`);
-        });
-        for (const key of promotedRegionKeys) if (isRecord(node[key])) visitTables(node[key], pathFor(path, key));
+      visitContentPayloads(slide, slidePath, (payload, path) => {
+        if (typeof payload.id === "string") {
+          if (documentIds.has(payload.id)) issues.push(semanticIssue(`${path}/id`, "content payload ids must be unique among slide and payload ids within a presentation", { id: payload.id }));
+          else documentIds.set(payload.id, "payload");
+        }
+      });
+      issues.push(...validateSlideRegions(slide, slidePath));
+      const payloadTableIssues = (payload, path) => {
+        if (isRecord(payload.table)) for (const issue of tableGrid(payload.table).issues) issues.push(semanticIssue(pathFor(path, "table") + issue.path.slice(5).replaceAll(".", "/"), issue.message));
       };
-      visitTables(slide, `/slides/${index}`);
+      payloadTableIssues(slide, slidePath);
+      visitContentPayloads(slide, slidePath, payloadTableIssues);
     }
   });
   return issues;
 }
-var bareIdPattern = /^[a-z0-9][a-z0-9-]*$/;
 function inlineCatalogEntry(context, kind) {
   const catalogsField = context.document.catalogs;
   if (!isRecord(catalogsField)) {
@@ -878,7 +907,7 @@ function unknownIdWarning(kind, value, path, context) {
       if (Array.isArray(entry.records) && entry.records.some((record) => isRecord(record) && record.id === value)) {
         return void 0;
       }
-      if (typeof entry.source === "string") {
+      if (typeof entry.source === "string" || Array.isArray(entry.source) && entry.source.length > 0) {
         return void 0;
       }
     }
@@ -932,6 +961,126 @@ function chartTypeWarnings(payload, path, context) {
   }
   return issues;
 }
+var cellBorderEdges = ["top", "right", "bottom", "left"];
+var variableIdPattern = /^[a-z][a-z0-9-]*$/;
+var hexColorPattern = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+var schemeColorNames = /* @__PURE__ */ new Set([
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "dark1",
+  "dark2",
+  "light1",
+  "light2",
+  "hyperlink",
+  "followedHyperlink",
+  "primary",
+  "secondary",
+  "accent",
+  "background",
+  "surface",
+  "text",
+  "textSecondary"
+]);
+function variableReferenceWarnings(value) {
+  if (!Array.isArray(value.slides)) {
+    return [];
+  }
+  const variables = isRecord(value.variables) ? value.variables : {};
+  const issues = [];
+  const colorRef = (entry, path) => {
+    if (typeof entry !== "string" || !entry.startsWith("var:")) return;
+    const id = entry.slice("var:".length);
+    if (!variableIdPattern.test(id) || hasOwn(variables, id)) return;
+    issues.push(semanticIssue(path, `unknown variable '${id}'; declare it in the top-level variables map`, { id }));
+  };
+  const runColor = (entry, path) => {
+    if (typeof entry !== "string") return;
+    if (hexColorPattern.test(entry) || schemeColorNames.has(entry)) return;
+    if (entry.startsWith("var:") && variableIdPattern.test(entry.slice("var:".length))) {
+      colorRef(entry, path);
+      return;
+    }
+    issues.push(semanticIssue(
+      path,
+      `run color '${entry}' is not a hex color, a color-scheme name, or a 'var:' reference; renderers fall back to the theme color`,
+      { color: entry }
+    ));
+  };
+  const richText = (entry, path) => {
+    if (!Array.isArray(entry)) return;
+    entry.forEach((run, index) => {
+      if (isRecord(run)) runColor(run.color, `${path}/${index}/color`);
+    });
+  };
+  const cellStyle = (style, path) => {
+    if (!isRecord(style)) return;
+    colorRef(style.fill, pathFor(path, "fill"));
+    colorRef(style.color, pathFor(path, "color"));
+    if (!isRecord(style.borders)) return;
+    const bordersPath = pathFor(path, "borders");
+    for (const edge of cellBorderEdges) {
+      const border = style.borders[edge];
+      if (isRecord(border)) colorRef(border.color, `${pathFor(bordersPath, edge)}/color`);
+    }
+  };
+  const tableCell = (cell, path) => {
+    if (Array.isArray(cell)) {
+      richText(cell, path);
+      return;
+    }
+    if (!isRecord(cell)) return;
+    richText(cell.value, pathFor(path, "value"));
+    cellStyle(cell.style, pathFor(path, "style"));
+  };
+  const table = (node, path) => {
+    if (!isRecord(node)) return;
+    if (Array.isArray(node.columns)) {
+      const columnsPath = pathFor(path, "columns");
+      node.columns.forEach((column, index) => {
+        tableCell(column, `${columnsPath}/${index}`);
+      });
+    }
+    if (Array.isArray(node.rows)) {
+      const rowsPath = pathFor(path, "rows");
+      node.rows.forEach((row, rowIndex) => {
+        if (!Array.isArray(row)) return;
+        row.forEach((cell, cellIndex) => {
+          tableCell(cell, `${rowsPath}/${rowIndex}/${cellIndex}`);
+        });
+      });
+    }
+  };
+  const textEntries = (entries, path) => {
+    if (!Array.isArray(entries)) return;
+    entries.forEach((entry, index) => {
+      const entryPath = `${path}/${index}`;
+      if (Array.isArray(entry)) {
+        richText(entry, entryPath);
+        return;
+      }
+      if (!isRecord(entry)) return;
+      richText(entry.text, pathFor(entryPath, "text"));
+      richText(entry.description, pathFor(entryPath, "description"));
+    });
+  };
+  const payload = (node, path) => {
+    richText(node.text, pathFor(path, "text"));
+    textEntries(node.items, pathFor(path, "items"));
+    textEntries(node.bullets, pathFor(path, "bullets"));
+    table(node.table, pathFor(path, "table"));
+  };
+  value.slides.forEach((slide, index) => {
+    if (!isRecord(slide)) return;
+    const slidePath = `/slides/${index}`;
+    payload(slide, slidePath);
+    visitContentPayloads(slide, slidePath, payload);
+  });
+  return issues;
+}
 function presentationReferenceWarnings(value) {
   if (!isRecord(value) || !Array.isArray(value.slides)) {
     return [];
@@ -942,6 +1091,7 @@ function presentationReferenceWarnings(value) {
     pushIfDefined(issues, unknownIdWarning("narratives", value.narrative, "/narrative", context));
   }
   issues.push(...designReferenceWarnings(value.design, "/design", context));
+  issues.push(...variableReferenceWarnings(value));
   value.slides.forEach((slide, index) => {
     if (!isRecord(slide)) {
       return;
@@ -1057,4 +1207,4 @@ function assertValidCatalogRecord(kind, value) {
   assertValid(value, kind);
 }
 
-export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, validate, validateCatalogRecord, validatePresentation, validationDefinition };
+export { OPFValidationError, assertValid, assertValidCatalogRecord, assertValidPresentation, bareIdPattern, isRecord, promotedRegionKeys, validate, validateCatalogRecord, validatePresentation, validationDefinition, visitContentPayloads };

package/dist/{chunk-EWJNRHXA.js → chunk-EQHZ3ZO4.js}

@@ -1,6 +1,6 @@
-import { validatePresentation, validationDefinition, validateCatalogRecord } from './chunk-ZIL7MGZU.js';
-import { schemas, schemaEntries } from './chunk-D3GQIREP.js';
-import { catalogKinds, catalogEntries, catalogSchemaNames } from './chunk-TU7I3KSB.js';
+import { validatePresentation, validationDefinition, validateCatalogRecord } from './chunk-CHKJ4QHQ.js';
+import { schemas, schemaEntries } from './chunk-GN52EE3P.js';
+import { catalogKinds, catalogEntries, catalogSchemaNames } from './chunk-6FU2KICU.js';
 import { parseTree, printParseErrorCode, getNodePath } from 'jsonc-parser';
 
 var own = (value, key) => Object.hasOwn(value, key);

package/dist/{chunk-PQJRDNA6.js → chunk-FTWNWFIV.js}

@@ -36,6 +36,77 @@ function tableRowBoundaries(value) {
 }
 
 // src/color.ts
+var schemeColorSlots = /* @__PURE__ */ new Set([
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "dark1",
+  "dark2",
+  "light1",
+  "light2",
+  "hyperlink",
+  "followedHyperlink"
+]);
+var schemeColorRoles = /* @__PURE__ */ new Set([
+  "primary",
+  "secondary",
+  "accent",
+  "background",
+  "surface",
+  "text",
+  "textSecondary"
+]);
+var defaultRoleSlots = {
+  primary: "accent1",
+  secondary: "accent2",
+  accent: "accent3",
+  background: "light1",
+  surface: "light2",
+  text: "dark1",
+  textSecondary: "dark2"
+};
+function normalizeHexColor(value) {
+  if (typeof value !== "string") return void 0;
+  let hex = value.trim();
+  if (/^#[0-9a-f]{3}$/i.test(hex)) hex = `#${[...hex.slice(1)].map((char) => char + char).join("")}`;
+  if (/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(hex)) return hex.length === 9 ? `#${hex.slice(1, 7).toUpperCase()}` : hex.toUpperCase();
+  return void 0;
+}
+function schemeSlot(colorScheme, slot, fallback) {
+  return normalizeHexColor(colorScheme[slot]) ?? fallback;
+}
+function resolveVariable(variables, id, fallback) {
+  const entry = variables[id];
+  if (typeof entry === "string") return normalizeHexColor(entry) ?? fallback;
+  if (entry && typeof entry === "object" && entry.type === "color") {
+    return normalizeHexColor(entry.value) ?? fallback;
+  }
+  return fallback;
+}
+function resolveColorRef(reference, options) {
+  const { colorScheme, roles, variables = {}, fallback } = options;
+  const literal = normalizeHexColor(reference);
+  if (literal) return literal;
+  if (reference.startsWith("var:")) {
+    const id = reference.slice("var:".length);
+    if (/^[a-z][a-z0-9-]*$/.test(id)) return resolveVariable(variables, id, fallback);
+    return fallback;
+  }
+  if (schemeColorRoles.has(reference)) {
+    const roleKey = reference;
+    const fromRoles = roles?.[roleKey];
+    if (fromRoles) return normalizeHexColor(fromRoles) ?? fallback;
+    const fromScheme = normalizeHexColor(colorScheme[reference]);
+    if (fromScheme) return fromScheme;
+    const slot = defaultRoleSlots[reference];
+    return slot ? schemeSlot(colorScheme, slot, fallback) : fallback;
+  }
+  if (schemeColorSlots.has(reference)) return schemeSlot(colorScheme, reference, fallback);
+  return fallback;
+}
 function luminance(value) {
   if (typeof value !== "string") return void 0;
   let hex = value.trim();
@@ -1426,4 +1497,4 @@ function resolveCanvasDimensions(input) {
   return { width, height };
 }
 
-export { MAX_COMPOSITION_DEPTH, OPFCompositionError, chartColorForFill, colorContrast, composeSlide, fitList, fitRichText, fitText, layoutCode, layoutFurniture, layoutMetric, layoutQuote, layoutTable, layoutTimeline, measureText, measureTextOutline, placeTextLines, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, wrapText };
+export { MAX_COMPOSITION_DEPTH, OPFCompositionError, chartColorForFill, colorContrast, composeSlide, fitList, fitRichText, fitText, layoutCode, layoutFurniture, layoutMetric, layoutQuote, layoutTable, layoutTimeline, measureText, measureTextOutline, normalizeHexColor, placeTextLines, resolveCanvasDimensions, resolveColorRef, resolveFontFamilies, resolveTextStyle, tableGrid, tableRowBoundaries, textColorForFill, textWidthMeasurer, wrapText };

package/dist/{chunk-FHGJX5QK.js → chunk-FWA5XB45.js}

@@ -1,6 +1,6 @@
-import { assertValidPresentation } from './chunk-ZIL7MGZU.js';
-import { resolveFontFamilies, resolveCanvasDimensions, composeSlide, tableRowBoundaries } from './chunk-PQJRDNA6.js';
-import { catalogs } from './chunk-TU7I3KSB.js';
+import { assertValidPresentation, visitContentPayloads } from './chunk-CHKJ4QHQ.js';
+import { resolveFontFamilies, resolveCanvasDimensions, composeSlide, tableRowBoundaries } from './chunk-FTWNWFIV.js';
+import { catalogs } from './chunk-6FU2KICU.js';
 
 // src/pagination.ts
 var OPFPaginationError = class extends Error {
@@ -16,6 +16,13 @@ var contentFields = /* @__PURE__ */ new Set(["text", "items", "bullets", "image"
 var headingFields = /* @__PURE__ */ new Set(["title", "subtitle", "tag"]);
 var isRecord = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 var clone = (value) => structuredClone(value);
+var slideIds = (slide) => {
+  const ids = typeof slide.id === "string" ? [slide.id] : [];
+  visitContentPayloads(slide, "", (payload) => {
+    if (typeof payload.id === "string") ids.push(payload.id);
+  });
+  return ids;
+};
 var textOf = (value) => typeof value === "string" ? value : Array.isArray(value) ? value.map(textOf).join("") : value?.text ?? "";
 var graphemes = new Intl.Segmenter("und", { granularity: "grapheme" });
 function sliceRichText(value, start, end) {
@@ -105,7 +112,26 @@ function paginateSlide(input, options = {}) {
   const slides = [], pages = [];
   let selected = /* @__PURE__ */ new Map();
   const reservedIds = new Set(options.reservedIds ?? []);
-  if (typeof source.id === "string") reservedIds.add(source.id);
+  for (const id of slideIds(source)) reservedIds.add(id);
+  const emittedIds = /* @__PURE__ */ new Set();
+  const pageId = (base, pageIndex) => {
+    if (!emittedIds.has(base)) {
+      emittedIds.add(base);
+      return base;
+    }
+    let suffix = pageIndex + 1, id = `${base}--${suffix}`;
+    while (reservedIds.has(id)) id = `${base}--${++suffix}`;
+    reservedIds.add(id);
+    emittedIds.add(id);
+    return id;
+  };
+  const assignPageIds = (slide, pageIndex) => {
+    const assign = (node) => {
+      if (typeof node.id === "string") node.id = pageId(node.id, pageIndex);
+    };
+    assign(slide);
+    visitContentPayloads(slide, "", assign);
+  };
   const project = (portions, pageIndex) => {
     const mappings = [];
     const visit = (node, path, out, root = false) => {
@@ -151,12 +177,7 @@ function paginateSlide(input, options = {}) {
     const { slide, mappings } = project(selected, slides.length);
     const issues = geometry(slide, slides.length).diagnostics;
     if (issues.length) throw new OPFPaginationError("A continuation page does not fit at its final page number. No partial result was returned.", issues);
-    if (slides.length && typeof source.id === "string") {
-      let suffix = slides.length + 1, id = `${source.id}--${suffix}`;
-      while (reservedIds.has(id)) id = `${source.id}--${++suffix}`;
-      slide.id = id;
-      reservedIds.add(id);
-    }
+    assignPageIds(slide, slides.length);
     assertValidPresentation({ slides: [slide] });
     slides.push(slide);
     pages.push({ slideIndex: sourceIndex + slides.length - 1, mappings, ...initial.furniture ? { repeatedMappings: repeatedMappings(slides.length - 1) } : {} });
@@ -215,7 +236,7 @@ function paginatePresentation(input, options = {}) {
   const maxSlides = options.maxSlides ?? 100;
   if (!Number.isInteger(maxSlides) || maxSlides < 1 || maxSlides > 1e4) throw new RangeError("maxSlides must be an integer between 1 and 10000.");
   const output = [], pages = [];
-  const reservedIds = presentation.slides.map((slide) => slide.id).filter(Boolean);
+  const reservedIds = presentation.slides.flatMap((slide) => slideIds(slide));
   const resolve = (kind, id) => presentation.catalogs?.[kind]?.records?.find((record) => record.id === id) ?? catalogs[kind].find((record) => record.id === id);
   presentation.slides.forEach((slide, index) => {
     const overrides = options.slideOptions?.(slide, index) ?? {};
@@ -236,7 +257,7 @@ function paginatePresentation(input, options = {}) {
       pages.push({ sourceSlideIndex: index, slideIndex: outputStart + pageIndex, mappings: page.mappings.map(remap), ...page.repeatedMappings ? { repeatedMappings: page.repeatedMappings.map(remap) } : {} });
     });
     output.push(...result.slides);
-    reservedIds.push(...result.slides.map((slide2) => slide2.id).filter(Boolean));
+    reservedIds.push(...result.slides.flatMap((slide2) => slideIds(slide2)));
   });
   presentation.slides = output;
   assertValidPresentation(presentation);