@sametalmdr/word-editor 0.2.0-alpha → 0.3.0-alpha

package/dist/model/ids.js

@@ -1,70 +1,70 @@
-/**
- * @typedef {object} IdFactory
- * @property {() => number} next
- * @property {() => number} peek
- */
-
-/**
- * Monotonic id source, scoped to one document. Per-document rather than global
- * so tests are deterministic; ARCHITECTURE.md §4 only requires uniqueness within
- * a document.
- *
- * When loading a document from storage, seed `start` past the largest existing
- * id so new nodes never collide with restored ones.
- *
- * @param {number} [start]
- * @returns {IdFactory}
- */
-export function createIdFactory(start = 1) {
-  let next = start;
-  return {
-    next() {
-      return next++;
-    },
-    peek() {
-      return next;
-    },
-  };
-}
-
-/**
- * Scans an already-constructed Doc for its highest NodeId — `doc.id`, every
- * container/paragraph id under `doc.content`, every decoration id, every
- * image id. Runs carry no NodeId (node.js's Run typedef has no `id` field) so
- * they are not visited.
- *
- * Mirrors the maxId-tracking pattern `document-json.js`'s JSON parser and
- * `import.js`'s DOCX importer each use to seed a factory past every id
- * already in use — but against a FINISHED Doc rather than while building one,
- * since neither existing tracker (one interleaved with raw JSON field
- * parsing, one a live mint-time counter) is callable against a Doc that
- * already exists. Used by `loadDocument` to reseed the shared IdFactory when
- * swapping documents (ADR-0027 Ek 49) — without this, a factory minted for
- * one document keeps handing out ids that may already be in use in the next.
- * @param {import("./node.js").Doc} doc
- * @returns {number}
- */
-export function maxNodeId(doc) {
-  let max = doc.id;
-  for (const container of doc.content) {
-    if (container.id > max) {
-      max = container.id;
-    }
-    for (const paragraph of container.content) {
-      if (paragraph.id > max) {
-        max = paragraph.id;
-      }
-    }
-  }
-  for (const decoration of doc.decorations) {
-    if (decoration.id > max) {
-      max = decoration.id;
-    }
-  }
-  for (const image of doc.images) {
-    if (image.id > max) {
-      max = image.id;
-    }
-  }
-  return max;
-}
+/**
+ * @typedef {object} IdFactory
+ * @property {() => number} next
+ * @property {() => number} peek
+ */
+
+/**
+ * Monotonic id source, scoped to one document. Per-document rather than global
+ * so tests are deterministic; ARCHITECTURE.md §4 only requires uniqueness within
+ * a document.
+ *
+ * When loading a document from storage, seed `start` past the largest existing
+ * id so new nodes never collide with restored ones.
+ *
+ * @param {number} [start]
+ * @returns {IdFactory}
+ */
+export function createIdFactory(start = 1) {
+  let next = start;
+  return {
+    next() {
+      return next++;
+    },
+    peek() {
+      return next;
+    },
+  };
+}
+
+/**
+ * Scans an already-constructed Doc for its highest NodeId — `doc.id`, every
+ * container/paragraph id under `doc.content`, every decoration id, every
+ * image id. Runs carry no NodeId (node.js's Run typedef has no `id` field) so
+ * they are not visited.
+ *
+ * Mirrors the maxId-tracking pattern `document-json.js`'s JSON parser and
+ * `import.js`'s DOCX importer each use to seed a factory past every id
+ * already in use — but against a FINISHED Doc rather than while building one,
+ * since neither existing tracker (one interleaved with raw JSON field
+ * parsing, one a live mint-time counter) is callable against a Doc that
+ * already exists. Used by `loadDocument` to reseed the shared IdFactory when
+ * swapping documents (ADR-0027 Ek 49) — without this, a factory minted for
+ * one document keeps handing out ids that may already be in use in the next.
+ * @param {import("./node.js").Doc} doc
+ * @returns {number}
+ */
+export function maxNodeId(doc) {
+  let max = doc.id;
+  for (const container of doc.content) {
+    if (container.id > max) {
+      max = container.id;
+    }
+    for (const paragraph of container.content) {
+      if (paragraph.id > max) {
+        max = paragraph.id;
+      }
+    }
+  }
+  for (const decoration of doc.decorations) {
+    if (decoration.id > max) {
+      max = decoration.id;
+    }
+  }
+  for (const image of doc.images) {
+    if (image.id > max) {
+      max = image.id;
+    }
+  }
+  return max;
+}

package/dist/model/normalize.js

