reslop 0.1.7 → 0.1.9

package/lib/deps/changes.js

@@ -0,0 +1,422 @@
+'use strict';
+
+const { itemPath } = require('../files.js');
+const {
+  countSides,
+  formatHunkHeader,
+  formatPatch,
+} = require('../diff/patch.js');
+
+const manifest = require('./manifest.js');
+const { MANIFEST, LOCKFILE, SECTION_KEYS, depFileMeta, relOf } = manifest;
+const { parseJson, readSections, emptySectionMaps } = manifest;
+const { lockRootSections, lockEntries, lockPackageCount } = manifest;
+
+const SECTION_ORDER = [...SECTION_KEYS, 'resolved', 'field'];
+const ACTION_ORDER = ['added', 'removed', 'changed', 'vulnerable'];
+const SECTION_NAMES = SECTION_KEYS.join('|');
+const SECTION_OPEN = new RegExp(`^\\s*"(${SECTION_NAMES})"\\s*:\\s*\\{\\s*$`);
+const SECTION_END = /^\s*\},?\s*$/;
+const DEP_ENTRY = /^\s*"([^"]+)"\s*:\s*"([^"]*)"\s*,?\s*$/;
+
+const diffMaps = (oldMap, newMap, section) => {
+  const keys = [...oldMap.keys(), ...newMap.keys()];
+  const names = [...new Set(keys)];
+  names.sort();
+  const changes = [];
+  for (const name of names) {
+    const from = oldMap.has(name) ? oldMap.get(name) : '';
+    const to = newMap.has(name) ? newMap.get(name) : '';
+    if (from === to) continue;
+    let action = 'changed';
+    if (!oldMap.has(name)) action = 'added';
+    else if (!newMap.has(name)) action = 'removed';
+    changes.push({ name, section, action, from, to });
+  }
+  return changes;
+};
+
+const diffSections = (oldMaps, newMaps) => {
+  const changes = [];
+  for (const key of SECTION_KEYS) {
+    const found = diffMaps(oldMaps[key], newMaps[key], key);
+    for (const change of found) changes.push(change);
+  }
+  return changes;
+};
+
+const fieldText = (value) => {
+  if (value === undefined) return '';
+  if (typeof value === 'string') return 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 ?? {};
+  const newObj = newPkg ?? {};
+  const keys = [...Object.keys(oldObj), ...Object.keys(newObj)];
+  const names = [...new Set(keys)];
+  names.sort();
+  const changes = [];
+  for (const name of names) {
+    if (SECTION_KEYS.includes(name)) continue;
+    const prev = oldObj[name];
+    const next = newObj[name];
+    if (sameJson(prev, next)) continue;
+    let action = 'changed';
+    if (!Object.hasOwn(oldObj, name)) action = 'added';
+    else if (!Object.hasOwn(newObj, name)) action = 'removed';
+    const from = fieldText(prev);
+    const to = fieldText(next);
+    const section = 'field';
+    changes.push({ name, section, action, from, to });
+  }
+  return changes;
+};
+
+const foldedDepNames = (changes) => {
+  const names = new Set();
+  for (const change of changes) {
+    if (change.section === 'field') continue;
+    names.add(change.name);
+  }
+  return names;
+};
+
+const lineEntryName = (text) => {
+  const entry = DEP_ENTRY.exec(text);
+  return entry ? entry[1] : '';
+};
+
+const lineInBlock = (item, line) => {
+  const blockId = item.blockId;
+  if (typeof blockId !== 'number') return true;
+  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;
+  for (const line of item.hunk.lines) {
+    if (line.type === 'ctx') continue;
+    if (!lineInBlock(item, line)) continue;
+    const name = lineEntryName(line.text);
+    if (name && names.has(name)) {
+      folded += 1;
+      continue;
+    }
+    if (isSectionFence(line.text)) continue;
+    return false;
+  }
+  return folded > 0;
+};
+
+const stripFoldedDepItem = (item, names) => {
+  if (!item.hunk || !names.size) return item;
+  const lines = [];
+  let removed = false;
+  for (const line of item.hunk.lines) {
+    if (line.type !== 'ctx') {
+      const name = lineEntryName(line.text);
+      if (name && names.has(name)) {
+        removed = true;
+        continue;
+      }
+    }
+    lines.push(line);
+  }
+  if (!removed) return item;
+  let hasEdit = false;
+  for (const line of lines) {
+    if (line.type === 'ctx') continue;
+    if (!lineInBlock(item, line)) continue;
+    hasEdit = true;
+    break;
+  }
+  if (!hasEdit) return null;
+  const counts = countSides(lines);
+  const hunk = {
+    ...item.hunk,
+    oldCount: counts.oldCount,
+    newCount: counts.newCount,
+    header: formatHunkHeader(
+      item.hunk.oldStart,
+      counts.oldCount,
+      item.hunk.newStart,
+      counts.newCount,
+    ),
+    lines,
+  };
+  const patchAdd = formatPatch(item.file, hunk, item.blockId, 'old');
+  const patchRevert = formatPatch(item.file, hunk, item.blockId, 'new');
+  return { ...item, hunk, patchAdd, patchRevert };
+};
+
+const onlyDepEdits = (items) => {
+  if (!items.length) return false;
+  for (const item of items) {
+    if (!item.hunk) return false;
+    const blockId = item.blockId;
+    const scoped = typeof blockId === 'number';
+    let section = '';
+    for (const line of item.hunk.lines) {
+      const open = SECTION_OPEN.exec(line.text);
+      let nextSection = section;
+      if (open) nextSection = open[1];
+      else if (section && SECTION_END.test(line.text)) nextSection = '';
+      const inBlock = !scoped || line.blockId === blockId;
+      if (inBlock && line.type !== 'ctx') {
+        const inDep = !!(open || section);
+        if (!inDep) return false;
+        const isEntry = DEP_ENTRY.test(line.text);
+        const isClose = SECTION_END.test(line.text);
+        if (!open && !isEntry && !isClose) return false;
+      }
+      section = nextSection;
+    }
+  }
+  return true;
+};
+
+const mapsFromHunks = (items) => {
+  const oldMaps = emptySectionMaps();
+  const newMaps = emptySectionMaps();
+  let section = '';
+  for (const item of items) {
+    if (!item.hunk) continue;
+    for (const line of item.hunk.lines) {
+      const open = SECTION_OPEN.exec(line.text);
+      if (open) {
+        section = open[1];
+        continue;
+      }
+      if (section && SECTION_END.test(line.text)) {
+        section = '';
+        continue;
+      }
+      if (!section) continue;
+      const entry = DEP_ENTRY.exec(line.text);
+      if (!entry) continue;
+      const name = entry[1];
+      const version = entry[2];
+      if (line.type === 'del' || line.type === 'ctx') {
+        oldMaps[section].set(name, version);
+      }
+      if (line.type === 'add' || line.type === 'ctx') {
+        newMaps[section].set(name, version);
+      }
+    }
+  }
+  return { oldMaps, newMaps };
+};
+
+const directNames = (oldMaps, newMaps) => {
+  const names = new Set();
+  for (const key of SECTION_KEYS) {
+    for (const name of oldMaps[key].keys()) names.add(name);
+    for (const name of newMaps[key].keys()) names.add(name);
+  }
+  return names;
+};
+
+const mergeResolved = (changes, oldResolved, newResolved, oldMaps, newMaps) => {
+  const seen = new Set();
+  const merged = [];
+  for (const change of changes) {
+    seen.add(change.name);
+    const resolvedFrom = oldResolved.get(change.name) ?? '';
+    const resolvedTo = newResolved.get(change.name) ?? '';
+    merged.push({ ...change, resolvedFrom, resolvedTo });
+  }
+  const names = [...directNames(oldMaps, newMaps)];
+  names.sort();
+  for (const name of names) {
+    if (seen.has(name)) continue;
+    const from = oldResolved.get(name) ?? '';
+    const to = newResolved.get(name) ?? '';
+    if (from === to) continue;
+    if (!from && !to) continue;
+    let action = 'changed';
+    if (!from) action = 'added';
+    else if (!to) action = 'removed';
+    const section = 'resolved';
+    const resolvedFrom = from;
+    const resolvedTo = to;
+    merged.push({ name, section, action, from, to, resolvedFrom, resolvedTo });
+  }
+  return merged;
+};
+
+const compareChangeOrder = (left, right) => {
+  const section = SECTION_ORDER.indexOf(left.section);
+  const other = SECTION_ORDER.indexOf(right.section);
+  if (section !== other) return section - other;
+  const leftAction = ACTION_ORDER.indexOf(left.action);
+  const rightAction = ACTION_ORDER.indexOf(right.action);
+  if (leftAction !== rightAction) return leftAction - rightAction;
+  return left.name.localeCompare(right.name);
+};
+
+const orderedChanges = (changes) => [...changes].sort(compareChangeOrder);
+
+const kindItems = (items, kind) => {
+  const matched = [];
+  for (const item of items) {
+    const rel = itemPath(item);
+    const meta = depFileMeta(rel);
+    if (meta && meta.kind === kind) matched.push(item);
+  }
+  return matched;
+};
+
+const readGroupSnapshot = (group, readSides) => {
+  const origin = group.origin;
+  const dir = group.dir;
+  const groupItems = group.items;
+  const manifestItems = kindItems(groupItems, 'manifest');
+  const lockItems = kindItems(groupItems, 'lockfile');
+  const manifestRel = relOf(dir, MANIFEST);
+  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 parsedManifest = !!(oldPkg || newPkg);
+  return {
+    origin,
+    dir,
+    groupItems,
+    manifestItems,
+    lockItems,
+    oldPkg,
+    newPkg,
+    oldLock,
+    newLock,
+    parsedManifest,
+  };
+};
+
+const sectionMapsOf = (snapshot) => {
+  if (snapshot.parsedManifest) {
+    const oldMaps = readSections(snapshot.oldPkg);
+    const newMaps = readSections(snapshot.newPkg);
+    return { oldMaps, newMaps };
+  }
+  if (snapshot.manifestItems.length) {
+    return mapsFromHunks(snapshot.manifestItems);
+  }
+  const oldMaps = lockRootSections(snapshot.oldLock);
+  const newMaps = lockRootSections(snapshot.newLock);
+  return { oldMaps, newMaps };
+};
+
+const comparedChanges = (snapshot) => {
+  const maps = sectionMapsOf(snapshot);
+  const oldMaps = maps.oldMaps;
+  const newMaps = maps.newMaps;
+  const manifestChanges = diffSections(oldMaps, newMaps);
+  const parsed = snapshot.parsedManifest;
+  let otherChanges = [];
+  if (parsed) {
+    otherChanges = diffOtherFields(snapshot.oldPkg, snapshot.newPkg);
+  }
+  const oldResolved = lockEntries(snapshot.oldLock);
+  const newResolved = lockEntries(snapshot.newLock);
+  const changes = mergeResolved(
+    manifestChanges,
+    oldResolved,
+    newResolved,
+    oldMaps,
+    newMaps,
+  );
+  const oldCount = lockPackageCount(snapshot.oldLock);
+  const newCount = lockPackageCount(snapshot.newLock);
+  return { changes, otherChanges, oldCount, newCount };
+};
+
+const foldingPolicy = (snapshot, compared) => {
+  const foldLock = snapshot.lockItems.length > 0;
+  const hasDepChanges = compared.changes.length > 0;
+  if (!snapshot.manifestItems.length) {
+    const foldManifest = false;
+    const takeAllManifest = false;
+    return { foldLock, foldManifest, takeAllManifest };
+  }
+  if (snapshot.parsedManifest) {
+    const foldManifest = hasDepChanges;
+    const takeAllManifest = hasDepChanges && compared.otherChanges.length === 0;
+    return { foldLock, foldManifest, takeAllManifest };
+  }
+  const foldManifest = hasDepChanges && onlyDepEdits(snapshot.manifestItems);
+  const takeAllManifest = foldManifest;
+  return { foldLock, foldManifest, takeAllManifest };
+};
+
+const summarizeGroup = (group, readSides) => {
+  const snapshot = readGroupSnapshot(group, readSides);
+  const compared = comparedChanges(snapshot);
+  const policy = foldingPolicy(snapshot, compared);
+  return {
+    changes: compared.changes,
+    oldCount: compared.oldCount,
+    newCount: compared.newCount,
+    foldLock: policy.foldLock,
+    foldManifest: policy.foldManifest,
+    takeAllManifest: policy.takeAllManifest,
+    manifestItems: snapshot.manifestItems,
+    lockItems: snapshot.lockItems,
+    pkg: snapshot.newPkg || snapshot.oldPkg,
+  };
+};
+
+const collectGroups = (items) => {
+  const groups = new Map();
+  for (const item of items) {
+    const rel = itemPath(item);
+    const meta = depFileMeta(rel);
+    if (!meta) continue;
+    const key = `${item.origin}\0${meta.dir}`;
+    let group = groups.get(key);
+    if (!group) {
+      const dir = meta.dir;
+      const origin = item.origin;
+      group = { dir, origin, items: [] };
+      groups.set(key, group);
+    }
+    group.items.push(item);
+  }
+  return groups;
+};
+
+const takeManifestItems = (summary) => {
+  if (!summary.foldManifest) return [];
+  if (summary.takeAllManifest) return [...summary.manifestItems];
+  const names = foldedDepNames(summary.changes);
+  const taken = [];
+  for (const item of summary.manifestItems) {
+    if (onlyDepEdits([item]) || hunkOnlyFoldedDeps(item, names)) {
+      taken.push(item);
+    }
+  }
+  return taken;
+};
+
+module.exports = {
+  diffSections,
+  mergeResolved,
+  orderedChanges,
+  summarizeGroup,
+  collectGroups,
+  takeManifestItems,
+  foldedDepNames,
+  stripFoldedDepItem,
+};

package/lib/deps/items.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const { itemPath } = require('../files.js');
+
+const { depFileMeta, listFilePath } = require('./manifest.js');
+const { orderedChanges } = require('./changes.js');
+const { buildRows, makeHunk } = require('./rows.js');
+
+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 items = [];
+  let blockId = 0;
+  for (const change of ordered) {
+    const made = makeDepItem(
+      origin,
+      fileItems,
+      hidden,
+      change,
+      summary,
+      blockId,
+    );
+    items.push(made);
+    blockId += 1;
+  }
+  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 = { makeDepItems, stubFileItem };

package/lib/deps/manifest.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const path = require('node:path');
+
+const MANIFEST = 'package.json';
+const LOCKFILE = 'package-lock.json';
+const DEP_KIND = { [MANIFEST]: 'manifest', [LOCKFILE]: 'lockfile' };
+const SECTION_KEYS = [
+  'dependencies',
+  'devDependencies',
+  'optionalDependencies',
+  'peerDependencies',
+];
+
+const posixRel = (rel) => {
+  const raw = `${rel ?? ''}`;
+  return raw.replaceAll('\\', '/');
+};
+
+const depFileMeta = (rel) => {
+  const normalized = posixRel(rel);
+  if (!normalized) return null;
+  const base = path.posix.basename(normalized);
+  const kind = DEP_KIND[base];
+  if (!kind) return null;
+  const dir = path.posix.dirname(normalized);
+  return { kind, dir, base, rel: 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 parseJson = (text) => {
+  if (!text || !`${text}`.trim()) return null;
+  try {
+    const data = JSON.parse(text);
+    if (!data || typeof data !== 'object' || Array.isArray(data)) return null;
+    return data;
+  } catch {
+    return null;
+  }
+};
+
+const emptySectionMaps = () => {
+  const maps = {};
+  for (const key of SECTION_KEYS) maps[key] = new Map();
+  return maps;
+};
+
+const readSectionMap = (pkg, key) => {
+  const map = new Map();
+  const raw = pkg ? pkg[key] : null;
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return map;
+  for (const name of Object.keys(raw)) {
+    const version = raw[name];
+    if (typeof version === 'string') map.set(name, version);
+  }
+  return map;
+};
+
+const readSections = (pkg) => {
+  const maps = emptySectionMaps();
+  if (!pkg) return maps;
+  for (const key of SECTION_KEYS) maps[key] = readSectionMap(pkg, key);
+  return maps;
+};
+
+const lockRootSections = (lock) => {
+  if (!lock) return emptySectionMaps();
+  const packages = lock.packages;
+  const root = packages && typeof packages === 'object' ? packages[''] : null;
+  const src = root && typeof root === 'object' ? root : lock;
+  return readSections(src);
+};
+
+const lockEntries = (lock) => {
+  const versions = new Map();
+  if (!lock) return versions;
+  const packages = lock.packages;
+  if (packages && typeof packages === 'object') {
+    for (const key of Object.keys(packages)) {
+      const entry = packages[key];
+      if (!key.startsWith('node_modules/')) continue;
+      if (key.includes('/node_modules/')) continue;
+      if (!entry || typeof entry.version !== 'string') continue;
+      const name = key.slice('node_modules/'.length);
+      versions.set(name, entry.version);
+    }
+  }
+  const deps = lock.dependencies;
+  if (!deps || typeof deps !== 'object') return versions;
+  for (const name of Object.keys(deps)) {
+    const entry = deps[name];
+    if (versions.has(name)) continue;
+    if (!entry || typeof entry.version !== 'string') continue;
+    versions.set(name, entry.version);
+  }
+  return versions;
+};
+
+const lockPackageCount = (lock) => {
+  if (!lock) return 0;
+  const packages = lock.packages;
+  if (packages && typeof packages === 'object') {
+    let count = 0;
+    for (const key of Object.keys(packages)) {
+      if (key !== '') count += 1;
+    }
+    return count;
+  }
+  const deps = lock.dependencies;
+  if (!deps || typeof deps !== 'object') return 0;
+  return Object.keys(deps).length;
+};
+
+const cloneJson = (value) => JSON.parse(JSON.stringify(value ?? null));
+
+const detectIndent = (text) => {
+  const match = /\n([ \t]+)"/.exec(text);
+  if (!match) return 2;
+  return match[1];
+};
+
+const stringifyJson = (value, original) => {
+  const indent = detectIndent(original || '');
+  const body = JSON.stringify(value, null, indent);
+  return `${body}\n`;
+};
+
+module.exports = {
+  MANIFEST,
+  LOCKFILE,
+  DEP_KIND,
+  SECTION_KEYS,
+  posixRel,
+  depFileMeta,
+  relOf,
+  listFilePath,
+  parseJson,
+  emptySectionMaps,
+  readSections,
+  lockRootSections,
+  lockEntries,
+  lockPackageCount,
+  cloneJson,
+  stringifyJson,
+};