@openpresentation/opf 0.13.0 → 0.15.1

package/dist/chunk-SPFV27O5.js

@@ -0,0 +1,210 @@
+// src/catalog-refs.ts
+var catalogKinds = ["layouts", "themes", "colorSchemes", "fontSchemes", "narratives", "audiences", "purposes", "tones"];
+var CATALOG_REFERENCE_PATTERN = /^(?:([a-z][a-z0-9-]*):)?([a-z][a-z0-9-]*)$/;
+var CATALOG_GROUP_PATTERN = /^[a-z][a-z0-9-]*$/;
+function provenanceOf(found) {
+  const { record: _record, ...provenance } = found;
+  return provenance;
+}
+var OPFCatalogsOptionError = class extends TypeError {
+  code = "invalid-catalogs";
+  constructor(entry, detail) {
+    super(`${entry}: the catalogs option must be an array of registered catalogs ({ source, <kind>: { <id>: record } } with known catalog kinds); ${detail}.`);
+    this.name = "OPFCatalogsOptionError";
+  }
+};
+function checkCatalogsOption(catalogs, entry) {
+  if (catalogs === void 0) return [];
+  if (!Array.isArray(catalogs)) throw new OPFCatalogsOptionError(entry, `got ${catalogs === null ? "null" : typeof catalogs}`);
+  catalogs.forEach((catalog, index) => {
+    if (!isRec(catalog) || typeof catalog.source !== "string") throw new OPFCatalogsOptionError(entry, `catalogs[${index}] is not an object with a string source`);
+    for (const [kind, records] of Object.entries(catalog)) {
+      if (kind === "source") continue;
+      if (!catalogKinds.includes(kind)) throw new OPFCatalogsOptionError(entry, `catalogs[${index}].${kind} is not a catalog kind`);
+      if (!isRec(records)) throw new OPFCatalogsOptionError(entry, `catalogs[${index}].${kind} is not an object of records keyed by id`);
+    }
+  });
+  return catalogs;
+}
+var OPFUnresolvedReferenceError = class extends Error {
+  diagnostics;
+  constructor(diagnostics) {
+    super(diagnostics.map((diagnostic) => diagnostic.message).join(" "));
+    this.name = "OPFUnresolvedReferenceError";
+    this.diagnostics = diagnostics;
+  }
+};
+var isRec = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var rec = (value) => isRec(value) ? value : {};
+var own = (value, key) => Object.hasOwn(value, key);
+function parseReference(reference) {
+  if (typeof reference !== "string") return void 0;
+  const match = CATALOG_REFERENCE_PATTERN.exec(reference);
+  if (!match) return void 0;
+  const [, group, id] = match;
+  return group === void 0 ? { id } : { group, id };
+}
+function groupsOf(document) {
+  return rec(rec(document).catalogs);
+}
+function catalogGroupDeclared(document, name) {
+  const groups = groupsOf(document);
+  return own(groups, name) && (isRec(groups[name]) || name === "default" && groups[name] === false);
+}
+function catalogGroupSource(document, name, options = {}) {
+  if (name === "custom") return void 0;
+  const group = groupsOf(document)[name];
+  if (name === "default") {
+    if (group === false) return void 0;
+    const source2 = rec(group).source;
+    return typeof source2 === "string" ? source2 : options.catalogs?.[0]?.source;
+  }
+  const source = rec(group).source;
+  return typeof source === "string" ? source : void 0;
+}
+function registeredCatalog(source, options = {}) {
+  if (source === void 0) return void 0;
+  return options.catalogs?.find((catalog) => catalog?.source === source);
+}
+function lookupInGroup(document, kind, group, id, reference, options = {}) {
+  const groups = groupsOf(document);
+  if (group === "default" && groups.default === false) return void 0;
+  if (group !== "default" && group !== "custom" && !isRec(groups[group])) return void 0;
+  const source = catalogGroupSource(document, group, options);
+  const embedded = rec(rec(groups[group])[kind]);
+  if (own(embedded, id) && isRec(embedded[id])) {
+    return { kind, reference, id, group, ...source !== void 0 ? { source } : {}, origin: "document", record: embedded[id] };
+  }
+  if (group === "custom") return void 0;
+  const hosted = registeredCatalog(source, options)?.[kind];
+  if (hosted && own(hosted, id) && isRec(hosted[id])) {
+    return { kind, reference, id, group, ...source !== void 0 ? { source } : {}, origin: "host", record: hosted[id] };
+  }
+  return void 0;
+}
+function resolveReference(document, kind, reference, options = {}) {
+  checkCatalogsOption(options.catalogs, "resolveReference");
+  const parsed = parseReference(reference);
+  if (!parsed) return void 0;
+  const written = reference;
+  if (parsed.group !== void 0) return lookupInGroup(document, kind, parsed.group, parsed.id, written, options);
+  const order = [...new Set([options.group, "custom", "default"].filter((group) => typeof group === "string"))];
+  for (const group of order) {
+    const found = lookupInGroup(document, kind, group, parsed.id, written, options);
+    if (found) return found;
+  }
+  return void 0;
+}
+var KIND_NOUNS = {
+  layouts: "Layout",
+  themes: "Theme",
+  colorSchemes: "Colour scheme",
+  fontSchemes: "Font scheme",
+  narratives: "Narrative",
+  audiences: "Audience",
+  purposes: "Purpose",
+  tones: "Tone"
+};
+function unresolvedReference(document, kind, reference, path, options = {}) {
+  const parsed = parseReference(reference);
+  const group = parsed?.group ?? "default";
+  const source = catalogGroupSource(document, group, options);
+  const noun = KIND_NOUNS[kind];
+  const where = parsed?.group !== void 0 && !catalogGroupDeclared(document, parsed.group) ? `the document declares no catalogs.${parsed.group} group` : group === "custom" ? "it is not in catalogs.custom" : group === "default" && groupsOf(document).default === false ? "it is not in catalogs.custom and catalogs.default is false" : source === void 0 ? `it is not embedded in catalogs.${group === "default" ? "custom or catalogs.default" : group} and no catalog is registered for it` : `it is not embedded in catalogs.${group === "default" ? "custom or catalogs.default" : group} and the catalog registered for ${source} ${registeredCatalog(source, options) ? "has no such record" : "is not registered"}`;
+  const fallback = kind === "layouts" ? "automatic" : "engine-default";
+  return {
+    code: "unresolved-reference",
+    kind,
+    reference,
+    path,
+    group,
+    ...source !== void 0 ? { source } : {},
+    fallback,
+    message: `${noun} '${reference}' resolves nowhere: ${where}; ${fallback === "automatic" ? "the slide composes automatically" : "the engine default is used"}.`
+  };
+}
+var pushReference = (sites, kind, value, path, group) => {
+  if (typeof value === "string" && parseReference(value)) sites.push({ kind, reference: value, path, ...group !== void 0 ? { group } : {} });
+};
+var pushObjectReference = (sites, kind, value, path, group) => {
+  if (typeof value === "string") pushReference(sites, kind, value, path, group);
+  else if (isRec(value)) pushReference(sites, kind, value.id, [...path, "id"], group);
+};
+function designSites(sites, design, path) {
+  if (!isRec(design)) return;
+  pushReference(sites, "themes", design.theme, [...path, "theme"]);
+  pushObjectReference(sites, "colorSchemes", design.colorScheme, [...path, "colorScheme"]);
+  pushObjectReference(sites, "fontSchemes", design.fontScheme, [...path, "fontScheme"]);
+}
+function recordReferenceSites(kind, record, path, group) {
+  const sites = [];
+  if (kind === "themes" && isRec(record)) {
+    pushObjectReference(sites, "colorSchemes", record.colorScheme, [...path, "colorScheme"], group);
+    pushObjectReference(sites, "fontSchemes", record.fontScheme, [...path, "fontScheme"], group);
+  }
+  return sites;
+}
+function catalogReferenceSites(document, options = {}) {
+  const deck = rec(document);
+  const sites = [];
+  pushReference(sites, "narratives", deck.narrative, ["narrative"]);
+  if (Array.isArray(deck.audience)) deck.audience.forEach((entry, index) => {
+    pushObjectReference(sites, "audiences", entry, ["audience", index]);
+  });
+  else pushObjectReference(sites, "audiences", deck.audience, ["audience"]);
+  pushObjectReference(sites, "purposes", deck.purpose, ["purpose"]);
+  pushObjectReference(sites, "tones", deck.tone, ["tone"]);
+  if (isRec(deck.language)) {
+    pushReference(sites, "fontSchemes", deck.language.fontScheme, ["language", "fontScheme"]);
+    pushReference(sites, "fontSchemes", deck.language.googleFontScheme, ["language", "googleFontScheme"]);
+  }
+  designSites(sites, deck.design, ["design"]);
+  if (options.slides !== false && Array.isArray(deck.slides))
+    deck.slides.forEach((slide, index) => {
+      if (!isRec(slide)) return;
+      pushReference(sites, "layouts", slide.layout, ["slides", index, "layout"]);
+      designSites(sites, slide.design, ["slides", index, "design"]);
+    });
+  if (options.records !== false)
+    for (const [group, value] of Object.entries(groupsOf(document))) {
+      if (!isRec(value)) continue;
+      for (const kind of catalogKinds)
+        for (const [id, record] of Object.entries(rec(value[kind]))) sites.push(...recordReferenceSites(kind, record, ["catalogs", group, kind, id], group));
+    }
+  return sites;
+}
+var dottedPath = (path) => path.join(".");
+var pointerPath = (path) => path.length ? `/${path.map((part) => String(part).replaceAll("~", "~0").replaceAll("/", "~1")).join("/")}` : "";
+function catalogRecords(document, kind, options = {}) {
+  checkCatalogsOption(options.catalogs, "catalogRecords");
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (entry) => {
+    if (seen.has(entry.reference)) return;
+    seen.add(entry.reference);
+    result.push(entry);
+  };
+  const groups = groupsOf(document);
+  const names = [.../* @__PURE__ */ new Set(["custom", "default", ...Object.keys(groups)])];
+  for (const group of names) {
+    if (group === "default" && groups.default === false) continue;
+    if (group !== "custom" && group !== "default" && !isRec(groups[group])) continue;
+    const prefix = group === "custom" || group === "default" ? "" : `${group}:`;
+    for (const id of Object.keys(rec(rec(groups[group])[kind]))) {
+      const found = lookupInGroup(document, kind, group, id, `${prefix}${id}`, options);
+      if (found) add(found);
+    }
+    if (group === "custom") continue;
+    const hosted = registeredCatalog(catalogGroupSource(document, group, options), options)?.[kind];
+    for (const id of Object.keys(hosted ?? {})) {
+      const found = lookupInGroup(document, kind, group, id, `${prefix}${id}`, options);
+      if (found) add(found);
+    }
+  }
+  return result;
+}
+function embeddedCopy(record) {
+  return Object.fromEntries(Object.entries(rec(record)).filter(([key]) => key !== "$schema" && key !== "id" && !key.startsWith("x-")).map(([key, value]) => [key, structuredClone(value)]));
+}
+
+export { CATALOG_GROUP_PATTERN, CATALOG_REFERENCE_PATTERN, OPFCatalogsOptionError, OPFUnresolvedReferenceError, catalogGroupDeclared, catalogGroupSource, catalogKinds, catalogRecords, catalogReferenceSites, checkCatalogsOption, dottedPath, embeddedCopy, parseReference, pointerPath, provenanceOf, recordReferenceSites, registeredCatalog, resolveReference, unresolvedReference };

package/dist/chunk-TRDXRRQK.js

@@ -0,0 +1,17 @@
+// src/catalog-schemas.ts
+var catalogDisplayKinds = ["chartTypes", "languages", "socialPlatforms"];
+var catalogSchemaNames = {
+  layouts: "layout",
+  themes: "theme",
+  colorSchemes: "colorScheme",
+  fontSchemes: "fontScheme",
+  narratives: "narrative",
+  audiences: "audience",
+  purposes: "purpose",
+  tones: "tone",
+  chartTypes: "chartType",
+  languages: "language",
+  socialPlatforms: "socialPlatform"
+};
+
+export { catalogDisplayKinds, catalogSchemaNames };