reslop 0.1.9 → 0.2.1

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

@@ -1,15 +1,16 @@
 'use strict';
 
-const { itemPath } = require('../files.js');
+const { jsonParse } = require('metautil');
+const { itemPath } = require('./files.js');
 const {
   countSides,
   formatHunkHeader,
   formatPatch,
-} = require('../diff/patch.js');
-
+} = require('./diff/patch.js');
+const { isCtxType } = require('./diff/diff.js');
 const manifest = require('./manifest.js');
 const { MANIFEST, LOCKFILE, SECTION_KEYS, depFileMeta, relOf } = manifest;
-const { parseJson, readSections, emptySectionMaps } = manifest;
+const { listFilePath, readSections, emptySectionMaps } = manifest;
 const { lockRootSections, lockEntries, lockPackageCount } = manifest;
 
 const SECTION_ORDER = [...SECTION_KEYS, 'resolved', 'field'];
@@ -51,9 +52,6 @@ const fieldText = (value) => {
   return JSON.stringify(value);
 };
 
-const sameJson = (left, right) =>
-  JSON.stringify(left) === JSON.stringify(right);
-
 const diffOtherFields = (oldPkg, newPkg) => {
   if (!oldPkg && !newPkg) return [];
   const oldObj = oldPkg ?? {};
@@ -66,7 +64,7 @@ const diffOtherFields = (oldPkg, newPkg) => {
     if (SECTION_KEYS.includes(name)) continue;
     const prev = oldObj[name];
     const next = newObj[name];
-    if (sameJson(prev, next)) continue;
+    if (JSON.stringify(prev) === JSON.stringify(next)) continue;
     let action = 'changed';
     if (!Object.hasOwn(oldObj, name)) action = 'added';
     else if (!Object.hasOwn(newObj, name)) action = 'removed';
@@ -98,9 +96,6 @@ const lineInBlock = (item, line) => {
   return line.blockId === blockId;
 };
 
-const isSectionFence = (text) =>
-  SECTION_OPEN.test(text) || SECTION_END.test(text);
-
 const hunkOnlyFoldedDeps = (item, names) => {
   if (!item.hunk || !names.size) return false;
   let folded = 0;
@@ -112,7 +107,7 @@ const hunkOnlyFoldedDeps = (item, names) => {
       folded += 1;
       continue;
     }
-    if (isSectionFence(line.text)) continue;
+    if (SECTION_OPEN.test(line.text) || SECTION_END.test(line.text)) continue;
     return false;
   }
   return folded > 0;
@@ -228,12 +223,14 @@ const directNames = (oldMaps, newMaps) => {
 
 const mergeResolved = (changes, oldResolved, newResolved, oldMaps, newMaps) => {
   const seen = new Set();
-  const merged = [];
-  for (const change of changes) {
+  const { length } = changes;
+  const merged = new Array(length);
+  for (let i = 0; i < length; i++) {
+    const change = changes[i];
     seen.add(change.name);
     const resolvedFrom = oldResolved.get(change.name) ?? '';
     const resolvedTo = newResolved.get(change.name) ?? '';
-    merged.push({ ...change, resolvedFrom, resolvedTo });
+    merged[i] = { ...change, resolvedFrom, resolvedTo };
   }
   const names = [...directNames(oldMaps, newMaps)];
   names.sort();
@@ -286,10 +283,10 @@ const readGroupSnapshot = (group, readSides) => {
   const lockRel = relOf(dir, LOCKFILE);
   const manifestSides = readSides(origin, manifestRel);
   const lockSides = readSides(origin, lockRel);
-  const oldPkg = parseJson(manifestSides.oldText);
-  const newPkg = parseJson(manifestSides.newText);
-  const oldLock = parseJson(lockSides.oldText);
-  const newLock = parseJson(lockSides.newText);
+  const oldPkg = jsonParse(manifestSides.oldText ?? '');
+  const newPkg = jsonParse(manifestSides.newText ?? '');
+  const oldLock = jsonParse(lockSides.oldText ?? '');
+  const newLock = jsonParse(lockSides.newText ?? '');
   const parsedManifest = !!(oldPkg || newPkg);
   return {
     origin,
@@ -410,7 +407,296 @@ const takeManifestItems = (summary) => {
   return taken;
 };
 
+const DEP_CAPTION = 'Dependencies in package.json & package-lock.json';
+
+const changeMarks = (change) => {
+  const marks = [];
+  if (change.unused) marks.push('unused');
+  if (change.outdated && !change.propose) marks.push('outdated');
+  if (change.audit) marks.push(change.audit.severity);
+  return marks;
+};
+
+const changeSources = (change) => {
+  const sources = [];
+  if (change.unused) {
+    sources.push('npm uninstall');
+    return sources;
+  }
+  if (change.propose && change.outdated) sources.push('npm outdated');
+  if (change.audit) sources.push('npm audit');
+  return sources;
+};
+
+const sectionTitle = (section, action, marks, sources) => {
+  const title = action === 'changed' ? 'version changed' : action;
+  const kind = section.replace(/ies$/, 'y');
+  let label = `${kind} ${title}`;
+  if (section === 'field') label = `package.json ${title}`;
+  if (section === 'resolved' && action === 'vulnerable') {
+    label = 'lockfile vulnerable';
+  } else if (section === 'resolved') {
+    label = `lockfile resolved ${title}`;
+  }
+  if (marks.includes('unused')) {
+    label = `${kind} unused`;
+    const extra = [];
+    for (const mark of marks) {
+      if (mark !== 'unused') extra.push(mark);
+    }
+    if (extra.length) label = `${label}, ${extra.join(', ')}`;
+  } else if (marks.length) {
+    label = `${label}, ${marks.join(', ')}`;
+  }
+  if (!sources.length) return label;
+  return `${sources.join(', ')}: ${label}`;
+};
+
+const entryText = (change, side) => {
+  const version = side === 'old' ? change.from : change.to;
+  return `"${change.name}": "${version}"`;
+};
+
+const ctxLine = (text) => {
+  const type = 'ctx';
+  return { type, text };
+};
+
+const warnLine = (text) => {
+  const type = 'warn';
+  return { type, text };
+};
+
+const noteLine = (text) => {
+  const type = 'note';
+  return { type, text };
+};
+
+const noteSepLine = () => {
+  const type = 'noteSep';
+  const text = '';
+  return { type, text };
+};
+
+const changeLine = (type, change, side) => {
+  const text = entryText(change, side);
+  return { type, text };
+};
+
+const pushChangeLines = (rows, change) => {
+  if (change.unused) {
+    const side = change.action === 'added' ? 'new' : 'old';
+    rows.push(changeLine('del', change, side));
+    return;
+  }
+  if (change.action === 'added') {
+    rows.push(changeLine('add', change, 'new'));
+    return;
+  }
+  if (change.action === 'removed') {
+    rows.push(changeLine('del', change, 'old'));
+    return;
+  }
+  if (change.from === change.to) {
+    rows.push(changeLine('ctx', change, 'old'));
+    return;
+  }
+  rows.push(changeLine('del', change, 'old'));
+  rows.push(changeLine('add', change, 'new'));
+};
+
+const lockCountText = (oldCount, newCount) => {
+  if (oldCount === newCount) return '';
+  return `lockfile packages  ${oldCount} → ${newCount}`;
+};
+
+const auditNoteTexts = (audit) => {
+  if (!audit) return [];
+  const notes = [];
+  if (Array.isArray(audit.titles)) {
+    for (const note of audit.titles) {
+      if (note && !notes.includes(note)) notes.push(note);
+    }
+  } else if (audit.title) {
+    notes.push(audit.title);
+  }
+  const severity = audit.severity;
+  if (!notes.length) return [`npm audit  ${severity}`];
+  const { length } = notes;
+  const texts = new Array(length);
+  for (let i = 0; i < length; i++) {
+    texts[i] = `npm audit  ${severity}  ${notes[i]}`;
+  }
+  return texts;
+};
+
+const pushAuditNotes = (rows, audit) => {
+  const texts = auditNoteTexts(audit);
+  if (!texts.length) return;
+  rows.push(ctxLine(''));
+  let first = true;
+  for (const text of texts) {
+    if (!first) rows.push(noteSepLine());
+    first = false;
+    rows.push(noteLine(text));
+  }
+};
+
+const buildRows = (change, oldCount, newCount) => {
+  const rows = [ctxLine(DEP_CAPTION), ctxLine('')];
+  if (change) {
+    const marks = changeMarks(change);
+    const sources = changeSources(change);
+    const title = sectionTitle(change.section, change.action, marks, sources);
+    const audited = sources.includes('npm audit');
+    rows.push(audited ? warnLine(title) : ctxLine(title));
+    rows.push(ctxLine(''));
+    pushChangeLines(rows, change);
+    pushAuditNotes(rows, change.audit);
+  }
+  const countLine = lockCountText(oldCount, newCount);
+  if (countLine) {
+    if (rows.at(-1).text !== '') rows.push(ctxLine(''));
+    rows.push(ctxLine(countLine));
+  }
+  return rows;
+};
+
+const toHunkLine = (row, blockId) => {
+  const type = row.type;
+  const text = row.text;
+  const noNl = false;
+  const id = isCtxType(type) ? null : blockId;
+  return { type, text, noNl, blockId: id };
+};
+
+const makeHunk = (rows, blockId) => {
+  const lines = rows.map((row) => toHunkLine(row, blockId));
+  const counts = countSides(lines);
+  const oldCount = counts.oldCount;
+  const newCount = counts.newCount;
+  const header = `@@ -1,${oldCount} +1,${newCount} @@`;
+  return { oldStart: 1, oldCount, newStart: 1, newCount, header, lines };
+};
+
+const uniquePaths = (items) => {
+  const files = [];
+  const seen = new Set();
+  for (const item of items) {
+    const rel = itemPath(item);
+    if (!rel || seen.has(rel)) continue;
+    seen.add(rel);
+    files.push(rel);
+  }
+  return files;
+};
+
+const filesForChange = (change, files) => {
+  const manifest = [];
+  const lockfile = [];
+  for (const rel of files) {
+    const meta = depFileMeta(rel);
+    if (!meta) continue;
+    if (meta.kind === 'manifest') manifest.push(rel);
+    else lockfile.push(rel);
+  }
+  if (change.section === 'field') {
+    if (manifest.length) return manifest;
+    return files;
+  }
+  if (change.section === 'resolved') {
+    if (lockfile.length) return lockfile;
+    return files;
+  }
+  if (change.propose) {
+    if (manifest.length) return manifest;
+    return files;
+  }
+  const both = [...manifest, ...lockfile];
+  if (both.length) return both;
+  return files;
+};
+
+const pickPrimary = (items) => {
+  for (const item of items) {
+    const rel = itemPath(item);
+    const meta = depFileMeta(rel);
+    if (meta && meta.kind === 'manifest') return item;
+  }
+  return items[0];
+};
+
+const makeDepItem = (origin, fileItems, hidden, change, extra, blockId) => {
+  const allFiles = uniquePaths(fileItems);
+  const files = change ? filesForChange(change, allFiles) : allFiles;
+  const primary = pickPrimary(fileItems);
+  const oldPath = listFilePath(itemPath(primary));
+  const newPath = oldPath;
+  const isNew = fileItems.some((item) => item.file && item.file.isNew);
+  const isDeleted = fileItems.every((item) => item.file && item.file.isDeleted);
+  let oldCount = 0;
+  let newCount = 0;
+  if (!change) {
+    oldCount = extra.oldCount ?? 0;
+    newCount = extra.newCount ?? 0;
+  }
+  const rows = buildRows(change, oldCount, newCount);
+  const hunk = makeHunk(rows, blockId);
+  const isBinary = false;
+  const preamble = [];
+  const hunks = [hunk];
+  const file = {
+    oldPath,
+    newPath,
+    isNew,
+    isDeleted,
+    isBinary,
+    preamble,
+    hunks,
+  };
+  const patchAdd = '';
+  const patchRevert = '';
+  const items = hidden;
+  const dep = { files, items, change };
+  const reload = !!(change && change.propose);
+  return { origin, file, hunk, blockId, patchAdd, patchRevert, dep, reload };
+};
+
+const makeDepItems = (origin, fileItems, hidden, summary) => {
+  const ordered = orderedChanges(summary.changes);
+  if (!ordered.length) {
+    const oldCount = summary.oldCount ?? 0;
+    const newCount = summary.newCount ?? 0;
+    if (oldCount === newCount) return [];
+    return [makeDepItem(origin, fileItems, hidden, null, summary, 0)];
+  }
+  const { length } = ordered;
+  const items = new Array(length);
+  for (let i = 0; i < length; i++) {
+    items[i] = makeDepItem(origin, fileItems, hidden, ordered[i], summary, i);
+  }
+  return items;
+};
+
+const stubFileItem = (rel, origin) => {
+  const file = {
+    oldPath: rel,
+    newPath: rel,
+    isNew: false,
+    isDeleted: false,
+    isBinary: false,
+    preamble: [],
+    hunks: [],
+  };
+  const hunk = null;
+  const blockId = 0;
+  const patchAdd = '';
+  const patchRevert = '';
+  return { origin, file, hunk, blockId, patchAdd, patchRevert };
+};
+
 module.exports = {
+  DEP_CAPTION,
   diffSections,
   mergeResolved,
   orderedChanges,
@@ -419,4 +705,8 @@ module.exports = {
   takeManifestItems,
   foldedDepNames,
   stripFoldedDepItem,
+  buildRows,
+  makeHunk,
+  makeDepItems,
+  stubFileItem,
 };