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

package/dist/commands/text.js

@@ -1,291 +1,291 @@
-import { devAssert } from "../dev.js";
-import { createRun, locateParagraph, paragraphLength, paragraphText } from "../model/node.js";
-import {
-  collapsedSelection,
-  containerIdOf,
-  createPosition,
-  isCollapsed,
-  isSingleContainer,
-  paragraphIdOf,
-  selectionRange,
-  withOffset,
-} from "../model/position.js";
-import { deleteStep, insertStep, mergeParagraphsStep, splitParagraphStep } from "../model/step.js";
-import { createTransaction } from "../model/transaction.js";
-import { marksAt } from "./marks.js";
-import { previousGraphemeStart, nextGraphemeEnd } from "./graphemes.js";
-
-/**
- * Deletes the selected range, appending steps to `tr`, and returns the position
- * the selection collapses to — already expressed in post-deletion coordinates.
- *
- * A multi-paragraph range decomposes into per-paragraph deletes plus merges,
- * because `DeleteStep` never spans paragraphs (ADR-0003):
- *
- *     A|B|C selected from A@2 to C@3
- *       delete A@2..A.end · delete all of B · delete C@0..C@3
- *       merge A (absorbs the emptied B) · merge A again (absorbs C's remainder)
- *
- * The range may span paragraphs but never containers (ADR-0007), which is what
- * keeps that decomposition unchanged from P1 — every step it emits stays inside
- * one container.
- *
- * @param {import("../model/transaction.js").TransactionBuilder} tr
- * @param {import("../model/position.js").Selection} selection
- * @returns {import("../model/position.js").Position}
- */
-export function deleteRange(tr, selection) {
-  const doc = tr.doc;
-  devAssert(
-    isSingleContainer(selection),
-    "deleteRange: a text selection may not span containers",
-  );
-  const range = selectionRange(doc, selection);
-  if (range === null || !isSingleContainer(selection)) {
-    return selection.head;
-  }
-
-  const fromAt = locateParagraph(doc, paragraphIdOf(range.from));
-  const toAt = locateParagraph(doc, paragraphIdOf(range.to));
-  if (fromAt === null || toAt === null || fromAt.containerIndex !== toAt.containerIndex) {
-    return range.from;
-  }
-
-  if (fromAt.paraIndex === toAt.paraIndex) {
-    if (range.to.offset > range.from.offset) {
-      tr.step(deleteStep(range.from, range.to));
-    }
-    return range.from;
-  }
-
-  const container = fromAt.container;
-  const containerId = container.id;
-  const firstId = fromAt.para.id;
-
-  // Trim each paragraph first, while their ids and offsets are still valid.
-  const firstEnd = paragraphLength(fromAt.para);
-  if (firstEnd > range.from.offset) {
-    tr.step(deleteStep(range.from, withOffset(range.from, firstEnd)));
-  }
-
-  for (let i = fromAt.paraIndex + 1; i < toAt.paraIndex; i += 1) {
-    const para = container.content[i];
-    const length = paragraphLength(para);
-    if (length > 0) {
-      tr.step(
-        deleteStep(
-          createPosition(containerId, para.id, 0),
-          createPosition(containerId, para.id, length),
-        ),
-      );
-    }
-  }
-
-  const lastId = toAt.para.id;
-  if (range.to.offset > 0) {
-    tr.step(
-      deleteStep(
-        createPosition(containerId, lastId, 0),
-        createPosition(containerId, lastId, range.to.offset),
-      ),
-    );
-  }
-
-  // Then pull the emptied paragraphs into the first one.
-  for (let i = fromAt.paraIndex; i < toAt.paraIndex; i += 1) {
-    tr.step(mergeParagraphsStep(firstId));
-  }
-
-  return createPosition(containerId, firstId, range.from.offset);
-}
-
-/**
- * Inserts text at the cursor, replacing the selection if there is one.
- *
- * The replacement happens **in the same transaction** as the insert. Two
- * transactions would mean two Ctrl+Z presses to undo one user action.
- *
- * @param {import("../state/editor-state.js").EditorState} state
- * @param {string} text
- * @param {import("../model/transaction.js").TransactionOrigin} [origin]
- * @returns {import("../model/transaction.js").Transaction | null}
- */
-export function insertText(state, text, origin = "input") {
-  if (text === "") {
-    return null;
-  }
-
-  const tr = createTransaction(state.doc, state.selection, origin);
-  const at = isCollapsed(state.selection)
-    ? state.selection.head
-    : deleteRange(tr, state.selection);
-
-  const marks = state.storedMarks ?? marksAt(tr.doc, at);
-  tr.step(insertStep(at, [createRun(text, marks)]));
-  tr.setSelection(collapsedSelection(withOffset(at, at.offset + text.length)));
-
-  return tr.build();
-}
-
-/**
- * Enter. Replaces the selection first, same single-transaction rule as
- * `insertText`. The new paragraph is a sibling inside the same container — Enter
- * never creates a box.
- * @param {import("../state/editor-state.js").EditorState} state
- * @param {import("../model/ids.js").IdFactory} ids
- * @returns {import("../model/transaction.js").Transaction}
- */
-export function splitParagraph(state, ids) {
-  const tr = createTransaction(state.doc, state.selection, "input");
-  const at = isCollapsed(state.selection)
-    ? state.selection.head
-    : deleteRange(tr, state.selection);
-
-  const newId = ids.next();
-  tr.step(splitParagraphStep(at, newId));
-  tr.setSelection(collapsedSelection(createPosition(containerIdOf(at), newId, 0)));
-
-  return tr.build();
-}
-
-/**
- * Backspace.
- *
- * | selection | position | action |
- * |---|---|---|
- * | range | — | delete the range |
- * | collapsed | `offset > 0` | delete the previous grapheme |
- * | collapsed | `offset === 0`, a paragraph precedes **in this container** | merge into it |
- * | collapsed | `offset === 0`, first paragraph of the container | no-op |
- *
- * The last row is the container rule: backspace at the top of a box does
- * nothing. It does **not** reach back into the previous box — boxes have no
- * meaningful document order between them, so merging across one would join two
- * unrelated pieces of the page.
- *
- * The merge case has to compute the join point *before* the step runs, because
- * the current paragraph is about to stop existing.
- *
- * @param {import("../state/editor-state.js").EditorState} state
- * @returns {import("../model/transaction.js").Transaction | null}
- */
-export function deleteBackward(state) {
-  const { doc, selection } = state;
-
-  if (!isCollapsed(selection)) {
-    return deleteSelection(state);
-  }
-
-  const pos = selection.head;
-  const at = locateParagraph(doc, paragraphIdOf(pos));
-  if (at === null) {
-    return null;
-  }
-
-  if (pos.offset > 0) {
-    const text = paragraphText(at.para);
-    const start = previousGraphemeStart(text, pos.offset);
-    const tr = createTransaction(doc, selection, "input");
-    tr.step(deleteStep(withOffset(pos, start), pos));
-    tr.setSelection(collapsedSelection(withOffset(pos, start)));
-    return tr.build();
-  }
-
-  if (at.paraIndex === 0) {
-    return null;
-  }
-
-  const previous = at.container.content[at.paraIndex - 1];
-  const joinAt = createPosition(at.container.id, previous.id, paragraphLength(previous));
-
-  const tr = createTransaction(doc, selection, "input");
-  tr.step(mergeParagraphsStep(previous.id));
-  tr.setSelection(collapsedSelection(joinAt));
-  return tr.build();
-}
-
-/**
- * Delete (forward). Mirrors `deleteBackward`:
- *
- * | selection | position | action |
- * |---|---|---|
- * | range | — | delete the range |
- * | collapsed | `offset < len` | delete the next grapheme |
- * | collapsed | `offset === len`, a paragraph follows **in this container** | merge it into this one |
- * | collapsed | `offset === len`, last paragraph of the container | no-op |
- *
- * Both directions land on the same join point; forward deletion simply already
- * sits there, so the selection does not move.
- *
- * @param {import("../state/editor-state.js").EditorState} state
- * @returns {import("../model/transaction.js").Transaction | null}
- */
-export function deleteForward(state) {
-  const { doc, selection } = state;
-
-  if (!isCollapsed(selection)) {
-    return deleteSelection(state);
-  }
-
-  const pos = selection.head;
-  const at = locateParagraph(doc, paragraphIdOf(pos));
-  if (at === null) {
-    return null;
-  }
-
-  const { para } = at;
-  const length = paragraphLength(para);
-
-  if (pos.offset < length) {
-    const end = nextGraphemeEnd(paragraphText(para), pos.offset);
-    const tr = createTransaction(doc, selection, "input");
-    tr.step(deleteStep(pos, withOffset(pos, end)));
-    tr.setSelection(collapsedSelection(pos));
-    return tr.build();
-  }
-
-  if (at.paraIndex === at.container.content.length - 1) {
-    return null;
-  }
-
-  const tr = createTransaction(doc, selection, "input");
-  tr.step(mergeParagraphsStep(para.id));
-  tr.setSelection(collapsedSelection(pos));
-  return tr.build();
-}
-
-/**
- * Deletes the current selection and nothing else.
- * @param {import("../state/editor-state.js").EditorState} state
- * @param {import("../model/transaction.js").TransactionOrigin} [origin]
- * @returns {import("../model/transaction.js").Transaction | null}
- */
-export function deleteSelection(state, origin = "input") {
-  if (isCollapsed(state.selection)) {
-    return null;
-  }
-  const tr = createTransaction(state.doc, state.selection, origin);
-  const at = deleteRange(tr, state.selection);
-  if (!tr.changesDoc) {
-    return null;
-  }
-  tr.setSelection(collapsedSelection(at));
-  return tr.build();
-}
-
-/**
- * Deletes an explicit range — used for the ranges the browser computes for word
- * and line deletion via `getTargetRanges()`.
- * @param {import("../state/editor-state.js").EditorState} state
- * @param {import("../model/position.js").Selection} range
- * @returns {import("../model/transaction.js").Transaction | null}
- */
-export function deleteExplicitRange(state, range) {
-  const tr = createTransaction(state.doc, state.selection, "input");
-  const at = deleteRange(tr, range);
-  if (!tr.changesDoc) {
-    return null;
-  }
-  tr.setSelection(collapsedSelection(at));
-  return tr.build();
-}
+import { devAssert } from "../dev.js";
+import { createRun, locateParagraph, paragraphLength, paragraphText } from "../model/node.js";
+import {
+  collapsedSelection,
+  containerIdOf,
+  createPosition,
+  isCollapsed,
+  isSingleContainer,
+  paragraphIdOf,
+  selectionRange,
+  withOffset,
+} from "../model/position.js";
+import { deleteStep, insertStep, mergeParagraphsStep, splitParagraphStep } from "../model/step.js";
+import { createTransaction } from "../model/transaction.js";
+import { marksAt } from "./marks.js";
+import { previousGraphemeStart, nextGraphemeEnd } from "./graphemes.js";
+
+/**
+ * Deletes the selected range, appending steps to `tr`, and returns the position
+ * the selection collapses to — already expressed in post-deletion coordinates.
+ *
+ * A multi-paragraph range decomposes into per-paragraph deletes plus merges,
+ * because `DeleteStep` never spans paragraphs (ADR-0003):
+ *
+ *     A|B|C selected from A@2 to C@3
+ *       delete A@2..A.end · delete all of B · delete C@0..C@3
+ *       merge A (absorbs the emptied B) · merge A again (absorbs C's remainder)
+ *
+ * The range may span paragraphs but never containers (ADR-0007), which is what
+ * keeps that decomposition unchanged from P1 — every step it emits stays inside
+ * one container.
+ *
+ * @param {import("../model/transaction.js").TransactionBuilder} tr
+ * @param {import("../model/position.js").Selection} selection
+ * @returns {import("../model/position.js").Position}
+ */
+export function deleteRange(tr, selection) {
+  const doc = tr.doc;
+  devAssert(
+    isSingleContainer(selection),
+    "deleteRange: a text selection may not span containers",
+  );
+  const range = selectionRange(doc, selection);
+  if (range === null || !isSingleContainer(selection)) {
+    return selection.head;
+  }
+
+  const fromAt = locateParagraph(doc, paragraphIdOf(range.from));
+  const toAt = locateParagraph(doc, paragraphIdOf(range.to));
+  if (fromAt === null || toAt === null || fromAt.containerIndex !== toAt.containerIndex) {
+    return range.from;
+  }
+
+  if (fromAt.paraIndex === toAt.paraIndex) {
+    if (range.to.offset > range.from.offset) {
+      tr.step(deleteStep(range.from, range.to));
+    }
+    return range.from;
+  }
+
+  const container = fromAt.container;
+  const containerId = container.id;
+  const firstId = fromAt.para.id;
+
+  // Trim each paragraph first, while their ids and offsets are still valid.
+  const firstEnd = paragraphLength(fromAt.para);
+  if (firstEnd > range.from.offset) {
+    tr.step(deleteStep(range.from, withOffset(range.from, firstEnd)));
+  }
+
+  for (let i = fromAt.paraIndex + 1; i < toAt.paraIndex; i += 1) {
+    const para = container.content[i];
+    const length = paragraphLength(para);
+    if (length > 0) {
+      tr.step(
+        deleteStep(
+          createPosition(containerId, para.id, 0),
+          createPosition(containerId, para.id, length),
+        ),
+      );
+    }
+  }
+
+  const lastId = toAt.para.id;
+  if (range.to.offset > 0) {
+    tr.step(
+      deleteStep(
+        createPosition(containerId, lastId, 0),
+        createPosition(containerId, lastId, range.to.offset),
+      ),
+    );
+  }
+
+  // Then pull the emptied paragraphs into the first one.
+  for (let i = fromAt.paraIndex; i < toAt.paraIndex; i += 1) {
+    tr.step(mergeParagraphsStep(firstId));
+  }
+
+  return createPosition(containerId, firstId, range.from.offset);
+}
+
+/**
+ * Inserts text at the cursor, replacing the selection if there is one.
+ *
+ * The replacement happens **in the same transaction** as the insert. Two
+ * transactions would mean two Ctrl+Z presses to undo one user action.
+ *
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @param {string} text
+ * @param {import("../model/transaction.js").TransactionOrigin} [origin]
+ * @returns {import("../model/transaction.js").Transaction | null}
+ */
+export function insertText(state, text, origin = "input") {
+  if (text === "") {
+    return null;
+  }
+
+  const tr = createTransaction(state.doc, state.selection, origin);
+  const at = isCollapsed(state.selection)
+    ? state.selection.head
+    : deleteRange(tr, state.selection);
+
+  const marks = state.storedMarks ?? marksAt(tr.doc, at);
+  tr.step(insertStep(at, [createRun(text, marks)]));
+  tr.setSelection(collapsedSelection(withOffset(at, at.offset + text.length)));
+
+  return tr.build();
+}
+
+/**
+ * Enter. Replaces the selection first, same single-transaction rule as
+ * `insertText`. The new paragraph is a sibling inside the same container — Enter
+ * never creates a box.
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @param {import("../model/ids.js").IdFactory} ids
+ * @returns {import("../model/transaction.js").Transaction}
+ */
+export function splitParagraph(state, ids) {
+  const tr = createTransaction(state.doc, state.selection, "input");
+  const at = isCollapsed(state.selection)
+    ? state.selection.head
+    : deleteRange(tr, state.selection);
+
+  const newId = ids.next();
+  tr.step(splitParagraphStep(at, newId));
+  tr.setSelection(collapsedSelection(createPosition(containerIdOf(at), newId, 0)));
+
+  return tr.build();
+}
+
+/**
+ * Backspace.
+ *
+ * | selection | position | action |
+ * |---|---|---|
+ * | range | — | delete the range |
+ * | collapsed | `offset > 0` | delete the previous grapheme |
+ * | collapsed | `offset === 0`, a paragraph precedes **in this container** | merge into it |
+ * | collapsed | `offset === 0`, first paragraph of the container | no-op |
+ *
+ * The last row is the container rule: backspace at the top of a box does
+ * nothing. It does **not** reach back into the previous box — boxes have no
+ * meaningful document order between them, so merging across one would join two
+ * unrelated pieces of the page.
+ *
+ * The merge case has to compute the join point *before* the step runs, because
+ * the current paragraph is about to stop existing.
+ *
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @returns {import("../model/transaction.js").Transaction | null}
+ */
+export function deleteBackward(state) {
+  const { doc, selection } = state;
+
+  if (!isCollapsed(selection)) {
+    return deleteSelection(state);
+  }
+
+  const pos = selection.head;
+  const at = locateParagraph(doc, paragraphIdOf(pos));
+  if (at === null) {
+    return null;
+  }
+
+  if (pos.offset > 0) {
+    const text = paragraphText(at.para);
+    const start = previousGraphemeStart(text, pos.offset);
+    const tr = createTransaction(doc, selection, "input");
+    tr.step(deleteStep(withOffset(pos, start), pos));
+    tr.setSelection(collapsedSelection(withOffset(pos, start)));
+    return tr.build();
+  }
+
+  if (at.paraIndex === 0) {
+    return null;
+  }
+
+  const previous = at.container.content[at.paraIndex - 1];
+  const joinAt = createPosition(at.container.id, previous.id, paragraphLength(previous));
+
+  const tr = createTransaction(doc, selection, "input");
+  tr.step(mergeParagraphsStep(previous.id));
+  tr.setSelection(collapsedSelection(joinAt));
+  return tr.build();
+}
+
+/**
+ * Delete (forward). Mirrors `deleteBackward`:
+ *
+ * | selection | position | action |
+ * |---|---|---|
+ * | range | — | delete the range |
+ * | collapsed | `offset < len` | delete the next grapheme |
+ * | collapsed | `offset === len`, a paragraph follows **in this container** | merge it into this one |
+ * | collapsed | `offset === len`, last paragraph of the container | no-op |
+ *
+ * Both directions land on the same join point; forward deletion simply already
+ * sits there, so the selection does not move.
+ *
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @returns {import("../model/transaction.js").Transaction | null}
+ */
+export function deleteForward(state) {
+  const { doc, selection } = state;
+
+  if (!isCollapsed(selection)) {
+    return deleteSelection(state);
+  }
+
+  const pos = selection.head;
+  const at = locateParagraph(doc, paragraphIdOf(pos));
+  if (at === null) {
+    return null;
+  }
+
+  const { para } = at;
+  const length = paragraphLength(para);
+
+  if (pos.offset < length) {
+    const end = nextGraphemeEnd(paragraphText(para), pos.offset);
+    const tr = createTransaction(doc, selection, "input");
+    tr.step(deleteStep(pos, withOffset(pos, end)));
+    tr.setSelection(collapsedSelection(pos));
+    return tr.build();
+  }
+
+  if (at.paraIndex === at.container.content.length - 1) {
+    return null;
+  }
+
+  const tr = createTransaction(doc, selection, "input");
+  tr.step(mergeParagraphsStep(para.id));
+  tr.setSelection(collapsedSelection(pos));
+  return tr.build();
+}
+
+/**
+ * Deletes the current selection and nothing else.
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @param {import("../model/transaction.js").TransactionOrigin} [origin]
+ * @returns {import("../model/transaction.js").Transaction | null}
+ */
+export function deleteSelection(state, origin = "input") {
+  if (isCollapsed(state.selection)) {
+    return null;
+  }
+  const tr = createTransaction(state.doc, state.selection, origin);
+  const at = deleteRange(tr, state.selection);
+  if (!tr.changesDoc) {
+    return null;
+  }
+  tr.setSelection(collapsedSelection(at));
+  return tr.build();
+}
+
+/**
+ * Deletes an explicit range — used for the ranges the browser computes for word
+ * and line deletion via `getTargetRanges()`.
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @param {import("../model/position.js").Selection} range
+ * @returns {import("../model/transaction.js").Transaction | null}
+ */
+export function deleteExplicitRange(state, range) {
+  const tr = createTransaction(state.doc, state.selection, "input");
+  const at = deleteRange(tr, range);
+  if (!tr.changesDoc) {
+    return null;
+  }
+  tr.setSelection(collapsedSelection(at));
+  return tr.build();
+}

