@effect-tui/core 0.1.1 → 0.1.5

package/src/present/writers/inline.ts

@@ -1,101 +0,0 @@
-import type { RunWriter } from "../../render/diff.js"
-import type { Palette } from "../../render/surface.js"
-import { ANSI } from "../../ansi.js"
-
-type Seg = { col: number; style: number; text: string }
-
-export class LineDiffWriter implements RunWriter {
-  private shadow = new Map<number, Seg[]>()
-  private printed = new Map<number, Seg[]>() // canonical content per row
-  private rows = 0
-  private baseRow = 0
-
-  constructor(private palette: Palette) {}
-
-  begin(vp: { cols: number; rows: number }) {
-    this.rows = vp.rows
-    this.shadow.clear()
-  }
-
-  setBaseRow(n: number) {
-    this.baseRow = Math.max(0, n | 0)
-  }
-
-  run(row: number, col: number, style: number, text: string) {
-    if (!text) return
-    const list = this.shadow.get(row) ?? []
-    list.push({ col, style, text })
-    this.shadow.set(row, list)
-  }
-
-  end() {
-    /* no-op */
-  }
-
-  private sameRow(a?: Seg[], b?: Seg[]): boolean {
-    if (!a && !b) return true
-    if (!a || !b || a.length !== b.length) return false
-    for (let i = 0; i < a.length; i++) {
-      const A = a[i],
-        B = b[i]
-      if (A.col !== B.col || A.style !== B.style || A.text !== B.text) return false
-    }
-    return true
-  }
-
-  flush(): string {
-    // Only process rows that the diff reported as changed.
-    // Unchanged rows are left intact to avoid accidental clearing.
-    const rowsToProcess = Array.from(this.shadow.keys()).sort((a, b) => a - b)
-
-    let out = ""
-
-    for (const row of rowsToProcess) {
-      const segs = (this.shadow.get(row) ?? []).sort((a, b) => a.col - b.col)
-      const prev = this.printed.get(row)
-      if (this.sameRow(prev, segs)) continue // nothing changed effectively
-
-      // coalesce adjacent segments with same style (keep this optimization)
-      const merged: Seg[] = []
-      for (const s of segs) {
-        const last = merged[merged.length - 1]
-        if (last && last.style === s.style && last.col + last.text.length === s.col) {
-          last.text += s.text
-        } else {
-          merged.push({ ...s })
-        }
-      }
-
-      // Move to absolute row (1-based) and place segments in-place.
-      // Avoid clearing the entire line; we only overwrite changed cells.
-      const termRow1 = this.baseRow + row + 1
-      out += ANSI.cursor.to(termRow1, 1)
-
-      let curStyle = -1
-      for (const s of merged) {
-        // Move to column (1-based) within the current row
-        out += ANSI.cursor.toCol(s.col + 1)
-        if (curStyle !== s.style) {
-          out += this.palette.sgr(s.style)
-          curStyle = s.style
-        }
-        out += s.text
-      }
-      if (curStyle !== -1) out += ANSI.reset
-      this.printed.set(row, merged)
-    }
-
-    // Determine printed height (last row index with any segments + 1)
-    let lastRow = -1
-    for (const [r, segs] of this.printed) {
-      if (segs.length > 0 && r > lastRow) lastRow = r
-    }
-    const printedHeight = lastRow + 1
-
-    // Park cursor at bottom-left of our region (clamped to viewport)
-    const parkRow = Math.min(this.rows, Math.max(1, this.baseRow + (printedHeight > 0 ? printedHeight : 1)))
-    out += ANSI.cursor.to(parkRow, 1)
-
-    return out
-  }
-}

package/src/render/color-utils.ts

