@uknows/setup 0.0.0-stage → 0.2.0

package/lib/diff.mjs

@@ -0,0 +1,147 @@
+/*
+ * Line diffs. Lines keep their endings, so a diff of CRLF, mixed or
+ * unterminated text is byte exact. The common prefix and suffix are cut off
+ * first, then a Myers O(ND) diff runs on the middle. When the middle is too
+ * different, it becomes 1 change, which is still correct, just less tidy.
+ */
+
+const MAX_D = 1000
+
+/** Lines with their endings. '' has no lines. */
+export const splitLines = (text) => (text ? text.split(/(?<=\n)/) : [])
+
+/** Changed regions between 2 line arrays: [{a, aEnd, b, bEnd}], 0-based, ends exclusive. */
+export function regions(a, b) {
+  let pre = 0
+  while (pre < a.length && pre < b.length && a[pre] === b[pre]) pre++
+  let suf = 0
+  while (suf < a.length - pre && suf < b.length - pre && a[a.length - 1 - suf] === b[b.length - 1 - suf]) suf++
+  const A = a.slice(pre, a.length - suf), B = b.slice(pre, b.length - suf)
+  const out = []
+  let i = 0, j = 0
+  for (const [mi, mj] of [...(matches(A, B) ?? []), [A.length, B.length]]) {
+    if (mi > i || mj > j) out.push({ a: pre + i, aEnd: pre + mi, b: pre + j, bEnd: pre + mj })
+    i = mi + 1
+    j = mj + 1
+  }
+  return out
+}
+
+/** Matched line pairs [i, j] in order (Myers), or null when more than MAX_D edits apart. */
+function matches(A, B) {
+  const n = A.length, m = B.length, max = n + m, off = max + 1
+  if (!n || !m) return []
+  const v = new Int32Array(2 * max + 3)
+  const trace = []
+  for (let d = 0; d <= Math.min(max, MAX_D); d++) {
+    trace.push(v.slice(off - d - 1, off + d + 2))
+    for (let k = -d; k <= d; k += 2) {
+      let x = k === -d || (k !== d && v[off + k - 1] < v[off + k + 1]) ? v[off + k + 1] : v[off + k - 1] + 1
+      let y = x - k
+      while (x < n && y < m && A[x] === B[y]) { x++; y++ }
+      v[off + k] = x
+      if (x >= n && y >= m) return backtrack(trace, n, m)
+    }
+  }
+  return null
+}
+
+function backtrack(trace, n, m) {
+  const pairs = []
+  let x = n, y = m
+  for (let d = trace.length - 1; d >= 0; d--) {
+    const snap = trace[d], at = (k) => snap[k + d + 1]
+    const k = x - y
+    const prevK = k === -d || (k !== d && at(k - 1) < at(k + 1)) ? k + 1 : k - 1
+    const prevX = at(prevK), prevY = prevX - prevK
+    while (x > prevX && y > prevY) pairs.push([--x, --y])
+    x = prevX
+    y = prevY
+  }
+  return pairs.reverse()
+}
+
+/**
+ * Zero-context hunks for the manifest. `at` is the 0-based line in the
+ * after-text. before null means a new file.
+ */
+export function hunks(before, after) {
+  const a = splitLines(before ?? ''), b = splitLines(after)
+  return regions(a, b).map((r) => ({ at: r.b, before: a.slice(r.a, r.aEnd), after: b.slice(r.b, r.bEnd) }))
+}
+
+/** Undo hunks by position. Returns the lines, or null when a hunk does not sit where it should. */
+export function reverseAt(lines, list) {
+  const out = [...lines]
+  for (const h of [...list].sort((p, q) => q.at - p.at)) {
+    if (!sameAt(out, h.at, h.after)) return null
+    out.splice(h.at, h.after.length, ...h.before)
+  }
+  return out
+}
+
+/**
+ * Undo hunks by content: each hunk's added lines must appear exactly once.
+ * Returns the lines, or null when a hunk is missing, ambiguous or overlaps another.
+ */
+export function reverseByContent(lines, list) {
+  const found = []
+  for (const h of list) {
+    if (!h.after.length) return null
+    const spots = []
+    for (let i = 0; i + h.after.length <= lines.length; i++) if (sameAt(lines, i, h.after)) spots.push(i)
+    if (spots.length !== 1) return null
+    found.push({ at: spots[0], h })
+  }
+  found.sort((p, q) => q.at - p.at)
+  for (let i = 1; i < found.length; i++) if (found[i].at + found[i].h.after.length > found[i - 1].at) return null
+  const out = [...lines]
+  for (const { at, h } of found) out.splice(at, h.after.length, ...h.before)
+  return out
+}
+
+function sameAt(lines, at, want) {
+  if (at < 0 || at + want.length > lines.length) return false
+  return want.every((line, i) => lines[at + i] === line)
+}
+
+/** Lines added and removed. */
+export function countLines(before, after) {
+  let added = 0, removed = 0
+  for (const r of regions(splitLines(before ?? ''), splitLines(after ?? ''))) {
+    added += r.bEnd - r.b
+    removed += r.aEnd - r.a
+  }
+  return { added, removed }
+}
+
+/** A unified diff for display. before null = new file. '' when nothing changed. */
+export function unified(file, before, after, context = 3) {
+  const a = splitLines(before ?? ''), b = splitLines(after ?? '')
+  const rs = regions(a, b)
+  if (!rs.length) return ''
+  const out = [`--- ${before === null ? '/dev/null' : `a/${file}`}`, `+++ b/${file}`]
+  const line = (sign, text) => {
+    out.push(sign + text.replace(/\r?\n$/, ''))
+    if (!text.endsWith('\n')) out.push('\')
+  }
+  for (let g = 0; g < rs.length;) {
+    let h = g
+    while (h + 1 < rs.length && rs[h + 1].a - rs[h].aEnd <= 2 * context) h++
+    const aS = Math.max(0, rs[g].a - context), aE = Math.min(a.length, rs[h].aEnd + context)
+    const bS = rs[g].b - (rs[g].a - aS), bE = rs[h].bEnd + (aE - rs[h].aEnd)
+    out.push(`@@ -${span(aS, aE - aS)} +${span(bS, bE - bS)} @@`)
+    let i = aS
+    for (let r = g; r <= h; r++) {
+      for (; i < rs[r].a; i++) line(' ', a[i])
+      for (let x = rs[r].a; x < rs[r].aEnd; x++) line('-', a[x])
+      for (let y = rs[r].b; y < rs[r].bEnd; y++) line('+', b[y])
+      i = rs[r].aEnd
+    }
+    for (; i < aE; i++) line(' ', a[i])
+    g = h + 1
+  }
+  return out.join('\n')
+}
+
+const span = (start, length) => (length === 1 ? `${start + 1}` : `${length ? start + 1 : start},${length}`)

package/lib/doc.mjs

@@ -0,0 +1,98 @@
+/*
+ * A text file as lines. Each line keeps its own line ending, so an edit
+ * changes only the lines it touches: CRLF, LF, mixed endings and a missing
+ * final newline all survive byte for byte. New lines use the dominant ending.
+ */
+
+export class Doc {
+  /** @param {string} text */
+  constructor(text = '') {
+    const parts = text === '' ? [] : text.split(/(?<=\n)/)
+    /** @type {string[]} line content without the ending */
+    this.lines = []
+    /** @type {string[]} '\n', '\r\n' or '' (last line without a newline) */
+    this.ends = []
+    for (const part of parts) {
+      const end = part.endsWith('\r\n') ? '\r\n' : part.endsWith('\n') ? '\n' : ''
+      this.lines.push(part.slice(0, part.length - end.length))
+      this.ends.push(end)
+    }
+    const crlf = this.ends.filter((e) => e === '\r\n').length
+    const lf = this.ends.filter((e) => e === '\n').length
+    /** The dominant line ending. */
+    this.eol = crlf > lf ? '\r\n' : '\n'
+  }
+
+  get length() { return this.lines.length }
+
+  /** @param {number} i */
+  get(i) { return this.lines[i] }
+
+  /** Replace the content of line i. Keeps its line ending. */
+  set(i, content) {
+    if (i < 0 || i >= this.lines.length) throw new RangeError(`no line ${i}`)
+    this.lines[i] = content
+  }
+
+  /** Insert lines before index i. i === length appends. */
+  insert(i, ...contents) {
+    if (i < 0 || i > this.lines.length) throw new RangeError(`no line ${i}`)
+    if (!contents.length) return
+    const last = this.lines.length - 1
+    if (i === this.lines.length && last >= 0 && this.ends[last] === '') {
+      // Appending after a final line without a newline: keep the file without a final newline.
+      this.ends[last] = this.eol
+      this.lines.push(...contents)
+      this.ends.push(...contents.map((_, k) => (k === contents.length - 1 ? '' : this.eol)))
+      return
+    }
+    this.lines.splice(i, 0, ...contents)
+    this.ends.splice(i, 0, ...contents.map(() => this.eol))
+  }
+
+  /** Remove count lines from index i. */
+  remove(i, count = 1) {
+    this.lines.splice(i, count)
+    this.ends.splice(i, count)
+  }
+
+  /** First index >= from whose line matches. test is a RegExp or a function. */
+  find(test, from = 0) {
+    for (let i = from; i < this.lines.length; i++) {
+      if (typeof test === 'function' ? test(this.lines[i], i) : test.test(this.lines[i])) return i
+    }
+    return -1
+  }
+
+  toString() {
+    let out = ''
+    for (let i = 0; i < this.lines.length; i++) out += this.lines[i] + this.ends[i]
+    return out
+  }
+}
+
+/** Indentation (leading spaces or tabs) of a line. */
+export const indentOf = (line) => /^[ \t]*/.exec(line)[0]
+
+/**
+ * Split a command into words when it is a plain literal command. Returns null
+ * when it has shell syntax this tool must not guess at: variables,
+ * substitution, globs, redirects, pipes, lists, a leading NAME=value, an
+ * unclosed quote or a newline. Quotes are removed.
+ * @param {string} text
+ * @returns {string[]|null}
+ */
+export function shellWords(text) {
+  if (typeof text !== 'string' || !text.trim() || /[\r\n\0$`;&|<>*?{}\\]/.test(text)) return null
+  const words = []
+  let word = '', quote = '', started = false
+  for (const c of text.trim()) {
+    if (quote) { if (c === quote) quote = ''; else word += c; started = true }
+    else if (c === '"' || c === "'") { quote = c; started = true }
+    else if (/\s/.test(c)) { if (started) { words.push(word); word = ''; started = false } }
+    else { word += c; started = true }
+  }
+  if (quote) return null
+  if (started) words.push(word)
+  return words.length && !/^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0]) ? words : null
+}