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

package/dist/commands/alignment.js

@@ -1,150 +1,150 @@
-import { DOC_DEFAULT_STYLE_REF, locateParagraph } from "../model/node.js";
-import { paragraphIdOf, selectionRange } from "../model/position.js";
-import { setAlignmentStep } from "../model/step.js";
-import { createTransaction } from "../model/transaction.js";
-
-// ADR-0029: paragraph alignment is editable through a DIRECT `Paragraph.jc`
-// override — never by mutating `Doc.styles`, which 70.5% of real corpus
-// paragraphs share with at least one other paragraph (worst case 471 on one
-// ref). This module is `commands/size.js`'s paragraph-level counterpart.
-
-/**
- * The OOXML `w:jc` tokens this editor writes. Deliberately NOT the full
- * `ST_Jc` enum — `distribute`, `thaiDistribute`, `mediumKashida` and the rest
- * exist in the schema and are READ correctly on import (they reach
- * `applyParagraphStyle` and render), but nothing in this UI produces them, so
- * nothing here claims to. `start`/`end` are likewise read-only: they are the
- * bidi-aware spellings of left/right, and writing them would silently change
- * meaning in an RTL document.
- * @type {readonly string[]}
- */
-export const ALIGNMENT_VALUES = /** @type {const} */ (["left", "center", "right", "both"]);
-
-/**
- * OOXML's own default when nothing in the chain declares one. ECMA-376's
- * `ST_Jc` has no "default" member — the default is the ABSENCE of `w:jc`, and
- * Word renders that as left-aligned for an LTR paragraph. Measured 2026-08-31:
- * all 46 real corpus documents declare an explicit `docDefaults` jc anyway
- * (every one of them "left"), so this last resort is only reachable for a
- * document that never went through `import.js` at all.
- */
-const FALLBACK_ALIGNMENT = "left";
-
-/**
- * The effective alignment at a paragraph: its own direct override, else the
- * import-resolved value for its `pPrRef`, else the document's own
- * `docDefaults` (ADR-0029 EKLEME A), else OOXML's absent-means-left.
- * @param {import("../model/node.js").Doc} doc
- * @param {import("../model/node.js").Paragraph} para
- * @returns {string}
- */
-export function paragraphAlignment(doc, para) {
-  if (typeof para.jc === "string") {
-    return para.jc;
-  }
-  if (para.pPrRef !== undefined) {
-    const resolved = doc.styles[para.pPrRef]?.jc;
-    if (typeof resolved === "string") {
-      return resolved;
-    }
-  }
-  const fromDefaults = doc.styles[DOC_DEFAULT_STYLE_REF]?.jc;
-  return typeof fromDefaults === "string" ? fromDefaults : FALLBACK_ALIGNMENT;
-}
-
-/**
- * The effective alignment at a position — what a toolbar button should light
- * up for, `marksAtSelection`'s paragraph-level analogue.
- * @param {import("../model/node.js").Doc} doc
- * @param {import("../model/position.js").Position} pos
- * @returns {string | null}  null when the position names no real paragraph
- */
-export function effectiveAlignment(doc, pos) {
-  const at = locateParagraph(doc, paragraphIdOf(pos));
-  return at === null ? null : paragraphAlignment(doc, at.para);
-}
-
-/**
- * The alignment shared by EVERY paragraph the selection touches, or null when
- * they disagree — the same all-or-nothing shape `marksAtSelection` uses, so a
- * lit button always means "every selected paragraph is already this".
- * @param {import("../state/editor-state.js").EditorState} state
- * @returns {string | null}
- */
-export function alignmentAtSelection(state) {
-  const paragraphs = selectedParagraphs(state);
-  if (paragraphs === null || paragraphs.length === 0) {
-    return null;
-  }
-  const first = paragraphAlignment(state.doc, paragraphs[0].para);
-  for (const entry of paragraphs) {
-    if (paragraphAlignment(state.doc, entry.para) !== first) {
-      return null; // mixed — no button lights up
-    }
-  }
-  return first;
-}
-
-/**
- * Every paragraph the selection touches, in document order. A collapsed
- * caret selects the ONE paragraph it sits in — unlike a run-level mark, an
- * alignment change with no selection still has an unambiguous target, so
- * there is no `storedMarks`-style pending state to model here.
- * @param {import("../state/editor-state.js").EditorState} state
- * @returns {{container: import("../model/node.js").Container, para: import("../model/node.js").Paragraph, paraIndex: number}[] | null}
- */
-function selectedParagraphs(state) {
-  const { doc, selection } = state;
-  const range = selectionRange(doc, selection) ?? { from: selection.head, to: selection.head };
-
-  const fromAt = locateParagraph(doc, paragraphIdOf(range.from));
-  const toAt = locateParagraph(doc, paragraphIdOf(range.to));
-  // A selection never spans containers (ADR-0007), same rule marks follow.
-  if (fromAt === null || toAt === null || fromAt.containerIndex !== toAt.containerIndex) {
-    return null;
-  }
-
-  const out = [];
-  for (let i = fromAt.paraIndex; i <= toAt.paraIndex; i += 1) {
-    out.push({ container: fromAt.container, para: fromAt.container.content[i], paraIndex: i });
-  }
-  return out;
-}
-
-/**
- * Sets the alignment of every paragraph the selection touches.
- *
- * Unlike `toggleMark`, this is NOT a toggle: the four alignments are mutually
- * exclusive, so pressing "center" on already-centered text is a no-op rather
- * than a revert-to-nothing. Returns null when nothing would change, so a
- * redundant press never reaches the history stack.
- *
- * @param {import("../state/editor-state.js").EditorState} state
- * @param {string} value  one of `ALIGNMENT_VALUES`
- * @returns {import("../model/transaction.js").Transaction | null}
- */
-export function setAlignment(state, value) {
-  const { doc, selection } = state;
-  const paragraphs = selectedParagraphs(state);
-  if (paragraphs === null || paragraphs.length === 0) {
-    return null;
-  }
-
-  const entries = paragraphs
-    .filter((entry) => entry.para.jc !== value)
-    .map((entry) => ({ containerId: entry.container.id, paragraphId: entry.para.id, value }));
-  if (entries.length === 0) {
-    return null;
-  }
-
-  const tr = createTransaction(doc, selection, "format");
-  tr.step(setAlignmentStep(entries));
-  if (!tr.changesDoc) {
-    return null;
-  }
-
-  // Alignment never moves characters, so the selection is preserved as-is.
-  tr.setSelection(selection);
-  tr.setStoredMarks(null);
-  return tr.build();
-}
+import { DOC_DEFAULT_STYLE_REF, locateParagraph } from "../model/node.js";
+import { paragraphIdOf, selectionRange } from "../model/position.js";
+import { setAlignmentStep } from "../model/step.js";
+import { createTransaction } from "../model/transaction.js";
+
+// ADR-0029: paragraph alignment is editable through a DIRECT `Paragraph.jc`
+// override — never by mutating `Doc.styles`, which 70.5% of real corpus
+// paragraphs share with at least one other paragraph (worst case 471 on one
+// ref). This module is `commands/size.js`'s paragraph-level counterpart.
+
+/**
+ * The OOXML `w:jc` tokens this editor writes. Deliberately NOT the full
+ * `ST_Jc` enum — `distribute`, `thaiDistribute`, `mediumKashida` and the rest
+ * exist in the schema and are READ correctly on import (they reach
+ * `applyParagraphStyle` and render), but nothing in this UI produces them, so
+ * nothing here claims to. `start`/`end` are likewise read-only: they are the
+ * bidi-aware spellings of left/right, and writing them would silently change
+ * meaning in an RTL document.
+ * @type {readonly string[]}
+ */
+export const ALIGNMENT_VALUES = /** @type {const} */ (["left", "center", "right", "both"]);
+
+/**
+ * OOXML's own default when nothing in the chain declares one. ECMA-376's
+ * `ST_Jc` has no "default" member — the default is the ABSENCE of `w:jc`, and
+ * Word renders that as left-aligned for an LTR paragraph. Measured 2026-08-31:
+ * all 46 real corpus documents declare an explicit `docDefaults` jc anyway
+ * (every one of them "left"), so this last resort is only reachable for a
+ * document that never went through `import.js` at all.
+ */
+const FALLBACK_ALIGNMENT = "left";
+
+/**
+ * The effective alignment at a paragraph: its own direct override, else the
+ * import-resolved value for its `pPrRef`, else the document's own
+ * `docDefaults` (ADR-0029 EKLEME A), else OOXML's absent-means-left.
+ * @param {import("../model/node.js").Doc} doc
+ * @param {import("../model/node.js").Paragraph} para
+ * @returns {string}
+ */
+export function paragraphAlignment(doc, para) {
+  if (typeof para.jc === "string") {
+    return para.jc;
+  }
+  if (para.pPrRef !== undefined) {
+    const resolved = doc.styles[para.pPrRef]?.jc;
+    if (typeof resolved === "string") {
+      return resolved;
+    }
+  }
+  const fromDefaults = doc.styles[DOC_DEFAULT_STYLE_REF]?.jc;
+  return typeof fromDefaults === "string" ? fromDefaults : FALLBACK_ALIGNMENT;
+}
+
+/**
+ * The effective alignment at a position — what a toolbar button should light
+ * up for, `marksAtSelection`'s paragraph-level analogue.
+ * @param {import("../model/node.js").Doc} doc
+ * @param {import("../model/position.js").Position} pos
+ * @returns {string | null}  null when the position names no real paragraph
+ */
+export function effectiveAlignment(doc, pos) {
+  const at = locateParagraph(doc, paragraphIdOf(pos));
+  return at === null ? null : paragraphAlignment(doc, at.para);
+}
+
+/**
+ * The alignment shared by EVERY paragraph the selection touches, or null when
+ * they disagree — the same all-or-nothing shape `marksAtSelection` uses, so a
+ * lit button always means "every selected paragraph is already this".
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @returns {string | null}
+ */
+export function alignmentAtSelection(state) {
+  const paragraphs = selectedParagraphs(state);
+  if (paragraphs === null || paragraphs.length === 0) {
+    return null;
+  }
+  const first = paragraphAlignment(state.doc, paragraphs[0].para);
+  for (const entry of paragraphs) {
+    if (paragraphAlignment(state.doc, entry.para) !== first) {
+      return null; // mixed — no button lights up
+    }
+  }
+  return first;
+}
+
+/**
+ * Every paragraph the selection touches, in document order. A collapsed
+ * caret selects the ONE paragraph it sits in — unlike a run-level mark, an
+ * alignment change with no selection still has an unambiguous target, so
+ * there is no `storedMarks`-style pending state to model here.
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @returns {{container: import("../model/node.js").Container, para: import("../model/node.js").Paragraph, paraIndex: number}[] | null}
+ */
+function selectedParagraphs(state) {
+  const { doc, selection } = state;
+  const range = selectionRange(doc, selection) ?? { from: selection.head, to: selection.head };
+
+  const fromAt = locateParagraph(doc, paragraphIdOf(range.from));
+  const toAt = locateParagraph(doc, paragraphIdOf(range.to));
+  // A selection never spans containers (ADR-0007), same rule marks follow.
+  if (fromAt === null || toAt === null || fromAt.containerIndex !== toAt.containerIndex) {
+    return null;
+  }
+
+  const out = [];
+  for (let i = fromAt.paraIndex; i <= toAt.paraIndex; i += 1) {
+    out.push({ container: fromAt.container, para: fromAt.container.content[i], paraIndex: i });
+  }
+  return out;
+}
+
+/**
+ * Sets the alignment of every paragraph the selection touches.
+ *
+ * Unlike `toggleMark`, this is NOT a toggle: the four alignments are mutually
+ * exclusive, so pressing "center" on already-centered text is a no-op rather
+ * than a revert-to-nothing. Returns null when nothing would change, so a
+ * redundant press never reaches the history stack.
+ *
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @param {string} value  one of `ALIGNMENT_VALUES`
+ * @returns {import("../model/transaction.js").Transaction | null}
+ */
+export function setAlignment(state, value) {
+  const { doc, selection } = state;
+  const paragraphs = selectedParagraphs(state);
+  if (paragraphs === null || paragraphs.length === 0) {
+    return null;
+  }
+
+  const entries = paragraphs
+    .filter((entry) => entry.para.jc !== value)
+    .map((entry) => ({ containerId: entry.container.id, paragraphId: entry.para.id, value }));
+  if (entries.length === 0) {
+    return null;
+  }
+
+  const tr = createTransaction(doc, selection, "format");
+  tr.step(setAlignmentStep(entries));
+  if (!tr.changesDoc) {
+    return null;
+  }
+
+  // Alignment never moves characters, so the selection is preserved as-is.
+  tr.setSelection(selection);
+  tr.setStoredMarks(null);
+  return tr.build();
+}