@@ -1,60 +0,0 @@
-// color-utils.ts - Shared color conversion utilities
-
-/**
- * Clamp a number to the 0-255 range and convert to integer.
- */
-export function clamp255(n: number): number {
-	return n < 0 ? 0 : n > 255 ? 255 : n | 0
-}
-
-/**
- * Convert a 256-color index to RGB values (approximate xterm palette).
- *
- * The 256-color palette is divided into:
- * - 0-15: Standard ANSI colors (system colors)
- * - 16-231: 6x6x6 RGB cube
- * - 232-255: Grayscale ramp (24 shades)
- */
-export function idxToRGB(idx: number): { r: number; g: number; b: number } {
-	if (idx < 0) idx = 0
-	if (idx > 255) idx = 255
-
-	// Standard ANSI colors (0-15)
-	if (idx < 16) {
-		const base: Array<[number, number, number]> = [
-			[0x00, 0x00, 0x00], // 0: black
-			[0x80, 0x00, 0x00], // 1: red
-			[0x00, 0x80, 0x00], // 2: green
-			[0x80, 0x80, 0x00], // 3: yellow
-			[0x00, 0x00, 0x80], // 4: blue
-			[0x80, 0x00, 0x80], // 5: magenta
-			[0x00, 0x80, 0x80], // 6: cyan
-			[0xc0, 0xc0, 0xc0], // 7: white
-			[0x80, 0x80, 0x80], // 8: bright black (gray)
-			[0xff, 0x00, 0x00], // 9: bright red
-			[0x00, 0xff, 0x00], // 10: bright green
-			[0xff, 0xff, 0x00], // 11: bright yellow
-			[0x00, 0x00, 0xff], // 12: bright blue
-			[0xff, 0x00, 0xff], // 13: bright magenta
-			[0x00, 0xff, 0xff], // 14: bright cyan
-			[0xff, 0xff, 0xff], // 15: bright white
-		]
-		const [r, g, b] = base[idx] ?? [0, 0, 0]
-		return { r, g, b }
-	}
-
-	// Grayscale ramp (232-255)
-	if (idx >= 232) {
-		const n = idx - 232 // 0..23
-		const v = 8 + n * 10
-		return { r: v, g: v, b: v }
-	}
-
-	// 6x6x6 RGB cube (16-231)
-	const n = idx - 16 // 0..215
-	const r = Math.floor(n / 36) % 6
-	const g = Math.floor(n / 6) % 6
-	const b = n % 6
-	const steps = [0, 95, 135, 175, 215, 255]
-	return { r: steps[r] ?? 0, g: steps[g] ?? 0, b: steps[b] ?? 0 }
-}

package/src/render/diff.ts

@@ -1,95 +0,0 @@
-import type { Surface } from "./surface.js"
-
-/**
- * Writer that consumes style runs produced by diffing two frames.
- * - Coordinates are 0-based: `row` in [0..rows), `col` in [0..cols).
- * - `begin` is called once with the viewport size, then `run` zero or more times,
- *   then `end`. Implementations may buffer and expose the result via `flush`.
- */
-export interface RunWriter {
-  begin(viewport: { cols: number; rows: number }): void
-  run(row: number, col: number, styleId: number, text: string): void
-  end(): void
-  flush(): string
-}
-
-/**
- * Stream a minimal set of style-runs for changes from prev → next.
- *
- * Algorithm (row-wise):
- * - For each row, compute a tight change window [left, right]. Skip entirely if equal.
- * - Within the window, emit contiguous runs grouped by style. A new run begins when:
- *   - A cell changes, and
- *   - Its style differs from the current run (or the run just started).
- * - Wide glyph continuation cells (cw=0) are skipped so they are not reprinted.
- *
- * Assumes both Surfaces are same size and compares their back buffers (B).
- */
-export function diffFrames(prev: Surface, next: Surface, w: RunWriter): void {
-  const width = next.w
-  const height = next.h
-  // Access back buffers (like Surface.flush does). B is private on Surface, so use `any`.
-  const gA = (prev as any).B.g as Uint32Array
-  const sA = (prev as any).B.s as Uint32Array
-  const gB = (next as any).B.g as Uint32Array
-  const sB = (next as any).B.s as Uint32Array
-  const cwB = (next as any).B.cw as Uint8Array
-
-  w.begin({ cols: width, rows: height })
-
-  for (let y = 0; y < height; y++) {
-    const row = y * width
-
-    // Fast skip window: [left..right] bounds that changed
-    let left = 0,
-      right = width - 1
-    while (left <= right) {
-      const i = row + left
-      if (gA[i] === gB[i] && sA[i] === sB[i]) left++
-      else break
-    }
-    if (left > right) continue
-
-    while (right >= left) {
-      const i = row + right
-      if (gA[i] === gB[i] && sA[i] === sB[i]) right--
-      else break
-    }
-
-    // Emit contiguous style runs within [left..right]
-    let x = left
-    while (x <= right) {
-      // Skip unchanged within window
-      while (x <= right) {
-        const i = row + x
-        if (gA[i] !== gB[i] || sA[i] !== sB[i]) break
-        x++
-      }
-      if (x > right) break
-
-      const style = sB[row + x]
-      const runX = x
-      let text = ""
-
-      while (x <= right) {
-        const i = row + x
-        if (sB[i] !== style) break
-        const cp = gB[i]
-        const ww = cwB[i]
-        if (ww !== 0) text += cp === 32 ? " " : String.fromCodePoint(cp)
-        x++
-        // skip continuation cells of wide glyphs from the next buffer
-        while (x <= right && cwB[row + x] === 0) x++
-
-        // Stop run if next cell is unchanged; diff window will reposition
-        if (x <= right) {
-          const j = row + x
-          if (gA[j] === gB[j] && sA[j] === sB[j]) break
-        }
-      }
-
-      if (text.length > 0) w.run(y, runX, style, text)
-    }
-  }
-  w.end()
-}

