@openpresentation/opf 0.13.0 → 0.14.0

package/dist/{chart-data-Cdr6rRVV.d.ts → chart-data-B_3z9VTb.d.ts}

@@ -33,6 +33,11 @@ interface ChartMapping {
     x?: string;
     series?: string[];
 }
+/** One series of a combo chart: drawn as a clustered column or as a line with markers, against the primary (left) or secondary (right) value axis. */
+interface ChartComboSeries {
+    role: 'bar' | 'line';
+    axis: 'primary' | 'secondary';
+}
 /** A text run as table cells and headers hold them (see the schema `TextRun`). */
 type DataTextRun = string | {
     text: string;
@@ -52,7 +57,7 @@ interface DataStyledCell {
 type DataTableCell = DataTableValue | DataStyledCell;
 /** A table column header: a cell, or a DataColumn. */
 type DataTableHeader = DataTableCell | DataColumn;
-type DataDiagnosticCode = 'chart-value-not-numeric' | 'chart-data-source-unresolved' | 'dataset-unknown' | 'dataset-field-unknown' | 'data-column-duplicate' | 'chart-mapping-unknown-column' | 'chart-mapping-adapted' | 'number-format-invalid';
+type DataDiagnosticCode = 'chart-value-not-numeric' | 'dataset-unknown' | 'dataset-field-unknown' | 'data-column-duplicate' | 'chart-mapping-unknown-column' | 'chart-mapping-adapted' | 'chart-highlight-unknown-name' | 'chart-highlight-adapted' | 'number-format-invalid';
 interface DataDiagnostic {
     code: DataDiagnosticCode;
     severity: 'error' | 'warning';
@@ -80,10 +85,16 @@ type ResolvedChartData = {
     source?: DataSourceRef;
     /** The dataset id when the chart references one. */
     dataset?: string;
+    /**
+     * Combo charts only (FA-15): how each series is drawn, aligned with the series columns (`columns.slice(1)`). The series
+     * are ordered column series first, then the line series on the primary axis, then those on the secondary axis, each in
+     * plotted order, so every engine draws, exports and lists them in the legend alike.
+     */
+    combo?: ChartComboSeries[];
     diagnostics: DataDiagnostic[];
 } | {
     ok: false;
-    reason: 'data-not-inline' | 'dataset-unknown' | 'no-rows' | 'no-columns';
+    reason: 'dataset-unknown' | 'no-rows' | 'no-columns';
     message: string;
     diagnostics: DataDiagnostic[];
 };
@@ -109,9 +120,9 @@ declare function numberFormatError(format: unknown): string | undefined;
 /** Format a number with a NumberFormat; an absent or invalid format prints the General form (String(value)). */
 declare function formatDataNumber(value: number, format?: string): string;
 /** NumberFormat -> Excel format code ("General" when absent or invalid). Literal prefix/suffix text is quoted or escaped; placeholders are written '#' before '0' ("0#" -> "#0"). */
-declare function excelNumberFormat(format?: string): string;
+declare function toExcelNumberFormat(format?: string): string;
 /** Excel format code -> NumberFormat, or undefined when the code has no exact NumberFormat equivalent (General, sections, scaling commas, and placeholder orders Excel reads by position such as "0#" or "0.#0"). */
-declare function numberFormatFromExcel(code: string): string | undefined;
+declare function fromExcelNumberFormat(code: string): string | undefined;
 /** True when the value is a dataset reference (`{ dataset: "<id>" }`). */
 declare function isDatasetRef(value: unknown): value is DatasetRef;
 /** Diagnostics of the top-level datasets themselves: duplicate column names and invalid column formats. */
@@ -174,4 +185,4 @@ declare function resolveTableData(table: unknown, document?: unknown, options?:
 /** Display value of a table cell: a number with a format (cell, else column) becomes formatted text; anything else is returned unchanged. */
 declare function tableCellDisplayValue(cell: DataTableCell, columnFormat?: string): DataTableCell;
 
-export { numberFormatFromExcel as A, resolveChartData as B, type ChartMapping as C, type DataCellValue as D, resolveTableData as E, suggestChartNumberFix as F, tableCellDisplayValue as G, unusedDatasets as H, type ResolvedChartData as R, type ChartNumberFix as a, type ChartNumberFixOperation as b, type ChartNumberFixOptions as c, type DataColumn as d, type DataDiagnostic as e, type DataDiagnosticCode as f, type DataResolveOptions as g, type DataSourceRef as h, type DataStyledCell as i, type DataTableCell as j, type DataTableHeader as k, type DataTableValue as l, type DataTextRun as m, type Dataset as n, type DatasetRef as o, type ResolvedTableData as p, chartNumber as q, datasetDiagnostics as r, excelNumberFormat as s, formatDataNumber as t, inlineChartData as u, inlineDatasets as v, inlineTableData as w, isDatasetRef as x, isXYChartType as y, numberFormatError as z };
+export { resolveChartData as A, resolveTableData as B, type ChartMapping as C, type DataCellValue as D, suggestChartNumberFix as E, tableCellDisplayValue as F, toExcelNumberFormat as G, unusedDatasets as H, type ChartComboSeries as I, type ResolvedChartData as R, type ChartNumberFix as a, type ChartNumberFixOperation as b, type ChartNumberFixOptions as c, type DataColumn as d, type DataDiagnostic as e, type DataDiagnosticCode as f, type DataResolveOptions as g, type DataSourceRef as h, type DataStyledCell as i, type DataTableCell as j, type DataTableHeader as k, type DataTableValue as l, type DataTextRun as m, type Dataset as n, type DatasetRef as o, type ResolvedTableData as p, chartNumber as q, datasetDiagnostics as r, formatDataNumber as s, fromExcelNumberFormat as t, inlineChartData as u, inlineDatasets as v, inlineTableData as w, isDatasetRef as x, isXYChartType as y, numberFormatError as z };

package/dist/chunk-4LDGKLUC.js

@@ -0,0 +1,192 @@
+import { isRecord, same } from './chunk-CSQHPVGL.js';
+import { parseDocument, YAMLMap, Scalar, stringify } from 'yaml';
+
+function splitLines(source) {
+  const lines = [];
+  let start = 0;
+  let no = 1;
+  let i = 0;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === "\n" || c === "\r") {
+      lines.push({ text: source.slice(start, i), start, end: i, no: no++ });
+      if (c === "\r" && source[i + 1] === "\n") i++;
+      i++;
+      start = i;
+    } else i++;
+  }
+  if (start < source.length) lines.push({ text: source.slice(start), start, end: source.length, no });
+  return lines;
+}
+var Ctx = class {
+  constructor(source) {
+    this.source = source;
+    for (let i = 0; i < source.length; i++) {
+      if (source[i] === "\r") {
+        if (source[i + 1] === "\n") i++;
+        this.lineStarts.push(i + 1);
+      } else if (source[i] === "\n") this.lineStarts.push(i + 1);
+    }
+  }
+  source;
+  findings = [];
+  /** JSON Pointer in the converted document to the source range that produced it. */
+  ranges = /* @__PURE__ */ new Map();
+  lineStarts = [0];
+  location(range) {
+    let lo = 0;
+    let hi = this.lineStarts.length;
+    while (lo + 1 < hi) {
+      const mid = lo + hi >> 1;
+      if ((this.lineStarts[mid] ?? 0) <= range.start) lo = mid;
+      else hi = mid;
+    }
+    return { offset: range.start, length: Math.max(0, range.end - range.start), line: lo + 1, column: range.start - (this.lineStarts[lo] ?? 0) + 1 };
+  }
+  report(ruleId, severity, message, help, range, path = "") {
+    this.findings.push({ ruleId, severity, category: "format", scope: "document", path, message, help, location: this.location(range) });
+  }
+  error(rule, message, help, range, path = "") {
+    this.report(`markdown/${rule}`, "error", message, help, range, path);
+  }
+  warn(rule, message, help, range, path = "") {
+    this.report(`markdown/${rule}`, "warning", message, help, range, path);
+  }
+  get errors() {
+    return this.findings.filter((d) => d.severity === "error").length;
+  }
+  /** The source range of a JSON Pointer, falling back to the nearest ancestor that has one. */
+  rangeOf(pointer) {
+    for (let path = pointer; ; path = path.slice(0, path.lastIndexOf("/"))) {
+      const found = this.ranges.get(path);
+      if (found) return found;
+      if (!path) return void 0;
+    }
+  }
+};
+var lineRange = (first, last = first) => ({ start: first.start, end: last.end });
+function readYamlMapping(text, base, ctx, rule, context) {
+  const keys = /* @__PURE__ */ new Map();
+  const doc = parseDocument(text, { schema: "core", uniqueKeys: true, merge: false, prettyErrors: false });
+  let ok = true;
+  for (const error of doc.errors) {
+    ok = false;
+    const [start, end] = error.pos;
+    ctx.error(rule, `YAML: ${error.message.split("\n")[0]}`, "Fix the YAML syntax. Front matter and embedded blocks hold JSON-compatible YAML: mappings, sequences and scalars, no anchors or tags.", { start: base + start, end: base + Math.max(end, start) });
+  }
+  if (!ok) return { value: {}, keys, ok };
+  if (doc.contents === null) return { value: {}, keys, ok };
+  if (!(doc.contents instanceof YAMLMap)) {
+    ctx.error(`${rule}-not-mapping`, "Expected a YAML mapping of keys and values.", "Write `key: value` lines; a list or a bare value is not accepted here.", context);
+    return { value: {}, keys, ok: false };
+  }
+  for (const pair of doc.contents.items) {
+    const key = pair.key;
+    const name = key instanceof Scalar ? String(key.value) : void 0;
+    if (name !== void 0 && key?.range) keys.set(name, { start: base + key.range[0], end: base + (pair.value?.range?.[1] ?? key.range[1]) });
+  }
+  let value;
+  try {
+    value = doc.toJS({ maxAliasCount: 0 });
+  } catch (error) {
+    ctx.error(rule, `YAML: ${error.message}`, "Anchors and aliases are not accepted; write each value out.", context);
+    return { value: {}, keys, ok: false };
+  }
+  const bad = nonJson(value);
+  if (bad) {
+    ctx.error(rule, `YAML value is not JSON-compatible (${bad}).`, "Quote special numbers such as .inf or .nan to keep them as strings.", context);
+    return { value: {}, keys, ok: false };
+  }
+  return { value, keys, ok };
+}
+function nonJson(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? void 0 : "a number that is not finite";
+  if (value === null || typeof value === "string" || typeof value === "boolean") return void 0;
+  if (Array.isArray(value)) return value.map(nonJson).find(Boolean);
+  if (isRecord(value)) return Object.values(value).map(nonJson).find(Boolean);
+  return `a ${typeof value}`;
+}
+function writeYaml(value) {
+  for (const blockQuote of [true, false]) {
+    const text = stringify(value, { indent: 2, lineWidth: 0, minContentWidth: 0, blockQuote, defaultStringType: "PLAIN", defaultKeyType: "PLAIN" });
+    const doc = parseDocument(text, { schema: "core", uniqueKeys: true, merge: false });
+    if (!doc.errors.length && same(doc.toJS({ maxAliasCount: 0 }), value)) return text.endsWith("\n") ? text : `${text}
+`;
+  }
+  return void 0;
+}
+var DECIMAL = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+function scalarText(value) {
+  if (typeof value === "number") return DECIMAL.test(String(value)) ? String(value) : JSON.stringify(String(value));
+  const plain = value !== "" && value === value.trim() && !value.startsWith('"') && !/[\r\n]/.test(value) && !DECIMAL.test(value);
+  return plain ? value : JSON.stringify(value);
+}
+function readCsv(text) {
+  const rows = [];
+  let row = [];
+  let i = 0;
+  const n = text.length;
+  const endRecord = () => {
+    rows.push(row);
+    row = [];
+  };
+  while (i < n) {
+    while (text[i] === " " || text[i] === "	") i++;
+    if (text[i] === '"') {
+      let value = "";
+      i++;
+      for (; ; ) {
+        if (i >= n) return { rows, error: "A quoted field is not closed." };
+        if (text[i] === '"') {
+          if (text[i + 1] === '"') {
+            value += '"';
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        value += text[i++];
+      }
+      while (text[i] === " " || text[i] === "	") i++;
+      if (i < n && text[i] !== "," && text[i] !== "\n" && text[i] !== "\r") return { rows, error: "Text follows a closing quote." };
+      row.push({ value, quoted: true });
+    } else {
+      let j = i;
+      while (j < n && text[j] !== "," && text[j] !== "\n" && text[j] !== "\r") j++;
+      row.push({ value: text.slice(i, j).trim(), quoted: false });
+      i = j;
+    }
+    if (text[i] === ",") {
+      i++;
+      if (i >= n || text[i] === "\n" || text[i] === "\r") row.push({ value: "", quoted: false });
+      continue;
+    }
+    if (text[i] === "\r" && text[i + 1] === "\n") i++;
+    i++;
+    endRecord();
+  }
+  if (row.length) endRecord();
+  return { rows };
+}
+var needsQuotes = (value) => /[",\r\n]/.test(value) || value !== value.trim() || value === "";
+function csvField(cell, header = false) {
+  if (cell === null) return "";
+  if (typeof cell === "number") return String(cell);
+  if (typeof cell === "boolean") return String(cell);
+  const text = String(cell);
+  const ambiguous = !header && (DECIMAL.test(text) || /^(?:true|false)$/.test(text));
+  return needsQuotes(text) || ambiguous ? `"${text.replaceAll('"', '""')}"` : text;
+}
+var OPFMarkdownError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = "OPFMarkdownError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+export { Ctx, DECIMAL, OPFMarkdownError, csvField, lineRange, readCsv, readYamlMapping, scalarText, splitLines, writeYaml };

package/dist/{chunk-II5EYKZU.js → chunk-4VJDTF55.js}

@@ -1,94 +1,4 @@
-import { validatePresentation } from './chunk-IYCJUKWD.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 result = validatePresentation({ ...datasets ? { datasets } : {}, slides });
-  const errors = datasets ? result.errors : result.errors.filter((issue) => issue.params.code !== "dataset-unknown" && issue.params.code !== "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"];
-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)]);
-}
+import { runText } from './chunk-CSQHPVGL.js';
 
 // src/convert/text-lines.ts
 var LIST_PREFIX = /^([ \t]*)(?:([-*•+]|\d{1,3}[.)])[ \t]+)?/;
@@ -197,4 +107,4 @@ function fenceCode(source, language, filename) {
   return [`${fence}${info}`, ...source.split(/\r\n|\r|\n/), fence];
 }
 
-export { CONTENT_KEYS, FORMATTING, Loss, OPFConversionError, assertValidOutput, assertValidOwner, clone, concatText, contentKeysOf, fenceCode, hasFormatting, isPlainRun, isRecord, isSlideLike, joinLines, levelsFromIndents, lineIsPlain, linePlain, lineValue, parseCodeFence, parseListLine, parseQuoteLines, plainOf, refuse, report, runText, runsOf, same, splitRuns, splitWhen };
+export { fenceCode, levelsFromIndents, parseCodeFence, parseListLine, parseQuoteLines, splitWhen };

package/dist/chunk-5ZU6JAPP.js

@@ -0,0 +1,83 @@
+import { presentation } from './chunk-LS2FMPI5.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 };