reslop 0.1.7 → 0.1.8

package/lib/diff/align.js

@@ -0,0 +1,226 @@
+'use strict';
+
+const { diffChars, tokenSimilarity } = require('./inline.js');
+
+const PAIR_MIN_SIM = 0.3;
+const PAIR_HEAD_WEIGHT = 0.4;
+const PAIR_TOKEN_WEIGHT = 0.6;
+const TOKEN_RE = /[A-Za-z_$][\w$]*|\d+|[^\s]/g;
+const CTX_TYPES = ['ctx', 'warn', 'note', 'noteSep'];
+
+const isCtxType = (type) => CTX_TYPES.includes(type);
+
+const lineTokens = (text) => {
+  TOKEN_RE.lastIndex = 0;
+  return text.match(TOKEN_RE) ?? [];
+};
+
+const pairScore = (a, b) => {
+  const token = tokenSimilarity(a, b);
+  const headA = a[0];
+  const headB = b[0];
+  const head = headA && headA === headB ? 1 : 0;
+  return PAIR_HEAD_WEIGHT * head + PAIR_TOKEN_WEIGHT * token;
+};
+
+const comparePair = (left, right) => {
+  if (right.score !== left.score) return right.score - left.score;
+  if (left.dist !== right.dist) return left.dist - right.dist;
+  if (left.i !== right.i) return left.i - right.i;
+  return left.j - right.j;
+};
+
+const pairCandidates = (delTexts, addTexts) => {
+  if (!delTexts.length || !addTexts.length) return [];
+  const delTokens = delTexts.map(lineTokens);
+  const addTokens = addTexts.map(lineTokens);
+  const candidates = [];
+  for (let i = 0; i < delTexts.length; i++) {
+    for (let j = 0; j < addTexts.length; j++) {
+      const score = pairScore(delTokens[i], addTokens[j]);
+      if (score < PAIR_MIN_SIM) continue;
+      const dist = Math.abs(i - j);
+      candidates.push({ i, j, score, dist });
+    }
+  }
+  candidates.sort(comparePair);
+  return candidates;
+};
+
+const pairIndices = (delTexts, addTexts) => {
+  const delToAdd = new Array(delTexts.length).fill(-1);
+  const addUsed = new Array(addTexts.length).fill(false);
+  const candidates = pairCandidates(delTexts, addTexts);
+  for (const pair of candidates) {
+    if (delToAdd[pair.i] >= 0 || addUsed[pair.j]) continue;
+    delToAdd[pair.i] = pair.j;
+    addUsed[pair.j] = true;
+  }
+  if (delTexts.length !== addTexts.length) return delToAdd;
+  for (let i = 0; i < delTexts.length; i++) {
+    if (delToAdd[i] >= 0 || addUsed[i]) continue;
+    delToAdd[i] = i;
+    addUsed[i] = true;
+  }
+  return delToAdd;
+};
+
+const changeSides = (block) => {
+  const dels = [];
+  const adds = [];
+  for (const line of block) {
+    if (line.type === 'del') dels.push(line);
+    if (line.type === 'add') adds.push(line);
+  }
+  return { dels, adds };
+};
+
+const applyInlineSpans = (dels, adds, delToAdd) => {
+  const addSeen = new Set();
+  for (let i = 0; i < dels.length; i++) {
+    const j = delToAdd[i];
+    if (j < 0) {
+      dels[i].spans = [{ text: dels[i].text, changed: true }];
+      continue;
+    }
+    addSeen.add(j);
+    const diff = diffChars(dels[i].text, adds[j].text);
+    dels[i].spans = diff.oldSpans;
+    adds[j].spans = diff.newSpans;
+  }
+  for (let j = 0; j < adds.length; j++) {
+    if (addSeen.has(j)) continue;
+    adds[j].spans = [{ text: adds[j].text, changed: true }];
+  }
+};
+
+const attachInline = (lines) => {
+  const painted = lines.map((line) => ({ ...line }));
+  const { dels, adds } = changeSides(painted);
+  const delToAdd = pairIndices(
+    dels.map((line) => line.text),
+    adds.map((line) => line.text),
+  );
+  applyInlineSpans(dels, adds, delToAdd);
+  for (const line of painted) {
+    if (isCtxType(line.type)) {
+      line.spans = [{ text: line.text, changed: false }];
+    }
+  }
+  return painted;
+};
+
+const addPartners = (delToAdd, addCount) => {
+  const addToDel = new Array(addCount).fill(-1);
+  for (let i = 0; i < delToAdd.length; i++) {
+    const j = delToAdd[i];
+    if (j >= 0) addToDel[j] = i;
+  }
+  return addToDel;
+};
+
+const walkAligned = (dels, adds, delToAdd, emit) => {
+  const addToDel = addPartners(delToAdd, adds.length);
+  const usedAdd = new Array(adds.length).fill(false);
+  let addPos = 0;
+  const takeUnpairedAdds = (limit) => {
+    while (addPos < limit) {
+      const free = addToDel[addPos] < 0 && !usedAdd[addPos];
+      if (free) {
+        emit.unpairedAdd(adds[addPos]);
+        usedAdd[addPos] = true;
+      }
+      addPos += 1;
+    }
+  };
+  for (let i = 0; i < dels.length; i++) {
+    const j = delToAdd[i];
+    if (j < 0) {
+      emit.unpairedDel(dels[i]);
+      continue;
+    }
+    takeUnpairedAdds(j);
+    emit.pair(dels[i], adds[j]);
+    usedAdd[j] = true;
+    if (addPos <= j) addPos = j + 1;
+  }
+  takeUnpairedAdds(adds.length);
+  for (let j = 0; j < adds.length; j++) {
+    if (!usedAdd[j]) emit.unpairedAdd(adds[j]);
+  }
+};
+
+const alignChangeBlock = (dels, adds, delToAdd) => {
+  const out = [];
+  walkAligned(dels, adds, delToAdd, {
+    unpairedDel: (del) => {
+      out.push(del);
+    },
+    unpairedAdd: (add) => {
+      out.push(add);
+    },
+    pair: (del, add) => {
+      out.push(del);
+      out.push(add);
+    },
+  });
+  return out;
+};
+
+const mapHunkBlocks = (lines, onCtx, onChange) => {
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    if (isCtxType(lines[i].type)) {
+      out.push(onCtx(lines[i]));
+      i += 1;
+      continue;
+    }
+    const start = i;
+    while (i < lines.length && !isCtxType(lines[i].type)) i += 1;
+    const block = lines.slice(start, i);
+    const { dels, adds } = changeSides(block);
+    const delToAdd = pairIndices(
+      dels.map((line) => line.text),
+      adds.map((line) => line.text),
+    );
+    for (const row of onChange(dels, adds, delToAdd)) out.push(row);
+  }
+  return out;
+};
+
+const alignPairs = (lines) =>
+  mapHunkBlocks(lines, (line) => line, alignChangeBlock);
+
+const alignSplitBlock = (dels, adds, delToAdd) => {
+  const out = [];
+  walkAligned(dels, adds, delToAdd, {
+    unpairedDel: (del) => {
+      out.push({ left: del, right: null });
+    },
+    unpairedAdd: (add) => {
+      out.push({ left: null, right: add });
+    },
+    pair: (del, add) => {
+      out.push({ left: del, right: add });
+    },
+  });
+  return out;
+};
+
+const splitCtxRow = (line) => ({ left: line, right: line });
+
+const alignSplit = (lines) =>
+  mapHunkBlocks(lines, splitCtxRow, alignSplitBlock);
+
+const LAYOUT_ALIGN = {
+  mixed: alignPairs,
+  side: alignSplit,
+};
+
+module.exports = {
+  isCtxType,
+  pairIndices,
+  attachInline,
+  LAYOUT_ALIGN,
+};

