reslop 0.2.3 → 0.2.5

package/lib/deps.js

@@ -2,8 +2,12 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const { jsonParse, isHashObject } = require('metautil');
-const { itemPath } = require('./files.js');
+const metautil = require('metautil');
+const { jsonParse, isHashObject } = metautil;
+const files = require('./files.js');
+const { itemPath } = files;
+const utilities = require('./utilities.js');
+const { asText } = utilities;
 const manifest = require('./manifest.js');
 const { MANIFEST, LOCKFILE, SECTION_KEYS, depFileMeta, relOf } = manifest;
 const { listFilePath, readSections, lockEntries, lockPackageCount } = manifest;
@@ -73,8 +77,6 @@ const pkgHasExportEntry = (pkg) => {
   return Object.keys(exported).length > 0;
 };
 
-const isTypeKey = (key) => key === 'types' || key === 'typings';
-
 const isRuntimeFile = (value) => {
   if (typeof value !== 'string' || !value) return false;
   return !value.endsWith('.d.ts');
@@ -82,16 +84,11 @@ const isRuntimeFile = (value) => {
 
 const hasRuntimeExport = (value) => {
   if (isRuntimeFile(value)) return true;
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      if (hasRuntimeExport(item)) return true;
-    }
-    return false;
-  }
+  if (Array.isArray(value)) return value.some(hasRuntimeExport);
   if (!value || typeof value !== 'object') return false;
   const keys = Object.keys(value);
   for (const key of keys) {
-    if (isTypeKey(key)) continue;
+    if (key === 'types' || key === 'typings') continue;
     if (hasRuntimeExport(value[key])) return true;
   }
   return false;
@@ -220,14 +217,7 @@ const declaredDepNames = (root, pkgDir) => {
     return [];
   }
   const maps = readSections(jsonParse(text));
-  let size = 0;
-  for (const key of SECTION_KEYS) size += maps[key].size;
-  const names = new Array(size);
-  let i = 0;
-  for (const key of SECTION_KEYS) {
-    for (const name of maps[key].keys()) names[i++] = name;
-  }
-  return names;
+  return SECTION_KEYS.flatMap((key) => [...maps[key].keys()]);
 };
 
 const collectExportMeta = (root, extra = {}) => {
@@ -252,7 +242,7 @@ const viaNotes = (via, pkgName) => {
   const notes = [];
   for (const item of via) {
     if (!item || typeof item !== 'object') continue;
-    const title = typeof item.title === 'string' ? item.title : '';
+    const title = asText(item.title);
     if (!title) continue;
     const hasName = typeof item.name === 'string' && item.name;
     const named = hasName ? item.name : pkgName;
@@ -283,32 +273,52 @@ const auditEntryNames = (key, entry) => {
   return names;
 };
 
-const keepHighestAudit = (audit, name, severity, fix, range, notes) => {
+const uniqueTexts = (list) => [...new Set(list.filter(Boolean))];
+
+const keepHighestAudit = (audit, found) => {
+  const { name, severity } = found;
   if (!name || !severity || severity === 'info') return;
-  const titles = [];
-  for (const note of notes) {
-    if (note && !titles.includes(note)) titles.push(note);
-  }
+  const titles = uniqueTexts(found.titles);
   const prev = audit.get(name);
   if (prev && severityRank(prev.severity) >= severityRank(severity)) {
-    const merged = [...prev.titles];
-    for (const note of titles) {
-      if (!merged.includes(note)) merged.push(note);
-    }
-    const next = {
+    audit.set(name, {
       ...prev,
-      titles: merged,
-      fix: prev.fix || fix,
-      range: prev.range || range,
-    };
-    audit.set(name, next);
+      titles: uniqueTexts([...prev.titles, ...titles]),
+      fix: prev.fix || found.fix,
+      range: prev.range || found.range,
+    });
     return;
   }
   const title = titles[0] || '';
-  const next = { name, severity, title, titles, fix, range };
-  next.fix ||= '';
-  next.range ||= '';
-  audit.set(name, next);
+  const fix = found.fix || '';
+  const range = found.range || '';
+  audit.set(name, { name, severity, title, titles, fix, range });
+};
+
+const isEntry = (value) => Boolean(value) && typeof value === 'object';
+
+const vulnFindings = (vulns) => {
+  const found = [];
+  for (const [key, entry] of Object.entries(vulns)) {
+    if (!isEntry(entry)) continue;
+    const { severity } = entry;
+    const titles = viaNotes(entry.via, entry.name || key);
+    const fix = auditFix(entry);
+    const range = asText(entry.range);
+    for (const name of auditEntryNames(key, entry)) {
+      found.push({ name, severity, fix, range, titles });
+    }
+  }
+  return found;
+};
+
+const advisoryFinding = (entry) => {
+  const name = entry.module_name || entry.name;
+  const title = namedTitle(name, asText(entry.title));
+  const titles = title ? [title] : [];
+  const fix = auditFix(entry);
+  const range = asText(entry.range);
+  return { name, severity: entry.severity, fix, range, titles };
 };
 
 const parseAuditReport = (text) => {
@@ -316,36 +326,13 @@ const parseAuditReport = (text) => {
   if (!text || !`${text}`.trim()) return audit;
   const data = jsonParse(text);
   if (!isHashObject(data)) return audit;
-  const vulns = data.vulnerabilities;
-  if (vulns && typeof vulns === 'object') {
-    for (const key of Object.keys(vulns)) {
-      const entry = vulns[key];
-      if (!entry || typeof entry !== 'object') continue;
-      const severity = entry.severity;
-      const names = auditEntryNames(key, entry);
-      const pkgName = entry.name || key;
-      const titles = viaNotes(entry.via, pkgName);
-      const fix = auditFix(entry);
-      const range = typeof entry.range === 'string' ? entry.range : '';
-      for (const name of names) {
-        keepHighestAudit(audit, name, severity, fix, range, titles);
-      }
-    }
-  }
-  const advisories = data.advisories;
-  if (advisories && typeof advisories === 'object') {
-    for (const entry of Object.values(advisories)) {
-      if (!entry || typeof entry !== 'object') continue;
-      const name = entry.module_name || entry.name;
-      const severity = entry.severity;
-      const raw = typeof entry.title === 'string' ? entry.title : '';
-      const title = namedTitle(name, raw);
-      const titles = title ? [title] : [];
-      const fix = auditFix(entry);
-      const range = typeof entry.range === 'string' ? entry.range : '';
-      keepHighestAudit(audit, name, severity, fix, range, titles);
-    }
+  const { vulnerabilities, advisories } = data;
+  const found = isEntry(vulnerabilities) ? vulnFindings(vulnerabilities) : [];
+  if (isEntry(advisories)) {
+    const listed = Object.values(advisories).filter(isEntry);
+    found.push(...listed.map(advisoryFinding));
   }
+  for (const entry of found) keepHighestAudit(audit, entry);
   return audit;
 };
 
@@ -357,11 +344,11 @@ const parseOutdatedReport = (text) => {
   for (const name of Object.keys(data)) {
     const entry = data[name];
     if (!entry || typeof entry !== 'object') continue;
-    const current = typeof entry.current === 'string' ? entry.current : '';
-    const wanted = typeof entry.wanted === 'string' ? entry.wanted : '';
-    const latest = typeof entry.latest === 'string' ? entry.latest : '';
-    const type = typeof entry.type === 'string' ? entry.type : '';
+    const wanted = asText(entry.wanted);
     if (!wanted) continue;
+    const current = asText(entry.current);
+    const latest = asText(entry.latest);
+    const type = asText(entry.type);
     outdated.set(name, { current, wanted, latest, type });
   }
   return outdated;
@@ -382,16 +369,7 @@ const markChanges = (changes, report, kind) => {
   });
 };
 
-const markAuditChanges = (changes, audit) =>
-  markChanges(changes, audit, 'audit');
-
-const markOutdatedChanges = (changes, outdated) =>
-  markChanges(changes, outdated, 'outdated');
-
-const depExports = (exportEntries, name) => {
-  if (!exportEntries || !exportEntries.has(name)) return false;
-  return exportEntries.get(name) === true;
-};
+const depExports = (exportEntries, name) => exportEntries?.get(name) === true;
 
 const isAddedDep = (change) => {
   if (change.action !== 'added') return false;
@@ -411,131 +389,94 @@ const unusedChangeNames = (changes, used) => {
   return names;
 };
 
-const unusedDeclaredNames = (pkg, used) => {
-  const names = [];
-  if (!pkgHasExportEntry(pkg)) return names;
-  if (!used || !used.size) return names;
+const unusedDeclared = (pkg, used) => {
+  const found = [];
+  if (!pkgHasExportEntry(pkg) || !used?.size) return found;
   const maps = readSections(pkg);
   for (const section of SECTION_KEYS) {
     if (section === 'peerDependencies') continue;
-    const keys = [...maps[section].keys()];
-    keys.sort();
-    for (const name of keys) {
-      if (used.has(name)) continue;
-      names.push(name);
+    const map = maps[section];
+    for (const name of [...map.keys()].sort()) {
+      if (!used.has(name)) found.push({ name, section, from: map.get(name) });
     }
   }
-  return names;
+  return found;
 };
 
 const markUnusedChanges = (changes, used, pkg, exportEntries) => {
-  if (!pkgHasExportEntry(pkg)) return changes;
-  if (!used || !used.size) return changes;
-  const { length } = changes;
-  const marked = new Array(length);
-  for (let i = 0; i < length; i++) {
-    const change = changes[i];
-    if (!isAddedDep(change) || used.has(change.name)) {
-      marked[i] = change;
-      continue;
-    }
-    if (!depExports(exportEntries, change.name)) {
-      marked[i] = change;
-      continue;
-    }
-    marked[i] = { ...change, unused: true, propose: true };
-  }
-  return marked;
+  if (!pkgHasExportEntry(pkg) || !used?.size) return changes;
+  return changes.map((change) => {
+    if (!isAddedDep(change) || used.has(change.name)) return change;
+    if (!depExports(exportEntries, change.name)) return change;
+    return { ...change, unused: true, propose: true };
+  });
 };
 
 const unusedDeclaredChanges = (pkg, used, exportEntries) => {
   const changes = [];
-  if (!pkgHasExportEntry(pkg)) return changes;
-  if (!used || !used.size) return changes;
-  const maps = readSections(pkg);
   const taken = new Set();
-  for (const section of SECTION_KEYS) {
-    if (section === 'peerDependencies') continue;
-    const map = maps[section];
-    const names = [...map.keys()];
-    names.sort();
-    for (const name of names) {
-      if (used.has(name)) continue;
-      if (taken.has(name)) continue;
-      if (!depExports(exportEntries, name)) continue;
-      taken.add(name);
-      const version = map.get(name);
-      changes.push({
-        name,
-        section,
-        action: 'removed',
-        from: version,
-        to: '',
-        propose: true,
-        unused: true,
-      });
-    }
+  for (const { name, section, from } of unusedDeclared(pkg, used)) {
+    if (taken.has(name) || !depExports(exportEntries, name)) continue;
+    taken.add(name);
+    const action = 'removed';
+    const to = '';
+    changes.push({
+      name,
+      section,
+      action,
+      from,
+      to,
+      propose: true,
+      unused: true,
+    });
   }
   return changes;
 };
 
+const resolvedChange = (name, vul, resolved) => {
+  const from = resolved.get(name) || '';
+  if (!vul || !from) return null;
+  const to = proposedLockVersion(from, vul);
+  const section = 'resolved';
+  const action = 'vulnerable';
+  return { name, section, action, from, to, propose: true, audit: vul };
+};
+
+const declaredChange = (name, declared, out, vul) => {
+  const wanted = proposedWanted(out, vul);
+  if (!wanted && !vul) return null;
+  const from = declared.version;
+  const to = wanted ? applyWantedRange(from, wanted) : from;
+  if (to === from && !vul) return null;
+  const action = to === from ? 'vulnerable' : 'changed';
+  const { section } = declared;
+  const change = { name, section, action, from, to, propose: true };
+  if (out) change.outdated = out;
+  if (vul) change.audit = vul;
+  return change;
+};
+
+const mapKeys = (map) => (map ? [...map.keys()] : []);
+
 const buildProposedChanges = (pkg, outdated, audit, lock, options = {}) => {
-  const used = options.used;
-  const exportEntries = options.exportEntries;
-  const names = new Set();
-  if (outdated) {
-    for (const name of outdated.keys()) names.add(name);
-  }
-  if (audit) {
-    for (const name of audit.keys()) names.add(name);
-  }
-  const listed = [...names];
+  const listed = [...new Set([...mapKeys(outdated), ...mapKeys(audit)])];
   listed.sort();
   const resolved = lockEntries(lock);
-  const unused = unusedDeclaredChanges(pkg, used, exportEntries);
-  const taken = new Set();
-  for (const change of unused) taken.add(change.name);
-  const changes = [...unused];
+  const changes = unusedDeclaredChanges(
+    pkg,
+    options.used,
+    options.exportEntries,
+  );
+  const taken = new Set(changes.map((change) => change.name));
   for (const name of listed) {
     if (taken.has(name)) continue;
     const out = outdated ? outdated.get(name) : null;
     const vul = audit ? audit.get(name) : null;
-    const type = out ? out.type : '';
-    const declared = findDeclared(pkg, name, type);
-    if (!declared) {
-      if (!vul) continue;
-      const version = resolved.get(name) || '';
-      if (!version) continue;
-      const to = proposedLockVersion(version, vul);
-      changes.push({
-        name,
-        section: 'resolved',
-        action: 'vulnerable',
-        from: version,
-        to,
-        propose: true,
-        audit: vul,
-      });
-      continue;
-    }
-    const wanted = proposedWanted(out, vul);
-    if (!wanted && !vul) continue;
-    let to = declared.version;
-    if (wanted) to = applyWantedRange(declared.version, wanted);
-    if (to === declared.version && !vul) continue;
-    let action = 'changed';
-    if (to === declared.version) action = 'vulnerable';
-    const change = {
-      name,
-      section: declared.section,
-      action,
-      from: declared.version,
-      to,
-      propose: true,
-    };
-    if (out) change.outdated = out;
-    if (vul) change.audit = vul;
-    changes.push(change);
+    const declared = findDeclared(pkg, name, out ? out.type : '');
+    const change = declared
+      ? declaredChange(name, declared, out, vul)
+      : resolvedChange(name, vul, resolved);
+    if (change) changes.push(change);
   }
   return changes;
 };
@@ -551,18 +492,16 @@ const loadExportEntries = (names, extra = {}, pkgDir) => {
   if (!missing.length) return supplied ?? new Map();
   const found = collectExportEntries(extra.root, dir, missing);
   if (!supplied) return found;
-  const merged = new Map(supplied);
-  for (const name of found.keys()) merged.set(name, found.get(name));
-  return merged;
+  return new Map([...supplied, ...found]);
 };
 
 const groupedSynthetics = (synthetic) => {
   const byPath = new Map();
-  for (const key of synthetic.keys()) {
+  for (const [key, items] of synthetic) {
     const dir = key.slice(key.indexOf('\0') + 1);
     const rel = relOf(dir, MANIFEST);
     const list = byPath.get(rel) ?? [];
-    for (const item of synthetic.get(key)) list.push(item);
+    for (const item of items) list.push(item);
     byPath.set(rel, list);
   }
   return byPath;
@@ -570,12 +509,10 @@ const groupedSynthetics = (synthetic) => {
 
 const spliceAtSlots = (out, synthetic, slot) => {
   const byPath = groupedSynthetics(synthetic);
-  const inserts = new Array(byPath.size);
-  let i = 0;
-  for (const rel of byPath.keys()) {
-    const at = slot.has(rel) ? slot.get(rel) : out.length;
-    inserts[i++] = { at, items: byPath.get(rel) };
-  }
+  const inserts = [...byPath].map(([rel, items]) => ({
+    at: slot.get(rel) ?? out.length,
+    items,
+  }));
   inserts.sort((left, right) => right.at - left.at);
   for (const insert of inserts) {
     out.splice(insert.at, 0, ...insert.items);
@@ -597,6 +534,30 @@ const insertAfterPath = (items, added, rel) => {
   return [...items.slice(0, at + 1), ...added, ...items.slice(at + 1)];
 };
 
+const placeFolded = (items, { folded, synthetic, leftoverNames }) => {
+  const out = [];
+  const slot = new Map();
+  for (const item of items) {
+    const meta = depFileMeta(itemPath(item));
+    const pkgRel = meta ? relOf(meta.dir, MANIFEST) : '';
+    const key = meta ? `${item.origin}\0${meta.dir}` : '';
+    if (meta && synthetic.has(key) && !slot.has(pkgRel)) {
+      slot.set(pkgRel, out.length);
+    }
+    if (folded.has(item)) continue;
+    if (!meta || meta.kind !== 'manifest') {
+      out.push(item);
+      continue;
+    }
+    const names = leftoverNames.get(key);
+    const kept = names ? stripFoldedDepItem(item, names) : item;
+    if (!kept) continue;
+    out.push(kept);
+    slot.set(pkgRel, out.length);
+  }
+  return spliceAtSlots(out, synthetic, slot);
+};
+
 const foldDepItems = (
   items,
   readSides = () => ({ oldText: '', newText: '' }),
@@ -610,56 +571,26 @@ const foldDepItems = (
   const folded = new Set();
   const synthetic = new Map();
   const leftoverNames = new Map();
-  for (const key of groups.keys()) {
-    const group = groups.get(key);
+  for (const [key, group] of groups) {
     const summary = summarizeGroup(group, readSides);
     const unusedNames = unusedChangeNames(summary.changes, usedNames);
     const exportEntries = loadExportEntries(unusedNames, extra, group.dir);
-    const unused = markUnusedChanges(
-      summary.changes,
-      usedNames,
-      summary.pkg,
-      exportEntries,
-    );
-    const audited = markAuditChanges(unused, audit);
-    const changes = markOutdatedChanges(audited, outdated);
+    const { pkg } = summary;
+    let changes = summary.changes;
+    changes = markUnusedChanges(changes, usedNames, pkg, exportEntries);
+    changes = markChanges(changes, audit, 'audit');
+    changes = markChanges(changes, outdated, 'outdated');
     const next = { ...summary, changes };
-    leftoverNames.set(key, foldedDepNames(next.changes));
+    leftoverNames.set(key, foldedDepNames(changes));
     const taken = takeManifestItems(next);
-    if (next.foldLock) {
-      for (const item of next.lockItems) taken.push(item);
-    }
-    if (!taken.length && !next.changes.length) continue;
+    if (next.foldLock) taken.push(...next.lockItems);
+    if (!taken.length && !changes.length) continue;
     const made = makeDepItems(group.origin, group.items, taken, next);
     if (made.length) synthetic.set(key, made);
     for (const item of taken) folded.add(item);
   }
   if (!synthetic.size && !folded.size) return items;
-  const out = [];
-  const slot = new Map();
-  for (const item of items) {
-    const rel = itemPath(item);
-    const meta = depFileMeta(rel);
-    if (meta) {
-      const pkgRel = relOf(meta.dir, MANIFEST);
-      const key = `${item.origin}\0${meta.dir}`;
-      if (synthetic.has(key) && !slot.has(pkgRel)) {
-        slot.set(pkgRel, out.length);
-      }
-    }
-    if (folded.has(item)) continue;
-    if (meta && meta.kind === 'manifest') {
-      const names = leftoverNames.get(`${item.origin}\0${meta.dir}`);
-      const kept = names ? stripFoldedDepItem(item, names) : item;
-      if (kept) {
-        out.push(kept);
-        slot.set(relOf(meta.dir, MANIFEST), out.length);
-      }
-      continue;
-    }
-    out.push(item);
-  }
-  return spliceAtSlots(out, synthetic, slot);
+  return placeFolded(items, { folded, synthetic, leftoverNames });
 };
 
 const proposeDepItems = (pkgText, outdated, audit, extra = {}) => {
@@ -667,7 +598,7 @@ const proposeDepItems = (pkgText, outdated, audit, extra = {}) => {
   if (!pkg) return [];
   const lock = jsonParse(extra.lockText ?? '');
   const used = extra.usedNames;
-  const names = unusedDeclaredNames(pkg, used);
+  const names = unusedDeclared(pkg, used).map((dep) => dep.name);
   const exportEntries = loadExportEntries(names, extra, extra.dir);
   const options = { used, exportEntries };
   const changes = buildProposedChanges(pkg, outdated, audit, lock, options);

package/lib/detect.js

@@ -1,9 +1,11 @@
 'use strict';
 
 const path = require('node:path');
-const { fileExt } = require('metautil');
+const metautil = require('metautil');
+const { fileExt } = metautil;
 
-const { mapLang } = require('./highlight.js');
+const highlight = require('./highlight.js');
+const { mapLang } = highlight;
 
 const PROSE_BASENAMES = [
   'license',

package/lib/diff/align.js

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

package/lib/diff/diff.js

@@ -1,8 +1,11 @@
 'use strict';
 
-const { diffChars } = require('./inline.js');
-const { isCtxType, pairIndices, attachInline } = require('./align.js');
-const { parseDiff } = require('./parse.js');
+const inline = require('./inline.js');
+const { diffChars } = inline;
+const align = require('./align.js');
+const { isCtxType, pairIndices, attachInline } = align;
+const parse = require('./parse.js');
+const { parseDiff } = parse;
 const patch = require('./patch.js');
 const { splitHunk, flattenBlock, countSides, formatPatch } = patch;
 const display = require('./display.js');

package/lib/diff/display.js

@@ -2,7 +2,8 @@
 
 const align = require('./align.js');
 const { isCtxType, attachInline, LAYOUT_ALIGN } = align;
-const { flattenBlock } = require('./patch.js');
+const patch = require('./patch.js');
+const { flattenBlock } = patch;
 
 const DISPLAY_CONTEXT = 3;