reslop 0.2.4 → 0.2.6

package/lib/npm-commands.js

@@ -9,7 +9,7 @@ const { jsonParse } = metautil;
 const ansi = require('./ansi.js');
 const { stripAnsi, visibleWidth } = ansi;
 const utilities = require('./utilities.js');
-const { npmBin, npmOpts, spawnBase } = utilities;
+const { npmBin, npmOpts, spawnBase, unquote, dateStamp } = utilities;
 
 const MANIFEST = 'package.json';
 const SECTIONS = ['dependencies', 'devDependencies', 'optionalDependencies'];
@@ -36,7 +36,7 @@ const writeManifest = (root, pkg) => {
 };
 
 const scriptEntries = (pkg) => {
-  const scripts = pkg && pkg.scripts;
+  const scripts = pkg.scripts;
   if (!scripts || typeof scripts !== 'object') return [];
   const entries = [];
   for (const name of Object.keys(scripts)) {
@@ -56,11 +56,8 @@ const binNames = (pkg) => {
     return base ? [base] : [];
   }
   if (!bin || typeof bin !== 'object' || Array.isArray(bin)) return [];
-  const names = [];
-  for (const name of Object.keys(bin)) {
-    if (typeof bin[name] === 'string' && bin[name]) names.push(name);
-  }
-  return names;
+  const isPath = (name) => typeof bin[name] === 'string' && bin[name] !== '';
+  return Object.keys(bin).filter(isPath);
 };
 
 const declaredNames = (pkg) => {
@@ -68,7 +65,7 @@ const declaredNames = (pkg) => {
   for (const section of SECTIONS) {
     const map = pkg[section];
     if (!map || typeof map !== 'object') continue;
-    for (const name of Object.keys(map)) names.push(name);
+    names.push(...Object.keys(map));
   }
   return names;
 };
@@ -107,36 +104,50 @@ const isPassingTest = (line) => {
   if (!text) return false;
   if (/^\s*[✔✓√] /.test(plain)) return true;
   if (/^ok \d+ /.test(text)) return true;
-  if (/^\s*PASS\b/.test(plain)) return true;
-  return false;
+  return /^\s*PASS\b/.test(plain);
 };
 
-const isNodeFrame = (line) => stripAnsi(line).includes('(node:');
-
 const indentStack = (line) => {
-  const plain = stripAnsi(line);
-  if (!/^\s*at\s/.test(plain)) return line;
-  const lead = line.match(/^\s*/)?.[0] ?? '';
-  const body = lead ? line.slice(lead.length) : line;
-  return `  ${body}`;
+  if (!/^\s*at\s/.test(stripAnsi(line))) return line;
+  return `  ${line.trimStart()}`;
 };
 
 const withoutNodeFrame = (line) => {
-  if (!isNodeFrame(line)) return line;
   const plain = stripAnsi(line);
-  if (/\{\s*$/.test(plain)) return '{';
-  return null;
+  if (!plain.includes('(node:')) return line;
+  return /\{\s*$/.test(plain) ? '{' : null;
 };
 
-const unquote = (value) => {
-  const text = `${value ?? ''}`;
-  if (text.length < 2) return text;
-  const open = text[0];
-  const close = text[text.length - 1];
-  const code = open.charCodeAt(0);
-  const quoted = open === close && (code === 34 || code === 39);
-  if (!quoted) return text;
-  return text.slice(1, -1);
+const withSep = (dir) => {
+  const sep = dir.includes('\\') ? '\\' : '/';
+  if (dir.endsWith(sep)) return dir;
+  return `${dir}${sep}`;
+};
+
+const stripOne = (text, dir) => {
+  if (!dir) return text;
+  let next = text.split(withSep(dir)).join('');
+  if (next.includes(dir)) next = next.split(dir).join('.');
+  return next;
+};
+
+const relativize = (text, root) => {
+  if (!root) return text;
+  const slash = root.replaceAll('\\', '/');
+  const back = slash.replaceAll('/', '\\');
+  const resolved = path.resolve(root).replaceAll('\\', '/');
+  const resolvedBack = resolved.replaceAll('/', '\\');
+  let next = text;
+  for (const dir of [slash, back, resolved, resolvedBack]) {
+    next = stripOne(next, dir);
+  }
+  return next;
+};
+
+const traceLine = (line, root) => {
+  const next = withoutNodeFrame(line);
+  if (next === null) return null;
+  return relativize(indentStack(next), root);
 };
 
 const objectEnd = (lines, start) => {
@@ -173,19 +184,18 @@ const showValue = (value) => {
 };
 
 const parseObject = (lines) => {
-  const body = lines.slice(1, -1);
   try {
     const value = JSON.parse(lines.join('\n'));
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
       return null;
     }
-    const entries = [];
-    for (const key of Object.keys(value)) {
-      entries.push([key, showValue(value[key])]);
-    }
+    const entries = Object.keys(value).map((key) => [
+      key,
+      showValue(value[key]),
+    ]);
     return entries.length ? entries : null;
   } catch {
-    return parseInspect(body);
+    return parseInspect(lines.slice(1, -1));
   }
 };
 
@@ -193,18 +203,22 @@ const TABLE_KEY = '\x1b[900m';
 const TABLE_VAL = '\x1b[901m';
 
 const formatTable = (entries) => {
-  let keyW = 0;
+  const prepared = [];
+  let keyWidth = 0;
   for (const entry of entries) {
-    keyW = Math.max(keyW, visibleWidth(entry[0]));
+    const lines = `${entry[1]}`.split('\n').filter((line) => line.trim());
+    if (!lines.length) continue;
+    prepared.push([entry[0], lines]);
+    keyWidth = Math.max(keyWidth, visibleWidth(entry[0]));
   }
   const rows = [];
-  for (const entry of entries) {
-    const parts = `${entry[1]}`.split('\n');
-    for (let i = 0; i < parts.length; i++) {
+  for (const entry of prepared) {
+    const lines = entry[1];
+    for (let i = 0; i < lines.length; i++) {
       const name = i === 0 ? entry[0] : '';
-      const pad = ' '.repeat(Math.max(0, keyW - visibleWidth(name)));
+      const pad = ' '.repeat(Math.max(0, keyWidth - visibleWidth(name)));
       const key = ` ${pad}${name} `;
-      const value = ` ${parts[i]} `;
+      const value = ` ${lines[i]} `;
       rows.push(`${TABLE_KEY}${key}${TABLE_VAL}  ${value}`);
     }
   }
@@ -215,67 +229,30 @@ const foldObjects = (lines) => {
   const out = [];
   for (let i = 0; i < lines.length; i++) {
     const end = objectEnd(lines, i);
-    if (end < 0) {
-      out.push(lines[i]);
-      continue;
-    }
-    const entries = parseObject(lines.slice(i, end + 1));
+    const entries = end < 0 ? null : parseObject(lines.slice(i, end + 1));
     if (!entries) {
       out.push(lines[i]);
       continue;
     }
     if (out.length && out[out.length - 1] !== '') out.push('');
-    for (const row of formatTable(entries)) out.push(row);
+    out.push(...formatTable(entries));
     i = end;
   }
   return out;
 };
 
-const withSep = (dir) => {
-  const sep = dir.includes('\\') ? '\\' : '/';
-  if (dir.endsWith(sep)) return dir;
-  return `${dir}${sep}`;
-};
-
-const stripOne = (text, dir) => {
-  if (!dir) return text;
-  let next = text.split(withSep(dir)).join('');
-  if (next.includes(dir)) next = next.split(dir).join('.');
-  return next;
-};
-
-const relativize = (text, root) => {
-  if (!root) return text;
-  const slash = root.replaceAll('\\', '/');
-  const back = slash.replaceAll('/', '\\');
-  const resolved = path.resolve(root).replaceAll('\\', '/');
-  const resolvedBack = resolved.replaceAll('/', '\\');
-  let next = text;
-  for (const dir of [slash, back, resolved, resolvedBack]) {
-    next = stripOne(next, dir);
-  }
-  return next;
-};
-
 const reduceOutput = (text, root, status) => {
-  const lines = `${text ?? ''}`.split(/\r?\n/);
   const kept = [];
-  for (const line of lines) {
+  for (const line of `${text ?? ''}`.split(/\r?\n/)) {
     if (isPassingTest(line)) continue;
-    const next = withoutNodeFrame(line);
-    if (next === null) continue;
-    kept.push(relativize(indentStack(next), root));
+    const next = traceLine(line, root);
+    if (next !== null) kept.push(next);
   }
   const folded = foldObjects(kept);
   while (folded.length && folded[folded.length - 1] === '') folded.pop();
-  if (status === '') {
-    if (!folded.length) return '';
-    return `${folded.join('\n')}\n`;
-  }
-  const code = status === undefined || status === null ? 'null' : status;
-  const exit = `exit ${code}`;
-  if (!folded.length) return `${exit}\n`;
-  return `${folded.join('\n')}\n${exit}\n`;
+  if (status !== '') folded.push(`exit ${status ?? 'null'}`);
+  if (!folded.length) return '';
+  return `${folded.join('\n')}\n`;
 };
 
 const logFileName = (command, date, index) => {
@@ -284,13 +261,6 @@ const logFileName = (command, date, index) => {
   return `${date}-${safe}-${n}.log`;
 };
 
-const dateStamp = (now) => {
-  const y = now.getFullYear();
-  const m = `${now.getMonth() + 1}`.padStart(2, '0');
-  const d = `${now.getDate()}`.padStart(2, '0');
-  return `${y}-${m}-${d}`;
-};
-
 const LOG_DIR = '.log';
 const LOG_STALE_DAYS = 5;
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -326,10 +296,9 @@ const readLogNames = (dir) => {
 
 const staleLogFiles = (root, now = new Date()) => {
   const dir = path.join(root, LOG_DIR);
-  const names = readLogNames(dir);
   const files = [];
   let bytes = 0;
-  for (const name of names) {
+  for (const name of readLogNames(dir)) {
     if (!name.endsWith('.log') || !isStaleLog(name, now)) continue;
     const full = path.join(dir, name);
     let stat;
@@ -352,31 +321,22 @@ const removeStaleLogs = (root, now = new Date()) => {
   return found.bytes;
 };
 
-const scaled = (value) => {
-  if (value >= 10) return `${Math.round(value)}`;
-  return `${Math.round(value * 10) / 10}`;
-};
-
-const formatSize = (bytes) => {
-  const size = bytes > 0 ? bytes : 0;
-  if (size < 1024) return `${size}b`;
-  const kb = size / 1024;
-  if (kb < 1024) return `${scaled(kb)}k`;
-  return `${scaled(kb / 1024)}m`;
+const logSlot = (dir, name) => {
+  const rawName = name.replace(/\.log$/, '.raw.log');
+  const full = path.join(dir, name);
+  const rawFull = path.join(dir, rawName);
+  return { name, full, dir, rawName, rawFull };
 };
 
 const nextLogFile = (root, command, now = new Date()) => {
   const date = dateStamp(now);
   const dir = path.join(root, LOG_DIR);
-  let index = 1;
-  let name = logFileName(command, date, index);
-  let full = path.join(dir, name);
-  while (index < 100 && fs.existsSync(full)) {
-    index += 1;
-    name = logFileName(command, date, index);
-    full = path.join(dir, name);
+  let slot = null;
+  for (let index = 1; index <= 100; index++) {
+    slot = logSlot(dir, logFileName(command, date, index));
+    if (!fs.existsSync(slot.full) && !fs.existsSync(slot.rawFull)) break;
   }
-  return { name, full, dir };
+  return slot;
 };
 
 const logText = (text) =>
@@ -385,26 +345,14 @@ const logText = (text) =>
     .map((line) => line.trimEnd())
     .join('\n');
 
-const writeLog = (root, command, text, now) => {
-  const file = nextLogFile(root, command, now);
-  fs.mkdirSync(file.dir, { recursive: true });
-  fs.writeFileSync(file.full, logText(text));
-  return file.name;
-};
-
-const parseScriptLine = (text) => {
-  const raw = `${text ?? ''}`.trim();
-  const at = raw.indexOf(': ');
-  if (at <= 0) return null;
-  const name = raw.slice(0, at).trim();
-  const command = raw.slice(at + 2).trim();
-  if (!name || !command) return null;
-  if (!/^[\w:.-]+$/.test(name)) return null;
-  return { name, command };
+const saveLogs = async (slot, reduced, raw) => {
+  await fs.promises.mkdir(slot.dir, { recursive: true });
+  await Promise.all([
+    fs.promises.writeFile(slot.full, logText(reduced)),
+    fs.promises.writeFile(slot.rawFull, logText(raw)),
+  ]);
 };
 
-const scriptLine = (entry) => `${entry.name}: ${entry.command}`;
-
 const orderedScripts = (pkg) => {
   const scripts = pkg.scripts;
   if (!scripts || typeof scripts !== 'object' || Array.isArray(scripts)) {
@@ -413,47 +361,25 @@ const orderedScripts = (pkg) => {
   return scripts;
 };
 
-const upsertScript = (pkg, prev, next) => {
-  const scripts = orderedScripts(pkg);
-  const names = Object.keys(scripts);
+const pickScripts = (scripts, names) => {
   const ordered = {};
-  if (prev && names.includes(prev)) {
-    for (const key of names) {
-      if (key === prev) ordered[next.name] = next.command;
-      else if (key !== next.name) ordered[key] = scripts[key];
-    }
-  } else {
-    for (const key of names) ordered[key] = scripts[key];
-    ordered[next.name] = next.command;
-  }
-  pkg.scripts = ordered;
-};
-
-const dropScript = (pkg, name) => {
-  const scripts = orderedScripts(pkg);
-  if (!Object.hasOwn(scripts, name)) return false;
-  const ordered = {};
-  for (const key of Object.keys(scripts)) {
-    if (key !== name) ordered[key] = scripts[key];
-  }
-  pkg.scripts = ordered;
-  return true;
+  for (const key of names) ordered[key] = scripts[key];
+  return ordered;
 };
 
-const moveScript = (pkg, name, delta) => {
+const upsertScript = (pkg, prev, next) => {
   const scripts = orderedScripts(pkg);
   const names = Object.keys(scripts);
-  const at = names.indexOf(name);
-  if (at < 0) return false;
-  const next = at + delta;
-  if (next < 0 || next >= names.length) return false;
-  const swap = names[at];
-  names[at] = names[next];
-  names[next] = swap;
+  if (!prev || !names.includes(prev)) {
+    pkg.scripts = { ...scripts, [next.name]: next.command };
+    return;
+  }
   const ordered = {};
-  for (const key of names) ordered[key] = scripts[key];
+  for (const key of names) {
+    if (key === prev) ordered[next.name] = next.command;
+    else if (key !== next.name) ordered[key] = scripts[key];
+  }
   pkg.scripts = ordered;
-  return true;
 };
 
 const saveScript = (root, prev, next) => {
@@ -464,23 +390,30 @@ const saveScript = (root, prev, next) => {
 
 const removeScript = (root, name) => {
   const pkg = readManifest(root);
-  if (!pkg || !dropScript(pkg, name)) return false;
+  if (!pkg) return false;
+  const scripts = orderedScripts(pkg);
+  if (!Object.hasOwn(scripts, name)) return false;
+  const names = Object.keys(scripts).filter((key) => key !== name);
+  pkg.scripts = pickScripts(scripts, names);
   writeManifest(root, pkg);
   return true;
 };
 
 const reorderScript = (root, name, delta) => {
   const pkg = readManifest(root);
-  if (!pkg || !moveScript(pkg, name, delta)) return false;
+  if (!pkg) return false;
+  const scripts = orderedScripts(pkg);
+  const names = Object.keys(scripts);
+  const at = names.indexOf(name);
+  const next = at + delta;
+  if (at < 0 || next < 0 || next >= names.length) return false;
+  names[at] = names[next];
+  names[next] = name;
+  pkg.scripts = pickScripts(scripts, names);
   writeManifest(root, pkg);
   return true;
 };
 
-const npmArgs = (entry) => {
-  if (entry.kind === 'bin') return ['exec', '--', entry.name];
-  return ['run', entry.name];
-};
-
 const signalPid = (pid, signal) => {
   try {
     process.kill(pid, signal);
@@ -491,7 +424,7 @@ const signalPid = (pid, signal) => {
 };
 
 const killTree = (proc) => {
-  const pid = proc && proc.pid;
+  const pid = proc.pid;
   if (!pid) return;
   if (process.platform === 'win32') {
     const killer = spawn(
@@ -528,6 +461,8 @@ const startNpm = (cwd, entry, onData, onClose) => {
     settled = true;
     onClose({ status, text: raw });
   };
+  const isBin = entry.kind === 'bin';
+  const args = isBin ? ['exec', '--', entry.name] : ['run', entry.name];
   let child;
   try {
     const opts = npmOpts({
@@ -535,7 +470,7 @@ const startNpm = (cwd, entry, onData, onClose) => {
       env: commandEnv(),
       detached: process.platform !== 'win32',
     });
-    child = spawn(npmBin(), npmArgs(entry), opts);
+    child = spawn(npmBin(), args, opts);
   } catch (error) {
     raw = `${error.message}\n`;
     finish(1);
@@ -546,13 +481,10 @@ const startNpm = (cwd, entry, onData, onClose) => {
     raw += chunk;
     onData(raw);
   };
-  if (child.stdout) {
-    child.stdout.setEncoding('utf8');
-    child.stdout.on('data', push);
-  }
-  if (child.stderr) {
-    child.stderr.setEncoding('utf8');
-    child.stderr.on('data', push);
+  for (const stream of [child.stdout, child.stderr]) {
+    if (!stream) continue;
+    stream.setEncoding('utf8');
+    stream.on('data', push);
   }
   child.on('error', (error) => {
     if (!stopped) raw += `${error.message}\n`;
@@ -572,21 +504,19 @@ module.exports = {
   listCommands,
   reduceOutput,
   logFileName,
-  writeLog,
+  nextLogFile,
+  saveLogs,
   staleLogFiles,
   removeStaleLogs,
-  formatSize,
-  parseScriptLine,
-  scriptLine,
   saveScript,
   removeScript,
   reorderScript,
   startNpm,
   commandEnv,
   isPassingTest,
-  withoutNodeFrame,
-  indentStack,
+  traceLine,
   relativize,
   TABLE_KEY,
   TABLE_VAL,
+  formatTable,
 };