@openpresentation/opf-editor 0.26.4 → 0.26.5

package/dist/source-snippets.js

@@ -76,6 +76,18 @@ export const SNIPPETS = Object.freeze([
   { prefix: "notes", where: "markdown", key: "notes", description: "Speaker notes for the slide", fragment: ph(1, "Speaker notes") },
 ]);
 
+/**
+ * Snippets a KEY of the deck is accepted as (SPEC 5: `design`, `organization`, `speaker`): not items of the list on their own (`SNIPPETS` holds
+ * those), but what accepting the property writes, as VS Code does for a property with default snippets. The fragment is the value of the key. They hold
+ * the required members of the object, each a tab stop (SPEC 5 lists only `name` for the speaker; the Speaker schema requires an id too), and `design`
+ * opens the list of the catalog at each stop.
+ */
+export const KEY_SNIPPETS = Object.freeze([
+  { prefix: "design", where: "deck-key", key: "design", description: "The design of the deck: a theme, a color scheme and a font scheme", fragment: { theme: ph(1, "", { choice: true }), colorScheme: ph(2, "", { choice: true }), fontScheme: ph(3, "", { choice: true }) } },
+  { prefix: "organization", where: "deck-key", key: "organization", description: "The organization presenting the deck: an id and a name", fragment: { id: ph(1, "acme"), name: ph(2, "Acme Inc.") } },
+  { prefix: "speaker", where: "deck-key", key: "speaker", description: "The person presenting the deck: an id and a name", fragment: { id: ph(1, "alice"), name: ph(2, "Name") } },
+]);
+
 /** The snippets that fit where the caret is: `where` and the path of the node (see source-json.js). */
 export function snippetsFor(mode, path) {
   const last = path.at(-1);
@@ -88,6 +100,14 @@ export function snippetsFor(mode, path) {
   });
 }
 
