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

package/dist/canvas/mode-controller.js

@@ -1,81 +1,81 @@
-// The box-mode <-> text-mode state machine for the unified canvas editor
-// (ADR-0024, P3b mode-merge parça 1). It owns ONLY the mode state and its two
-// transitions. Deliberately inert otherwise: it listens to NO DOM events (parça
-// 3's click-router calls enterTextMode/exitToBoxMode), and touches NO model, NO
-// renderer, NO editing. SelectionController and the future click-router only
-// READ `mode`; nothing writes it except the two methods here.
-//
-//   - box mode  (initial): a single click selects/moves a box (CanvasController).
-//   - text mode: a caret lives in one box; typing edits it (editing assembly).
-//
-// Double-click a box enters text mode on it; Esc — or a single click on another
-// box / outside — returns to box mode (ADR-0024 §1). Those DOM triggers are
-// parça 3's job; here they are just the two methods those handlers will call.
-
-/** @typedef {"box" | "text"} Mode */
-
-export class ModeController {
-  /**
-   * @param {object} [options]
-   * @param {(mode: Mode, activeContainerId: import("../model/node.js").NodeId | null) => void} [options.onChange]
-   *   Fired after every REAL transition (never on a no-op). Omitted -> no observer.
-   */
-  constructor({ onChange } = {}) {
-    /** @type {Mode} */
-    this._mode = "box";
-    /** @type {import("../model/node.js").NodeId | null} */
-    this._activeContainerId = null;
-    this._onChange = onChange ?? null;
-  }
-
-  /** @returns {Mode} */
-  get mode() {
-    return this._mode;
-  }
-
-  /**
-   * The box currently in text mode, or null in box mode.
-   * @returns {import("../model/node.js").NodeId | null}
-   */
-  get activeContainerId() {
-    return this._activeContainerId;
-  }
-
-  /**
-   * box -> text on `containerId` (a double-click on a box, ADR-0024). Also
-   * switches the active box when already in text mode on a DIFFERENT one
-   * (double-click box B while editing box A). A no-op — no `onChange` — when
-   * already in text mode on the SAME box.
-   * @param {import("../model/node.js").NodeId} containerId
-   * @returns {void}
-   */
-  enterTextMode(containerId) {
-    if (this._mode === "text" && this._activeContainerId === containerId) {
-      return;
-    }
-    this._mode = "text";
-    this._activeContainerId = containerId;
-    this._emit();
-  }
-
-  /**
-   * text -> box (Esc, or a single click on another box / outside — ADR-0024).
-   * A no-op — no `onChange` — when already in box mode.
-   * @returns {void}
-   */
-  exitToBoxMode() {
-    if (this._mode === "box") {
-      return;
-    }
-    this._mode = "box";
-    this._activeContainerId = null;
-    this._emit();
-  }
-
-  /** @returns {void} */
-  _emit() {
-    if (this._onChange !== null) {
-      this._onChange(this._mode, this._activeContainerId);
-    }
-  }
-}
+// The box-mode <-> text-mode state machine for the unified canvas editor
+// (ADR-0024, P3b mode-merge parça 1). It owns ONLY the mode state and its two
+// transitions. Deliberately inert otherwise: it listens to NO DOM events (parça
+// 3's click-router calls enterTextMode/exitToBoxMode), and touches NO model, NO
+// renderer, NO editing. SelectionController and the future click-router only
+// READ `mode`; nothing writes it except the two methods here.
+//
+//   - box mode  (initial): a single click selects/moves a box (CanvasController).
+//   - text mode: a caret lives in one box; typing edits it (editing assembly).
+//
+// Double-click a box enters text mode on it; Esc — or a single click on another
+// box / outside — returns to box mode (ADR-0024 §1). Those DOM triggers are
+// parça 3's job; here they are just the two methods those handlers will call.
+
+/** @typedef {"box" | "text"} Mode */
+
+export class ModeController {
+  /**
+   * @param {object} [options]
+   * @param {(mode: Mode, activeContainerId: import("../model/node.js").NodeId | null) => void} [options.onChange]
+   *   Fired after every REAL transition (never on a no-op). Omitted -> no observer.
+   */
+  constructor({ onChange } = {}) {
+    /** @type {Mode} */
+    this._mode = "box";
+    /** @type {import("../model/node.js").NodeId | null} */
+    this._activeContainerId = null;
+    this._onChange = onChange ?? null;
+  }
+
+  /** @returns {Mode} */
+  get mode() {
+    return this._mode;
+  }
+
+  /**
+   * The box currently in text mode, or null in box mode.
+   * @returns {import("../model/node.js").NodeId | null}
+   */
+  get activeContainerId() {
+    return this._activeContainerId;
+  }
+
+  /**
+   * box -> text on `containerId` (a double-click on a box, ADR-0024). Also
+   * switches the active box when already in text mode on a DIFFERENT one
+   * (double-click box B while editing box A). A no-op — no `onChange` — when
+   * already in text mode on the SAME box.
+   * @param {import("../model/node.js").NodeId} containerId
+   * @returns {void}
+   */
+  enterTextMode(containerId) {
+    if (this._mode === "text" && this._activeContainerId === containerId) {
+      return;
+    }
+    this._mode = "text";
+    this._activeContainerId = containerId;
+    this._emit();
+  }
+
+  /**
+   * text -> box (Esc, or a single click on another box / outside — ADR-0024).
+   * A no-op — no `onChange` — when already in box mode.
+   * @returns {void}
+   */
+  exitToBoxMode() {
+    if (this._mode === "box") {
+      return;
+    }
+    this._mode = "box";
+    this._activeContainerId = null;
+    this._emit();
+  }
+
+  /** @returns {void} */
+  _emit() {
+    if (this._onChange !== null) {
+      this._onChange(this._mode, this._activeContainerId);
+    }
+  }
+}