package/lib/diff/display.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const align = require('./align.js');
+const { isCtxType, attachInline, LAYOUT_ALIGN } = align;
+const { flattenBlock } = require('./patch.js');
+
+const DISPLAY_CONTEXT = 3;
+
+const windowAroundBlock = (lines, blockId, radius) => {
+  let start = -1;
+  let end = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].blockId !== blockId) continue;
+    if (start < 0) start = i;
+    end = i + 1;
+  }
+  if (start < 0) return lines;
+  const from = Math.max(0, start - radius);
+  const to = Math.min(lines.length, end + radius);
+  return lines.slice(from, to);
+};
+
+const insertAddIndex = (lines) => {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (isCtxType(lines[i].type)) continue;
+    return i + 1;
+  }
+  return lines.length;
+};
+
+const taggedAdd = (text, blockId, start, end) => ({
+  type: 'add',
+  text,
+  noNl: false,
+  blockId,
+  wrap: true,
+  editStart: start,
+  editEnd: end,
+  editLast: true,
+});
+
+const replaceAdds = (lines, overlay, blockId) => {
+  const text = overlay.text ?? '';
+  const keepEmpty = overlay.keepEmpty === true;
+  if (text === '' && !keepEmpty) {
+    return lines.filter((line) => line.type !== 'add');
+  }
+  const texts = text.split('\n');
+  const tagged = [];
+  let offset = 0;
+  for (let i = 0; i < texts.length; i++) {
+    const row = texts[i];
+    const start = offset;
+    const end = start + row.length;
+    const isLast = i === texts.length - 1;
+    tagged.push(taggedAdd(row, blockId, start, end));
+    offset = isLast ? end : end + 1;
+  }
+  const out = [];
+  let placed = 0;
+  let lastAdd = -1;
+  for (const line of lines) {
+    if (line.type !== 'add') {
+      out.push(line);
+      continue;
+    }
+    if (placed >= tagged.length) continue;
+    out.push(tagged[placed]);
+    lastAdd = out.length - 1;
+    placed += 1;
+  }
+  const extras = tagged.slice(placed);
+  if (!extras.length) return out;
+  const at = lastAdd >= 0 ? lastAdd + 1 : insertAddIndex(out);
+  out.splice(at, 0, ...extras);
+  return out;
+};
+
+const blockAddText = (hunk, blockId) => {
+  if (!hunk) return '';
+  const parts = [];
+  for (const line of hunk.lines) {
+    if (line.type !== 'add') continue;
+    if (line.blockId !== blockId) continue;
+    parts.push(line.text);
+  }
+  return parts.join('\n');
+};
+
+const displayLines = (hunk, blockId, layout = 'unified', radius, overlay) => {
+  const flat = flattenBlock(hunk, blockId, 'new');
+  const source = overlay ? replaceAdds(flat, overlay, blockId) : flat;
+  const around = radius ?? DISPLAY_CONTEXT;
+  const windowed = windowAroundBlock(source, blockId, around);
+  const painted = attachInline(windowed);
+  const alignRows = LAYOUT_ALIGN[layout];
+  if (alignRows) return alignRows(painted);
+  return painted;
+};
+
+module.exports = { DISPLAY_CONTEXT, displayLines, blockAddText };

