reslop 0.2.5 → 0.2.7

package/lib/manifest.js

@@ -15,20 +15,17 @@ const SECTION_KEYS = [
   'optionalDependencies',
   'peerDependencies',
 ];
+const LOCK_PREFIX = 'node_modules/';
 
-const posixRel = (rel) => {
-  const raw = `${rel ?? ''}`;
-  return raw.replaceAll('\\', '/');
-};
+const isObject = (value) => !!value && typeof value === 'object';
+
+const posixRel = (rel) => `${rel ?? ''}`.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 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}`);
@@ -59,28 +56,22 @@ const emptySectionMaps = () => readSections(null);
 
 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 root = isObject(lock.packages) ? lock.packages[''] : null;
+  return readSections(isObject(root) ? root : lock);
 };
 
 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 packages = isObject(lock.packages) ? lock.packages : {};
+  for (const key of Object.keys(packages)) {
+    const entry = packages[key];
+    if (!key.startsWith(LOCK_PREFIX)) continue;
+    if (key.includes('/node_modules/')) continue;
+    if (!entry || typeof entry.version !== 'string') continue;
+    versions.set(key.slice(LOCK_PREFIX.length), entry.version);
   }
-  const deps = lock.dependencies;
-  if (!deps || typeof deps !== 'object') return versions;
+  const deps = isObject(lock.dependencies) ? lock.dependencies : {};
   for (const name of Object.keys(deps)) {
     const entry = deps[name];
     if (versions.has(name)) continue;
@@ -92,44 +83,31 @@ const lockEntries = (lock) => {
 
 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;
+  if (isObject(lock.packages)) {
+    return Object.keys(lock.packages).filter((key) => key !== '').length;
   }
-  const deps = lock.dependencies;
-  if (!deps || typeof deps !== 'object') return 0;
-  return Object.keys(deps).length;
+  if (!isObject(lock.dependencies)) return 0;
+  return Object.keys(lock.dependencies).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`;
+  const match = /\n([ \t]+)"/.exec(original);
+  const indent = match ? match[1] : 2;
+  return `${JSON.stringify(value, null, indent)}\n`;
 };
 
 const setSectionEntry = (pkg, section, name, version) => {
-  if (!version) {
-    const map = pkg[section];
-    if (!map || typeof map !== 'object') return;
-    delete map[name];
-    if (!Object.keys(map).length) delete pkg[section];
+  const map = pkg[section];
+  if (version) {
+    if (!isObject(map)) pkg[section] = {};
+    pkg[section][name] = version;
     return;
   }
-  const map = pkg[section];
-  if (!map || typeof map !== 'object') pkg[section] = {};
-  pkg[section][name] = version;
+  if (!isObject(map)) return;
+  delete map[name];
+  if (!Object.keys(map).length) delete pkg[section];
 };
 
 const dropsEntry = (change, side) => {
@@ -138,73 +116,41 @@ const dropsEntry = (change, side) => {
 };
 
 const applyManifestChange = (pkg, change, side) => {
-  if (change.section === 'resolved') return pkg;
+  if (change.section === 'resolved') return;
   const value = side === 'new' ? change.to : change.from;
-  if (change.section === 'field') {
-    if (value === '') {
-      delete pkg[change.name];
-      return pkg;
-    }
-    pkg[change.name] = jsonParse(value ?? '') ?? value;
-    return pkg;
-  }
   const version = dropsEntry(change, side) ? '' : value;
   setSectionEntry(pkg, change.section, change.name, version);
-  return pkg;
 };
 
-const ensureLockRoot = (lock) => {
-  if (!lock.packages || typeof lock.packages !== 'object') {
-    lock.packages = {};
-  }
-  const root = lock.packages[''];
-  if (!root || typeof root !== 'object') lock.packages[''] = {};
+const lockRoot = (lock) => {
+  if (!isObject(lock.packages)) lock.packages = {};
+  if (!isObject(lock.packages[''])) lock.packages[''] = {};
   return lock.packages[''];
 };
 
-const applyLegacyLockDep = (lock, change, side, src) => {
-  const deps = lock.dependencies;
-  if (!deps || typeof deps !== 'object') return;
-  if (dropsEntry(change, side)) {
-    delete deps[change.name];
-    return;
-  }
-  const srcDeps = src && src.dependencies;
-  if (!srcDeps || typeof srcDeps !== 'object') return;
-  const entry = srcDeps[change.name];
-  if (entry) deps[change.name] = cloneJson(entry);
+const copyLockEntry = (target, source, key, drop) => {
+  if (!isObject(target)) return;
+  if (drop) return void delete target[key];
+  const entry = isObject(source) ? source[key] : null;
+  if (entry) target[key] = cloneJson(entry);
 };
 
 const applyLockChange = (lock, change, side, oldLock, newLock) => {
-  if (change.section === 'field') return lock;
-  const src = side === 'new' ? newLock : oldLock;
+  const src = (side === 'new' ? newLock : oldLock) ?? {};
+  const drop = dropsEntry(change, side);
   if (change.section !== 'resolved') {
-    const root = ensureLockRoot(lock);
-    applyManifestChange(root, change, side);
-    applyLegacyLockDep(lock, change, side, src);
-  }
-  const packages = lock.packages;
-  if (!packages || typeof packages !== 'object') return lock;
-  const key = `node_modules/${change.name}`;
-  if (dropsEntry(change, side)) {
-    delete packages[key];
-    return lock;
+    applyManifestChange(lockRoot(lock), change, side);
+    copyLockEntry(lock.dependencies, src.dependencies, change.name, drop);
   }
-  const srcPkgs = src && src.packages;
-  if (!srcPkgs || typeof srcPkgs !== 'object') return lock;
-  const entry = srcPkgs[key];
-  if (entry) packages[key] = cloneJson(entry);
-  return lock;
+  const key = `${LOCK_PREFIX}${change.name}`;
+  copyLockEntry(lock.packages, src.packages, key, drop);
 };
 
 const seedManifest = (oldObj, newObj) => {
   const base = cloneJson(oldObj) || {};
-  if (!newObj) return base;
-  for (const key of Object.keys(newObj)) {
-    const value = newObj[key];
-    if (SECTION_KEYS.includes(key)) continue;
-    if (Object.hasOwn(base, key)) continue;
-    base[key] = cloneJson(value);
+  for (const key of Object.keys(newObj ?? {})) {
+    if (SECTION_KEYS.includes(key) || Object.hasOwn(base, key)) continue;
+    base[key] = cloneJson(newObj[key]);
   }
   return base;
 };
@@ -219,8 +165,7 @@ const mergeDepFile = (baseText, oldText, newText, change, side, kind) => {
   else base = cloneJson(oldObj) || {};
   if (kind === 'lockfile') applyLockChange(base, change, side, oldObj, newObj);
   else applyManifestChange(base, change, side);
-  const original = baseText || newText || oldText || '';
-  return stringifyJson(base, original);
+  return stringifyJson(base, baseText || newText || oldText || '');
 };
 
 const applyWantedRange = (declared, wanted) => {
@@ -229,25 +174,26 @@ const applyWantedRange = (declared, wanted) => {
   if (/^(file:|git[+@:]|workspace:|https?:|npm:)/.test(declared)) {
     return declared;
   }
-  if (declared.includes(' ') || declared.includes('|')) return declared;
-  if (declared.includes('<') || declared.includes('>')) return declared;
+  if (/[ |<>]/.test(declared)) return declared;
   const prefix = declared.startsWith('^') || declared.startsWith('~');
   const mark = prefix ? declared[0] : '';
   return `${mark}${wanted}`;
 };
 
+const declaredIn = (pkg, section, name) => {
+  const map = pkg[section];
+  if (!map || typeof map[name] !== 'string') return null;
+  return { section, version: map[name] };
+};
+
 const findDeclared = (pkg, name, type) => {
   if (type && SECTION_KEYS.includes(type)) {
-    const map = pkg[type];
-    if (map && typeof map[name] === 'string') {
-      return { section: type, version: map[name] };
-    }
+    const found = declaredIn(pkg, type, name);
+    if (found) return found;
   }
   for (const section of SECTION_KEYS) {
-    const map = pkg[section];
-    if (map && typeof map[name] === 'string') {
-      return { section, version: map[name] };
-    }
+    const found = declaredIn(pkg, section, name);
+    if (found) return found;
   }
   return null;
 };
@@ -255,15 +201,12 @@ const findDeclared = (pkg, name, type) => {
 const fmtVer = (parts) => `${parts.major}.${parts.minor}.${parts.patch}`;
 
 const clauseUpper = (clause) => {
-  const pattern = /(<=?)\s*(\d+\.\d+\.\d+)/g;
-  const matches = clause.matchAll(pattern);
   let best = null;
-  for (const match of matches) {
-    const op = match[1];
+  for (const match of clause.matchAll(/(<=?)\s*(\d+\.\d+\.\d+)/g)) {
     const parsed = parseVersion(match[2]);
     if (!parsed) continue;
     if (best && cmpVersion(parsed, best.ver) >= 0) continue;
-    best = { op, ver: parsed };
+    best = { op: match[1], ver: parsed };
   }
   return best;
 };
@@ -272,8 +215,7 @@ const patchedFromRange = (current, range) => {
   if (!current || !range) return '';
   const now = parseVersion(current);
   if (!now) return '';
-  const clauses = `${range}`.split('||');
-  for (const clause of clauses) {
+  for (const clause of `${range}`.split('||')) {
     const upper = clauseUpper(clause);
     if (!upper) continue;
     if (now.major !== upper.ver.major) continue;
@@ -287,8 +229,7 @@ const patchedFromRange = (current, range) => {
 const sameMajor = (from, to) => {
   const left = parseVersion(from);
   const right = parseVersion(to);
-  if (!left || !right) return false;
-  return left.major === right.major;
+  return !!left && !!right && left.major === right.major;
 };
 
 const proposedLockVersion = (current, vul) => {
@@ -297,8 +238,7 @@ const proposedLockVersion = (current, vul) => {
   const fix = vul.fix;
   if (fix && sameMajor(current, fix) && fix !== current) return fix;
   const patched = patchedFromRange(current, vul.range);
-  if (patched && patched !== current) return patched;
-  return current;
+  return patched || current;
 };
 
 const proposedWanted = (out, vul) => {
@@ -311,6 +251,7 @@ module.exports = {
   MANIFEST,
   LOCKFILE,
   SECTION_KEYS,
+  isObject,
   depFileMeta,
   relOf,
   listFilePath,