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

package/dist/commands/clipboard.js

@@ -1,93 +1,93 @@
-import { createRun, locateParagraph, paragraphText } from "../model/node.js";
-import {
-  collapsedSelection,
-  containerIdOf,
-  createPosition,
-  isCollapsed,
-  paragraphIdOf,
-  selectionRange,
-  withOffset,
-} from "../model/position.js";
-import { insertStep, splitParagraphStep } from "../model/step.js";
-import { createTransaction } from "../model/transaction.js";
-import { marksAt } from "./marks.js";
-import { deleteRange } from "./text.js";
-
-/**
- * Plain-text clipboard commands. ARCHITECTURE.md §2: the browser's HTML is
- * never the data model, which cuts the other way too — we never *write* HTML
- * to the clipboard either. Everything here is `text/plain`, in and out.
- */
-
-/**
- * Pastes pre-split lines at the cursor, replacing the selection first in the
- * same transaction — same single-transaction rule as `insertText` (§2.5):
- * pasting over a selection is one user action, not two.
- *
- * Lines after the first each start a new paragraph, exactly as if the user
- * had typed the text with Enter between lines. Splitting on `\r\n|\r|\n` is
- * the caller's job (`input/clipboard.js`) — this command only knows about
- * already-separated lines, so it stays testable without a `ClipboardEvent`.
- *
- * @param {import("../state/editor-state.js").EditorState} state
- * @param {string[]} lines
- * @param {import("../model/ids.js").IdFactory} ids
- * @returns {import("../model/transaction.js").Transaction | null}
- */
-export function pasteText(state, lines, ids) {
-  if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) {
-    return null;
-  }
-
-  const tr = createTransaction(state.doc, state.selection, "paste");
-  let at = isCollapsed(state.selection) ? state.selection.head : deleteRange(tr, state.selection);
-
-  const marks = state.storedMarks ?? marksAt(tr.doc, at);
-
-  for (let i = 0; i < lines.length; i += 1) {
-    if (lines[i] !== "") {
-      tr.step(insertStep(at, [createRun(lines[i], marks)]));
-      at = withOffset(at, at.offset + lines[i].length);
-    }
-    if (i < lines.length - 1) {
-      const newParagraphId = ids.next();
-      tr.step(splitParagraphStep(at, newParagraphId));
-      // The pasted paragraphs stay inside the container the cursor was in —
-      // pasting multi-line text never spills into the next box.
-      at = createPosition(containerIdOf(at), newParagraphId, 0);
-    }
-  }
-
-  tr.setSelection(collapsedSelection(at));
-  return tr.build();
-}
-
-/**
- * The selected text as a plain string, paragraphs joined by `\n`. Used by
- * `copy` and `cut` alike — cut is this plus a deletion, not a different
- * serialisation.
- * @param {import("../model/node.js").Doc} doc
- * @param {import("../model/position.js").Selection} selection
- * @returns {string}
- */
-export function serializeToText(doc, selection) {
-  const range = selectionRange(doc, selection);
-  if (range === null) {
-    return "";
-  }
-
-  const fromAt = locateParagraph(doc, paragraphIdOf(range.from));
-  const toAt = locateParagraph(doc, paragraphIdOf(range.to));
-  if (fromAt === null || toAt === null || fromAt.containerIndex !== toAt.containerIndex) {
-    return "";
-  }
-
-  const parts = [];
-  for (let i = fromAt.paraIndex; i <= toAt.paraIndex; i += 1) {
-    const text = paragraphText(fromAt.container.content[i]);
-    const start = i === fromAt.paraIndex ? range.from.offset : 0;
-    const end = i === toAt.paraIndex ? range.to.offset : text.length;
-    parts.push(text.slice(start, end));
-  }
-  return parts.join("\n");
-}
+import { createRun, locateParagraph, paragraphText } from "../model/node.js";
+import {
+  collapsedSelection,
+  containerIdOf,
+  createPosition,
+  isCollapsed,
+  paragraphIdOf,
+  selectionRange,
+  withOffset,
+} from "../model/position.js";
+import { insertStep, splitParagraphStep } from "../model/step.js";
+import { createTransaction } from "../model/transaction.js";
+import { marksAt } from "./marks.js";
+import { deleteRange } from "./text.js";
+
+/**
+ * Plain-text clipboard commands. ARCHITECTURE.md §2: the browser's HTML is
+ * never the data model, which cuts the other way too — we never *write* HTML
+ * to the clipboard either. Everything here is `text/plain`, in and out.
+ */
+
+/**
+ * Pastes pre-split lines at the cursor, replacing the selection first in the
+ * same transaction — same single-transaction rule as `insertText` (§2.5):
+ * pasting over a selection is one user action, not two.
+ *
+ * Lines after the first each start a new paragraph, exactly as if the user
+ * had typed the text with Enter between lines. Splitting on `\r\n|\r|\n` is
+ * the caller's job (`input/clipboard.js`) — this command only knows about
+ * already-separated lines, so it stays testable without a `ClipboardEvent`.
+ *
+ * @param {import("../state/editor-state.js").EditorState} state
+ * @param {string[]} lines
+ * @param {import("../model/ids.js").IdFactory} ids
+ * @returns {import("../model/transaction.js").Transaction | null}
+ */
+export function pasteText(state, lines, ids) {
+  if (lines.length === 0 || (lines.length === 1 && lines[0] === "")) {
+    return null;
+  }
+
+  const tr = createTransaction(state.doc, state.selection, "paste");
+  let at = isCollapsed(state.selection) ? state.selection.head : deleteRange(tr, state.selection);
+
+  const marks = state.storedMarks ?? marksAt(tr.doc, at);
+
+  for (let i = 0; i < lines.length; i += 1) {
+    if (lines[i] !== "") {
+      tr.step(insertStep(at, [createRun(lines[i], marks)]));
+      at = withOffset(at, at.offset + lines[i].length);
+    }
+    if (i < lines.length - 1) {
+      const newParagraphId = ids.next();
+      tr.step(splitParagraphStep(at, newParagraphId));
+      // The pasted paragraphs stay inside the container the cursor was in —
+      // pasting multi-line text never spills into the next box.
+      at = createPosition(containerIdOf(at), newParagraphId, 0);
+    }
+  }
+
+  tr.setSelection(collapsedSelection(at));
+  return tr.build();
+}
+
+/**
+ * The selected text as a plain string, paragraphs joined by `\n`. Used by
+ * `copy` and `cut` alike — cut is this plus a deletion, not a different
+ * serialisation.
+ * @param {import("../model/node.js").Doc} doc
+ * @param {import("../model/position.js").Selection} selection
+ * @returns {string}
+ */
+export function serializeToText(doc, selection) {
+  const range = selectionRange(doc, selection);
+  if (range === null) {
+    return "";
+  }
+
+  const fromAt = locateParagraph(doc, paragraphIdOf(range.from));
+  const toAt = locateParagraph(doc, paragraphIdOf(range.to));
+  if (fromAt === null || toAt === null || fromAt.containerIndex !== toAt.containerIndex) {
+    return "";
+  }
+
+  const parts = [];
+  for (let i = fromAt.paraIndex; i <= toAt.paraIndex; i += 1) {
+    const text = paragraphText(fromAt.container.content[i]);
+    const start = i === fromAt.paraIndex ? range.from.offset : 0;
+    const end = i === toAt.paraIndex ? range.to.offset : text.length;
+    parts.push(text.slice(start, end));
+  }
+  return parts.join("\n");
+}