package/lib/diff/edit.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const contentLines = (content) => {
+  if (content === '') return { lines: [], ended: false };
+  const ended = content.endsWith('\n');
+  const body = ended ? content.slice(0, -1) : content;
+  return { lines: body.split('\n'), ended };
+};
+
+const joinLines = (lines, ended) => {
+  const body = lines.join('\n');
+  if (!ended) return body;
+  if (!lines.length) return '\n';
+  return `${body}\n`;
+};
+
+const addBlockRange = (hunk, blockId) => {
+  let newLine = hunk.newStart;
+  let start = 0;
+  let count = 0;
+  for (const line of hunk.lines) {
+    if (line.type === 'del') {
+      if (line.blockId === blockId && start === 0) start = newLine;
+      continue;
+    }
+    if (line.type === 'add' && line.blockId === blockId) {
+      if (count === 0) start = newLine;
+      count += 1;
+    }
+    newLine += 1;
+  }
+  if (start === 0) start = hunk.newStart;
+  return { start, count };
+};
+
+const replaceBlockAdds = (content, hunk, blockId, text) => {
+  const range = addBlockRange(hunk, blockId);
+  const parsed = contentLines(content);
+  const last = parsed.lines.length;
+  const from = Math.min(last, Math.max(0, range.start - 1));
+  const added = text === '' ? [] : text.split('\n');
+  const next = parsed.lines.slice();
+  next.splice(from, range.count, ...added);
+  return joinLines(next, parsed.ended);
+};
+
+module.exports = { addBlockRange, replaceBlockAdds };