package/dist/docx.d.ts

@@ -1,3 +1,4 @@
 export { importDocx } from "./io/ooxml/import.js";
 export { exportDocx } from "./io/ooxml/export.js";
+export { checkFit } from "./io/ooxml/fit.js";
 export { inspectTemplate, validateTemplate, fillTemplate, TemplateError, ENGINE_VERSION } from "./io/ooxml/fill.js";

package/dist/docx.js

@@ -1,13 +1,15 @@
-// The /docx subpath (FR2, ADR-0037): DOCX import/export for the editor, and
-// the template fill engine. DOM-free — it runs in browsers, Node and Deno
-// (invariant #4) and needs only TextEncoder/TextDecoder and
-// CompressionStream/DecompressionStream("deflate-raw"). It makes no network
-// request (invariant #3).
-//
-// importDocx/exportDocx are the editor's own IO; their shapes are not yet
-// stable at 0.x alpha. The fill engine's surface is inspectTemplate,
-// validateTemplate, fillTemplate and TemplateError.
-
-export { importDocx } from "./io/ooxml/import.js";
-export { exportDocx } from "./io/ooxml/export.js";
-export { inspectTemplate, validateTemplate, fillTemplate, TemplateError, ENGINE_VERSION } from "./io/ooxml/fill.js";
+// The /docx subpath (FR2, ADR-0037): DOCX import/export for the editor, and
+// the template fill engine. DOM-free — it runs in browsers, Node and Deno
+// (invariant #4) and needs only TextEncoder/TextDecoder and
+// CompressionStream/DecompressionStream("deflate-raw"). It makes no network
+// request (invariant #3).
+//
+// importDocx/exportDocx are the editor's own IO; their shapes are not yet
+// stable at 0.x alpha. The fill engine's surface is inspectTemplate,
+// validateTemplate, fillTemplate and TemplateError, and checkFit (FR4a,
+// ADR-0042): whether each value stays on the lines its box gives it.
+
+export { importDocx } from "./io/ooxml/import.js";
+export { exportDocx } from "./io/ooxml/export.js";
+export { inspectTemplate, validateTemplate, fillTemplate, TemplateError, ENGINE_VERSION } from "./io/ooxml/fill.js";
+export { checkFit } from "./io/ooxml/fit.js";