+/**
+ * The snippets a key of the object at `path` is accepted as (the deck's `design`, `organization`, `speaker`): not items of their own in the list,
+ * but what accepting that property writes, as VS Code does for a property with default snippets.
+ */
+export function keySnippetsFor(path) {
+  return path.length === 0 ? KEY_SNIPPETS : [];
+}
+
 /** The JSON text of a snippet for insertion: `{ text, fields }`; a dataset is a `"name": { ... }` entry. */
 export function snippetJson(snippet, { comma = false } = {}) {
   if (snippet.key !== undefined) {

package/dist/source-undo-groups.js

@@ -0,0 +1,46 @@
+// One undo step for a suggestion and the value list it opened (artifacts/source-editor/SPEC.md, section 4.6, item 4; TEST-PLAN J-INS-017). Accepting a key
+// of a closed set of values writes `"key": ""` and opens the list of the values; accepting a value is a second edit. Each is an edit of its own in
+// CodeMirror's history, as every accepted suggestion is, so the pair is recorded here and Undo and Redo step over both: one Cmd+Z puts back the text
+// the author had typed before accepting the key (VS Code: "accept is one step with its typed prefix undoable"). Anything typed in between, or any
+// other edit after the pair, makes the pair void, so Undo is the plain one again. Plain functions over an editor view, no DOM.
+import { redo, undo, undoDepth, redoDepth } from "@codemirror/commands";
+
+const pending = new WeakMap();
+const pairs = new WeakMap();
+
+/** A suggestion that opens a list of values was accepted: the text before it and after it. */
+export function beginUndoGroup(view, before) {
+  pending.set(view, { before, after: view.state.doc });
+}
+
+/** A suggestion is about to be accepted: the pair it completes (the key accepted just before, with nothing typed since), or null. */
+export function takeUndoGroup(view) {
+  const link = pending.get(view);
+  pending.delete(view);
+  pairs.delete(view);
+  return link && link.after.eq(view.state.doc) ? link : null;
+}
+
+/** The value was accepted (and the history closed after it): the key and the value are one undo step from now on. */
+export function finishUndoGroup(view, link) {
+  pairs.set(view, { before: link.before, after: view.state.doc, depth: undoDepth(view.state), undone: false });
+}
+
+/** Whether Undo should step over the last pair; does it when so (returns true). Otherwise the caller does the plain undo. */
+export function undoPair(view) {
+  const pair = pairs.get(view);
+  if (!pair || pair.undone || undoDepth(view.state) !== pair.depth || !view.state.doc.eq(pair.after)) return false;
+  for (let step = 0; step < 3 && !view.state.doc.eq(pair.before); step++) if (!undo(view)) break;
+  pair.undone = view.state.doc.eq(pair.before);
+  pair.redoDepth = redoDepth(view.state);
+  return true;
+}
+
+/** The same for Redo: after the pair was undone, Redo puts both back. */
+export function redoPair(view) {
+  const pair = pairs.get(view);
+  if (!pair || !pair.undone || redoDepth(view.state) !== pair.redoDepth || !view.state.doc.eq(pair.before)) return false;
+  for (let step = 0; step < 3 && !view.state.doc.eq(pair.after); step++) if (!redo(view)) break;
+  pair.undone = !view.state.doc.eq(pair.after);
+  return true;
+}

package/dist/source-yaml.js

@@ -220,16 +220,40 @@ function inComment(line, column) {
   return false;
 }
 
+/** The quote character of a quoted scalar that `value` opens and does not close, or null (a quoted scalar may run over several lines). */
+export function openQuote(value) {
+  const text = value.trimStart();
+  const quote = text[0];
+  if (quote !== '"' && quote !== "'") return null;
+  return closesQuote(text.slice(1), quote) ? null : quote;
+}
+
+/** Whether `text` (the rest of a quoted scalar) holds its closing quote. */
+function closesQuote(text, quote) {
+  for (let index = 0; index < text.length; index++) {
+    if (quote === '"' && text[index] === "\\") { index++; continue; }
+    if (text[index] === quote) {
+      if (quote === "'" && text[index + 1] === "'") { index++; continue; }
+      return true;
+    }
+  }
+  return false;
+}
+
 /**
- * Walk the lines before `stop` (a line index), applying each to `stack`. Lines inside a block scalar or a flow collection that spans lines, blank
- * lines, comments and document markers change nothing. Returns `{ block, flow }`: the column a block scalar's text must be indented past (or -1) and
- * the depth of an unclosed flow collection (0 when none) at line `stop`, so the caller knows whether that line is inside either.
+ * Walk the lines before `stop` (a line index), applying each to `stack`. Lines inside a block scalar, a flow collection or a quoted scalar that span
+ * lines, blank lines, comments and document markers change nothing. Returns `{ block, flow, quote, open }`: the column a block scalar's text must be
+ * indented past (or -1), the depth of an unclosed flow collection (0 when none), the quote of an unclosed quoted scalar (or null) at line `stop`, so
+ * the caller knows whether that line is inside any of them, and for a flow collection `open`: the line it began on and where it sits in the stack.
  */
 function walk(lines, stop, stack) {
   let block = -1;
   let flow = 0;
+  let quote = null;
+  let open = null;
   for (let number = 0; number < stop; number++) {
     const text = lines[number].text;
+    if (quote) { if (closesQuote(text, quote)) quote = null; continue; }
     if (text.trim() === "") continue;
     const indent = text.length - text.trimStart().length;
     if (block >= 0) {
@@ -244,11 +268,14 @@ function walk(lines, stop, stack) {
     const value = entry ? parsed.rest.slice(entry.valueStart) : parsed.rest;
     const shape = entry ? shapeOfValue(value) : (parsed.markers.length ? shapeOfValue(value) : undefined);
     if (!entry && !parsed.markers.length) continue;
-    enter(stack, parsed, entry, shape);
+    const placed = enter(stack, parsed, entry, shape);
     if (shape?.block) block = entry ? parsed.restStart + entry.keyStart : parsed.markers.at(-1);
-    else if (shape?.flow) flow = flowDepth(value, 0);
+    else if (shape?.flow) {
+      flow = flowDepth(value, 0);
+      open = flow > 0 ? { number, parsed, entry, value, placed } : null;
+    } else if (shape && "scalar" in shape) quote = openQuote(value);
   }
-  return { block, flow };
+  return { block, flow, quote, open };
 }
 
 // ---- flow collections on one line --------------------------------------------------------------------------------------------------
@@ -401,7 +428,13 @@ function keyToken(text, line, restStart, position) {
  * colon yet. Options: `explicit` (Ctrl+Space also takes an empty place), `prefix` (the path of the node the text is the body of, for YAML in a fence of
  * a Markdown slide), `exclude` (keys never offered, the `slides` of front matter).
  */
-export function yamlContextAt(text, position, { explicit = false, prefix = [], exclude = [] } = {}) {
+export function yamlContextAt(text, position, options = {}) {
+  const context = readContext(text, position, options);
+  // The text the context was read from, and the path it is the body of: the references the value lists offer are looked up in it.
+  return context ? { ...context, sourceText: text, prefix: options.prefix ?? [] } : null;
+}
+
+function readContext(text, position, { explicit = false, prefix = [], exclude = [] }) {
   const lines = linesOf(text);
   const number = lineIndex(lines, position);
   const line = lines[number];
@@ -414,8 +447,10 @@ export function yamlContextAt(text, position, { explicit = false, prefix = [], e
   const state = walk(lines, number, stack);
   const lineIndent = lineText.length - lineText.trimStart().length;
   if (state.block >= 0 && (trimmedLine === "" ? column > state.block : lineIndent > state.block)) return null;
-  if (state.flow > 0) return null;
   const before = lineText.slice(0, column);
+  // A line inside a quoted scalar that began above: text, in which only `{{` of a variable is completed.
+  if (state.quote) return continuationContext({ text, line, position, before, explicit });
+  if (state.flow > 0) return flowContinuation({ text, lines, number, line, position, column, explicit, prefix, exclude, open: state.open });
   const parsed = readMarkers(before);
   // The key is read from the whole line: a colon after the caret that ends the key (`top:le|ft: x`) is not the colon before it.
   const whole = readMarkers(lineText);
@@ -425,6 +460,53 @@ export function yamlContextAt(text, position, { explicit = false, prefix = [], e
   return entry ? valueContext({ ...shared, entry }) : keyOrItemContext(shared);
 }
 
+const VARIABLE_OPEN = /\{\{[A-Za-z0-9._-]*$/;
+
+/**
+ * A line of text that continues a scalar begun on a line above (a quoted scalar left open, or a sentence that runs on): nothing to complete in it
+ * except the name of a variable after `{{`. The context is a value in the text sense (`multiline`), with no path.
+ */
+function continuationContext({ text, line, position, before, explicit }) {
+  if (!VARIABLE_OPEN.test(before)) return null;
+  let end = position;
+  while (end < line.end && /[A-Za-z0-9._-]/.test(text[end])) end++;
+  const start = line.start + (line.text.length - line.text.trimStart().length);
+  return { format: "yaml", mode: "value", multiline: true, token: { quoted: true, closed: false, start, end, from: start, to: end }, path: [], key: undefined, existing: new Set(), document: {}, itemStart: false, flow: false, needsSpace: false, column: 0, indent: 0, explicit };
+}
+
+// The text of a line without its comment (a `#` after a space, outside quotes).
+function withoutComment(text) {
+  let quote = null;
+  for (let index = 0; index < text.length; index++) {
+    const character = text[index];
+    if (quote) {
+      if (quote === '"' && character === "\\") index++;
+      else if (character === quote) quote = null;
+    } else if (character === '"' || character === "'") {
+      if (index === 0 || /[\s[{,:-]/.test(text[index - 1])) quote = character;
+    } else if (character === "#" && (index === 0 || isSpace(text[index - 1]))) return text.slice(0, index);
+  }
+  return text;
+}
+
+/**
+ * A caret on a line inside a flow collection that began on an earlier line (`tags: [a,` / `  b, |]`, `{theme: minimal,` / `  |}`): the lines from
+ * the opening one to the caret are read as one text, so the containers open at the caret and the keys and items before it are known as on one line.
+ */
+function flowContinuation({ text, lines, number, line, position, column, explicit, prefix, exclude, open }) {
+  if (!open) return null;
+  const first = lines[open.number].text;
+  const start = open.entry ? open.parsed.restStart + open.entry.valueStart : open.parsed.restStart;
+  const middle = lines.slice(open.number + 1, number).map((item) => withoutComment(item.text).trim());
+  const joined = [withoutComment(first.slice(start)).trimStart(), ...middle, line.text.slice(0, column).trimStart()].join(" ");
+  const flow = flowAt(joined, joined.length);
+  if (!flow) return null;
+  const { map, seq } = open.placed;
+  const frame = open.entry ? map : seq;
+  const base = open.entry ? [...map.path, open.entry.key] : [...seq.path, seq.count - 1];
+  return flowContext({ text, line, position, flow, base, frame, lines, explicit, prefix, exclude });
+}
+
 function valueContext({ text, lines, line, position, parsed, entry, explicit, prefix, stack, lineIndent, exclude }) {
   const lineText = line.text;
   let valueFrom = line.start + parsed.restStart + entry.valueStart;
@@ -465,7 +547,10 @@ function keyOrItemContext({ text, lines, number, line, position, parsed, explici
   }
   const quoteOpen = rest[0] === '"' || rest[0] === "'";
   // The word before the caret is a plain key (or the start of a scalar item) or an unfinished quoted key; anything else (a sentence) is prose.
-  if (!quoteOpen && rest !== "" && !/^[A-Za-z0-9_.$+:-]+$/.test(rest)) return null;
+  if (!quoteOpen && rest !== "" && !/^[A-Za-z0-9_.$+:-]+$/.test(rest)) {
+    // A sentence that runs on from a scalar above: only a variable (`{{`) is completed in it.
+    return parsed.markers.length ? null : continuationContext({ text, line, position, before: lineText.slice(0, position - line.start), explicit });
+  }
   let seq = null;
   for (const col of parsed.markers) { seq = stack.seqAt(col); seq.items[seq.count - 1] = { open: true }; }
   const frame = stack.mapAt(parsed.restStart);

package/dist/styles.css

@@ -3639,6 +3639,13 @@ input.opf-lx-input[data-field="max"] { font-family: var(--opf-ui-mono); font-siz
   opacity: 0.85;
 }
 
+:root :is(.opf-ui, .opf-json, .opf-code) .cm-tooltip-autocomplete > .opf-completion-footer {
+  padding: 4px 8px;
+  font: 12px/1.4 var(--opf-ui-font);
+  color: var(--opf-ui-muted-fg);
+  border-top: 1px solid var(--opf-ui-border);
+}
+
 :root :is(.opf-ui, .opf-json, .opf-code) .cm-tooltip-autocomplete .cm-completionMatchedText {
   font-weight: 600;
   text-decoration: none;
@@ -4268,6 +4275,25 @@ input.opf-lx-input[data-field="max"] { font-family: var(--opf-ui-mono); font-siz
   cursor: pointer;
 }
 .opf-source-finding-fix:hover { background: var(--opf-ui-muted); }
+.opf-source-finding-details {
+  min-height: 22px;
+  padding: 0 8px;
+  border: 1px solid transparent;
+  border-radius: var(--opf-ui-radius-sm);
+  background: transparent;
+  color: var(--opf-ui-muted-fg);
+  font-size: 12px;
+  text-decoration: underline;
+  cursor: pointer;
+}
+.opf-source-finding-details:hover { background: var(--opf-ui-muted); }
+.opf-source-finding-details[aria-expanded="true"] { text-decoration: none; background: var(--opf-ui-muted); }
+.opf-source-finding-explain { display: flex; flex-direction: column; gap: 4px; margin: 0 6px 6px 28px; padding: 6px 8px; border-left: 2px solid var(--opf-ui-border); color: var(--opf-ui-fg); font-size: 12px; }
+.opf-source-finding-explain[hidden] { display: none; }
+.opf-source-finding-explain-line { margin: 0; overflow-wrap: anywhere; }
+.opf-source-finding-explain-example { font: 11px var(--opf-ui-mono); overflow-wrap: anywhere; white-space: pre-wrap; }
+.opf-source-finding-explain-example code { padding: 1px 4px; border-radius: var(--opf-ui-radius-sm); background: var(--opf-ui-muted); }
+.opf-source-finding-explain-link { color: var(--opf-ui-muted-fg); }
 .opf-source-finding-more { padding: 3px 6px; color: var(--opf-ui-muted-fg); font-size: 12px; }
 
 .opf-source-status { position: absolute; width: 1px; height: 1px; margin: -1px; padding: 0; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; border: 0; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-editor",
-  "version": "0.26.4",
+  "version": "0.26.5",
   "description": "Embeddable local OPF editor primitives built on the deterministic renderer.",
   "license": "MIT",
   "type": "module",
@@ -283,10 +283,10 @@
     "@lezer/highlight": "1.2.5",
     "jsonc-parser": "3.3.1",
     "yaml": "^2.9.1",
-    "@openpresentation/opf": "^0.26.4"
+    "@openpresentation/opf": "^0.26.5"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.26.4"
+    "@openpresentation/opf-render": "^0.26.5"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -345,9 +345,9 @@
     "pdf-lib": "1.17.1",
     "pdfjs-dist": "6.4.299",
     "playwright": "1.64.0",
-    "@openpresentation/gallery": "0.26.4",
-    "@openpresentation/opf-pptx": "0.26.4",
-    "@openpresentation/opf-render": "0.26.4"
+    "@openpresentation/gallery": "0.26.5",
+    "@openpresentation/opf-render": "0.26.5",
+    "@openpresentation/opf-pptx": "0.26.5"
   },
   "scripts": {
     "build": "node scripts/build.mjs",
@@ -388,6 +388,7 @@
     "test:source-keyboard-json-browser": "node test/source-keyboard-json-browser.mjs",
     "test:source-keyboard-yaml-browser": "node test/source-keyboard-yaml-browser.mjs",
     "test:source-keyboard-markdown-browser": "node test/source-keyboard-markdown-browser.mjs",
+    "test:source-diagnostics-browser": "node test/source-diagnostics-browser.mjs",
     "test:layout-editor-browser": "node test/layout-editor-browser.mjs",
     "test:export-license-browser": "node test/export-license-browser.mjs",
     "test:chart-options-browser": "node test/chart-options-browser.mjs",
@@ -397,5 +398,5 @@
     "test:export-menu-browser": "node test/export-menu-browser.mjs",
     "test:agent-handoff-browser": "node test/agent-handoff-browser.mjs"
   },
-  "gitHead": "8809122a74a43aa99cdd383a856839ad6f018af6"
+  "gitHead": "750d120e715b6c4930906aa71322d092d057c58d"
 }