package/lib/diff/inline.js

@@ -0,0 +1,300 @@
+'use strict';
+
+const { graphemes } = require('../ansi.js');
+
+const LCS_CELL_LIMIT = 250000;
+const NOISY_TINY_SPANS = 6;
+const WORD_REFINE_MIN = 0.6;
+const PIECE_RE = /[A-Za-z_$][\w$]*|\d+|\s+|./g;
+const CAMEL_RE = /[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|\d+|./g;
+
+const collapseSpans = (parts) => {
+  const spans = [];
+  for (const part of parts) {
+    const last = spans[spans.length - 1];
+    if (last && last.changed === part.changed) {
+      last.text += part.text;
+      continue;
+    }
+    spans.push({ text: part.text, changed: part.changed });
+  }
+  return spans;
+};
+
+const isNoisy = (spans) => {
+  let tiny = 0;
+  for (const span of spans) {
+    if (span.changed && graphemes(span.text).length <= 2) tiny += 1;
+  }
+  return tiny > NOISY_TINY_SPANS;
+};
+
+const wholeChanged = (a, b) => ({
+  oldSpans: a.length ? [{ text: a.join(''), changed: true }] : [],
+  newSpans: b.length ? [{ text: b.join(''), changed: true }] : [],
+});
+
+const lcsLength = (a, b) => {
+  const n = a.length;
+  const m = b.length;
+  if (n === 0 || m === 0) return 0;
+  if (n * m > LCS_CELL_LIMIT) {
+    let lo = 0;
+    while (lo < n && lo < m && a[lo] === b[lo]) lo += 1;
+    let hiA = n;
+    let hiB = m;
+    while (hiA > lo && hiB > lo && a[hiA - 1] === b[hiB - 1]) {
+      hiA -= 1;
+      hiB -= 1;
+    }
+    return lo + (n - hiA);
+  }
+  let prev = new Uint32Array(m + 1);
+  let cur = new Uint32Array(m + 1);
+  for (let i = 1; i <= n; i++) {
+    const ai = a[i - 1];
+    for (let j = 1; j <= m; j++) {
+      if (ai === b[j - 1]) cur[j] = prev[j - 1] + 1;
+      else cur[j] = prev[j] > cur[j - 1] ? prev[j] : cur[j - 1];
+    }
+    const swap = prev;
+    prev = cur;
+    cur = swap;
+    cur.fill(0);
+  }
+  return prev[m];
+};
+
+const tokenSimilarity = (a, b) => {
+  if (a.length === 0 && b.length === 0) return 1;
+  if (a.length === 0 || b.length === 0) return 0;
+  const lcs = lcsLength(a, b);
+  return (2 * lcs) / (a.length + b.length);
+};
+
+const similarity = (left, right) =>
+  tokenSimilarity(graphemes(left), graphemes(right));
+
+const fillLcsTable = (a, b) => {
+  const n = a.length;
+  const m = b.length;
+  const dp = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+  for (let i = 1; i <= n; i++) {
+    const ai = a[i - 1];
+    const row = dp[i];
+    const prev = dp[i - 1];
+    for (let j = 1; j <= m; j++) {
+      if (ai === b[j - 1]) row[j] = prev[j - 1] + 1;
+      else row[j] = prev[j] > row[j - 1] ? prev[j] : row[j - 1];
+    }
+  }
+  return dp;
+};
+
+const tracebackLcs = (a, b, dp) => {
+  const rev = [];
+  let i = a.length;
+  let j = b.length;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      rev.push({ type: 'eq', text: a[i - 1] });
+      i -= 1;
+      j -= 1;
+      continue;
+    }
+    if (dp[i - 1][j] >= dp[i][j - 1]) {
+      rev.push({ type: 'del', text: a[i - 1] });
+      i -= 1;
+      continue;
+    }
+    rev.push({ type: 'add', text: b[j - 1] });
+    j -= 1;
+  }
+  while (i > 0) {
+    rev.push({ type: 'del', text: a[i - 1] });
+    i -= 1;
+  }
+  while (j > 0) {
+    rev.push({ type: 'add', text: b[j - 1] });
+    j -= 1;
+  }
+  rev.reverse();
+  return rev;
+};
+
+const lcsOps = (a, b) => tracebackLcs(a, b, fillLcsTable(a, b));
+
+const lcsSpans = (a, b) => {
+  const oldParts = [];
+  const newParts = [];
+  for (const op of lcsOps(a, b)) {
+    if (op.type === 'eq') {
+      oldParts.push({ text: op.text, changed: false });
+      newParts.push({ text: op.text, changed: false });
+      continue;
+    }
+    if (op.type === 'del') {
+      oldParts.push({ text: op.text, changed: true });
+      continue;
+    }
+    newParts.push({ text: op.text, changed: true });
+  }
+  return {
+    oldSpans: collapseSpans(oldParts),
+    newSpans: collapseSpans(newParts),
+  };
+};
+
+const trimSharedEnds = (a, b) => {
+  let lo = 0;
+  while (lo < a.length && lo < b.length && a[lo] === b[lo]) lo += 1;
+  let hiA = a.length;
+  let hiB = b.length;
+  while (hiA > lo && hiB > lo && a[hiA - 1] === b[hiB - 1]) {
+    hiA -= 1;
+    hiB -= 1;
+  }
+  return {
+    prefix: a.slice(0, lo),
+    suffix: a.slice(hiA),
+    midA: a.slice(lo, hiA),
+    midB: b.slice(lo, hiB),
+  };
+};
+
+const diffTokenMiddle = (midA, midB) => {
+  if (midA.length * midB.length > LCS_CELL_LIMIT) {
+    return wholeChanged(midA, midB);
+  }
+  if (midA.length === 0 && midB.length === 0) {
+    return { oldSpans: [], newSpans: [] };
+  }
+  if (midA.length === 0 || midB.length === 0) return wholeChanged(midA, midB);
+  return lcsSpans(midA, midB);
+};
+
+const joinAffix = (prefix, mid, suffix) => {
+  const parts = [];
+  if (prefix.length) {
+    parts.push({ text: prefix.join(''), changed: false });
+  }
+  for (const span of mid) parts.push(span);
+  if (suffix.length) {
+    parts.push({ text: suffix.join(''), changed: false });
+  }
+  return collapseSpans(parts);
+};
+
+const joinTrimmedSpans = (prefix, mid, suffix) => ({
+  oldSpans: joinAffix(prefix, mid.oldSpans, suffix),
+  newSpans: joinAffix(prefix, mid.newSpans, suffix),
+});
+
+const diffTokens = (a, b) => {
+  if (a.length === 0 && b.length === 0) {
+    return { oldSpans: [], newSpans: [] };
+  }
+  if (a.length === 0 || b.length === 0) return wholeChanged(a, b);
+  const trimmed = trimSharedEnds(a, b);
+  const mid = diffTokenMiddle(trimmed.midA, trimmed.midB);
+  const joined = joinTrimmedSpans(trimmed.prefix, mid, trimmed.suffix);
+  if (isNoisy(joined.oldSpans) || isNoisy(joined.newSpans)) {
+    return wholeChanged(a, b);
+  }
+  return joined;
+};
+
+const splitCamel = (part) => {
+  if (!/[a-z]/.test(part) || !/[A-Z]/.test(part)) return [part];
+  return part.match(CAMEL_RE) ?? [part];
+};
+
+const splitIdentWords = (part) => {
+  const words = [];
+  for (const chunk of part.split(/(_+)/)) {
+    if (chunk === '') continue;
+    if (chunk.includes('_')) {
+      words.push(chunk);
+      continue;
+    }
+    for (const word of splitCamel(chunk)) words.push(word);
+  }
+  return words;
+};
+
+const splitPieces = (text) => {
+  if (text === '') return [];
+  PIECE_RE.lastIndex = 0;
+  const coarse = text.match(PIECE_RE) ?? [];
+  const pieces = [];
+  for (const part of coarse) {
+    for (const word of splitIdentWords(part)) pieces.push(word);
+  }
+  return pieces;
+};
+
+const spansFromWordOps = (ops) => {
+  const oldParts = [];
+  const newParts = [];
+  let i = 0;
+  while (i < ops.length) {
+    const op = ops[i];
+    if (op.type === 'eq') {
+      oldParts.push({ text: op.text, changed: false });
+      newParts.push({ text: op.text, changed: false });
+      i += 1;
+      continue;
+    }
+    const dels = [];
+    const adds = [];
+    while (i < ops.length && ops[i].type !== 'eq') {
+      if (ops[i].type === 'del') dels.push(ops[i].text);
+      else adds.push(ops[i].text);
+      i += 1;
+    }
+    const one = dels.length === 1 && adds.length === 1;
+    const close = one && similarity(dels[0], adds[0]) >= WORD_REFINE_MIN;
+    if (close) {
+      const inner = diffTokens(graphemes(dels[0]), graphemes(adds[0]));
+      for (const span of inner.oldSpans) oldParts.push(span);
+      for (const span of inner.newSpans) newParts.push(span);
+      continue;
+    }
+    if (dels.length) {
+      oldParts.push({ text: dels.join(''), changed: true });
+    }
+    if (adds.length) {
+      newParts.push({ text: adds.join(''), changed: true });
+    }
+  }
+  return {
+    oldSpans: collapseSpans(oldParts),
+    newSpans: collapseSpans(newParts),
+  };
+};
+
+const diffChars = (oldText, newText) => {
+  const a = splitPieces(oldText);
+  const b = splitPieces(newText);
+  if (a.length === 0 && b.length === 0) {
+    return { oldSpans: [], newSpans: [] };
+  }
+  if (a.length === 0 || b.length === 0) return wholeChanged(a, b);
+  const { prefix, suffix, midA, midB } = trimSharedEnds(a, b);
+  let mid;
+  if (midA.length === 0 && midB.length === 0) {
+    mid = { oldSpans: [], newSpans: [] };
+  } else if (midA.length === 0 || midB.length === 0) {
+    mid = wholeChanged(midA, midB);
+  } else if (midA.length * midB.length > LCS_CELL_LIMIT) {
+    mid = wholeChanged(midA, midB);
+  } else {
+    mid = spansFromWordOps(lcsOps(midA, midB));
+  }
+  return {
+    oldSpans: joinAffix(prefix, mid.oldSpans, suffix),
+    newSpans: joinAffix(prefix, mid.newSpans, suffix),
+  };
+};
+
+module.exports = { tokenSimilarity, diffChars };