@openpresentation/opf-editor 0.11.3 → 0.12.1

package/dist/switches.js

@@ -2,6 +2,7 @@
 // dimension that turns "switch this dimension to X" into a validated JSON Patch, and applies
 // it to an editor session as one undoable transaction. The preview recomposes and the PPTX
 // export follows from the same document, so no dimension needs a special refresh path.
+import * as core from "@openpresentation/opf";
 import { catalogSchemaNames, catalogs as bundledCatalogs, schemas } from "@openpresentation/opf";
 import {
   OPFEditorError,
@@ -251,7 +252,7 @@ export function prepareDimensionSwitch(document, dimension, value, options = {})
       throw fail("path-slide-mismatch", "options.path is not on the slide named by options.slideIndex.", { slideIndex, path: options.path });
     const chart = owner && getValueAtPath(document, [...owner, "chart"]);
     if (!chart || typeof chart !== "object") throw fail("chart-not-found", "This slide has no chart to switch. Insert a chart block first.", { slideIndex, path: options.path });
-    patches = [...catalogRecordPatches(document, dimension, options), ...(chart.type === value ? [] : createValuePatch(document, [...owner, "chart", "type"], value))];
+    patches = [...catalogRecordPatches(document, dimension, options), ...(chart.type === value ? [] : [...createValuePatch(document, [...owner, "chart", "type"], value), ...staleMappingPatches(document, owner, chart, value)])];
   } else if (dimension === "blocks") {
     if (options.path === undefined) throw fail("missing-path", "Choose the block to replace with options.path.");
     // convert: true moves the block's own text into the new kind (block-convert.js) instead of replacing it.
@@ -394,11 +395,27 @@ const SINGLE_SERIES_ONLY = new Set(["pieChart", "doughnutChart", "funnelChart",
 const MULTI_SERIES_CAPABLE = new Set(["barChart", "lineChart", "areaChart", "radarChart"]);
 const DISTRIBUTION_ELEMENTS = new Set(["histogramChart", "boxWhiskerChart", "mapChart"]);
 
-function chartDataShape(chart) {
-  const data = chart?.data;
-  if (!data || !Array.isArray(data.columns) || !Array.isArray(data.rows)) return undefined;
-  // The renderers read the first column as the category label and every further column as a series.
-  return { series: Math.max(0, data.columns.length - 1), categories: data.rows.length };
+// RR-54: `mapping.x` names the X column of an XY chart; a type without an X axis ignores it (core warns chart-mapping-adapted). Switching to such a
+// type removes it, and the whole mapping when nothing else is left, so the document does not keep a warning it cannot act on.
+function staleMappingPatches(document, owner, chart, type) {
+  const mapping = chart.mapping;
+  if (!mapping || typeof mapping !== "object" || Array.isArray(mapping) || mapping.x === undefined) return [];
+  if (typeof core.isXYChartType !== "function" || core.isXYChartType(type)) return [];
+  const { x: _x, ...rest } = mapping;
+  const parts = [...owner, "chart", "mapping"];
+  return Object.keys(rest).length ? createValuePatch(document, parts, rest) : [{ op: "remove", path: opfPathToJsonPointer(parts) }];
+}
+
+function chartDataShape(chart, document) {
+  // RR-54: inline data, a dataset reference and a series mapping all resolve to the columns the renderers read: the first column labels
+  // the categories and every further column is a series.
+  if (typeof core.resolveChartData !== "function") {
+    const data = chart?.data;
+    return data && Array.isArray(data.columns) && Array.isArray(data.rows) ? { series: Math.max(0, data.columns.length - 1), categories: data.rows.length } : undefined;
+  }
+  const resolved = core.resolveChartData(chart, document);
+  if (!resolved.ok) return undefined;
+  return { series: Math.max(0, resolved.columns.length - 1), categories: resolved.rows.length };
 }
 
 /**
@@ -415,7 +432,7 @@ export function compatibleChartTypes(document, options = {}) {
   const owner = options.path ? splitOpfPath(options.path) : document.slides?.[slideIndex] ? findChartOwner(document, slideIndex) : undefined;
   const chart = owner && getValueAtPath(document, [...owner, "chart"]);
   if (!chart || typeof chart !== "object") return [];
-  const shape = chartDataShape(chart);
+  const shape = chartDataShape(chart, document);
   const result = [];
   for (const option of listSwitchOptions(document, "charts", options)) {
     const record = option.record;

package/dist/table-options.js

@@ -32,7 +32,11 @@ const RULE_COLOR = "textSecondary";
 
 const isObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 const isStyled = (cell) => isObject(cell) && Object.hasOwn(cell, "value");
-const valueOf = (cell) => (isStyled(cell) ? cell.value : cell);
+// RR-54: a header may be a DataColumn `{ name, format? }`. Styling or merging it makes it the equivalent styled header `{ value: name, format?, ... }`
+// (a styled header's `format` is the column's format, the same as a DataColumn's).
+const isColumnObject = (cell) => isObject(cell) && Object.hasOwn(cell, "name") && !Object.hasOwn(cell, "value");
+const asStyled = (cell) => (isColumnObject(cell) ? { value: cell.name, ...(typeof cell.format === "string" ? { format: cell.format } : {}) } : cell);
+const valueOf = (cell) => (isStyled(cell) ? cell.value : isColumnObject(cell) ? cell.name : cell);
 const isEmptyValue = (value) => value === null || value === undefined || value === "" || (Array.isArray(value) && value.every((run) => (typeof run === "string" ? run === "" : run?.text === "")));
 const clone = (value) => structuredClone(value);
 
@@ -58,6 +62,8 @@ export function parseTableCellPath(path) {
 function tableAt(document, tablePath) {
   const parts = splitOpfPath(tablePath);
   const table = getValueAtPath(document, parts);
+  if (isObject(table) && !Array.isArray(table.rows) && typeof table.dataset === "string")
+    throw fail("table-dataset-backed", `This table shows the shared dataset '${table.dataset}', which holds no cell styles or merged cells. Use a copy of the data (in the data grid) to style it.`, { tablePath, dataset: table.dataset });
   if (!isObject(table) || !Array.isArray(table.rows)) throw fail("table-not-found", "Choose a table (a path ending in .table).", { tablePath });
   return { parts, table };
 }
@@ -143,14 +149,17 @@ function joinedValue(values) {
   return parts.map(plainText).join(" ");
 }
 
-function withCell(raw, patch) {
+function withCell(cell, patch) {
   // A styled cell with no style and no spans collapses back to the plain value.
+  const raw = asStyled(cell);
   const merged = isStyled(raw) ? { ...raw } : { value: raw };
   for (const [key, value] of Object.entries(patch)) {
     if (value === undefined || value === null || (key === "style" && isObject(value) && !Object.keys(value).length)) delete merged[key];
     else merged[key] = value;
   }
   const keys = Object.keys(merged);
+  // A DataColumn header that gained no style or span stays a DataColumn.
+  if (isColumnObject(cell) && keys.every((key) => key === "value" || key === "format")) return cell;
   return keys.length === 1 && keys[0] === "value" ? merged.value : merged;
 }
 
@@ -226,7 +235,8 @@ export function prepareTableMerge(document, tablePath, cell, span, options = {})
     for (const entry of covered) entry.line[entry.column] = null;
     const anchorLine = lineOf(table, target);
     const raw = anchorLine[target.column];
-    anchorLine[target.column] = withCell(isStyled(raw) ? { ...raw, value: anchorValue } : anchorValue, { colSpan: colSpan > 1 ? colSpan : undefined, rowSpan: rowSpan > 1 ? rowSpan : undefined });
+    const base = asStyled(raw);
+    anchorLine[target.column] = withCell(isStyled(base) ? { ...base, value: anchorValue } : anchorValue, { colSpan: colSpan > 1 ? colSpan : undefined, rowSpan: rowSpan > 1 ? rowSpan : undefined });
     return { merged: true, joined: filled.length > 0 };
   }, { action: "merge", cell, span: { colSpan, rowSpan } });
 }

package/dist/transfer.js

@@ -187,6 +187,30 @@ export function prepareOpfImport(
     assetIds.add(next);
     assetMap.set(id, next);
   }
+  // RR-54: a chart or table that shows a shared dataset (`{ dataset: id }`) brings that dataset along. A dataset the deck already holds
+  // with the same content is shared; one with the same id and other content is stored under a free id and the references follow it.
+  const datasetMap = new Map();
+  const usedDatasets = new Set();
+  const collectDatasets = (value, key = "") => {
+    if (Array.isArray(value)) value.forEach((child) => collectDatasets(child, key));
+    else if (value && typeof value === "object") for (const [childKey, child] of Object.entries(value)) collectDatasets(child, childKey);
+    else if (key === "dataset" && typeof value === "string") usedDatasets.add(value);
+  };
+  collectDatasets(incoming.slides);
+  const datasetIds = new Set(Object.keys(document.datasets ?? {}));
+  for (const id of usedDatasets) {
+    const mine = incoming.datasets && Object.hasOwn(incoming.datasets, id) ? incoming.datasets[id] : undefined;
+    if (mine === undefined) continue;
+    if (datasetIds.has(id) && JSON.stringify(document.datasets[id]) === JSON.stringify(mine)) {
+      datasetMap.set(id, id);
+      continue;
+    }
+    let next = id,
+      n = 2;
+    while (datasetIds.has(next)) next = `${id}-${n++}`;
+    datasetIds.add(next);
+    datasetMap.set(id, next);
+  }
   const rewrite = (value, key = "") => {
     if (Array.isArray(value)) return value.map((child) => rewrite(child, key));
     if (value && typeof value === "object") {
@@ -210,6 +234,7 @@ export function prepareOpfImport(
       return result;
     }
     if (typeof value === "string") {
+      if (key === "dataset" && datasetMap.has(value)) return datasetMap.get(value);
       if (mappings[key]?.has(value)) return mappings[key].get(value);
       if (
         ["src", "image", "video", "poster"].includes(key) &&
@@ -243,6 +268,11 @@ export function prepareOpfImport(
           ? `asset:${assetMap.get(asset.slice(6))}`
           : asset;
   }
+  for (const [id, next] of datasetMap) {
+    if (document.datasets && Object.hasOwn(document.datasets, next)) continue;
+    document.datasets ??= {};
+    document.datasets[next] = clone(incoming.datasets[id]);
+  }
   const ids = new Set(collectReservedPresentationIds(document));
   for (const slide of rewritten.slides) remapSlideTreeIds(slide, ids);
   const index = Math.max(0, Math.min(document.slides.length, slideIndex + 1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-editor",
-  "version": "0.11.3",
+  "version": "0.12.1",
   "description": "Embeddable local OPF editor primitives built on the deterministic renderer.",
   "license": "MIT",
   "type": "module",
@@ -230,6 +230,8 @@
     "test:template-panel-browser": "node test/template-panel-browser.mjs",
     "test:design-gaps-browser": "node test/design-gaps-browser.mjs",
     "test:data-grid-browser": "node test/data-grid-browser.mjs",
+    "test:data-grid-datasets-browser": "node test/data-grid-datasets-browser.mjs",
+    "test:data-import-dataset-browser": "node test/data-import-dataset-browser.mjs",
     "test:slides-browser": "node test/slides-browser.mjs",
     "test:persistence-browser": "node test/persistence-browser.mjs",
     "test:find-browser": "node test/find-replace-browser.mjs",
@@ -249,11 +251,11 @@
     "@codemirror/state": "6.7.6",
     "@codemirror/view": "6.43.13",
     "@lezer/highlight": "1.2.4",
-    "@openpresentation/opf": "^0.12.2",
+    "@openpresentation/opf": "^0.13.0",
     "jsonc-parser": "3.3.1"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.12.2"
+    "@openpresentation/opf-render": "^0.13.1"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -295,8 +297,8 @@
     "@expo-google-fonts/noto-sans-thai": "0.4.2",
     "@expo-google-fonts/noto-serif-hebrew": "0.4.2",
     "@expo-google-fonts/noto-serif-tibetan": "0.4.2",
-    "@openpresentation/opf-pptx": "^0.12.4",
-    "@openpresentation/opf-render": "^0.12.2",
+    "@openpresentation/opf-pptx": "^0.13.2",
+    "@openpresentation/opf-render": "^0.13.1",
     "axe-core": "4.13.0",
     "esbuild": "0.28.2",
     "jszip": "3.10.2",