@trendr/core 0.2.11 → 0.4.0

package/src/animation.js

@@ -27,7 +27,7 @@ function tickAll() {
 
   batch(() => {
     for (const anim of active) {
-      const result = anim.interpolator(anim.current, anim.target, anim.velocity, dt)
+      const result = anim.interpolator(anim.current, anim.target, anim.velocity, dt, anim)
       anim.current = result.value
       anim.velocity = result.velocity
       anim.setter(result.value)
@@ -52,6 +52,7 @@ export function animated(initial, interpolator) {
     current: initial,
     target: initial,
     velocity: 0,
+    generation: 0,
     interpolator,
     setter: set,
     onTick: null,
@@ -59,7 +60,12 @@ export function animated(initial, interpolator) {
 
   function setTarget(target) {
     if (target === anim.target && !active.has(anim)) return
-    anim.target = target
+    if (target !== anim.target) {
+      anim.target = target
+      // retargeting mid-flight starts a fresh timing curve in stateful
+      // interpolators like ease() instead of lurching along the old one
+      anim.generation++
+    }
     active.add(anim)
     startLoop()
   }
@@ -141,20 +147,27 @@ export function spring({ frequency = 2, damping = 0.3 } = {}) {
 }
 
 export function ease(durationMs, easingFn = easeOutCubic) {
-  let elapsed = 0
-  let startValue = null
-
-  return function stepEase(current, target, velocity, dt) {
-    if (startValue === null) startValue = current
+  // state is keyed per animation (and per retarget generation) so one ease()
+  // instance can safely drive several animated() values
+  const states = new WeakMap()
+  const fallbackKey = {}
+
+  return function stepEase(current, target, velocity, dt, anim) {
+    const key = anim ?? fallbackKey
+    const generation = anim?.generation ?? 0
+    let state = states.get(key)
+    if (!state || state.generation !== generation) {
+      state = { elapsed: 0, startValue: current, generation }
+      states.set(key, state)
+    }
 
-    elapsed += dt * 1000
-    const t = Math.min(1, elapsed / durationMs)
+    state.elapsed += dt * 1000
+    const t = Math.min(1, state.elapsed / durationMs)
     const eased = easingFn(t)
-    const value = startValue + (target - startValue) * eased
+    const value = state.startValue + (target - state.startValue) * eased
 
     if (t >= 1) {
-      startValue = null
-      elapsed = 0
+      states.delete(key)
       return { value: target, velocity: 0, done: true }
     }
 

package/src/ansi.js

@@ -17,6 +17,7 @@ export const exitAltScreen = `${ESC}?1049l`
 export const sgrReset = `${ESC}0m`
 
 export const setTitle = (title) => `\x1b]2;${title}\x07`
+export const osc52Copy = (text) => `\x1b]52;c;${Buffer.from(text, 'utf8').toString('base64')}\x07`
 
 export const enableMouse = `${ESC}?1002h${ESC}?1006h`
 export const disableMouse = `${ESC}?1002l${ESC}?1006l`
@@ -148,6 +149,11 @@ export function parseSgr(params, state) {
   return state
 }
 
+export function fgSgr(color) {
+  const code = parseColor(color, 38)
+  return code ? `${ESC}${code}m` : ''
+}
+
 export function sgr(fg, bg, attrs) {
   const parts = ['0']
 

package/src/buffer.js

@@ -1,5 +1,5 @@
 import { parseSgr } from './ansi.js'
-import { charWidth } from './wrap.js'
+import { charWidth, ansiSeqEnd } from './wrap.js'
 
 const EMPTY = { ch: ' ', fg: null, bg: null, attrs: 0 }
 
@@ -7,12 +7,13 @@ export function createBuffer(width, height) {
   const size = width * height
   const cells = new Array(size)
   for (let i = 0; i < size; i++) cells[i] = EMPTY
-  return { width, height, cells }
+  return { width, height, cells, softWrap: new Uint8Array(height) }
 }
 
 export function clearBuffer(buf) {
   const len = buf.cells.length
   for (let i = 0; i < len; i++) buf.cells[i] = EMPTY
+  buf.softWrap.fill(0)
 }
 
 export function resizeBuffer(buf, width, height) {
@@ -20,6 +21,7 @@ export function resizeBuffer(buf, width, height) {
   buf.height = height
   buf.cells = new Array(width * height)
   for (let i = 0; i < buf.cells.length; i++) buf.cells[i] = EMPTY
+  buf.softWrap = new Uint8Array(height)
 }
 
 export function setCell(buf, x, y, ch, fg, bg, attrs) {
@@ -27,69 +29,80 @@ export function setCell(buf, x, y, ch, fg, bg, attrs) {
   buf.cells[y * buf.width + x] = { ch, fg: fg ?? null, bg: bg ?? null, attrs: attrs ?? 0 }
 }
 
+function putCell(buf, idx, ch, fg, bg, attrs) {
+  const prev = buf.cells[idx]
+  const transparent = ch === ' ' && !bg && prev.ch !== ' '
+  buf.cells[idx] = {
+    ch: transparent ? prev.ch : ch,
+    fg: transparent ? prev.fg : (fg ?? prev.fg),
+    bg: bg ?? prev.bg,
+    attrs: transparent ? prev.attrs : (attrs ?? prev.attrs),
+  }
+}
+
+// non-SGR escapes (OSC, cursor CSI, ...) are dropped: cells hold one glyph
+// plus style, there is nothing for them to attach to. zero-width chars fold
+// into the previous cell's glyph. tabs expand to spaces at 8-column stops
+// measured from the start of the write, matching measureText
 export function writeText(buf, x, y, text, fg, bg, attrs, maxWidth) {
   if (y < 0 || y >= buf.height) return
   const max = maxWidth ?? (buf.width - x)
-
-  if (text.indexOf('\x1b') === -1) {
-    let col = 0
-    let i = 0
-    while (i < text.length && col < max) {
-      const code = text.codePointAt(i)
-      const len = code > 0xffff ? 2 : 1
-      const w = charWidth(code)
-      const cx = x + col
-      if (cx >= 0 && cx < buf.width) {
-        const ch = len === 1 ? text[i] : text.slice(i, i + len)
-        const prev = buf.cells[y * buf.width + cx]
-        const transparent = ch === ' ' && !bg && prev.ch !== ' '
-        buf.cells[y * buf.width + cx] = {
-          ch: transparent ? prev.ch : ch,
-          fg: transparent ? prev.fg : (fg ?? prev.fg),
-          bg: bg ?? prev.bg,
-          attrs: transparent ? prev.attrs : (attrs || prev.attrs),
-        }
-        if (w === 2 && cx + 1 < buf.width) {
-          buf.cells[y * buf.width + cx + 1] = { ch: '', fg: fg ?? null, bg: bg ?? null, attrs: attrs ?? 0 }
-        }
-      }
-      col += w
-      i += len
-    }
-    return
-  }
-
+  const base = y * buf.width
+  let ansi = null
   let col = 0
-  const ansi = { fg: null, bg: null, attrs: 0 }
   let i = 0
 
-  while (i < text.length && col < max) {
-    if (text[i] === '\x1b' && text[i + 1] === '[') {
-      const end = text.indexOf('m', i + 2)
+  while (i < text.length) {
+    if (text.charCodeAt(i) === 27) {
+      const end = ansiSeqEnd(text, i)
       if (end !== -1) {
-        parseSgr(text.slice(i + 2, end), ansi)
-        i = end + 1
+        if (text[i + 1] === '[' && text[end - 1] === 'm') {
+          if (ansi === null) ansi = { fg: null, bg: null, attrs: 0 }
+          parseSgr(text.slice(i + 2, end - 1), ansi)
+        }
+        i = end
         continue
       }
     }
 
+    const efg = ansi === null ? fg : (ansi.fg ?? fg)
+    const ebg = ansi === null ? bg : (ansi.bg ?? bg)
+    const eattrs = ansi === null || ansi.attrs === 0 ? attrs : ansi.attrs
+
     const code = text.codePointAt(i)
     const len = code > 0xffff ? 2 : 1
-    const w = charWidth(code)
-    const cx = x + col
-    if (cx >= 0 && cx < buf.width) {
-      const ch = len === 1 ? text[i] : text.slice(i, i + len)
-      const prev = buf.cells[y * buf.width + cx]
-      const transparent = ch === ' ' && !bg && prev.ch !== ' '
-      buf.cells[y * buf.width + cx] = {
-        ch: transparent ? prev.ch : ch,
-        fg: transparent ? prev.fg : (ansi.fg ?? fg ?? prev.fg),
-        bg: ansi.bg ?? bg ?? prev.bg,
-        attrs: transparent ? prev.attrs : (ansi.attrs || attrs || prev.attrs),
+
+    if (code === 9) {
+      let stop = col + 8 - (col % 8)
+      if (stop > max) stop = max
+      while (col < stop) {
+        const cx = x + col
+        if (cx >= 0 && cx < buf.width) putCell(buf, base + cx, ' ', efg, ebg, eattrs)
+        col++
       }
-      if (w === 2 && cx + 1 < buf.width) {
-        buf.cells[y * buf.width + cx + 1] = { ch: '', fg: ansi.fg ?? fg ?? null, bg: ansi.bg ?? bg ?? null, attrs: ansi.attrs || attrs || 0 }
+      i++
+      continue
+    }
+
+    const w = charWidth(code)
+
+    if (w === 0) {
+      const px = x + col - 1
+      if (col > 0 && px >= 0 && px < buf.width) {
+        let pi = base + px
+        if (buf.cells[pi].ch === '' && px > 0) pi--
+        const pc = buf.cells[pi]
+        if (pc.ch !== '') buf.cells[pi] = { ch: pc.ch + text.slice(i, i + len), fg: pc.fg, bg: pc.bg, attrs: pc.attrs }
       }
+      i += len
+      continue
+    }
+
+    if (col + w > max) break
+    const cx = x + col
+    if (cx >= 0 && cx + w <= buf.width) {
+      putCell(buf, base + cx, len === 1 ? text[i] : text.slice(i, i + len), efg, ebg, eattrs)
+      if (w === 2) buf.cells[base + cx + 1] = { ch: '', fg: efg ?? null, bg: ebg ?? null, attrs: eattrs ?? 0 }
     }
     col += w
     i += len

package/src/button.js

@@ -2,7 +2,7 @@ import { jsx } from '../jsx-runtime.js'
 import { useInput, useMouse, useLayout, useTheme } from './hooks.js'
 
 export function Button({ label, onPress, focused = false, variant }) {
-  const { accent = 'cyan' } = useTheme()
+  const { accent = 'cyan', accentText = 'black', muted = 'gray' } = useTheme()
   const layout = useLayout()
 
   useInput((event) => {
@@ -26,7 +26,7 @@ export function Button({ label, onPress, focused = false, variant }) {
   return jsx('text', {
     style: {
       bg: focused ? accent : null,
-      color: focused ? 'black' : (dim ? 'gray' : null),
+      color: focused ? accentText : (dim ? muted : null),
       bold: focused,
       dim: !focused && dim,
     },

package/src/checkbox.js

@@ -2,7 +2,7 @@ import { jsx, jsxs } from '../jsx-runtime.js'
 import { useInput, useMouse, useLayout, useTheme } from './hooks.js'
 
 export function Checkbox({ checked = false, label, onChange, focused = false, checkedIcon = '[x]', uncheckedIcon = '[ ]' }) {
-  const { accent = 'cyan' } = useTheme()
+  const { accent = 'cyan', accentText = 'black' } = useTheme()
   const layout = useLayout()
 
   useInput((event) => {
@@ -23,7 +23,7 @@ export function Checkbox({ checked = false, label, onChange, focused = false, ch
 
   const icon = checked ? checkedIcon : uncheckedIcon
   const bg = focused ? accent : null
-  const color = focused ? 'black' : null
+  const color = focused ? accentText : null
 
   const children = [
     jsx('text', { style: { color, bold: focused }, children: icon }),

package/src/diff-engine.js

@@ -0,0 +1,313 @@
+// turns before/after text, a unified patch string, or structured hunks into a
+// single normalized row model the Diff component renders. each row carries
+// line numbers, a type, and optional intra-line change ranges (word-level)
+
+const LCS_CELL_LIMIT = 4_000_000
+
+function splitLines(text) {
+  if (text == null || text === '') return []
+  const lines = String(text).split('\n')
+  if (lines.length > 1 && lines[lines.length - 1] === '') lines.pop()
+  return lines
+}
+
+// classic LCS edit script over arrays, with common prefix/suffix trimming so a
+// small edit inside a large file stays cheap. returns ops in sequence order
+function diffSequences(a, b, eq = (x, y) => x === y) {
+  const ops = []
+  let lo = 0
+  let aHi = a.length
+  let bHi = b.length
+
+  while (lo < aHi && lo < bHi && eq(a[lo], b[lo])) {
+    ops.push({ type: 'equal', a: lo, b: lo })
+    lo++
+  }
+
+  const tail = []
+  while (aHi > lo && bHi > lo && eq(a[aHi - 1], b[bHi - 1])) {
+    aHi--
+    bHi--
+    tail.push({ type: 'equal', a: aHi, b: bHi })
+  }
+  tail.reverse()
+
+  const n = aHi - lo
+  const m = bHi - lo
+
+  if (n === 0 || m === 0 || (n + 1) * (m + 1) > LCS_CELL_LIMIT) {
+    for (let i = lo; i < aHi; i++) ops.push({ type: 'del', a: i })
+    for (let j = lo; j < bHi; j++) ops.push({ type: 'add', b: j })
+    return ops.concat(tail)
+  }
+
+  const W = m + 1
+  const dp = new Int32Array((n + 1) * W)
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[i * W + j] = eq(a[lo + i], b[lo + j])
+        ? dp[(i + 1) * W + (j + 1)] + 1
+        : Math.max(dp[(i + 1) * W + j], dp[i * W + (j + 1)])
+    }
+  }
+
+  let i = 0
+  let j = 0
+  while (i < n && j < m) {
+    if (eq(a[lo + i], b[lo + j])) {
+      ops.push({ type: 'equal', a: lo + i, b: lo + j })
+      i++
+      j++
+    } else if (dp[(i + 1) * W + j] >= dp[i * W + (j + 1)]) {
+      ops.push({ type: 'del', a: lo + i })
+      i++
+    } else {
+      ops.push({ type: 'add', b: lo + j })
+      j++
+    }
+  }
+  while (i < n) ops.push({ type: 'del', a: lo + i++ })
+  while (j < m) ops.push({ type: 'add', b: lo + j++ })
+
+  return ops.concat(tail)
+}
+
+// codepoint-aware tokenizer so intra ranges line up with the renderer's
+// visible-character slicing. runs of word chars stay whole, everything else
+// splits per character
+function tokenize(line) {
+  const chars = Array.from(line)
+  const tokens = []
+  let i = 0
+  while (i < chars.length) {
+    if (/\w/.test(chars[i])) {
+      const start = i
+      while (i < chars.length && /\w/.test(chars[i])) i++
+      tokens.push({ text: chars.slice(start, i).join(''), start, end: i })
+    } else {
+      tokens.push({ text: chars[i], start: i, end: i + 1 })
+      i++
+    }
+  }
+  return tokens
+}
+
+function mergeRanges(ranges) {
+  if (ranges.length === 0) return null
+  ranges.sort((x, y) => x[0] - y[0])
+  const merged = [ranges[0].slice()]
+  for (let k = 1; k < ranges.length; k++) {
+    const last = merged[merged.length - 1]
+    if (ranges[k][0] <= last[1]) last[1] = Math.max(last[1], ranges[k][1])
+    else merged.push(ranges[k].slice())
+  }
+  return merged
+}
+
+// word-level diff of two lines. returns the changed codepoint ranges on each
+// side, or null when the lines are too dissimilar for sub-line highlighting to
+// read as anything but noise
+function diffWords(oldLine, newLine, { minSimilarity = 0.25 } = {}) {
+  const aTok = tokenize(oldLine)
+  const bTok = tokenize(newLine)
+  const ops = diffSequences(aTok.map(t => t.text), bTok.map(t => t.text))
+
+  let common = 0
+  for (const op of ops) if (op.type === 'equal') common += aTok[op.a].end - aTok[op.a].start
+  const total = Array.from(oldLine).length + Array.from(newLine).length
+  if (total > 0 && (2 * common) / total < minSimilarity) return { old: null, new: null }
+
+  const oldRanges = []
+  const newRanges = []
+  for (const op of ops) {
+    if (op.type === 'del') oldRanges.push([aTok[op.a].start, aTok[op.a].end])
+    else if (op.type === 'add') newRanges.push([bTok[op.b].start, bTok[op.b].end])
+  }
+
+  return { old: mergeRanges(oldRanges), new: mergeRanges(newRanges) }
+}
+
+// for every block of deletions immediately followed by additions, pair the
+// lines index-wise and compute their intra ranges
+function annotateIntra(rows, wordDiff) {
+  if (!wordDiff) return rows
+  let k = 0
+  while (k < rows.length) {
+    if (rows[k].type !== 'del') { k++; continue }
+    let delEnd = k
+    while (delEnd < rows.length && rows[delEnd].type === 'del') delEnd++
+    let addEnd = delEnd
+    while (addEnd < rows.length && rows[addEnd].type === 'add') addEnd++
+
+    const dels = delEnd - k
+    const adds = addEnd - delEnd
+    const pairs = Math.min(dels, adds)
+    for (let p = 0; p < pairs; p++) {
+      const delRow = rows[k + p]
+      const addRow = rows[delEnd + p]
+      const { old, new: nw } = diffWords(delRow.text, addRow.text)
+      delRow.intra = old
+      addRow.intra = nw
+    }
+    k = addEnd > k ? addEnd : k + 1
+  }
+  return rows
+}
+
+function rowsFromOps(ops, aLines, bLines) {
+  const rows = []
+  for (const op of ops) {
+    if (op.type === 'equal') {
+      rows.push({ type: 'context', oldNo: op.a + 1, newNo: op.b + 1, text: aLines[op.a], intra: null })
+    } else if (op.type === 'del') {
+      rows.push({ type: 'del', oldNo: op.a + 1, newNo: null, text: aLines[op.a], intra: null })
+    } else {
+      rows.push({ type: 'add', oldNo: null, newNo: op.b + 1, text: bLines[op.b], intra: null })
+    }
+  }
+  return rows
+}
+
+function rowsFromBeforeAfter(before, after, wordDiff) {
+  const aLines = splitLines(before)
+  const bLines = splitLines(after)
+  const ops = diffSequences(aLines, bLines)
+  return annotateIntra(rowsFromOps(ops, aLines, bLines), wordDiff)
+}
+
+const HUNK_RE = /^@@+ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@@*(.*)$/
+
+function rowsFromPatch(patch, wordDiff) {
+  const rows = []
+  let oldNo = 0
+  let newNo = 0
+  let oldRemain = 0
+  let newRemain = 0
+
+  for (const raw of String(patch).split('\n')) {
+    if (raw.startsWith('\\')) {
+      const prev = rows[rows.length - 1]
+      if (prev && (prev.type === 'add' || prev.type === 'del' || prev.type === 'context')) prev.noNewline = true
+      continue
+    }
+
+    if (oldRemain <= 0 && newRemain <= 0) {
+      const hunk = HUNK_RE.exec(raw)
+      if (hunk) {
+        oldNo = parseInt(hunk[1], 10)
+        newNo = parseInt(hunk[3], 10)
+        oldRemain = hunk[2] != null ? parseInt(hunk[2], 10) : 1
+        newRemain = hunk[4] != null ? parseInt(hunk[4], 10) : 1
+        rows.push({ type: 'hunk', oldNo: null, newNo: null, text: raw, intra: null })
+        continue
+      }
+      if (raw !== '' && (raw.startsWith('diff ') || raw.startsWith('index ') ||
+          raw.startsWith('--- ') || raw.startsWith('+++ ') || raw.startsWith('old mode') ||
+          raw.startsWith('new mode') || raw.startsWith('similarity ') ||
+          raw.startsWith('rename ') || raw.startsWith('new file') ||
+          raw.startsWith('deleted file') || raw.startsWith('Binary '))) {
+        rows.push({ type: 'meta', oldNo: null, newNo: null, text: raw, intra: null })
+      }
+      continue
+    }
+
+    const marker = raw[0]
+    const text = raw.slice(1)
+    if (marker === '+') {
+      rows.push({ type: 'add', oldNo: null, newNo: newNo++, text, intra: null })
+      newRemain--
+    } else if (marker === '-') {
+      rows.push({ type: 'del', oldNo: oldNo++, newNo: null, text, intra: null })
+      oldRemain--
+    } else {
+      rows.push({ type: 'context', oldNo: oldNo++, newNo: newNo++, text, intra: null })
+      oldRemain--
+      newRemain--
+    }
+  }
+
+  return annotateIntra(rows, wordDiff)
+}
+
+function rowsFromHunks(hunks, wordDiff) {
+  const rows = []
+  for (const hunk of hunks) {
+    let oldNo = hunk.oldStart ?? 1
+    let newNo = hunk.newStart ?? 1
+    if (hunk.header !== false) {
+      rows.push({ type: 'hunk', oldNo: null, newNo: null, text: hunk.header ?? hunkHeader(hunk), intra: null })
+    }
+    for (const line of hunk.lines ?? []) {
+      const type = line.type ?? 'context'
+      const text = line.content ?? line.text ?? ''
+      if (type === 'add') rows.push({ type: 'add', oldNo: null, newNo: newNo++, text, intra: null })
+      else if (type === 'del') rows.push({ type: 'del', oldNo: oldNo++, newNo: null, text, intra: null })
+      else rows.push({ type: 'context', oldNo: oldNo++, newNo: newNo++, text, intra: null })
+    }
+  }
+  return annotateIntra(rows, wordDiff)
+}
+
+function hunkHeader(hunk) {
+  let oldCount = 0
+  let newCount = 0
+  for (const line of hunk.lines ?? []) {
+    const type = line.type ?? 'context'
+    if (type !== 'add') oldCount++
+    if (type !== 'del') newCount++
+  }
+  return `@@ -${hunk.oldStart ?? 1},${oldCount} +${hunk.newStart ?? 1},${newCount} @@`
+}
+
+// collapses runs of unchanged context longer than 2*context into a fold row, so
+// a small edit in a large file shows just the neighborhood of each change
+function foldContext(rows, context) {
+  if (!Number.isFinite(context)) return rows
+  const keep = new Array(rows.length).fill(false)
+  for (let i = 0; i < rows.length; i++) {
+    if (rows[i].type === 'context') continue
+    for (let d = -context; d <= context; d++) {
+      const j = i + d
+      if (j >= 0 && j < rows.length) keep[j] = true
+    }
+  }
+
+  const out = []
+  let i = 0
+  while (i < rows.length) {
+    if (keep[i] || rows[i].type !== 'context') {
+      out.push(rows[i])
+      i++
+      continue
+    }
+    let j = i
+    while (j < rows.length && !keep[j] && rows[j].type === 'context') j++
+    const count = j - i
+    if (count > 0) out.push({ type: 'fold', oldNo: null, newNo: null, text: `${count} unchanged ${count === 1 ? 'line' : 'lines'}`, count, intra: null })
+    i = j
+  }
+  return out
+}
+
+function countStats(rows) {
+  let additions = 0
+  let deletions = 0
+  for (const row of rows) {
+    if (row.type === 'add') additions++
+    else if (row.type === 'del') deletions++
+  }
+  return { additions, deletions }
+}
+
+export function computeDiff({ before, after, patch, hunks, wordDiff = true, context = Infinity } = {}) {
+  let rows
+  if (hunks != null) rows = rowsFromHunks(hunks, wordDiff)
+  else if (patch != null) rows = rowsFromPatch(patch, wordDiff)
+  else rows = rowsFromBeforeAfter(before ?? '', after ?? '', wordDiff)
+
+  const stats = countStats(rows)
+  rows = foldContext(rows, context)
+  return { rows, stats }
+}
+
+export { diffSequences, diffWords, tokenize, splitLines }