@@ -1,146 +1,146 @@
-import { devAssert } from "../dev.js";
-import { canvasOf, createContainer, createDoc, createRun, marksEqual, rebuildParagraph } from "./node.js";
-
-/**
- * Canonicalises a run list:
- *   1. drop empty runs
- *   2. merge adjacent runs that share a mark set
- *   3. a paragraph with no text keeps exactly one empty run, so the renderer has
- *      somewhere to put the caret
- *
- * None of these rules move a character, so **no offset changes** — that is what
- * lets positions survive normalisation without being mapped (ADR-0002).
- *
- * @param {import("./node.js").Run[]} runs
- * @returns {import("./node.js").Run[]}
- */
-function normalizeRuns(runs) {
-  /** @type {import("./node.js").Run[]} */
-  const out = [];
-
-  for (const run of runs) {
-    if (run.text === "") {
-      continue;
-    }
-    const last = out[out.length - 1];
-    if (last !== undefined && marksEqual(last.marks, run.marks)) {
-      out[out.length - 1] = createRun(last.text + run.text, last.marks);
-    } else {
-      out.push(run);
-    }
-  }
-
-  if (out.length === 0) {
-    // Keep the first original run rather than a fresh one so an empty paragraph
-    // retains its marks — a paragraph split after bold text stays bold.
-    out.push(runs.length > 0 ? runs[0] : createRun(""));
-  }
-
-  return out;
-}
-
-/**
- * Returns the same paragraph object when it is already normalised. Preserving
- * identity matters: the renderer skips paragraphs that compare `===`.
- * @param {import("./node.js").Paragraph} para
- * @returns {import("./node.js").Paragraph}
- */
-export function normalizeParagraph(para) {
-  const runs = normalizeRuns(para.content);
-
-  if (runs.length === para.content.length) {
-    let identical = true;
-    for (let i = 0; i < runs.length; i += 1) {
-      if (runs[i] !== para.content[i]) {
-        identical = false;
-        break;
-      }
-    }
-    if (identical) {
-      return para;
-    }
-  }
-
-  return rebuildParagraph(para, runs);
-}
-
-/**
- * Returns the same container object when every paragraph in it is already
- * normalised — the identity preservation that lets the renderer skip whole
- * boxes with `===`.
- * @param {import("./node.js").Container} container
- * @param {Set<import("./node.js").NodeId>} [dirtyIds]
- * @returns {import("./node.js").Container}
- */
-export function normalizeContainer(container, dirtyIds) {
-  devAssert(
-    container.content.length > 0,
-    "container must always hold at least one paragraph",
-  );
-
-  /** @type {import("./node.js").Paragraph[] | null} */
-  let paragraphs = null;
-
-  for (let i = 0; i < container.content.length; i += 1) {
-    const para = container.content[i];
-    if (dirtyIds !== undefined && !dirtyIds.has(para.id)) {
-      continue;
-    }
-    const next = normalizeParagraph(para);
-    if (next !== para) {
-      if (paragraphs === null) {
-        paragraphs = container.content.slice();
-      }
-      paragraphs[i] = next;
-    }
-  }
-
-  return paragraphs === null ? container : createContainer(container.id, paragraphs);
-}
-
-/**
- * Normalises the paragraphs a transaction touched, walking containers then
- * paragraphs. Pass `dirtyIds` to skip the rest — untouched nodes keep their
- * identity either way, but skipping saves the scan on large documents.
- *
- * Two emptiness rules, both **bugs rather than states to repair**: a document
- * with zero containers, and a container with zero paragraphs. No step in the set
- * can produce either (`DeleteStep` cannot remove a paragraph,
- * `MergeParagraphsStep` requires a following sibling *inside the same
- * container*, and `RemoveContainerStep` is the only way to drop a container at
- * all). Repairing them here would mean minting a node id inside normalisation,
- * which would break `invert(apply(step)) === identity`. So they are asserted.
- *
- * Note this permits a document to reach zero containers via `RemoveContainer` —
- * the assertion catches it, and it is the command layer's job not to remove the
- * last one.
- *
- * @param {import("./node.js").Doc} doc
- * @param {Set<import("./node.js").NodeId>} [dirtyIds]
- * @returns {import("./node.js").Doc}
- */
-export function normalizeDoc(doc, dirtyIds) {
-  devAssert(doc.content.length > 0, "document must always hold at least one container");
-
-  /** @type {import("./node.js").Container[] | null} */
-  let content = null;
-
-  for (let i = 0; i < doc.content.length; i += 1) {
-    const container = doc.content[i];
-    const next = normalizeContainer(container, dirtyIds);
-    if (next !== container) {
-      if (content === null) {
-        content = doc.content.slice();
-      }
-      content[i] = next;
-    }
-  }
-
-  if (content === null) {
-    return doc;
-  }
-  // canvasOf, never a hand-listed set: a branch missing here would be silently
-  // reset to its empty default by createDoc (that is exactly how Doc.images was
-  // lost on every edit — see canvasOf's own note).
-  return createDoc(doc.id, content, doc.layout, canvasOf(doc));
-}
+import { devAssert } from "../dev.js";
+import { canvasOf, createContainer, createDoc, createRun, marksEqual, rebuildParagraph } from "./node.js";
+
+/**
+ * Canonicalises a run list:
+ *   1. drop empty runs
+ *   2. merge adjacent runs that share a mark set
+ *   3. a paragraph with no text keeps exactly one empty run, so the renderer has
+ *      somewhere to put the caret
+ *
+ * None of these rules move a character, so **no offset changes** — that is what
+ * lets positions survive normalisation without being mapped (ADR-0002).
+ *
+ * @param {import("./node.js").Run[]} runs
+ * @returns {import("./node.js").Run[]}
+ */
+function normalizeRuns(runs) {
+  /** @type {import("./node.js").Run[]} */
+  const out = [];
+
+  for (const run of runs) {
+    if (run.text === "") {
+      continue;
+    }
+    const last = out[out.length - 1];
+    if (last !== undefined && marksEqual(last.marks, run.marks)) {
+      out[out.length - 1] = createRun(last.text + run.text, last.marks);
+    } else {
+      out.push(run);
+    }
+  }
+
+  if (out.length === 0) {
+    // Keep the first original run rather than a fresh one so an empty paragraph
+    // retains its marks — a paragraph split after bold text stays bold.
+    out.push(runs.length > 0 ? runs[0] : createRun(""));
+  }
+
+  return out;
+}
+
+/**
+ * Returns the same paragraph object when it is already normalised. Preserving
+ * identity matters: the renderer skips paragraphs that compare `===`.
+ * @param {import("./node.js").Paragraph} para
+ * @returns {import("./node.js").Paragraph}
+ */
+export function normalizeParagraph(para) {
+  const runs = normalizeRuns(para.content);
+
+  if (runs.length === para.content.length) {
+    let identical = true;
+    for (let i = 0; i < runs.length; i += 1) {
+      if (runs[i] !== para.content[i]) {
+        identical = false;
+        break;
+      }
+    }
+    if (identical) {
+      return para;
+    }
+  }
+
+  return rebuildParagraph(para, runs);
+}
+
+/**
+ * Returns the same container object when every paragraph in it is already
+ * normalised — the identity preservation that lets the renderer skip whole
+ * boxes with `===`.
+ * @param {import("./node.js").Container} container
+ * @param {Set<import("./node.js").NodeId>} [dirtyIds]
+ * @returns {import("./node.js").Container}
+ */
+export function normalizeContainer(container, dirtyIds) {
+  devAssert(
+    container.content.length > 0,
+    "container must always hold at least one paragraph",
+  );
+
+  /** @type {import("./node.js").Paragraph[] | null} */
+  let paragraphs = null;
+
+  for (let i = 0; i < container.content.length; i += 1) {
+    const para = container.content[i];
+    if (dirtyIds !== undefined && !dirtyIds.has(para.id)) {
+      continue;
+    }
+    const next = normalizeParagraph(para);
+    if (next !== para) {
+      if (paragraphs === null) {
+        paragraphs = container.content.slice();
+      }
+      paragraphs[i] = next;
+    }
+  }
+
+  return paragraphs === null ? container : createContainer(container.id, paragraphs);
+}
+
+/**
+ * Normalises the paragraphs a transaction touched, walking containers then
+ * paragraphs. Pass `dirtyIds` to skip the rest — untouched nodes keep their
+ * identity either way, but skipping saves the scan on large documents.
+ *
+ * Two emptiness rules, both **bugs rather than states to repair**: a document
+ * with zero containers, and a container with zero paragraphs. No step in the set
+ * can produce either (`DeleteStep` cannot remove a paragraph,
+ * `MergeParagraphsStep` requires a following sibling *inside the same
+ * container*, and `RemoveContainerStep` is the only way to drop a container at
+ * all). Repairing them here would mean minting a node id inside normalisation,
+ * which would break `invert(apply(step)) === identity`. So they are asserted.
+ *
+ * Note this permits a document to reach zero containers via `RemoveContainer` —
+ * the assertion catches it, and it is the command layer's job not to remove the
+ * last one.
+ *
+ * @param {import("./node.js").Doc} doc
+ * @param {Set<import("./node.js").NodeId>} [dirtyIds]
+ * @returns {import("./node.js").Doc}
+ */
+export function normalizeDoc(doc, dirtyIds) {
+  devAssert(doc.content.length > 0, "document must always hold at least one container");
+
+  /** @type {import("./node.js").Container[] | null} */
+  let content = null;
+
+  for (let i = 0; i < doc.content.length; i += 1) {
+    const container = doc.content[i];
+    const next = normalizeContainer(container, dirtyIds);
+    if (next !== container) {
+      if (content === null) {
+        content = doc.content.slice();
+      }
+      content[i] = next;
+    }
+  }
+
+  if (content === null) {
+    return doc;
+  }
+  // canvasOf, never a hand-listed set: a branch missing here would be silently
+  // reset to its empty default by createDoc (that is exactly how Doc.images was
+  // lost on every edit — see canvasOf's own note).
+  return createDoc(doc.id, content, doc.layout, canvasOf(doc));
+}