@openpresentation/opf 0.13.0 → 0.15.1

package/dist/{chunk-RAYB46AB.js → chunk-UBFJ2QHH.js}

@@ -1,6 +1,6 @@
-import { assertValidPresentation } from './chunk-IYCJUKWD.js';
-import { DEFAULT_FONT_SCHEME, resolveFontSchemeReference, resolveFontFamilies, resolveCanvasDimensions, composeSlide, tableRowBoundaries, visitContentPayloads, sliceNumberedItems } from './chunk-MPM7NRG7.js';
-import { catalogs } from './chunk-E34DJ5LL.js';
+import { assertValid, resolveSlideContext } from './chunk-QDI75P2M.js';
+import { composeSlide, codeHighlightSlice, tableRowBoundaries, visitContentPayloads, sliceNumberedItems } from './chunk-O744SXXA.js';
+import { checkCatalogsOption } from './chunk-SPFV27O5.js';
 
 // src/pagination.ts
 var OPFPaginationError = class extends Error {
@@ -48,8 +48,17 @@ function leafFor(path, field, value) {
   }
   if (field === "code" || field === "quote") {
     const key = field === "code" ? "source" : "text";
-    text = typeof value === "string" ? value : value[key];
-    leaf.slice = (a, b) => typeof value === "string" ? value.slice(a, b) : { ...value, [key]: text.slice(a, b) };
+    text = typeof value === "string" ? value : field === "quote" ? textOf(value[key]) : value[key];
+    leaf.slice = (a, b) => {
+      if (typeof value === "string") return value.slice(a, b);
+      const piece = { ...value, [key]: field === "quote" ? sliceRichText(value[key], a, b) : text.slice(a, b) };
+      if (field === "code" && value.highlight !== void 0) {
+        const highlight = codeHighlightSlice(value.highlight, text, a, b);
+        if (highlight) piece.highlight = highlight;
+        else delete piece.highlight;
+      }
+      return piece;
+    };
   }
   if (text !== void 0) {
     leaf.unit = "utf16";
@@ -70,7 +79,7 @@ function leafFor(path, field, value) {
   return leaf;
 }
 function paginateSlide(input, options = {}) {
-  assertValidPresentation({ ...deckContext(options.presentation), slides: [input] });
+  assertValid({ ...deckContext(options.presentation), slides: [input] }, { only: ["format"] });
   let source = clone(input);
   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.");
@@ -94,9 +103,11 @@ function paginateSlide(input, options = {}) {
   };
   source = withReadability(source);
   let evaluations = 0;
+  const { fonts, minFontSize: _minFontSize, maxSlides: _maxSlides, reservedIds: _reservedIds, ...engineOptions } = options;
+  const composeOptions = { ...engineOptions, ...fonts?.textMeasurement ? { textMeasurement: fonts.textMeasurement } : {} };
   const geometry = (slide, pageIndex = 0) => {
     if (++evaluations > 2e4) throw new OPFPaginationError("Pagination exceeded its layout evaluation limit. Split the input into smaller sections.");
-    return composeSlide(withReadability(slide, true), { ...options, slideNumber: (options.slideNumber ?? sourceIndex + 1) + pageIndex });
+    return composeSlide(withReadability(slide, true), { ...composeOptions, slideNumber: (options.slideNumber ?? sourceIndex + 1) + pageIndex });
   };
   const initial = geometry(source);
   const fit = (diagnostics) => diagnostics.filter((issue) => issue.code === "text-overflow" || issue.code === "small-cell" || !!initial.furniture?.diagnostics.includes(issue));
@@ -183,7 +194,7 @@ function paginateSlide(input, options = {}) {
     const issues = fit(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);
     assignPageIds(slide, slides.length);
-    assertValidPresentation({ ...deckContext(options.presentation), slides: [slide] });
+    assertValid({ ...deckContext(options.presentation), slides: [slide] }, { only: ["format"] });
     slides.push(slide);
     pages.push({ slideIndex: sourceIndex + slides.length - 1, mappings, ...initial.furniture ? { repeatedMappings: repeatedMappings(slides.length - 1) } : {} });
     selected = /* @__PURE__ */ new Map();
@@ -195,7 +206,7 @@ function paginateSlide(input, options = {}) {
     while (true) {
       const make = (limit) => ({ leaf, start, end: limit, value: leaf.slice ? leaf.slice(start, limit) : leaf.value });
       let candidate = new Map(selected).set(leaf.path, make(end));
-      let issues = diagnosticsFor(candidate);
+      const issues = diagnosticsFor(candidate);
       if (!issues.length) {
         selected = candidate;
         break;
@@ -239,34 +250,27 @@ var usesSlideTotal = (presentation) => [presentation, ...presentation.slides].so
   const content = owner?.design?.[kind]?.[zone];
   return content?.slideNumber === true && typeof content.slideNumberFormat === "string" && content.slideNumberFormat.includes("{total}");
 })));
-function paginatePresentation(input, options = {}) {
-  assertValidPresentation(input);
+function paginate(input, options = {}) {
+  checkCatalogsOption(options.catalogs, "paginate");
+  assertValid(input, { only: ["format"] });
   const presentation = clone(input);
   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 authoredIds = 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);
   const reported = /* @__PURE__ */ new Set();
   const run = (slideCount2) => {
     const output2 = [], pages2 = [], reservedIds = [...authoredIds];
     presentation.slides.forEach((slide, index) => {
-      const overrides = options.slideOptions?.(slide, index) ?? {};
-      const layout = overrides.layout ?? (slide.layout ? resolve("layouts", slide.layout) : void 0);
-      if (slide.layout && !layout) throw new OPFPaginationError(`Layout '${slide.layout}' must be supplied inline or resolved by the host before pagination.`);
-      const design = { ...presentation.design, ...slide.design };
-      const reference = design.theme ?? "minimal";
-      const theme = typeof reference === "string" ? resolve("themes", reference) : { ...resolve("themes", reference.id), ...reference };
-      if (!theme) throw new OPFPaginationError(`Theme '${reference}' must be supplied inline before pagination.`);
-      if (output2.length >= maxSlides) throw new OPFPaginationError(`Pagination needs more than ${maxSlides} slides. No partial result was returned.`);
-      const fontReference = design.fontScheme ?? theme.fontScheme ?? DEFAULT_FONT_SCHEME;
-      const fontPath = slide.design?.fontScheme !== void 0 ? `slides.${index}.design.fontScheme` : presentation.design?.fontScheme !== void 0 ? "design.fontScheme" : slide.design?.theme !== void 0 ? `slides.${index}.design.theme` : "design.theme";
-      const { scheme: fontScheme, diagnostic } = resolveFontSchemeReference(fontReference, (id) => resolve("fontSchemes", id), fontPath);
-      if (diagnostic && !reported.has(diagnostic.path)) {
-        reported.add(diagnostic.path);
-        options.onDiagnostic?.(diagnostic);
+      const context = resolveSlideContext(presentation, index, { slideNumber: output2.length + 1, slideCount: slideCount2, date: options.date, ...options.catalogs ? { catalogs: options.catalogs } : {}, ...options.strictReferences ? { strictReferences: true } : {} });
+      for (const diagnostic of context.diagnostics) {
+        const key = `${diagnostic.code}:${diagnostic.path}`;
+        if (!reported.has(key)) {
+          reported.add(key);
+          options.onDiagnostic?.(diagnostic);
+        }
       }
-      const fonts = resolveFontFamilies(fontScheme);
-      const result2 = paginateSlide(slide, { ...resolveCanvasDimensions(design.dimensions ?? theme.dimensions), layout, fonts, contentAlignment: design.contentAlignment, titleAlignment: design.titleAlignment, contentBox: design.contentBox, textMeasurement: options.textMeasurement, textRasterPadding: options.textRasterPadding, socialPlatforms: catalogs.socialPlatforms, ...overrides, presentation, slideIndex: index, slideNumber: output2.length + 1, slideCount: slideCount2, date: options.date, maxSlides: maxSlides - output2.length, minFontSize: options.minFontSize, reservedIds });
+      if (output2.length >= maxSlides) throw new OPFPaginationError(`Pagination needs more than ${maxSlides} slides. No partial result was returned.`);
+      const result2 = paginateSlide(slide, { ...context.options, textRasterPadding: options.textRasterPadding, fonts: options.fonts, presentation, slideIndex: index, slideNumber: output2.length + 1, slideCount: slideCount2, date: options.date, maxSlides: maxSlides - output2.length, minFontSize: options.minFontSize, reservedIds });
       const outputStart = output2.length;
       result2.pages.forEach((page, pageIndex) => {
         const remap = (mapping) => ({ ...mapping, outputPath: mapping.outputPath.replace(/^slides\.\d+/, `slides.${outputStart + pageIndex}`) });
@@ -285,8 +289,8 @@ function paginatePresentation(input, options = {}) {
   }
   const { output, pages } = result;
   presentation.slides = output;
-  assertValidPresentation(presentation);
+  assertValid(presentation, { only: ["format"] });
   return { presentation, pages };
 }
 
-export { OPFPaginationError, paginatePresentation, paginateSlide };
+export { OPFPaginationError, paginate, paginateSlide };

package/dist/chunk-VGAOJEY7.js

@@ -0,0 +1,94 @@
+import { validate } from './chunk-QDI75P2M.js';
+
+// src/convert/shared.ts
+var CONTENT_KEYS = ["text", "items", "bullets", "image", "video", "chart", "table", "code", "metric", "quote", "timeline"];
+var SLIDE_ONLY_KEYS = ["title", "subtitle", "tag", "layout", "design", "notes", "section", "hidden", "beat"];
+var OPFConversionError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "OPFConversionError";
+    this.code = code;
+    this.details = details;
+  }
+};
+var refuse = (message, details = {}) => new OPFConversionError("not-convertible", message, details);
+var Loss = class {
+  list = [];
+  note(message) {
+    if (!this.list.includes(message)) this.list.push(message);
+  }
+  merge(other) {
+    for (const message of other) this.note(message);
+  }
+};
+var report = (loss) => ({ lossless: loss.length === 0, loss: [...loss] });
+var isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var clone = (value) => structuredClone(value);
+var own = (value, key) => Object.hasOwn(value, key);
+var same = (a, b) => JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (isRecord(value)) return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
+  return value;
+}
+var isSlideLike = (payload) => SLIDE_ONLY_KEYS.some((key) => own(payload, key));
+var contentKeysOf = (payload) => CONTENT_KEYS.filter((key) => payload[key] !== void 0);
+function assertValidOutput(value, as = "block", context = {}) {
+  const slides = as === "slides" ? value : as === "slide" ? [value] : [{ blocks: [value] }];
+  const datasets = isRecord(context.datasets) ? context.datasets : void 0;
+  const report2 = validate({ ...datasets ? { datasets } : {}, slides }, { only: ["format"] });
+  const found = report2.findings.filter((entry) => entry.severity === "error");
+  const errors = datasets ? found : found.filter((entry) => entry.ruleId !== "opf/dataset-unknown" && entry.ruleId !== "opf/dataset-field-unknown");
+  if (errors.length) {
+    const first = errors[0];
+    throw new OPFConversionError("invalid-output", `The converted content is not valid OPF: ${first?.message ?? "unknown error"}${first?.path ? ` (${first.path})` : ""}.`, { issues: errors });
+  }
+}
+var assertValidOwner = (owner, context = {}) => assertValidOutput(owner, isSlideLike(owner) ? "slide" : "block", context);
+var FORMATTING = ["bold", "italic", "underline", "strikethrough", "color", "fontSize", "fontFamily", "link", "superscript", "subscript", "code", "lang"];
+var isPlainRun = (run) => typeof run === "string" || isRecord(run) && !FORMATTING.some((key) => run[key] !== void 0);
+var runText = (run) => typeof run === "string" ? run : run.text ?? "";
+var runsOf = (value) => typeof value === "string" ? [value] : Array.isArray(value) ? value : [];
+var plainOf = (value) => runsOf(value).map(runText).join("");
+var hasFormatting = (value) => runsOf(value).some((run) => !isPlainRun(run));
+var NEWLINE = /\r\n|\r|\n/;
+function splitRuns(runs) {
+  const lines = [[]];
+  for (const run of runs) {
+    const parts = runText(run).split(NEWLINE);
+    parts.forEach((part, index) => {
+      if (index > 0) lines.push([]);
+      if (part === "") return;
+      lines[lines.length - 1].push(typeof run === "string" ? part : { ...run, text: part });
+    });
+  }
+  return lines;
+}
+function mergeRuns(runs) {
+  const merged = [];
+  for (const run of runs) {
+    if (typeof run === "string" && typeof merged.at(-1) === "string") merged[merged.length - 1] += run;
+    else merged.push(run);
+  }
+  return merged;
+}
+var linePlain = (line) => line.map(runText).join("");
+var lineIsPlain = (line) => line.every(isPlainRun);
+var lineValue = (line) => lineIsPlain(line) ? linePlain(line) : mergeRuns(line);
+function joinLines(lines) {
+  if (lines.every(lineIsPlain)) return lines.map(linePlain).join("\n");
+  const runs = [];
+  lines.forEach((line, index) => {
+    if (index > 0) runs.push("\n");
+    runs.push(...line);
+  });
+  return mergeRuns(runs);
+}
+function concatText(a, b) {
+  if (typeof a === "string" && typeof b === "string") return a + b;
+  return mergeRuns([...runsOf(a), ...runsOf(b)]);
+}
+
+export { CONTENT_KEYS, FORMATTING, Loss, OPFConversionError, assertValidOutput, assertValidOwner, clone, concatText, contentKeysOf, hasFormatting, isPlainRun, isRecord, isSlideLike, joinLines, lineIsPlain, linePlain, lineValue, plainOf, refuse, report, runText, runsOf, same, splitRuns };

package/dist/chunk-ZPU46TFA.js

@@ -0,0 +1,83 @@
+import { presentation } from './chunk-2CJPC4HI.js';
+
+// src/format.ts
+var OPFFormatError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OPFFormatError";
+  }
+};
+var root = presentation;
+var flattenCache = /* @__PURE__ */ new WeakMap();
+function collect(schema, seen) {
+  if (!schema || typeof schema !== "object" || seen.has(schema)) return [];
+  seen.add(schema);
+  const node = schema;
+  const out = [node];
+  if (typeof node.$ref === "string" && node.$ref.startsWith("#/$defs/")) out.push(...collect(root.$defs?.[node.$ref.slice("#/$defs/".length)], seen));
+  for (const list of [node.oneOf, node.anyOf, node.allOf]) for (const branch of list ?? []) out.push(...collect(branch, seen));
+  out.push(...collect(node.then, seen), ...collect(node.else, seen));
+  return out;
+}
+function flatten(schema) {
+  if (!schema || typeof schema !== "object") return [];
+  const cached = flattenCache.get(schema);
+  if (cached) return cached;
+  const nodes = collect(schema, /* @__PURE__ */ new Set());
+  flattenCache.set(schema, nodes);
+  return nodes;
+}
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+function arrange(value, schemas) {
+  if (Array.isArray(value)) {
+    const itemSchemas = schemas.flatMap((node) => node.items && typeof node.items === "object" ? flatten(node.items) : []);
+    return value.map((item) => arrange(item, itemSchemas));
+  }
+  if (!value || typeof value !== "object") return value;
+  const record = value;
+  const declared = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of schemas) for (const key of Object.keys(node.properties ?? {})) if (!seen.has(key)) {
+    seen.add(key);
+    declared.push(key);
+  }
+  const present = Object.keys(record);
+  const ordered = [...declared.filter((key) => own(record, key)), ...present.filter((key) => !seen.has(key))];
+  const out = {};
+  for (const key of ordered) {
+    let children = schemas.flatMap((node) => node.properties && own(node.properties, key) ? flatten(node.properties[key]) : []);
+    if (!children.length && !seen.has(key)) children = schemas.flatMap((node) => node.additionalProperties && typeof node.additionalProperties === "object" ? flatten(node.additionalProperties) : []);
+    Object.defineProperty(out, key, { value: arrange(record[key], children), enumerable: true, configurable: true, writable: true });
+  }
+  return out;
+}
+function sortPresentationKeys(document) {
+  return arrange(document, flatten(root));
+}
+function format(input, options = {}) {
+  let document = input;
+  if (typeof input === "string") {
+    try {
+      document = JSON.parse(input.replace(/^/u, ""));
+    } catch (error) {
+      throw new OPFFormatError(`Invalid JSON: ${error.message}`);
+    }
+  }
+  const indent = options.indent ?? 2;
+  if (!Number.isInteger(indent) || indent < 0 || indent > 8) throw new OPFFormatError("indent must be an integer from 0 to 8.");
+  if (options.eol !== void 0 && options.eol !== "lf" && options.eol !== "crlf") throw new OPFFormatError("eol must be lf or crlf.");
+  const text = JSON.stringify(sortPresentationKeys(document), null, indent);
+  if (text === void 0) throw new OPFFormatError("Nothing to format.");
+  return options.eol === "crlf" ? `${text.replaceAll("\n", "\r\n")}\r
+` : `${text}
+`;
+}
+function isFormatted(source, options = {}) {
+  try {
+    return format(source, options) === source;
+  } catch {
+    return false;
+  }
+}
+
+export { OPFFormatError, format, isFormatted, sortPresentationKeys };