@openpresentation/opf 0.26.0 → 0.26.2

package/dist/chunk-IY5SCRTV.js

@@ -1,261 +0,0 @@
-import { validate } from './chunk-P7S3ORB4.js';
-
-// src/patch.ts
-var OPFPatchError = 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 = "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 OPFPatchValidationError = class extends OPFPatchError {
-  validation;
-  constructor(validation) {
-    super("patch-invalid-document", "The patched document is not a valid OPF presentation.");
-    this.name = "OPFPatchValidationError";
-    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 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);
-}
-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 OPFPatchError("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 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) {
-  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 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 OPFPatchError("invalid-array-index", `Invalid array index: ${token}`, { path });
-  const at = Number(token);
-  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 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 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)) {
-    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 OPFPatchError("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 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 });
-  }
-  return { document, inverse: { op: "replace", path, value: clone(previous) } };
-}
-function removeAt(document, path) {
-  const tokens = parsePointer(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)) {
-    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 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) } };
-}
-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 OPFPatchError("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 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);
-      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 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 = { presentation: working, inverse, patch: operations };
-  if (options.validate) {
-    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 && 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).presentation;
-}
-function invertPatch(document, patch) {
-  return applyPatchWithInverse(document, patch).inverse;
-}
-
-export { OPFPatchError, OPFPatchValidationError, applyPatch, applyPatchWithInverse, escapePointerToken, formatPointer, getAtPointer, hasPointer, invertPatch, jsonEqual, normalizePatch, parsePointer, pointerFromPath, readPointer, splitPointer, unescapePointerToken };

package/dist/conversion-ZPBLP2K6.js

@@ -1,19 +0,0 @@
-export { convertFiles, deckFileFormat, exportFormatOf, openDeck, planConversion, readInput, saveDeck, writePlanned } from './chunk-F7USLFZE.js';
-import './chunk-IC6OPLMU.js';
-import './chunk-WW62PPYV.js';
-import './chunk-UJSAR6GF.js';
-import './chunk-TKQ2VFV5.js';
-import './chunk-3OE6PZIC.js';
-import './chunk-MJ57RSYO.js';
-import './chunk-F5ABHDUX.js';
-import './chunk-GS37EBPQ.js';
-import './chunk-X7RANZWP.js';
-import './chunk-IY5SCRTV.js';
-import './chunk-EQ6S5SEZ.js';
-import './chunk-FITOGMR3.js';
-import './chunk-IWFXFWGD.js';
-import './chunk-LU6XM5JQ.js';
-import './chunk-P7S3ORB4.js';
-import './chunk-XRMV2GMB.js';
-import './chunk-F4HFDP6I.js';
-import './chunk-PJSPHHRK.js';

package/dist/validator-Dym2zYVK.d.ts

@@ -1,67 +0,0 @@
-import { b as CatalogKind } from './catalog-refs-CSHevLn1.js';
-import { SchemaName } from './schemas.js';
-import { a as Finding } from './finding-l9dlQ2NF.js';
-import { P as Presentation } from './presentation-Bwo8Ko6D.js';
-import { b as ValidationThresholds, c as ValidationRuleInfo, V as ValidationReport, a as ValidateOptions } from './validation-types-JW8e06ee.js';
-
-/**
- * RR-78: the version of the catalog record schemas (spec/schemas/<kind>.schema.json) this core reads. A catalog package
- * declares the version its records target (`opf.catalogSchema` in its package.json, `CATALOG_SCHEMA` in its exports, as
- * @openpresentation/gallery does); the Node defaults refuse a gallery that targets another one. A record schema change that
- * old records no longer validate against raises it.
- */
-declare const CATALOG_SCHEMA = 4;
-/** Kinds of catalog display metadata: published by catalogs for pickers, never referenced by documents. */
-declare const catalogDisplayKinds: readonly ["chartTypes", "languages", "socialPlatforms"];
-type CatalogDisplayKind = (typeof catalogDisplayKinds)[number];
-/** Every kind of record a catalog publishes: the content kinds documents reference, and the display kinds. */
-type CatalogRecordKind = CatalogKind | CatalogDisplayKind;
-/** The companion schema each catalog record kind validates against. */
-declare const catalogSchemaNames: Readonly<Record<CatalogRecordKind, SchemaName>>;
-
-/**
- * The rule registry: every rule `validate` can report, with its category, default severity, cost, rationale and the
- * standard it follows. The format, references and policy rules are produced by the schema and reference checks; the
- * accessibility, layout and content rules are implemented in `rules-*.ts`. Each rule has a stable `opf/<name>` id.
- */
-declare const DEFAULT_VALIDATION_THRESHOLDS: Readonly<ValidationThresholds>;
-/**
- * Every rule `validate` can report, with its category, default severity, cost, rationale and approximations, ordered by
- * category (format, references, policy, accessibility, layout, content) and, within one, in report order.
- */
-declare const validationRules: readonly ValidationRuleInfo[];
-/** The rule a full id (`opf/text-contrast`) or bare name (`text-contrast`) names, or undefined. */
-declare function findValidationRule(name: string): ValidationRuleInfo | undefined;
-
-declare const promotedRegionKeys: readonly ["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"];
-
-declare class OPFValidationError extends Error {
-    /** The full report that failed. */
-    readonly report: ValidationReport;
-    /** The error-severity findings of the report. */
-    readonly findings: Finding[];
-    constructor(report: ValidationReport);
-}
-/**
- * Check a presentation. `input` is a parsed presentation (an object) or the text of one, which is read as strict JSON and nothing
- * else: syntax errors and duplicate keys come back with line and column, and findings carry the range of the value they are
- * about. YAML and Markdown go through `fromYaml` and `fromMarkdown`, which call this for you.
- *
- * Never throws for a bad document, only for bad options (a `TypeError` naming the unknown rule, threshold or option, so a
- * typo cannot silently disable a check).
- */
-declare function validate(input: unknown, options?: ValidateOptions): ValidationReport;
-/**
- * Throw `OPFValidationError` (carrying the `report`) unless `validate(value, options)` is valid; afterwards TypeScript
- * knows `value` is a `Presentation`. It takes a parsed value, not text. Pass `{ only: ['format'] }` for the cheap check.
- */
-declare function assertValid(value: unknown, options?: ValidateOptions): asserts value is Presentation;
-/**
- * Check one published catalog record file (an audience, theme, layout, font scheme, chart type and so on) against its
- * companion schema, `$schema` and `id` included. The report has the same shape as `validate`'s; every finding is `format`.
- * A record a document embeds is checked by `validate`, keyed by its id and without `$schema`.
- */
-declare function validateCatalogRecord(kind: CatalogRecordKind, value: unknown): ValidationReport;
-declare function assertValidCatalogRecord(kind: CatalogRecordKind, value: unknown): void;
-
-export { CATALOG_SCHEMA as C, DEFAULT_VALIDATION_THRESHOLDS as D, OPFValidationError as O, type CatalogDisplayKind as a, type CatalogRecordKind as b, assertValid as c, assertValidCatalogRecord as d, catalogDisplayKinds as e, catalogSchemaNames as f, findValidationRule as g, validateCatalogRecord as h, validationRules as i, promotedRegionKeys as p, validate as v };