reslop 0.2.6 → 0.3.0

package/lib/{deps-diff.js → deps/diff.js}

@@ -1,13 +1,10 @@
 'use strict';
 
-const metautil = require('metautil');
-const { jsonParse } = metautil;
-const files = require('./files.js');
-const { itemPath } = files;
-const patch = require('./diff/patch.js');
+const { jsonParse } = require('metautil');
+const { itemPath } = require('../common/files.js');
+const patch = require('../diff/patch.js');
 const { countSides, formatHunkHeader, formatPatch } = patch;
-const diff = require('./diff/diff.js');
-const { isCtxType } = diff;
+const { isCtxType } = require('../diff/diff.js');
 const manifest = require('./manifest.js');
 const { MANIFEST, LOCKFILE, SECTION_KEYS, depFileMeta, relOf } = manifest;
 const { listFilePath, readSections, emptySectionMaps } = manifest;
@@ -66,8 +63,10 @@ const lineEntryName = (text) => {
   return entry ? entry[1] : '';
 };
 
-const lineInBlock = (item, line) =>
-  typeof item.blockId !== 'number' || line.blockId === item.blockId;
+const lineInBlock = (item, line) => {
+  const open = typeof item.blockId !== 'number';
+  return open || line.blockId === item.blockId;
+};
 
 const hunkOnlyFoldedDeps = (item, names) => {
   if (!item.hunk || !names.size) return false;
@@ -86,8 +85,10 @@ const hunkOnlyFoldedDeps = (item, names) => {
 
 const stripFoldedDepItem = (item, names) => {
   if (!item.hunk || !names.size) return item;
-  const isFolded = (line) =>
-    line.type !== 'ctx' && names.has(lineEntryName(line.text));
+  const isFolded = (line) => {
+    const changed = line.type !== 'ctx';
+    return changed && names.has(lineEntryName(line.text));
+  };
   const lines = item.hunk.lines.filter((line) => !isFolded(line));
   if (lines.length === item.hunk.lines.length) return item;
   const isEdit = (line) => line.type !== 'ctx' && lineInBlock(item, line);
@@ -164,8 +165,15 @@ const mergeResolved = (changes, oldResolved, newResolved, oldMaps, newMaps) => {
     const action = changeAction(from, to);
     const resolvedFrom = from;
     const resolvedTo = to;
-    const section = 'resolved';
-    merged.push({ name, section, action, from, to, resolvedFrom, resolvedTo });
+    merged.push({
+      name,
+      section: 'resolved',
+      action,
+      from,
+      to,
+      resolvedFrom,
+      resolvedTo,
+    });
   }
   return merged;
 };
@@ -194,29 +202,31 @@ const readJsonSides = (readSides, origin, rel) => {
 
 const sectionMapsOf = (pkg, lock, manifestItems) => {
   if (pkg.before || pkg.after) {
-    return {
-      oldMaps: readSections(pkg.before),
-      newMaps: readSections(pkg.after),
-    };
+    const oldMaps = readSections(pkg.before);
+    const newMaps = readSections(pkg.after);
+    return { oldMaps, newMaps };
   }
   if (manifestItems.length) return mapsFromHunks(manifestItems);
   const oldMaps = lockRootSections(lock.before);
-  return { oldMaps, newMaps: lockRootSections(lock.after) };
+  const newMaps = lockRootSections(lock.after);
+  return { oldMaps, newMaps };
 };
 
 const manifestPolicy = (manifestItems, pkg, hasChanges) => {
   if (!manifestItems.length) {
-    return { foldManifest: false, takeAllManifest: false };
+    const foldManifest = false;
+    const takeAllManifest = false;
+    return { foldManifest, takeAllManifest };
   }
   if (pkg.before || pkg.after) {
     const onlyDeps = !hasFieldChanges(pkg.before, pkg.after);
-    return {
-      foldManifest: hasChanges,
-      takeAllManifest: hasChanges && onlyDeps,
-    };
+    const foldManifest = hasChanges;
+    const takeAllManifest = hasChanges && onlyDeps;
+    return { foldManifest, takeAllManifest };
   }
-  const fold = hasChanges && manifestItems.every(isDepOnlyItem);
-  return { foldManifest: fold, takeAllManifest: fold };
+  const foldManifest = hasChanges && manifestItems.every(isDepOnlyItem);
+  const takeAllManifest = foldManifest;
+  return { foldManifest, takeAllManifest };
 };
 
 const summarizeGroup = (group, readSides) => {

package/lib/{manifest.js → deps/manifest.js}

@@ -1,14 +1,10 @@
 'use strict';
 
-const path = require('node:path');
-const metautil = require('metautil');
-const { isHashObject, jsonParse } = metautil;
-const utilities = require('./utilities.js');
-const { parseVersion, cmpVersion } = utilities;
-
-const MANIFEST = 'package.json';
-const LOCKFILE = 'package-lock.json';
-const DEP_KIND = { [MANIFEST]: 'manifest', [LOCKFILE]: 'lockfile' };
+const { isHashObject, jsonParse } = require('metautil');
+const { parseVersion, cmpVersion } = require('../common/utilities.js');
+const files = require('../common/files.js');
+const { MANIFEST, LOCKFILE, depFileMeta, relOf, listFilePath } = files;
+
 const SECTION_KEYS = [
   'dependencies',
   'devDependencies',
@@ -19,23 +15,6 @@ const LOCK_PREFIX = 'node_modules/';
 
 const isObject = (value) => !!value && typeof value === 'object';
 
-const posixRel = (rel) => `${rel ?? ''}`.replaceAll('\\', '/');
-
-const depFileMeta = (rel) => {
-  const normalized = posixRel(rel);
-  const kind = DEP_KIND[path.posix.basename(normalized)];
-  if (!normalized || !kind) return null;
-  return { kind, dir: path.posix.dirname(normalized) };
-};
-
-const relOf = (dir, name) => (dir === '.' ? name : `${dir}/${name}`);
-
-const listFilePath = (rel) => {
-  const meta = depFileMeta(rel);
-  if (meta && meta.kind === 'lockfile') return relOf(meta.dir, MANIFEST);
-  return posixRel(rel);
-};
-
 const readSectionMap = (pkg, key) => {
   const map = new Map();
   const raw = pkg ? pkg[key] : null;
@@ -155,14 +134,17 @@ const seedManifest = (oldObj, newObj) => {
   return base;
 };
 
+const mergedBase = (parsedBase, oldObj, newObj, kind) => {
+  if (parsedBase) return cloneJson(parsedBase);
+  if (kind === 'manifest') return seedManifest(oldObj, newObj);
+  return cloneJson(oldObj) || {};
+};
+
 const mergeDepFile = (baseText, oldText, newText, change, side, kind) => {
   const oldObj = jsonParse(oldText ?? '');
   const newObj = jsonParse(newText ?? '');
   const parsedBase = jsonParse(baseText ?? '');
-  let base;
-  if (parsedBase) base = cloneJson(parsedBase);
-  else if (kind === 'manifest') base = seedManifest(oldObj, newObj);
-  else base = cloneJson(oldObj) || {};
+  const base = mergedBase(parsedBase, oldObj, newObj, kind);
   if (kind === 'lockfile') applyLockChange(base, change, side, oldObj, newObj);
   else applyManifestChange(base, change, side);
   return stringifyJson(base, baseText || newText || oldText || '');
@@ -247,7 +229,42 @@ const proposedWanted = (out, vul) => {
   return '';
 };
 
+const cmpText = (left, right) => {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (!a || !b) return null;
+  return cmpVersion(a, b);
+};
+
+const boundHolds = (cmp, op) => {
+  if (op === '<') return cmp < 0;
+  if (op === '<=') return cmp <= 0;
+  if (op === '>') return cmp > 0;
+  return cmp >= 0;
+};
+
+const inClause = (version, clause) => {
+  const ver = parseVersion(version);
+  if (!ver) return false;
+  const bounds = [...clause.matchAll(/(>=|<=|>|<)\s*(\d+\.\d+\.\d+)/g)];
+  if (!bounds.length) return false;
+  for (const match of bounds) {
+    const bound = parseVersion(match[2]);
+    if (!bound) return false;
+    if (!boundHolds(cmpVersion(ver, bound), match[1])) return false;
+  }
+  return true;
+};
+
+const inRange = (version, range) =>
+  `${range ?? ''}`.split('||').some((clause) => inClause(version, clause));
+
+const hasRange = (range) => /[<>]=?\s*\d+\.\d+\.\d+/.test(`${range ?? ''}`);
+
 module.exports = {
+  cmpText,
+  inRange,
+  hasRange,
   MANIFEST,
   LOCKFILE,
   SECTION_KEYS,

package/lib/diff/align.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const inline = require('./inline.js');
-const { diffChars, tokenSimilarity } = inline;
+const { diffChars, tokenSimilarity } = require('./inline.js');
 
 const PAIR_MIN_SIM = 0.3;
 const PAIR_HEAD_WEIGHT = 0.4;

package/lib/diff/diff.js

@@ -5,7 +5,6 @@ const align = require('./align.js');
 const parse = require('./parse.js');
 const patch = require('./patch.js');
 const display = require('./display.js');
-const edit = require('./edit.js');
 const items = require('./items.js');
 const unit = require('./unit.js');
 
@@ -19,7 +18,8 @@ module.exports = {
   flattenBlock: patch.flattenBlock,
   formatPatch: patch.formatPatch,
   ...display,
-  ...edit,
+  addBlockRange: patch.addBlockRange,
+  replaceBlockAdds: patch.replaceBlockAdds,
   ...items,
   ...unit,
 };

package/lib/diff/display.js

@@ -1,9 +1,7 @@
 'use strict';
 
-const align = require('./align.js');
-const { isCtxType, attachInline, LAYOUT_ALIGN } = align;
-const patch = require('./patch.js');
-const { flattenBlock } = patch;
+const { isCtxType, attachInline, LAYOUT_ALIGN } = require('./align.js');
+const { flattenBlock } = require('./patch.js');
 
 const DISPLAY_CONTEXT = 3;
 
@@ -80,11 +78,37 @@ const blockAddText = (hunk, blockId) => {
   return parts.join('\n');
 };
 
+const countsOld = (line) => {
+  if (line.type === 'add' || line.synthetic === true) return false;
+  return line.type !== 'note' && line.type !== 'noteSep';
+};
+
+const countsNew = (line) => line.type !== 'del';
+
+const stampLineNumbers = (lines, hunk) => {
+  let oldNo = hunk && hunk.oldStart > 0 ? hunk.oldStart : 0;
+  let newNo = hunk && hunk.newStart > 0 ? hunk.newStart : 1;
+  return lines.map((line) => {
+    const next = { ...line };
+    if (line.type === 'note' || line.type === 'noteSep') return next;
+    if (countsOld(line)) {
+      if (oldNo > 0) next.oldNo = oldNo;
+      oldNo += 1;
+    }
+    if (countsNew(line)) {
+      next.newNo = newNo;
+      newNo += 1;
+    }
+    return next;
+  });
+};
+
 const displayLines = (hunk, blockId, layout = 'unified', radius, overlay) => {
   const flat = flattenBlock(hunk, blockId, 'new');
   const source = overlay ? replaceAdds(flat, overlay, blockId) : flat;
+  const numbered = stampLineNumbers(source, hunk);
   const around = radius ?? DISPLAY_CONTEXT;
-  const painted = attachInline(windowAroundBlock(source, blockId, around));
+  const painted = attachInline(windowAroundBlock(numbered, blockId, around));
   const alignRows = LAYOUT_ALIGN[layout];
   return alignRows ? alignRows(painted) : painted;
 };

package/lib/diff/inline.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const ansi = require('../ansi.js');
-const { graphemes } = ansi;
+const { graphemes } = require('../term/ansi.js');
 
 const LCS_CELL_LIMIT = 250000;
 const NOISY_TINY_SPANS = 6;
@@ -131,10 +130,9 @@ const opsSpans = (ops) => {
       newParts.push({ text: op.text, changed: op.type === 'add' });
     }
   }
-  return {
-    oldSpans: collapseSpans(oldParts),
-    newSpans: collapseSpans(newParts),
-  };
+  const oldSpans = collapseSpans(oldParts);
+  const newSpans = collapseSpans(newParts);
+  return { oldSpans, newSpans };
 };
 
 const joinAffix = (prefix, mid, suffix) => {
@@ -154,10 +152,9 @@ const diffTrimmed = (a, b, spansOfOps) => {
   const mid = whole ? wholeChanged(midA, midB) : spansOfOps(lcsOps(midA, midB));
   const prefix = a.slice(0, lo);
   const suffix = a.slice(hiA);
-  return {
-    oldSpans: joinAffix(prefix, mid.oldSpans, suffix),
-    newSpans: joinAffix(prefix, mid.newSpans, suffix),
-  };
+  const oldSpans = joinAffix(prefix, mid.oldSpans, suffix);
+  const newSpans = joinAffix(prefix, mid.newSpans, suffix);
+  return { oldSpans, newSpans };
 };
 
 const diffTokens = (a, b) => {
@@ -221,10 +218,9 @@ const refineWordOps = (ops) => {
     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 oldSpans = collapseSpans(oldParts);
+  const newSpans = collapseSpans(newParts);
+  return { oldSpans, newSpans };
 };
 
 const opRuns = (ops) => {

package/lib/diff/items.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const patch = require('./patch.js');
-const { splitHunk, formatHunkHeader, formatPatch } = patch;
+const { splitHunk, formatHunkHeader, formatPatch } = require('./patch.js');
 
 const BINARY_ITEM = {
   hunk: null,
@@ -70,8 +69,11 @@ const itemsFromFiles = (files, origin) => {
 
 const refreshIndexPatches = (items, item) => {
   if (!item.hunk) return items;
-  const isPeer = (other) =>
-    other.hunk === item.hunk && other.file === item.file;
+  const isPeer = (other) => {
+    const sameHunk = other.hunk === item.hunk;
+    const sameFile = other.file === item.file;
+    return sameHunk && sameFile;
+  };
   const peers = items.filter(isPeer);
   const sides = {};
   for (const peer of peers) sides[peer.blockId] = indexSide(peer.origin);

package/lib/diff/patch.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const align = require('./align.js');
-const { isCtxType } = align;
+const { clamp } = require('../common/utilities.js');
+const { isCtxType } = require('./align.js');
 
 const LINE_MARK = { add: '+', del: '-' };
 
@@ -40,7 +40,11 @@ const flattenBlock = (hunk, blockId, contextSide) => {
     }
     const kept = sideOf(contextSide, line.blockId) === 'old' ? 'del' : 'add';
     if (line.type === kept) {
-      out.push({ type: 'ctx', text: line.text, noNl: line.noNl });
+      const type = 'ctx';
+      const { text, noNl } = line;
+      const synthetic = true;
+      const row = { type, text, noNl, synthetic };
+      out.push(row);
     }
   }
   return out;
@@ -72,10 +76,42 @@ const formatPatch = (file, hunk, blockId, contextSide) => {
   return `${parts.join('\n')}\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 ended = content.endsWith('\n');
+  const body = ended ? content.slice(0, -1) : content;
+  const lines = content === '' ? [] : body.split('\n');
+  const from = clamp(range.start - 1, 0, lines.length);
+  const added = text === '' ? [] : text.split('\n');
+  lines.splice(from, range.count, ...added);
+  return lines.join('\n') + (ended ? '\n' : '');
+};
+
 module.exports = {
   splitHunk,
   flattenBlock,
   countSides,
   formatHunkHeader,
   formatPatch,
+  addBlockRange,
+  replaceBlockAdds,
 };

package/lib/diff/unit.js

@@ -1,9 +1,7 @@
 'use strict';
 
-const align = require('./align.js');
-const { attachInline } = align;
-const files = require('../files.js');
-const { listPath } = files;
+const { attachInline } = require('./align.js');
+const { listPath } = require('../common/files.js');
 
 const LCS_CELLS = 4000000;
 
@@ -75,6 +73,16 @@ const rowsFromAdds = (items) => {
   return rows;
 };
 
+const stampFileNumbers = (lines) => {
+  let newNo = 1;
+  for (const line of lines) {
+    if (line.type === 'del') continue;
+    line.newNo = newNo;
+    newNo += 1;
+  }
+  return lines;
+};
+
 const unitLines = (text, items) => {
   let rows = splitFile(text);
   if (!rows.length) rows = rowsFromAdds(items);
@@ -95,11 +103,14 @@ const unitLines = (text, items) => {
     out.push(tagged('del', del.text, del));
   }
   if (!out.length) out.push(tagged('ctx', '', NO_EXTRA));
-  return attachInline(out);
+  return stampFileNumbers(attachInline(out));
 };
 
-const sameBlock = (line, item) =>
-  line.item === item && line.blockId === item.blockId;
+const sameBlock = (line, item) => {
+  const sameItem = line.item === item;
+  const sameId = line.blockId === item.blockId;
+  return sameItem && sameId;
+};
 
 const changedLineRange = (lines, item, belongs) => {
   let start = -1;
@@ -187,25 +198,33 @@ const zipOps = (prev, next) => {
 };
 
 const lcsOps = (prev, next) => {
-  const dp = lcsTable(prev, next);
   const ops = [];
+  const limit = Math.min(prev.length, next.length);
+  let head = 0;
+  while (head < limit && prev[head] === next[head]) {
+    ops.push({ kind: 'eq', text: next[head] });
+    head += 1;
+  }
+  const left = head ? prev.slice(head) : prev;
+  const right = head ? next.slice(head) : next;
+  const dp = lcsTable(left, right);
   let i = 0;
   let j = 0;
-  while (i < prev.length && j < next.length) {
-    if (prev[i] === next[j]) {
-      ops.push({ kind: 'eq', text: next[j] });
+  while (i < left.length && j < right.length) {
+    if (left[i] === right[j]) {
+      ops.push({ kind: 'eq', text: right[j] });
       i += 1;
       j += 1;
     } else if (dp[i + 1][j] >= dp[i][j + 1]) {
       ops.push({ kind: 'del' });
       i += 1;
     } else {
-      ops.push({ kind: 'ins', text: next[j] });
+      ops.push({ kind: 'ins', text: right[j] });
       j += 1;
     }
   }
-  for (; i < prev.length; i++) ops.push({ kind: 'del' });
-  for (; j < next.length; j++) ops.push({ kind: 'ins', text: next[j] });
+  for (; i < left.length; i++) ops.push({ kind: 'del' });
+  for (; j < right.length; j++) ops.push({ kind: 'ins', text: right[j] });
   return ops;
 };
 
@@ -241,7 +260,7 @@ const pushDels = (out, base, at) => {
   return i;
 };
 
-const mergeEditRows = (base, nextTexts) => {
+const mergeRows = (base, nextTexts) => {
   const texts = nextTexts.length ? nextTexts : [''];
   const prev = [];
   for (const row of base) if (row.type !== 'del') prev.push(row.text);
@@ -259,7 +278,17 @@ const mergeEditRows = (base, nextTexts) => {
   }
   pushDels(out, base, at);
   if (!out.length) out.push(tagged('ctx', '', NO_EXTRA));
-  return attachEditSpans(attachInline(out));
+  return stampFileNumbers(attachEditSpans(attachInline(out)));
+};
+
+let merged = { base: null, text: '', rows: [] };
+
+const mergeEditRows = (base, nextTexts) => {
+  const text = nextTexts.join('\n');
+  if (merged.base === base && merged.text === text) return merged.rows;
+  const rows = mergeRows(base, nextTexts);
+  merged = { base, text, rows };
+  return rows;
 };
 
 module.exports = {