@openpresentation/opf 0.12.2 → 0.14.0

package/dist/{chunk-RUC7L5DJ.js → chunk-BFLVSVA7.js}

@@ -1,7 +1,7 @@
-import { validatePresentation } from './chunk-JKVKYVWL.js';
+import { validate } from './chunk-JDJBDYSR.js';
 
 // src/patch.ts
-var PatchError = class extends Error {
+var OPFPatchError = class extends Error {
   code;
   /** The JSON Pointer the failing operation addressed, when known. */
   path;
@@ -11,18 +11,18 @@ var PatchError = class extends Error {
   operation;
   constructor(code, message, details = {}) {
     super(message);
-    this.name = "PatchError";
+    this.name = "OPFPatchError";
     this.code = code;
     if (details.path !== void 0) this.path = details.path;
     if (details.index !== void 0) this.index = details.index;
     if (details.operation !== void 0) this.operation = details.operation;
   }
 };
-var PatchValidationError = class extends PatchError {
+var OPFPatchValidationError = class extends OPFPatchError {
   validation;
   constructor(validation) {
     super("patch-invalid-document", "The patched document is not a valid OPF presentation.");
-    this.name = "PatchValidationError";
+    this.name = "OPFPatchValidationError";
     this.validation = validation;
   }
 };
@@ -49,7 +49,7 @@ function unescapePointerToken(token) {
 }
 function parsePointer(pointer) {
   if (typeof pointer !== "string" || pointer !== "" && !pointer.startsWith("/") || /~(?![01])/u.test(pointer)) {
-    throw new PatchError("invalid-json-pointer", "Expected a JSON Pointer (empty string or /path with ~0 and ~1 escapes).", { path: typeof pointer === "string" ? pointer : void 0 });
+    throw new OPFPatchError("invalid-json-pointer", "Expected a JSON Pointer (empty string or /path with ~0 and ~1 escapes).", { path: typeof pointer === "string" ? pointer : void 0 });
   }
   return pointer === "" ? [] : pointer.slice(1).split("/").map(unescapePointerToken);
 }
@@ -58,7 +58,7 @@ function formatPointer(tokens) {
 }
 function pointerFromPath(path) {
   if (Array.isArray(path)) return formatPointer(path);
-  if (typeof path !== "string") throw new PatchError("invalid-json-pointer", "A path must be a string or an array of segments.");
+  if (typeof path !== "string") throw new OPFPatchError("invalid-json-pointer", "A path must be a string or an array of segments.");
   if (path === "") return "";
   if (path.startsWith("/")) {
     parsePointer(path);
@@ -68,7 +68,7 @@ function pointerFromPath(path) {
 }
 function splitPointer(pointer) {
   const tokens = parsePointer(pointer);
-  if (!tokens.length) throw new PatchError("invalid-json-pointer", "The root pointer has no parent.", { path: pointer });
+  if (!tokens.length) throw new OPFPatchError("invalid-json-pointer", "The root pointer has no parent.", { path: pointer });
   return { parent: formatPointer(tokens.slice(0, -1)), token: tokens[tokens.length - 1] };
 }
 function readPointer(document, pointer) {
@@ -89,24 +89,24 @@ function getAtPointer(document, pointer) {
   const result = readPointer(document, pointer);
   if (!result.found) {
     const shown = typeof pointer === "string" ? pointer : formatPointer(pointer);
-    throw new PatchError("patch-path-missing", `Patch path does not exist: ${shown || "/"}`, { path: shown });
+    throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${shown || "/"}`, { path: shown });
   }
   return result.value;
 }
 var hasPointer = (document, pointer) => readPointer(document, pointer).found;
 function arrayIndex(token, length, allowEnd, path) {
   if (allowEnd && token === "-") return length;
-  if (!/^(0|[1-9][0-9]*)$/.test(token)) throw new PatchError("invalid-array-index", `Invalid array index: ${token}`, { path });
+  if (!/^(0|[1-9][0-9]*)$/.test(token)) throw new OPFPatchError("invalid-array-index", `Invalid array index: ${token}`, { path });
   const at = Number(token);
-  if (!Number.isSafeInteger(at) || at > length || !allowEnd && at >= length) throw new PatchError("invalid-array-index", `Array index out of bounds: ${token}`, { path });
+  if (!Number.isSafeInteger(at) || at > length || !allowEnd && at >= length) throw new OPFPatchError("invalid-array-index", `Array index out of bounds: ${token}`, { path });
   return at;
 }
 function normalizePatch(patch) {
-  if (!Array.isArray(patch)) throw new PatchError("invalid-patch", "A JSON Patch must be an array of operations.");
+  if (!Array.isArray(patch)) throw new OPFPatchError("invalid-patch", "A JSON Patch must be an array of operations.");
   return patch.map((operation, index) => normalizeOperation(operation, index));
 }
 function normalizeOperation(operation, index) {
-  const fail = (code, message, path) => new PatchError(code, index === void 0 ? message : `Operation ${index}: ${message}`, { index, operation, path });
+  const fail = (code, message, path) => new OPFPatchError(code, index === void 0 ? message : `Operation ${index}: ${message}`, { index, operation, path });
   if (!isObject(operation)) throw fail("invalid-patch-operation", "Expected an operation object.");
   const op = operation.op;
   if (typeof op !== "string" || !["add", "remove", "replace", "move", "copy", "test"].includes(op)) {
@@ -135,7 +135,7 @@ function parentOf(document, tokens, path) {
   const key = tokens[tokens.length - 1];
   const found = readPointer(document, tokens.slice(0, -1));
   if (!found.found || !found.value || typeof found.value !== "object") {
-    throw new PatchError("patch-parent-missing", `Patch parent does not exist for ${path}.`, { path });
+    throw new OPFPatchError("patch-parent-missing", `Patch parent does not exist for ${path}.`, { path });
   }
   return { parent: found.value, key };
 }
@@ -165,7 +165,7 @@ function replaceAt(document, path, value) {
     parent[at] = clone(value);
   } else {
     const record = parent;
-    if (!own(record, key)) throw new PatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
+    if (!own(record, key)) throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
     previous = record[key];
     Object.defineProperty(record, key, { value: clone(value), enumerable: true, configurable: true, writable: true });
   }
@@ -173,7 +173,7 @@ function replaceAt(document, path, value) {
 }
 function removeAt(document, path) {
   const tokens = parsePointer(path);
-  if (!tokens.length) throw new PatchError("patch-root-remove", "The document root cannot be removed.", { path });
+  if (!tokens.length) throw new OPFPatchError("patch-root-remove", "The document root cannot be removed.", { path });
   const { parent, key } = parentOf(document, tokens, path);
   let previous;
   if (Array.isArray(parent)) {
@@ -183,7 +183,7 @@ function removeAt(document, path) {
     return { document, inverse: { op: "add", path: formatPointer([...tokens.slice(0, -1), at]), value: clone(previous) } };
   }
   const record = parent;
-  if (!own(record, key)) throw new PatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
+  if (!own(record, key)) throw new OPFPatchError("patch-path-missing", `Patch path does not exist: ${path}.`, { path });
   previous = record[key];
   delete record[key];
   return { document, inverse: { op: "add", path, value: clone(previous) } };
@@ -204,7 +204,7 @@ function applyOne(document, operation) {
     }
     case "test": {
       const found = readPointer(document, operation.path);
-      if (!found.found || !jsonEqual(found.value, operation.value)) throw new PatchError("patch-test-failed", `Test failed at ${operation.path || "/"}: the value changed.`, { path: operation.path });
+      if (!found.found || !jsonEqual(found.value, operation.value)) throw new OPFPatchError("patch-test-failed", `Test failed at ${operation.path || "/"}: the value changed.`, { path: operation.path });
       return { document, inverse: [] };
     }
     case "copy": {
@@ -217,7 +217,7 @@ function applyOne(document, operation) {
       const value = clone(getAtPointer(document, from));
       if (from.length === to.length && from.every((token, i) => token === to[i])) return { document, inverse: [] };
       if (to.length > from.length && from.every((token, i) => to[i] === token)) {
-        throw new PatchError("patch-invalid-move", "Cannot move a value into its descendant.", { path: operation.path });
+        throw new OPFPatchError("patch-invalid-move", "Cannot move a value into its descendant.", { path: operation.path });
       }
       const removed = removeAt(document, operation.from);
       const added = addAt(removed.document, operation.path, value);
@@ -235,27 +235,27 @@ function applyPatchWithInverse(document, patch, options = {}) {
       working = step.document;
       inverse.unshift(...step.inverse);
     } catch (error) {
-      if (error instanceof PatchError && error.index === void 0) {
-        const wrapped = new PatchError(error.code, `Operation ${index}: ${error.message}`, { path: error.path, index, operation });
+      if (error instanceof OPFPatchError && error.index === void 0) {
+        const wrapped = new OPFPatchError(error.code, `Operation ${index}: ${error.message}`, { path: error.path, index, operation });
         throw wrapped;
       }
       throw error;
     }
   }
-  const result = { document: working, inverse, patch: operations };
+  const result = { presentation: working, inverse, patch: operations };
   if (options.validate) {
-    const validator = typeof options.validate === "function" ? options.validate : (value) => validatePresentation(value);
+    const validator = typeof options.validate === "function" ? options.validate : (value) => validate(value, { only: options.strict ? ["format", "references"] : ["format"] });
     const validation = validator(working);
-    if (!validation.valid || options.strict && Array.isArray(validation.warnings) && validation.warnings.length) throw new PatchValidationError(validation);
+    if (!validation.valid || options.strict && validation.findings?.some((entry) => entry.severity === "warning")) throw new OPFPatchValidationError(validation);
     result.validation = validation;
   }
   return result;
 }
 function applyPatch(document, patch, options = {}) {
-  return applyPatchWithInverse(document, patch, options).document;
+  return applyPatchWithInverse(document, patch, options).presentation;
 }
 function invertPatch(document, patch) {
   return applyPatchWithInverse(document, patch).inverse;
 }
 
-export { PatchError, PatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken };
+export { OPFPatchError, OPFPatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken };

package/dist/chunk-CSQHPVGL.js

@@ -0,0 +1,94 @@
+import { validate } from './chunk-JDJBDYSR.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 };