@silvery/tea 0.3.0

package/src/text-ops.ts

@@ -0,0 +1,150 @@
+/**
+ * Text Operations -- invertible, composable text mutations.
+ *
+ * Every text change produces a TextOp that can be inverted (for undo)
+ * and composed (for merging consecutive typing). Foundation for
+ * operations-based undo/redo without document snapshots.
+ *
+ * Architecture layer 0 -- no state, no hooks, no components.
+ *
+ * @example
+ * ```ts
+ * import { applyTextOp, invertTextOp, mergeTextOps } from '@silvery/react'
+ *
+ * const op: TextOp = { type: "insert", offset: 5, text: "hello" }
+ * const result = applyTextOp("world", op)  // "worlhellod"
+ * const inv = invertTextOp(op)             // { type: "delete", offset: 5, text: "hello" }
+ * ```
+ */
+
+// =============================================================================
+// Types
+// =============================================================================
+
+/**
+ * An invertible text operation.
+ *
+ * - `insert`: text was inserted at `offset`
+ * - `delete`: text was deleted starting at `offset` (the deleted content is
+ *   stored in `text` so the operation can be inverted)
+ * - `replace`: text at `offset` was replaced — `deleted` holds the old text,
+ *   `text` holds the new text. The inverse swaps them.
+ */
+export type TextOp =
+  | { type: "insert"; offset: number; text: string }
+  | { type: "delete"; offset: number; text: string }
+  | { type: "replace"; offset: number; text: string; deleted: string }
+
+// =============================================================================
+// Core Functions
+// =============================================================================
+
+/**
+ * Apply a text operation to a string, returning the modified string.
+ *
+ * Throws if the offset is out of bounds or if a delete operation's stored
+ * text doesn't match what's actually in the string at that position.
+ */
+export function applyTextOp(text: string, op: TextOp): string {
+  if (op.offset < 0 || op.offset > text.length) {
+    throw new RangeError(`TextOp offset ${op.offset} out of bounds for text of length ${text.length}`)
+  }
+
+  if (op.type === "insert") {
+    return text.slice(0, op.offset) + op.text + text.slice(op.offset)
+  }
+
+  if (op.type === "replace") {
+    const end = op.offset + op.deleted.length
+    if (end > text.length) {
+      throw new RangeError(
+        `TextOp replace extends past end: offset=${op.offset}, deleteLen=${op.deleted.length}, textLen=${text.length}`,
+      )
+    }
+    const actual = text.slice(op.offset, end)
+    if (actual !== op.deleted) {
+      throw new Error(
+        `TextOp replace mismatch at offset ${op.offset}: expected ${JSON.stringify(op.deleted)}, got ${JSON.stringify(actual)}`,
+      )
+    }
+    return text.slice(0, op.offset) + op.text + text.slice(end)
+  }
+
+  // delete
+  const end = op.offset + op.text.length
+  if (end > text.length) {
+    throw new RangeError(
+      `TextOp delete extends past end: offset=${op.offset}, deleteLen=${op.text.length}, textLen=${text.length}`,
+    )
+  }
+  const actual = text.slice(op.offset, end)
+  if (actual !== op.text) {
+    throw new Error(
+      `TextOp delete mismatch at offset ${op.offset}: expected ${JSON.stringify(op.text)}, got ${JSON.stringify(actual)}`,
+    )
+  }
+  return text.slice(0, op.offset) + text.slice(end)
+}
+
+/**
+ * Invert a text operation (insert becomes delete and vice versa).
+ *
+ * The inverse of an insert at offset N is a delete of the same text at
+ * offset N; the inverse of a delete is an insert.
+ */
+export function invertTextOp(op: TextOp): TextOp {
+  if (op.type === "insert") {
+    return { type: "delete", offset: op.offset, text: op.text }
+  }
+  if (op.type === "replace") {
+    return { type: "replace", offset: op.offset, text: op.deleted, deleted: op.text }
+  }
+  return { type: "insert", offset: op.offset, text: op.text }
+}
+
+/**
+ * Attempt to merge two consecutive text operations into one.
+ *
+ * Returns the merged operation, or `null` if the operations can't be merged.
+ *
+ * Merge rules:
+ * - Two inserts where `b` starts exactly where `a` ends -> single insert
+ * - Two deletes where `b` ends exactly where `a` starts (backspace sequence)
+ *   -> single delete covering both ranges
+ * - Two deletes where `b` starts at `a`'s offset (forward-delete sequence)
+ *   -> single delete covering both ranges
+ * - Otherwise -> null (can't merge)
+ */
+export function mergeTextOps(a: TextOp, b: TextOp): TextOp | null {
+  // insert + insert: b inserts right after a's inserted text
+  if (a.type === "insert" && b.type === "insert") {
+    if (b.offset === a.offset + a.text.length) {
+      return { type: "insert", offset: a.offset, text: a.text + b.text }
+    }
+    return null
+  }
+
+  // delete + delete
+  if (a.type === "delete" && b.type === "delete") {
+    // Backspace sequence: b deletes the character just before a's range.
+    // After a deletes at offset X, the next backspace deletes at offset X-1.
+    if (b.offset + b.text.length === a.offset) {
+      return { type: "delete", offset: b.offset, text: b.text + a.text }
+    }
+    // Forward-delete sequence: b deletes at the same position as a (because
+    // after a removed its text, the next character slid into the same offset).
+    if (b.offset === a.offset) {
+      return { type: "delete", offset: a.offset, text: a.text + b.text }
+    }
+    return null
+  }
+
+  // insert + delete that exactly cancels the insert
+  if (a.type === "insert" && b.type === "delete") {
+    if (b.offset === a.offset && b.text === a.text) {
+      return null // operations cancel out
+    }
+  }
+
+  return null
+}

package/src/tree-utils.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared tree utilities for silvery event systems.
+ *
+ * Functions used by both focus-events.ts and mouse-events.ts.
+ */
+
+import type { TeaNode, Rect } from "./types.js"
+
+/**
+ * Collect the ancestor path from target to root (inclusive).
+ */
+export function getAncestorPath(node: TeaNode): TeaNode[] {
+  const path: TeaNode[] = []
+  let current: TeaNode | null = node
+  while (current) {
+    path.push(current)
+    current = current.parent
+  }
+  return path
+}
+
+/**
+ * Check if a point is inside a rect.
+ */
+export function pointInRect(x: number, y: number, rect: Rect): boolean {
+  return x >= rect.x && x < rect.x + rect.width && y >= rect.y && y < rect.y + rect.height
+}