@openpresentation/opf 0.11.3 → 0.12.0

package/dist/chunk-S5W34SIJ.js

@@ -0,0 +1 @@
+

package/dist/chunk-S667QI3M.js

@@ -0,0 +1,261 @@
+import { validatePresentation } from './chunk-UQKJWHSS.js';
+
+// src/patch.ts
+var PatchError = class extends Error {
+  code;
+  /** The JSON Pointer the failing operation addressed, when known. */
+  path;
+  /** The index of the failing operation within the patch, when known. */
+  index;
+  /** The failing operation, when known. */
+  operation;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "PatchError";
+    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 {
+  validation;
+  constructor(validation) {
+    super("patch-invalid-document", "The patched document is not a valid OPF presentation.");
+    this.name = "PatchValidationError";
+    this.validation = validation;
+  }
+};
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+var isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var clone = (value) => structuredClone(value);
+function jsonEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const other = b;
+    return a.length === other.length && a.every((item, i) => jsonEqual(item, other[i]));
+  }
+  const left = a, right = b;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => own(right, key) && jsonEqual(left[key], right[key]));
+}
+function escapePointerToken(token) {
+  return String(token).replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function unescapePointerToken(token) {
+  return token.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+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 });
+  }
+  return pointer === "" ? [] : pointer.slice(1).split("/").map(unescapePointerToken);
+}
+function formatPointer(tokens) {
+  return tokens.length ? `/${tokens.map(escapePointerToken).join("/")}` : "";
+}
+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 (path === "") return "";
+  if (path.startsWith("/")) {
+    parsePointer(path);
+    return path;
+  }
+  return formatPointer(path.split(".").filter(Boolean));
+}
+function splitPointer(pointer) {
+  const tokens = parsePointer(pointer);
+  if (!tokens.length) throw new PatchError("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) {
+  const tokens = typeof pointer === "string" ? parsePointer(pointer) : pointer;
+  let value = document;
+  for (const token of tokens) {
+    if (Array.isArray(value)) {
+      if (!/^(0|[1-9][0-9]*)$/.test(token)) return { found: false };
+      const at = Number(token);
+      if (!Number.isSafeInteger(at) || at >= value.length) return { found: false };
+      value = value[at];
+    } else if (value && typeof value === "object" && own(value, token)) value = value[token];
+    else return { found: false };
+  }
+  return { found: true, value };
+}
+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 });
+  }
+  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 });
+  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 });
+  return at;
+}
+function normalizePatch(patch) {
+  if (!Array.isArray(patch)) throw new PatchError("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 });
+  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)) {
+    throw fail("unsupported-patch-operation", `Unknown operation: ${String(op)}`);
+  }
+  if (typeof operation.path !== "string") throw fail("invalid-patch-operation", "An operation needs a string path.");
+  try {
+    parsePointer(operation.path);
+  } catch (error) {
+    throw fail("invalid-json-pointer", error.message, operation.path);
+  }
+  if (op === "move" || op === "copy") {
+    if (typeof operation.from !== "string") throw fail("invalid-patch-operation", `${op} requires a string from.`, operation.path);
+    try {
+      parsePointer(operation.from);
+    } catch (error) {
+      throw fail("invalid-json-pointer", error.message, operation.from);
+    }
+    return { op, from: operation.from, path: operation.path };
+  }
+  if (op === "remove") return { op, path: operation.path };
+  if (!own(operation, "value")) throw fail("invalid-patch-operation", `${op} requires value.`, operation.path);
+  return { op, path: operation.path, value: clone(operation.value) };
+}
+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 });
+  }
+  return { parent: found.value, key };
+}
+var NONE = /* @__PURE__ */ Symbol("none");
+function addAt(document, path, value) {
+  const tokens = parsePointer(path);
+  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) } };
+  const { parent, key } = parentOf(document, tokens, path);
+  if (Array.isArray(parent)) {
+    const at = arrayIndex(key, parent.length, true, path);
+    parent.splice(at, 0, clone(value));
+    return { document, inverse: { op: "remove", path: formatPointer([...tokens.slice(0, -1), at]) } };
+  }
+  const record = parent;
+  const previous = own(record, key) ? record[key] : NONE;
+  Object.defineProperty(record, key, { value: clone(value), enumerable: true, configurable: true, writable: true });
+  return { document, inverse: previous === NONE ? { op: "remove", path } : { op: "replace", path, value: clone(previous) } };
+}
+function replaceAt(document, path, value) {
+  const tokens = parsePointer(path);
+  if (!tokens.length) return { document: clone(value), inverse: { op: "replace", path: "", value: clone(document) } };
+  const { parent, key } = parentOf(document, tokens, path);
+  let previous;
+  if (Array.isArray(parent)) {
+    const at = arrayIndex(key, parent.length, false, path);
+    previous = parent[at];
+    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 });
+    previous = record[key];
+    Object.defineProperty(record, key, { value: clone(value), enumerable: true, configurable: true, writable: true });
+  }
+  return { document, inverse: { op: "replace", path, value: clone(previous) } };
+}
+function removeAt(document, path) {
+  const tokens = parsePointer(path);
+  if (!tokens.length) throw new PatchError("patch-root-remove", "The document root cannot be removed.", { path });
+  const { parent, key } = parentOf(document, tokens, path);
+  let previous;
+  if (Array.isArray(parent)) {
+    const at = arrayIndex(key, parent.length, false, path);
+    previous = parent[at];
+    parent.splice(at, 1);
+    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 });
+  previous = record[key];
+  delete record[key];
+  return { document, inverse: { op: "add", path, value: clone(previous) } };
+}
+function applyOne(document, operation) {
+  switch (operation.op) {
+    case "add": {
+      const r = addAt(document, operation.path, operation.value);
+      return { document: r.document, inverse: [r.inverse] };
+    }
+    case "replace": {
+      const r = replaceAt(document, operation.path, operation.value);
+      return { document: r.document, inverse: [r.inverse] };
+    }
+    case "remove": {
+      const r = removeAt(document, operation.path);
+      return { document: r.document, inverse: [r.inverse] };
+    }
+    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 });
+      return { document, inverse: [] };
+    }
+    case "copy": {
+      const value = clone(getAtPointer(document, operation.from));
+      const r = addAt(document, operation.path, value);
+      return { document: r.document, inverse: [r.inverse] };
+    }
+    case "move": {
+      const from = parsePointer(operation.from), to = parsePointer(operation.path);
+      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 });
+      }
+      const removed = removeAt(document, operation.from);
+      const added = addAt(removed.document, operation.path, value);
+      return { document: added.document, inverse: [added.inverse, removed.inverse] };
+    }
+  }
+}
+function applyPatchWithInverse(document, patch, options = {}) {
+  const operations = normalizePatch(patch);
+  let working = clone(document);
+  const inverse = [];
+  for (const [index, operation] of operations.entries()) {
+    try {
+      const step = applyOne(working, operation);
+      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 });
+        throw wrapped;
+      }
+      throw error;
+    }
+  }
+  const result = { document: working, inverse, patch: operations };
+  if (options.validate) {
+    const validator = typeof options.validate === "function" ? options.validate : (value) => validatePresentation(value);
+    const validation = validator(working);
+    if (!validation.valid || options.strict && Array.isArray(validation.warnings) && validation.warnings.length) throw new PatchValidationError(validation);
+    result.validation = validation;
+  }
+  return result;
+}
+function applyPatch(document, patch, options = {}) {
+  return applyPatchWithInverse(document, patch, options).document;
+}
+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 };