package/dist/canvas/nudge.js

@@ -1,108 +1,108 @@
-// The keyboard nudge bracket (ADR-0016 §4, measured in two engines). No
-// src/, DOM, or history import.
-//
-// ⚠ SENTETİK DİZİLER KANIT DEĞİL — same disclaimer as gesture.js: this
-// file's tests drive hand-written keydown/keyup sequences. That proves the
-// state machine is correct GIVEN that sequence, not that a real keyboard
-// produces it. The real evidence is ADR-0016's G9/G10 measurements.
-//
-// MEASURED RULES this module encodes:
-//   - PRIMARY signal is the `repeat: true` flag, NOT a time window. Measured
-//     reason: first-repeat delay is 501.1-562.5ms (Chrome) / 500-593ms
-//     (Firefox) — every single measured first repeat lands 1-64ms ABOVE
-//     `COALESCE_MS` (500), so a time-window bracket sits right on the
-//     boundary and would jitter between one undo entry and two.
-//   - `keyup` is NOT reliable: an orphaned keyup (no matching keydown,
-//     key: "Tab") was observed twice in Chrome, seven times in Firefox.
-//   - G10 (Firefox): a key's own `keyup` can arrive AFTER the NEXT key's
-//     `keydown` (observed twice) — `keyUpSealsOpenBracket` must still
-//     recognize it, checking only which KEY it belongs to, never assuming
-//     arrival order.
-//   - A `repeat: false` keydown after a focus loss always opens a NEW
-//     bracket, even on the same key — the conservative choice (splitting
-//     one gesture into two costs less than wrongly merging two).
-//   - The nudge window is `idleAbandonMs`-shaped but must NEVER reuse
-//     `COALESCE_MS` — see the first bullet. Reuses `isIdleAbandoned`
-//     (gesture.js) rather than redefining its own copy: both brackets ask
-//     "how long since the last event", the SAME question `Gesture` already
-//     answers, just with a different injected threshold.
-
-/**
- * @typedef {object} NudgeBracket
- * @property {number} gestureId  minted by the caller's IdFactory
- * @property {string} key  e.g. "ArrowUp" — the physical key this bracket belongs to
- * @property {number} lastEventAt
- */
-
-/**
- * @typedef {object} NudgeKeyEvent
- * @property {"keydown" | "keyup"} type
- * @property {string} key
- * @property {boolean} [repeat]  keydown only
- * @property {number} timestamp
- * @property {number} [gestureId]  keydown only: pre-minted id for the bracket this event WOULD open
- */
-
-/**
- * @typedef {object} NudgePlan
- * @property {NudgeBracket} bracket  the bracket to use for THIS keydown
- * @property {boolean} extend  true = the SAME gesture as an already-open bracket; false = a NEW one
- */
-
-/**
- * PRIMARY signal only: `event.repeat` on the SAME key extends the existing
- * bracket. Anything else — a different key, `repeat: false` even on the
- * same key (the post-focus-loss reset case), or no bracket open at all —
- * opens a NEW one. Never mints its own id; `event.gestureId` is the
- * caller's pre-minted candidate, used only when actually needed.
- *
- * @param {NudgeBracket | null} bracket
- * @param {NudgeKeyEvent} event  a "keydown"
- * @returns {NudgePlan}
- */
-export function nudgeTransition(bracket, event) {
-  if (bracket !== null && bracket.key === event.key && event.repeat) {
-    return { bracket: { ...bracket, lastEventAt: event.timestamp }, extend: true };
-  }
-  return {
-    bracket: { gestureId: /** @type {number} */ (event.gestureId), key: event.key, lastEventAt: event.timestamp },
-    extend: false,
-  };
-}
-
-/**
- * Whether `event` (a "keyup") finalizes `bracket` — true purely by KEY
- * match, never by arrival order (G10: a key's own keyup can arrive after
- * the NEXT key's keydown has already opened a new bracket). Sealing is
- * IDEMPOTENT: calling this again for an already-finalized bracket, or for
- * an unmatched/orphaned keyup (G9: a keyup with no matching keydown was
- * observed for "Tab"), is harmless — it simply returns `false` because no
- * candidate bracket has that key.
- *
- * @param {NudgeBracket | null} bracket
- * @param {NudgeKeyEvent} event  a "keyup"
- * @returns {boolean}
- */
-export function keyUpSealsOpenBracket(bracket, event) {
-  return bracket !== null && bracket.key === event.key;
-}
-
-const KEY_DIRECTIONS = {
-  ArrowUp: { dx: 0, dy: -1 },
-  ArrowDown: { dx: 0, dy: 1 },
-  ArrowLeft: { dx: -1, dy: 0 },
-  ArrowRight: { dx: 1, dy: 0 },
-};
-
-/**
- * @param {string} key  one of ArrowUp/ArrowDown/ArrowLeft/ArrowRight
- * @param {number} step  pt — injected, no default (an unmeasured UI constant, CanvasMetrics' `nudgeStep`)
- * @returns {{dx: number, dy: number}}
- */
-export function nudgeDelta(key, step) {
-  const direction = KEY_DIRECTIONS[/** @type {keyof typeof KEY_DIRECTIONS} */ (key)];
-  if (direction === undefined) {
-    throw new TypeError(`nudgeDelta: unknown key ${JSON.stringify(key)}`);
-  }
-  return { dx: direction.dx * step, dy: direction.dy * step };
-}
+// The keyboard nudge bracket (ADR-0016 §4, measured in two engines). No
+// src/, DOM, or history import.
+//
+// ⚠ SENTETİK DİZİLER KANIT DEĞİL — same disclaimer as gesture.js: this
+// file's tests drive hand-written keydown/keyup sequences. That proves the
+// state machine is correct GIVEN that sequence, not that a real keyboard
+// produces it. The real evidence is ADR-0016's G9/G10 measurements.
+//
+// MEASURED RULES this module encodes:
+//   - PRIMARY signal is the `repeat: true` flag, NOT a time window. Measured
+//     reason: first-repeat delay is 501.1-562.5ms (Chrome) / 500-593ms
+//     (Firefox) — every single measured first repeat lands 1-64ms ABOVE
+//     `COALESCE_MS` (500), so a time-window bracket sits right on the
+//     boundary and would jitter between one undo entry and two.
+//   - `keyup` is NOT reliable: an orphaned keyup (no matching keydown,
+//     key: "Tab") was observed twice in Chrome, seven times in Firefox.
+//   - G10 (Firefox): a key's own `keyup` can arrive AFTER the NEXT key's
+//     `keydown` (observed twice) — `keyUpSealsOpenBracket` must still
+//     recognize it, checking only which KEY it belongs to, never assuming
+//     arrival order.
+//   - A `repeat: false` keydown after a focus loss always opens a NEW
+//     bracket, even on the same key — the conservative choice (splitting
+//     one gesture into two costs less than wrongly merging two).
+//   - The nudge window is `idleAbandonMs`-shaped but must NEVER reuse
+//     `COALESCE_MS` — see the first bullet. Reuses `isIdleAbandoned`
+//     (gesture.js) rather than redefining its own copy: both brackets ask
+//     "how long since the last event", the SAME question `Gesture` already
+//     answers, just with a different injected threshold.
+
+/**
+ * @typedef {object} NudgeBracket
+ * @property {number} gestureId  minted by the caller's IdFactory
+ * @property {string} key  e.g. "ArrowUp" — the physical key this bracket belongs to
+ * @property {number} lastEventAt
+ */
+
+/**
+ * @typedef {object} NudgeKeyEvent
+ * @property {"keydown" | "keyup"} type
+ * @property {string} key
+ * @property {boolean} [repeat]  keydown only
+ * @property {number} timestamp
+ * @property {number} [gestureId]  keydown only: pre-minted id for the bracket this event WOULD open
+ */
+
+/**
+ * @typedef {object} NudgePlan
+ * @property {NudgeBracket} bracket  the bracket to use for THIS keydown
+ * @property {boolean} extend  true = the SAME gesture as an already-open bracket; false = a NEW one
+ */
+
+/**
+ * PRIMARY signal only: `event.repeat` on the SAME key extends the existing
+ * bracket. Anything else — a different key, `repeat: false` even on the
+ * same key (the post-focus-loss reset case), or no bracket open at all —
+ * opens a NEW one. Never mints its own id; `event.gestureId` is the
+ * caller's pre-minted candidate, used only when actually needed.
+ *
+ * @param {NudgeBracket | null} bracket
+ * @param {NudgeKeyEvent} event  a "keydown"
+ * @returns {NudgePlan}
+ */
+export function nudgeTransition(bracket, event) {
+  if (bracket !== null && bracket.key === event.key && event.repeat) {
+    return { bracket: { ...bracket, lastEventAt: event.timestamp }, extend: true };
+  }
+  return {
+    bracket: { gestureId: /** @type {number} */ (event.gestureId), key: event.key, lastEventAt: event.timestamp },
+    extend: false,
+  };
+}
+
+/**
+ * Whether `event` (a "keyup") finalizes `bracket` — true purely by KEY
+ * match, never by arrival order (G10: a key's own keyup can arrive after
+ * the NEXT key's keydown has already opened a new bracket). Sealing is
+ * IDEMPOTENT: calling this again for an already-finalized bracket, or for
+ * an unmatched/orphaned keyup (G9: a keyup with no matching keydown was
+ * observed for "Tab"), is harmless — it simply returns `false` because no
+ * candidate bracket has that key.
+ *
+ * @param {NudgeBracket | null} bracket
+ * @param {NudgeKeyEvent} event  a "keyup"
+ * @returns {boolean}
+ */
+export function keyUpSealsOpenBracket(bracket, event) {
+  return bracket !== null && bracket.key === event.key;
+}
+
+const KEY_DIRECTIONS = {
+  ArrowUp: { dx: 0, dy: -1 },
+  ArrowDown: { dx: 0, dy: 1 },
+  ArrowLeft: { dx: -1, dy: 0 },
+  ArrowRight: { dx: 1, dy: 0 },
+};
+
+/**
+ * @param {string} key  one of ArrowUp/ArrowDown/ArrowLeft/ArrowRight
+ * @param {number} step  pt — injected, no default (an unmeasured UI constant, CanvasMetrics' `nudgeStep`)
+ * @returns {{dx: number, dy: number}}
+ */
+export function nudgeDelta(key, step) {
+  const direction = KEY_DIRECTIONS[/** @type {keyof typeof KEY_DIRECTIONS} */ (key)];
+  if (direction === undefined) {
+    throw new TypeError(`nudgeDelta: unknown key ${JSON.stringify(key)}`);
+  }
+  return { dx: direction.dx * step, dy: direction.dy * step };
+}