@effect-tui/react 0.14.1 → 0.14.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effect-tui/react",
-	"version": "0.14.1",
+	"version": "0.14.3",
 	"description": "React bindings for @effect-tui/core",
 	"type": "module",
 	"files": [
@@ -83,8 +83,8 @@
 		"prepublishOnly": "bun run typecheck && bun run build"
 	},
 	"dependencies": {
-		"@effect-tui/core": "^0.14.1",
-		"@effect/platform": "^0.94.0",
+		"@effect-tui/core": "^0.14.3",
+		"@effect/platform": "^0.94.1",
 		"@effect/platform-bun": "^0.87.0",
 		"@effect/rpc": "^0.73.0",
 		"@parcel/watcher": "^2.5.1",
@@ -92,8 +92,8 @@
 		"shiki": "^3.20.0"
 	},
 	"peerDependencies": {
-		"effect": "^3.19.13",
-		"react": "^19.2.3",
+		"effect": "^3.0.0",
+		"react": "^19.0.0",
 		"@effect/opentelemetry": "^0.60.0",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.2.0"
@@ -119,7 +119,7 @@
 		"@types/node": "^25.0.3",
 		"@types/react": "^19.0.0",
 		"@types/react-reconciler": "^0.32.3",
-		"effect": "^3.19.13",
+		"effect": "^3.19.14",
 		"react": "^19.2.3",
 		"typescript": "^5.9.3",
 		"vitest": "^4.0.16"

package/src/components/MultilineTextInput.tsx

@@ -2,6 +2,7 @@ import { type Color, Colors, displayWidth, graphemes } from "@effect-tui/core"
 import { useCallback, useEffect, useMemo, useRef, useState } from "react"
 import { useKeyboard } from "../hooks/use-keyboard.js"
 import { usePaste } from "../hooks/use-paste.js"
+import { isWhitespace } from "../utils/word-boundaries.js"
 import type { DrawContext } from "../hosts/canvas.js"
 import {
 	deleteCharBackwardMultiline,
@@ -97,7 +98,7 @@ function wrapLogicalLine(line: string, logicalRow: number, maxWidth: number): Li
 	}
 
 	// Find break opportunities (after spaces)
-	const isBreakable = graphemeList.map((g) => /\s/.test(g))
+	const isBreakable = graphemeList.map((g) => isWhitespace(g))
 
 	const visualLines: VisualLine[] = []
 	let start = 0

package/src/components/text-editing.ts

@@ -5,6 +5,7 @@
  */
 
 import { graphemes } from "@effect-tui/core"
+import { matchNextWord, matchPrevWord } from "../utils/word-boundaries.js"
 
 // ============================================================================
 // Types
@@ -34,15 +35,7 @@ export interface EditResult<T> {
 // Word boundary helpers (shared by TextInput and MultilineTextInput)
 // ============================================================================
 
-/** Match the previous word (and trailing whitespace) or whitespace-only chunk. */
-export function matchPrevWord(beforeCursor: string): string | null {
-	return beforeCursor.match(/(\S+\s*|\s+)$/)?.[0] ?? null
-}
-
-/** Match the next word (including leading whitespace). */
-export function matchNextWord(afterCursor: string): string | null {
-	return afterCursor.match(/^\s*\S+/)?.[0] ?? null
-}
+export { matchNextWord, matchPrevWord }
 
 // ============================================================================
 // Single-line operations (for TextInput)

package/src/hosts/text.ts

@@ -1,7 +1,7 @@
 import { type CellBuffer, type Color, displayWidth, type Palette } from "@effect-tui/core"
 import type { ColorMotionValue } from "../motion/color-motion-value.js"
 import type { CommonProps, HostContext, HostInstance, Rect, Size } from "../reconciler/types.js"
-import { resolveInheritedBgStyle, styleIdFromProps, wrapSpans } from "../utils/index.js"
+import { isWhitespace, resolveInheritedBgStyle, splitWords, styleIdFromProps, wrapSpans } from "../utils/index.js"
 import { BaseHost, getInheritedBg } from "./base.js"
 
 /** Color prop that can be a static Color or a spring-animated ColorMotionValue */
@@ -230,19 +230,19 @@ export class TextHost extends BaseHost {
 			}
 
 			// Split into words (keeping whitespace as separate tokens)
-			const tokens = rawLine.split(/(\s+)/)
+			const tokens = splitWords(rawLine)
 			let line = ""
 			let lineW = 0
 
 			for (const token of tokens) {
 				const tokenW = displayWidth(token)
-				const isWhitespace = /^\s+$/.test(token)
+				const isWs = isWhitespace(token)
 
 				if (lineW + tokenW <= maxWidth) {
 					// Token fits on current line
 					line += token
 					lineW += tokenW
-				} else if (isWhitespace) {
+				} else if (isWs) {
 					// Whitespace doesn't fit - just skip it (don't start new line with space)
 					continue
 				} else if (tokenW <= maxWidth) {

package/src/utils/index.ts

@@ -21,3 +21,4 @@ export {
 	toColorValue,
 } from "./styles.js"
 export { wrapSpans } from "./text-wrap.js"
+export { isWhitespace, matchNextWord, matchPrevWord, splitWords } from "./word-boundaries.js"

package/src/utils/text-wrap.ts

@@ -1,4 +1,5 @@
 import { displayWidth } from "@effect-tui/core"
+import { isWhitespace, splitWords } from "./word-boundaries.js"
 
 type SpanLike = { text: string }
 
@@ -12,18 +13,18 @@ export function wrapSpans<T extends SpanLike>(spans: T[], maxWidth: number): T[]
 
 	for (const span of spans) {
 		// Split span text into words (keeping whitespace as separate tokens)
-		const tokens = span.text.split(/(\s+)/)
+		const tokens = splitWords(span.text)
 
 		for (const token of tokens) {
 			if (!token) continue
 			const tokenWidth = displayWidth(token)
-			const isWhitespace = /^\s+$/.test(token)
+			const isWs = isWhitespace(token)
 
 			if (lineWidth + tokenWidth <= maxWidth) {
 				// Token fits on current line
 				lines[lines.length - 1].push({ ...span, text: token })
 				lineWidth += tokenWidth
-			} else if (isWhitespace) {
+			} else if (isWs) {
 				// Skip whitespace at line break
 				continue
 			} else if (tokenWidth <= maxWidth) {

package/src/utils/word-boundaries.ts

@@ -0,0 +1,40 @@
+const whitespaceRegex = /^\s+$/u
+
+export function isWhitespace(text: string): boolean {
+	return whitespaceRegex.test(text)
+}
+
+export function splitWords(text: string): string[] {
+	if (!text) return []
+	return text.split(/(\s+)/u).filter((token) => token.length > 0)
+}
+
+/** Match the previous word (and trailing whitespace) or whitespace-only chunk. */
+export function matchPrevWord(beforeCursor: string): string | null {
+	const tokens = splitWords(beforeCursor)
+	if (tokens.length === 0) return null
+	const last = tokens[tokens.length - 1]
+	if (isWhitespace(last)) {
+		const prev = tokens[tokens.length - 2]
+		if (prev && !isWhitespace(prev)) {
+			return prev + last
+		}
+		return last
+	}
+	return last
+}
+
+/** Match the next word (including leading whitespace). */
+export function matchNextWord(afterCursor: string): string | null {
+	const tokens = splitWords(afterCursor)
+	if (tokens.length === 0) return null
+	const first = tokens[0]
+	if (isWhitespace(first)) {
+		const next = tokens[1]
+		if (next && !isWhitespace(next)) {
+			return first + next
+		}
+		return null
+	}
+	return first
+}