package/dist/commands/graphemes.js

@@ -1,112 +1,112 @@
-// Backspace must remove a whole grapheme cluster, never a UTF-16 code unit.
-// "👍" is two code units; "e" plus a combining acute is two code points; Turkish
-// text composed with a dead key can be either. Deleting half of one corrupts the
-// document.
-//
-// The input layer prefers the browser's own answer from `getTargetRanges()`.
-// This module is the fallback chain behind that: Intl.Segmenter, then surrogate
-// pair handling on its own.
-
-/** @type {Intl.Segmenter | null | undefined} */
-let cachedSegmenter;
-
-/**
- * @returns {Intl.Segmenter | null}
- */
-function graphemeSegmenter() {
-  if (cachedSegmenter !== undefined) {
-    return cachedSegmenter;
-  }
-  cachedSegmenter =
-    typeof Intl !== "undefined" && typeof Intl.Segmenter === "function"
-      ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
-      : null;
-  return cachedSegmenter;
-}
-
-/**
- * Start index of the grapheme that ends at `offset`.
- * @param {string} text
- * @param {number} offset
- * @returns {number}
- */
-export function previousGraphemeStart(text, offset) {
-  if (offset <= 0) {
-    return 0;
-  }
-
-  const segmenter = graphemeSegmenter();
-  if (segmenter === null) {
-    return previousCodePointStart(text, offset);
-  }
-
-  let start = 0;
-  for (const { index } of segmenter.segment(text)) {
-    if (index >= offset) {
-      break;
-    }
-    start = index;
-  }
-  return start;
-}
-
-/**
- * End index of the grapheme that starts at `offset`.
- * @param {string} text
- * @param {number} offset
- * @returns {number}
- */
-export function nextGraphemeEnd(text, offset) {
-  if (offset >= text.length) {
-    return text.length;
-  }
-
-  const segmenter = graphemeSegmenter();
-  if (segmenter === null) {
-    return nextCodePointEnd(text, offset);
-  }
-
-  for (const { index, segment } of segmenter.segment(text)) {
-    const end = index + segment.length;
-    if (end > offset) {
-      return end;
-    }
-  }
-  return text.length;
-}
-
-/**
- * Surrogate-aware fallback. Handles astral characters but not combining marks —
- * it exists only for engines without `Intl.Segmenter`.
- * @param {string} text
- * @param {number} offset
- * @returns {number}
- */
-export function previousCodePointStart(text, offset) {
-  let index = offset - 1;
-  if (index > 0) {
-    const code = text.charCodeAt(index);
-    const previous = text.charCodeAt(index - 1);
-    if (code >= 0xdc00 && code <= 0xdfff && previous >= 0xd800 && previous <= 0xdbff) {
-      index -= 1;
-    }
-  }
-  return Math.max(0, index);
-}
-
-/**
- * @param {string} text
- * @param {number} offset
- * @returns {number}
- */
-export function nextCodePointEnd(text, offset) {
-  let index = offset + 1;
-  if (index < text.length) {
-    const code = text.charCodeAt(offset);
-    const next = text.charCodeAt(index);
-    if (code >= 0xd800 && code <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) {
-      index += 1;
-    }
-  }
-  return Math.min(text.length, index);
-}
+// Backspace must remove a whole grapheme cluster, never a UTF-16 code unit.
+// "👍" is two code units; "e" plus a combining acute is two code points; Turkish
+// text composed with a dead key can be either. Deleting half of one corrupts the
+// document.
+//
+// The input layer prefers the browser's own answer from `getTargetRanges()`.
+// This module is the fallback chain behind that: Intl.Segmenter, then surrogate
+// pair handling on its own.
+
+/** @type {Intl.Segmenter | null | undefined} */
+let cachedSegmenter;
+
+/**
+ * @returns {Intl.Segmenter | null}
+ */
+function graphemeSegmenter() {
+  if (cachedSegmenter !== undefined) {
+    return cachedSegmenter;
+  }
+  cachedSegmenter =
+    typeof Intl !== "undefined" && typeof Intl.Segmenter === "function"
+      ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+      : null;
+  return cachedSegmenter;
+}
+
+/**
+ * Start index of the grapheme that ends at `offset`.
+ * @param {string} text
+ * @param {number} offset
+ * @returns {number}
+ */
+export function previousGraphemeStart(text, offset) {
+  if (offset <= 0) {
+    return 0;
+  }
+
+  const segmenter = graphemeSegmenter();
+  if (segmenter === null) {
+    return previousCodePointStart(text, offset);
+  }
+
+  let start = 0;
+  for (const { index } of segmenter.segment(text)) {
+    if (index >= offset) {
+      break;
+    }
+    start = index;
+  }
+  return start;
+}
+
+/**
+ * End index of the grapheme that starts at `offset`.
+ * @param {string} text
+ * @param {number} offset
+ * @returns {number}
+ */
+export function nextGraphemeEnd(text, offset) {
+  if (offset >= text.length) {
+    return text.length;
+  }
+
+  const segmenter = graphemeSegmenter();
+  if (segmenter === null) {
+    return nextCodePointEnd(text, offset);
+  }
+
+  for (const { index, segment } of segmenter.segment(text)) {
+    const end = index + segment.length;
+    if (end > offset) {
+      return end;
+    }
+  }
+  return text.length;
+}
+
+/**
+ * Surrogate-aware fallback. Handles astral characters but not combining marks —
+ * it exists only for engines without `Intl.Segmenter`.
+ * @param {string} text
+ * @param {number} offset
+ * @returns {number}
+ */
+export function previousCodePointStart(text, offset) {
+  let index = offset - 1;
+  if (index > 0) {
+    const code = text.charCodeAt(index);
+    const previous = text.charCodeAt(index - 1);
+    if (code >= 0xdc00 && code <= 0xdfff && previous >= 0xd800 && previous <= 0xdbff) {
+      index -= 1;
+    }
+  }
+  return Math.max(0, index);
+}
+
+/**
+ * @param {string} text
+ * @param {number} offset
+ * @returns {number}
+ */
+export function nextCodePointEnd(text, offset) {
+  let index = offset + 1;
+  if (index < text.length) {
+    const code = text.charCodeAt(offset);
+    const next = text.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) {
+      index += 1;
+    }
+  }
+  return Math.min(text.length, index);
+}