package/src/spring-physics.ts

@@ -1,151 +0,0 @@
-// spring-physics.ts - Core spring physics primitives
-
-export type SpringState = {
-	// current normalized position (e.g., 0..1)
-	x: number
-	// current velocity in units per second
-	v: number
-	// target normalized position
-	target: number
-}
-
-export type SpringConfig = {
-	// natural frequency in Hz (cycles per second). e.g., 3 = fairly snappy
-	frequency?: number
-	// damping ratio (1 = critical damping, < 1 underdamped, > 1 overdamped)
-	dampingRatio?: number
-	// when |x-target| and |v| fall below epsilon, consider settled
-	epsilon?: number
-	// Optional UX-style controls akin to Motion libraries:
-	// approximate settle time in seconds (to ~2% band)
-	duration?: number
-	// bounce amount (0..1), maps to overshoot ratio; default 0 = no overshoot
-	bounce?: number
-}
-
-export const DEFAULTS: Required<Omit<SpringConfig, "duration">> & { duration?: number } = {
-	frequency: 3,
-	dampingRatio: 1,
-	epsilon: 0.0005,
-	duration: undefined,
-	bounce: 0,
-}
-
-export function fromDurationBounce(durationSec: number, bounce = 0): { frequency: number; dampingRatio: number } {
-	const d = Math.max(0.05, durationSec)
-	let zeta: number
-	const b = Math.max(0, Math.min(0.999, bounce))
-	if (b <= 0) {
-		zeta = 1 // critically damped, no overshoot
-	} else {
-		// Map overshoot ratio M_p=b to damping ratio via standard 2nd-order step response
-		const lnMp = Math.log(Math.max(1e-6, b))
-		zeta = Math.sqrt((lnMp * lnMp) / (Math.PI * Math.PI + lnMp * lnMp))
-		zeta = Math.max(0.02, Math.min(0.999, zeta))
-	}
-	// Use ~2% settling time approximation Ts ≈ 4/(ζ ω_n)
-	const omega = 4 / (Math.max(0.02, zeta) * d)
-	const freq = omega / (2 * Math.PI)
-	return { frequency: freq, dampingRatio: zeta }
-}
-
-/**
- * Advance a 1D damped spring towards its target using a semi-implicit Euler step.
- * - Stable enough for small dt (<= ~1/30s) typical of frame ticks.
- * - Uses frequency/dampingRatio to feel similar across frame rates.
- */
-export function advanceSpring(
-	state: SpringState,
-	dtSeconds: number,
-	config?: SpringConfig,
-): SpringState & { settled: boolean } {
-	let { frequency, dampingRatio, epsilon } = { ...DEFAULTS, ...(config ?? {}) }
-	const bounce = config?.bounce ?? DEFAULTS.bounce
-	// If duration is provided, derive frequency/dampingRatio from it and bounce
-	if (config?.duration != null) {
-		const derived = fromDurationBounce(config.duration, config.bounce ?? DEFAULTS.bounce)
-		frequency = derived.frequency
-		dampingRatio = derived.dampingRatio
-	}
-	const omega = Math.PI * 2 * Math.max(0.001, frequency)
-	const k = omega * omega // stiffness
-	const c = 2 * dampingRatio * omega // damping
-
-	let { x, v, target } = state
-	const prevX = x
-	if (dtSeconds <= 0)
-		return {
-			x,
-			v,
-			target,
-			settled: Math.abs(x - target) < epsilon && Math.abs(v) < epsilon,
-		}
-
-	// semi-implicit Euler integration
-	const a = k * (target - x) - c * v
-	v += a * dtSeconds
-	x += v * dtSeconds
-
-	// With bounce=0 users expect a monotonic approach; clamp if we cross the target.
-	if (bounce <= 0) {
-		const crossed = (prevX - target) * (x - target) <= 0
-		if (crossed) {
-			x = target
-			v = 0
-		}
-	}
-
-	// snap to target when sufficiently close to avoid long tails
-	const settled = Math.abs(x - target) < epsilon && Math.abs(v) < epsilon
-	if (settled) {
-		x = target
-		v = 0
-	}
-	return { x, v, target, settled }
-}
-
-/**
- * Internal exact spring step for 1D channel (frame-rate independent).
- * Uses closed-form analytical solution for underdamped/critically-damped/overdamped cases.
- */
-export function stepSpring1D(
-	x: number,
-	v: number,
-	target: number,
-	dt: number,
-	freq: number,
-	zeta: number,
-): { x: number; v: number } {
-	const omega = Math.max(0.001, freq) * 2 * Math.PI
-	const A0 = x - target
-	const exp = Math.exp(-zeta * omega * dt)
-	if (zeta < 1) {
-		// Underdamped
-		const wd = omega * Math.sqrt(1 - zeta * zeta)
-		const cos = Math.cos(wd * dt)
-		const sin = Math.sin(wd * dt)
-		const B0 = v + zeta * omega * A0
-		const A = exp * (A0 * cos + (B0 / wd) * sin)
-		const dA = exp * (-zeta * omega * (A0 * cos + (B0 / wd) * sin) + (-A0 * wd * sin + B0 * cos))
-		return { x: target + A, v: dA }
-	} else if (zeta === 1) {
-		// Critically damped
-		const t = dt
-		const C2 = v + omega * A0
-		const A = exp * (A0 + C2 * t)
-		const dA = exp * (C2 - omega * (A0 + C2 * t))
-		return { x: target + A, v: dA }
-	} else {
-		// Overdamped
-		const s = Math.sqrt(zeta * zeta - 1)
-		const r1 = -omega * (zeta - s)
-		const r2 = -omega * (zeta + s)
-		const C1 = (v - r2 * A0) / (r1 - r2)
-		const C2 = A0 - C1
-		const e1 = Math.exp(r1 * dt)
-		const e2 = Math.exp(r2 * dt)
-		const A = C1 * e1 + C2 * e2
-		const dA = C1 * r1 * e1 + C2 * r2 * e2
-		return { x: target + A, v: dA }
-	}
-}

package/src/spring.ts

@@ -1,234 +0,0 @@
-// spring.ts - Higher-level spring API for number and color values
-
-import type { ColorLike, ColorValue } from "./render/surface.js"
-import { parseColor } from "./render/surface.js"
-import { idxToRGB } from "./render/color-utils.js"
-import { advanceSpring, DEFAULTS, type SpringConfig, type SpringState } from "./spring-physics.js"
-
-// ---- Types ----
-
-export type SpringValue = SpringState & {
-	/** last timestamp in ms used for dt; hidden from callers */
-	_last?: number
-	/** default config for ticks (optional) */
-	_config?: SpringConfig
-}
-
-export type SpringColorValue = {
-	x: { r: number; g: number; b: number }
-	v: { r: number; g: number; b: number }
-	target: { r: number; g: number; b: number }
-	_last?: number
-	_config?: SpringConfig
-}
-
-export type AnySpringValue = SpringValue | SpringColorValue
-
-export type SpringAutoOptions = SpringConfig & {
-	as?: "auto" | "number" | "color"
-}
-
-// ---- Helpers ----
-
-export function colorLikeToRGB(c: ColorLike): { r: number; g: number; b: number } {
-	const v = parseColor(c)
-	if (typeof v === "number") return idxToRGB(v)
-	return { r: v.r | 0, g: v.g | 0, b: v.b | 0 }
-}
-
-function isColorSpring(s: AnySpringValue): s is SpringColorValue {
-	return typeof (s as any).x === "object"
-}
-
-// ---- Number spring primitives ----
-
-function initNumber(initial: number, cfg?: SpringConfig): SpringValue {
-	return {
-		x: initial,
-		v: 0,
-		target: initial,
-		...(cfg && { _config: cfg }),
-	}
-}
-
-function tickNumber(s: SpringValue, nowMs: number, cfg?: SpringConfig): SpringValue {
-	const last = s._last ?? nowMs
-	const dt = Math.max(0, Math.min(0.1, (nowMs - last) / 1000))
-	const stepped = advanceSpring(s, dt, cfg ?? s._config)
-	return {
-		...s,
-		x: stepped.x,
-		v: stepped.v,
-		target: stepped.target,
-		_last: nowMs,
-		...(cfg || s._config ? { _config: cfg ?? s._config } : {}),
-	}
-}
-
-function toNumber(s: SpringValue, target: number): SpringValue {
-	return { ...s, target }
-}
-
-function valueNumber(s: SpringValue): number {
-	return s.x
-}
-
-function settledNumber(s: SpringValue, eps = DEFAULTS.epsilon): boolean {
-	return Math.abs(s.x - s.target) < eps && Math.abs(s.v) < eps
-}
-
-// ---- Color spring primitives ----
-
-const SpringColor = {
-	init(initial: ColorLike, cfg?: SpringConfig): SpringColorValue {
-		const rgb = colorLikeToRGB(initial)
-		return {
-			x: { ...rgb },
-			v: { r: 0, g: 0, b: 0 },
-			target: { ...rgb },
-			...(cfg && { _config: cfg }),
-		}
-	},
-	to(s: SpringColorValue, target: ColorLike): SpringColorValue {
-		const rgb = colorLikeToRGB(target)
-		return { ...s, target: { ...rgb } }
-	},
-	tick(s: SpringColorValue, nowMs: number, cfg?: SpringConfig): SpringColorValue {
-		const last = s._last ?? nowMs
-		const dt = Math.max(0, Math.min(0.1, (nowMs - last) / 1000))
-		const rx = advanceSpring({ x: s.x.r, v: s.v.r, target: s.target.r }, dt, cfg ?? s._config)
-		const gx = advanceSpring({ x: s.x.g, v: s.v.g, target: s.target.g }, dt, cfg ?? s._config)
-		const bx = advanceSpring({ x: s.x.b, v: s.v.b, target: s.target.b }, dt, cfg ?? s._config)
-		return {
-			x: { r: rx.x, g: gx.x, b: bx.x },
-			v: { r: rx.v, g: gx.v, b: bx.v },
-			target: { r: s.target.r, g: s.target.g, b: s.target.b },
-			_last: nowMs,
-			...(cfg || s._config ? { _config: cfg ?? s._config } : {}),
-		}
-	},
-	value(s: SpringColorValue): ColorValue {
-		const clamp = (n: number) => (n < 0 ? 0 : n > 255 ? 255 : n | 0)
-		return { r: clamp(s.x.r), g: clamp(s.x.g), b: clamp(s.x.b) }
-	},
-	settled(s: SpringColorValue, eps = DEFAULTS.epsilon): boolean {
-		const dx = Math.abs(s.x.r - s.target.r) + Math.abs(s.x.g - s.target.g) + Math.abs(s.x.b - s.target.b)
-		const dv = Math.abs(s.v.r) + Math.abs(s.v.g) + Math.abs(s.v.b)
-		return dx < eps * 3 && dv < eps * 3
-	},
-}
-
-// ---- Unified, type-agnostic helpers ----
-
-// Overloads for the ergonomic, single-API surface
-function create(initial: number, cfg?: SpringAutoOptions): SpringValue
-function create(initial: ColorLike, cfg?: SpringAutoOptions): SpringColorValue
-function create(initial: number | ColorLike, cfg?: SpringAutoOptions): AnySpringValue {
-	const as = cfg?.as ?? (typeof initial === "number" ? "number" : "color")
-	return as === "number" ? initNumber(initial as number, cfg) : SpringColor.init(initial as ColorLike, cfg)
-}
-
-function to(s: SpringValue, target: number): SpringValue
-function to(s: SpringColorValue, target: ColorLike): SpringColorValue
-function to(s: AnySpringValue, target: number | ColorLike): AnySpringValue {
-	return isColorSpring(s) ? SpringColor.to(s, target as ColorLike) : toNumber(s as SpringValue, target as number)
-}
-
-function tick(s: SpringValue, nowMs: number, cfg?: SpringConfig): SpringValue
-function tick(s: SpringColorValue, nowMs: number, cfg?: SpringConfig): SpringColorValue
-function tick(s: AnySpringValue, nowMs: number, cfg?: SpringConfig): AnySpringValue {
-	return isColorSpring(s) ? SpringColor.tick(s, nowMs, cfg) : tickNumber(s as SpringValue, nowMs, cfg)
-}
-
-function read(s: SpringValue): number
-function read(s: SpringColorValue): ColorValue
-function read(s: AnySpringValue): number | ColorValue {
-	return isColorSpring(s) ? SpringColor.value(s) : valueNumber(s as SpringValue)
-}
-
-function isSettled(s: SpringValue, eps?: number): boolean
-function isSettled(s: SpringColorValue, eps?: number): boolean
-function isSettled(s: AnySpringValue, eps = DEFAULTS.epsilon): boolean {
-	return isColorSpring(s) ? SpringColor.settled(s, eps) : settledNumber(s as SpringValue, eps)
-}
-
-// ---- Public Spring API ----
-
-export type SpringAPI = {
-	// number
-	init(initial: number, cfg?: SpringConfig): SpringValue
-	to(s: SpringValue, target: number): SpringValue
-	tick(s: SpringValue, nowMs: number, cfg?: SpringConfig): SpringValue
-	value(s: SpringValue): number
-	settled(s: SpringValue, eps?: number): boolean
-
-	// color (legacy explicit path kept for convenience)
-	color: {
-		init(initial: ColorLike, cfg?: SpringConfig): SpringColorValue
-		to(s: SpringColorValue, target: ColorLike): SpringColorValue
-		tick(s: SpringColorValue, nowMs: number, cfg?: SpringConfig): SpringColorValue
-		value(s: SpringColorValue): ColorValue
-		settled(s: SpringColorValue, eps?: number): boolean
-	}
-
-	// unified ergonomic API (overloads)
-	create(initial: number, cfg?: SpringAutoOptions): SpringValue
-	create(initial: ColorLike, cfg?: SpringAutoOptions): SpringColorValue
-	to(s: SpringColorValue, target: ColorLike): SpringColorValue // overload of number variant
-	tick(s: SpringColorValue, nowMs: number, cfg?: SpringConfig): SpringColorValue // overload of number variant
-	advance(s: SpringValue, nowMs: number, cfg?: SpringConfig): SpringValue
-	advance(s: SpringColorValue, nowMs: number, cfg?: SpringConfig): SpringColorValue
-	read(s: SpringValue): number
-	read(s: SpringColorValue): ColorValue
-	isSettled(s: SpringValue, eps?: number): boolean
-	isSettled(s: SpringColorValue, eps?: number): boolean
-}
-
-export const Spring: SpringAPI = {
-	// number
-	init: initNumber,
-	to,
-	tick,
-	value: valueNumber,
-	settled: settledNumber,
-
-	// color (explicit path)
-	color: SpringColor,
-
-	// unified ergonomic API
-	create,
-	advance: tick,
-	read,
-	isSettled,
-}
-
-// ---- Stepper (frame-based discrete animation) ----
-
-export type Stepper = {
-	index: number
-	length: number
-	intervalMs: number
-	_accumMs: number
-	_last?: number
-}
-
-export const Step = {
-	init(length: number, intervalMs: number, startIndex = 0): Stepper {
-		return {
-			index: ((startIndex % length) + length) % length,
-			length: Math.max(1, length | 0),
-			intervalMs: Math.max(1, intervalMs | 0),
-			_accumMs: 0,
-		}
-	},
-	tick(s: Stepper, nowMs: number): Stepper {
-		const last = s._last ?? nowMs
-		let accum = s._accumMs + Math.max(0, nowMs - last)
-		let idx = s.index
-		while (accum >= s.intervalMs) {
-			accum -= s.intervalMs
-			idx = (idx + 1) % s.length
-		}
-		return { ...s, index: idx, _accumMs: accum, _last: nowMs }
-	},
-}

package/src/ui/__snapshots__/wrappedtext.test.ts.snap

@@ -1,57 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`WrappedText > basic word wrapping > should handle single words longer than width 1`] = `
-"verylo
-ngword
-"
-`;
-
-exports[`WrappedText > basic word wrapping > should preserve explicit line breaks 1`] = `
-"line1
-line2
-line3
-
-"
-`;
-
-exports[`WrappedText > basic word wrapping > should wrap text at word boundaries 1`] = `
-"hello
-world
-test"
-`;
-
-exports[`WrappedText > wrapping strategies > should break words when breakWords is enabled 1`] = `
-"supercalif
-ragilistic
-expialidoc
-ious
-"
-`;
-
-exports[`WrappedText basic word wrapping should wrap text at word boundaries 1`] = `
-"hello
-world
-test"
-`;
-
-exports[`WrappedText basic word wrapping should handle single words longer than width 1`] = `
-"verylo
-ngword
-"
-`;
-
-exports[`WrappedText basic word wrapping should preserve explicit line breaks 1`] = `
-"line1
-line2
-line3
-
-"
-`;
-
-exports[`WrappedText wrapping strategies should break words when breakWords is enabled 1`] = `
-"supercalif
-ragilistic
-expialidoc
-ious
-"
-`;