@tapjs/processinfo 1.0.12 → 2.0.0

package/lib/index.d.ts

@@ -1,208 +0,0 @@
-/// <reference types="node" />
-import {
-  ChildProcess,
-  ExecException,
-  ExecFileOptions,
-  ExecFileSyncOptions,
-  ExecOptions,
-  ExecSyncOptions,
-  SpawnOptions,
-  SpawnSyncOptions,
-  SpawnSyncReturns,
-} from 'node:child_process'
-
-declare interface ProcessInfoOptions {
-  dir?: string
-  exclude?: RegExp
-}
-
-declare class ProcessInfoNode {
-  parent: ProcessInfoNode | null
-  root: ProcessInfoNode | null
-  children: ProcessInfoNode[] | null
-  files: string[] | null
-  externalID?: string | null
-  uuid: string
-  date: string
-  argv: string[]
-  execArgv: string[]
-  pid: number
-  ppid: number
-  cwd: string
-  code?: number | null
-  signal: string | null
-  runtime: number
-  link(db: ProcessInfo): void
-  NODE_OPTIONS?: string | null
-}
-
-declare interface ProcessInfoSpawnOptions extends SpawnOptions {
-  externalID?: string
-}
-
-declare interface ProcessInfoSpawnSyncOptions extends SpawnSyncOptions {
-  externalID?: string
-}
-declare interface ProcessInfoSpawnSyncOptionsWithStringEncoding
-  extends ProcessInfoSpawnSyncOptions {
-  encoding: BufferEncoding
-}
-interface ProcessInfoSpawnSyncOptionsWithBufferEncoding
-  extends ProcessInfoSpawnSyncOptions {
-  encoding?: 'buffer' | null | undefined
-}
-
-declare interface ProcessInfoExecSyncOptions extends ExecSyncOptions {
-  externalID?: string
-}
-declare interface ProcessInfoExecSyncOptionsWithStringEncoding
-  extends ProcessInfoExecSyncOptions {
-  encoding: BufferEncoding
-}
-declare interface ProcessInfoExecSyncOptionsWithBufferEncoding
-  extends ProcessInfoExecSyncOptions {
-  encoding?: 'buffer' | null | undefined
-}
-
-declare interface ProcessInfoExecOptions extends ExecOptions {
-  externalID?: string
-}
-declare interface ProcessInfoExecFileSyncOptions extends ExecFileSyncOptions {
-  externalID?: string
-}
-declare interface ProcessInfoExecFileSyncOptionsWithStringEncoding
-  extends ProcessInfoExecFileSyncOptions {
-  encoding: BufferEncoding
-}
-declare interface ProcessInfoExecFileSyncOptionsWithBufferEncoding
-  extends ProcessInfoExecFileSyncOptions {
-  encoding?: 'buffer' | null | undefined
-}
-declare interface ProcessInfoExecFileOptions extends ExecFileOptions {
-  externalID?: string
-}
-
-declare class ProcessInfo {
-  public dir: string
-  public exclude: RegExp
-  public roots: Set<ProcessInfoNode>
-  public files: Map<string, Set<ProcessInfoNode>>
-  public uuids: Map<string, ProcessInfoNode>
-  public externalIDs: Map<string, ProcessInfoNode>
-
-  private pendingRoot: Map<string, ProcessInfoNode>
-  private pendingParent: Map<string, ProcessInfoNode>
-
-  constructor(options?: ProcessInfoOptions)
-
-  save(): Promise<void>
-  saveSync(): void
-  erase(): Promise<void>
-  eraseSync(): void
-
-  load(): Promise<ProcessInfo>
-  loadSync(): ProcessInfo
-
-  static get Node(): typeof ProcessInfoNode
-  static get ProcessInfo(): typeof ProcessInfo
-
-  static spawn(
-    cmd: string,
-    args: string[],
-    options: ProcessInfoSpawnOptions
-  ): ChildProcess
-
-  static spawnSync(cmd: string): SpawnSyncReturns<Buffer>
-  static spawnSync(
-    cmd: string,
-    options: ProcessInfoSpawnSyncOptionsWithStringEncoding
-  ): SpawnSyncReturns<string>
-  static spawnSync(
-    cmd: string,
-    options: ProcessInfoSpawnSyncOptionsWithBufferEncoding
-  ): SpawnSyncReturns<Buffer>
-  static spawnSync(
-    cmd: string,
-    options?: ProcessInfoSpawnSyncOptions
-  ): SpawnSyncReturns<string | Buffer>
-  static spawnSync(
-    cmd: string,
-    args: readonly string[]
-  ): SpawnSyncReturns<Buffer>
-  static spawnSync(
-    cmd: string,
-    args: readonly string[],
-    options: ProcessInfoSpawnSyncOptionsWithStringEncoding
-  ): SpawnSyncReturns<string>
-  static spawnSync(
-    cmd: string,
-    args: readonly string[],
-    options: ProcessInfoSpawnSyncOptionsWithBufferEncoding
-  ): SpawnSyncReturns<Buffer>
-  static spawnSync(
-    cmd: string,
-    args?: readonly string[],
-    options?: ProcessInfoSpawnSyncOptions
-  ): SpawnSyncReturns<string | Buffer>
-
-  static exec(
-    cmd: string,
-    options: ProcessInfoExecOptions,
-    callback?: (
-      error: ExecException | null,
-      stdout: Buffer,
-      stderr: Buffer
-    ) => void
-  ): ChildProcess
-
-  static execSync(
-    cmd: string,
-    options: ProcessInfoExecSyncOptionsWithStringEncoding
-  ): string
-  static execSync(
-    cmd: string,
-    options: ProcessInfoExecSyncOptionsWithBufferEncoding
-  ): Buffer
-  static execSync(
-    cmd: string,
-    options?: ProcessInfoExecSyncOptions
-  ): string | Buffer
-
-  static execFile(
-    cmd: string,
-    args: string[],
-    options: ProcessInfoExecFileOptions
-  ): ChildProcess
-
-  static execFileSync(file: string): Buffer
-  static execFileSync(
-    file: string,
-    options: ProcessInfoExecFileSyncOptionsWithStringEncoding
-  ): string
-  static execFileSync(
-    file: string,
-    options: ProcessInfoExecFileSyncOptionsWithBufferEncoding
-  ): Buffer
-  static execFileSync(
-    file: string,
-    options?: ProcessInfoExecFileSyncOptions
-  ): string | Buffer
-  static execFileSync(file: string, args: readonly string[]): Buffer
-  static execFileSync(
-    file: string,
-    args: readonly string[],
-    options: ProcessInfoExecFileSyncOptionsWithStringEncoding
-  ): string
-  static execFileSync(
-    file: string,
-    args: readonly string[],
-    options: ProcessInfoExecFileSyncOptionsWithBufferEncoding
-  ): Buffer
-  static execFileSync(
-    file: string,
-    args?: readonly string[],
-    options?: ProcessInfoExecFileSyncOptions
-  ): string | Buffer
-}
-
-export = ProcessInfo

package/lib/json-file.cjs

@@ -1,19 +0,0 @@
-// read the file and json decode it, if anything fails, return {}
-
-const { readFile } = require('fs/promises')
-const { readFileSync } = require('fs')
-
-const safeJSONSync = f => {
-  try {
-    return JSON.parse(readFileSync(f, 'utf8'))
-  } catch (e) {
-    return {}
-  }
-}
-
-const safeJSON = f =>
-  readFile(f, 'utf8')
-    .then(d => JSON.parse(d))
-    .catch(() => ({}))
-
-module.exports = { safeJSON, safeJSONSync }

package/lib/node-options-env.cjs

@@ -1,100 +0,0 @@
-const cjsLoader = require.resolve('./cjs.cjs')
-const esmLoader = require.resolve('./esm.mjs')
-
-// esm --loader is actually last-wins, so only counts as having
-// it if it's the last loader in line.  To get around that, we pass
-// ALL loaders to our loader as ?a&b&c&...
-//
-// cjs --require stacks in order, so as long as it's there, it counts.
-
-const hasCJSLoader = args => hasLoader(args, ['-r', '--require'], cjsLoader)
-
-const hasESMLoader = args =>
-  hasLoader(args, ['--experimental-loader', '--loader'], esmLoader, true)
-
-const addCJS = args =>
-  !hasCJSLoader(args) ? args.concat('--require=' + cjsLoader) : args
-const addESM = args => squashLoaders(args)
-
-const cjsOnly = args => (hasESMLoader(args) ? false : hasCJSLoader(args))
-
-const { nodeOptionsToArgv } = require('./node-options-to-argv.cjs')
-const { argvToNodeOptions } = require('./argv-to-node-options.cjs')
-const { fileURLToPath, pathToFileURL } = require('url')
-
-const { resolve } = require('path')
-const resolveLoader = (path, isURI) => {
-  path = decode(path, isURI)
-  try {
-    return require.resolve(/^\.?\.[\\/]/.test(path) ? resolve(path) : path)
-  } catch (e) {
-    return path
-  }
-}
-
-const decode = (path, isURI) =>
-  !isURI
-    ? path
-    : /^file:/.test(path)
-    ? fileURLToPath(path)
-    : decodeURIComponent(path)
-
-const squashLoaders = args => {
-  const loaders = []
-  const re = /^--(?:experimental-)?loader(?:=(.*))?$/
-  const squashed = []
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]
-    const parsed = arg.match(re)
-    if (!parsed) {
-      squashed.push(arg)
-      continue
-    }
-    const val = parsed[1] || args[++i]
-    if (!val) {
-      // --loader with no value anywhere, just put it back how it was
-      // and let node barf on it
-      squashed.push(arg, args[i - 1])
-      continue
-    }
-    const resolved = resolveLoader(val, true)
-    if (resolved === esmLoader) {
-      continue
-    }
-    loaders.push(encodeURIComponent(val.replace(/\\/g, '/')))
-  }
-  const q = loaders.length ? '?' : ''
-  squashed.push(`--loader=${pathToFileURL(esmLoader)}${q}${loaders.join('&')}`)
-  return squashed
-}
-
-const hasLoader = (args, keys, value, isURI = false) => {
-  value = decode(value, isURI)
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]
-    // -r <value>
-    if (
-      keys.includes(arg) &&
-      i < args.length - 1 &&
-      resolveLoader(args[i + 1], isURI) === value
-    ) {
-      return true
-    } else if (arg.startsWith('--') && arg.includes('=')) {
-      // --require=<value>
-      const [k, ...rest] = arg.split('=')
-      if (keys.includes(k) && resolveLoader(rest.join('='), isURI) === value) {
-        return true
-      } else {
-        continue
-      }
-    }
-  }
-  return false
-}
-
-const nodeOptionsEnv = (env, args) => {
-  const no = nodeOptionsToArgv(env.NODE_OPTIONS)
-  return argvToNodeOptions(cjsOnly(args.concat(no)) ? addCJS(no) : addESM(no))
-}
-
-module.exports = { nodeOptionsEnv }

package/lib/node-options-to-argv.cjs

@@ -1,52 +0,0 @@
-exports.nodeOptionsToArgv = no => {
-  if (!no) return []
-  const argv = []
-  let escaping = false
-  let inquote = false
-  let tokStart = 0
-  let tok = ''
-  for (let i = 0; i < no.length; i++) {
-    const c = no.charAt(i)
-    switch (c) {
-      case '"':
-        if (escaping) {
-          tok += no.slice(tokStart, i - 1) + '"'
-          tokStart = i + 1
-          escaping = false
-        } else if (inquote) {
-          tok += no.slice(tokStart, i)
-          tokStart = i + 1
-          inquote = false
-        } else {
-          inquote = true
-          tok += no.slice(tokStart, i)
-          tokStart = i + 1
-        }
-        continue
-
-      case '\\':
-        if (inquote) {
-          escaping = true
-        }
-        continue
-
-      case ' ':
-        if (inquote) continue
-        tok += no.slice(tokStart, i)
-        tokStart = i + 1
-        argv.push(tok)
-        tok = ''
-        continue
-
-      default:
-        escaping = false
-        continue
-    }
-  }
-  if (inquote) {
-    return []
-  }
-  tok += no.slice(tokStart)
-  argv.push(tok)
-  return argv
-}

package/lib/process-info-node.cjs

@@ -1,84 +0,0 @@
-class ProcessInfoNode {
-  constructor(data) {
-    this.parent = null
-    this.children = null
-    this.files = null
-    this.externalID = null
-    Object.assign(this, data)
-  }
-
-  toJSON() {
-    return Object.fromEntries(
-      Object.entries(this)
-        .filter(([_, val]) => val !== null && val !== undefined)
-        .map(([key, val]) =>
-          key === 'root'
-            ? [key, val.uuid]
-            : key === 'parent'
-            ? [key, val.uuid]
-            : key === 'children'
-            ? [key, [...val].map(c => c.uuid)]
-            : [key, val]
-        )
-    )
-  }
-
-  link(db) {
-    db.uuids.set(this.uuid, this)
-    this.parent = db.uuids.get(this.parent) || this.parent || null
-    this.root = db.uuids.get(this.root) || this.root
-
-    if (this.parent === null) {
-      this.root = this
-      if (db.pendingRoot.has(this.uuid)) {
-        for (const n of db.pendingRoot.get(this.uuid)) {
-          n.root = this
-        }
-        db.pendingRoot.delete(this.uuid)
-      }
-      db.roots.add(this)
-    } else if (typeof this.root === 'string') {
-      if (db.pendingRoot.has(this.root)) {
-        db.pendingRoot.get(this.root).add(this)
-      } else {
-        db.pendingRoot.set(this.root, new Set([this]))
-      }
-    }
-
-    if (typeof this.parent === 'string') {
-      if (db.pendingParent.has(this.parent)) {
-        db.pendingParent.get(this.parent).add(this)
-      } else {
-        db.pendingParent.set(this.parent, new Set([this]))
-      }
-    } else if (this.parent !== null) {
-      if (!this.parent.children) {
-        this.parent.children = new Set([this])
-      } else {
-        this.parent.children.add(this)
-      }
-    }
-
-    if (db.pendingParent.has(this.uuid)) {
-      this.children = db.pendingParent.get(this.uuid)
-      for (const n of this.children) {
-        n.parent = this
-      }
-      db.pendingParent.delete(this.uuid)
-    }
-
-    for (const f of this.files) {
-      if (!db.files.has(f)) {
-        db.files.set(f, new Set([this]))
-      } else {
-        db.files.get(f).add(this)
-      }
-    }
-
-    if (this.externalID) {
-      db.externalIDs.set(this.externalID, this)
-    }
-  }
-}
-
-module.exports = { ProcessInfoNode }

package/lib/register-coverage.cjs

@@ -1,74 +0,0 @@
-// start tracking coverage, unless disabled explicltly
-// export so that we know to collect at the end of the process
-const enabled = process.env._TAPJS_PROCESSINFO_COVERAGE_ !== '0'
-if (enabled) {
-  process.env._TAPJS_PROCESSINFO_COVERAGE_ = '1'
-  process.setSourceMapsEnabled(true)
-
-  // NB: coverage exclusion is in addition to processinfo
-  // exclusion.  Only show coverage for a file we care
-  // about at least somewhat, but coverage is a subset.
-  const { getExclude } = require('./get-exclude.cjs')
-  const exclude = getExclude('_TAPJS_PROCESSINFO_COV_EXCLUDE_')
-  const inspector = require('inspector')
-  const session = new inspector.Session()
-  module.exports.session = session
-  session.connect()
-  session.post('Profiler.enable')
-  session.post('Runtime.enable')
-  session.post('Profiler.startPreciseCoverage', {
-    callCount: true,
-    detailed: true,
-  })
-
-  const { fileURLToPath } = require('url')
-  const { findSourceMap } = require('module')
-
-  const lineLengths = f =>
-    readFileSync(f, 'utf8')
-      .split(/\n|\u2028|\u2029/)
-      .map(l => l.length)
-
-  const { mkdirSync, writeFileSync, readFileSync } = require('fs')
-
-  const coverageOnProcessEnd = (cwd, processInfo) => {
-    const f = `${cwd}/.tap/coverage/${processInfo.uuid}.json`
-    mkdirSync(`${cwd}/.tap/coverage`, { recursive: true })
-
-    session.post('Profiler.takePreciseCoverage', (er, cov) => {
-      session.post('Profiler.stopPreciseCoverage')
-
-      /* istanbul ignore next - something very strange and bad happened */
-      if (er) {
-        throw er
-      }
-
-      const sourceMapCache = (cov['source-map-cache'] = {})
-      cov.result = cov.result.filter(obj => {
-        if (!/^file:/.test(obj.url)) {
-          return false
-        }
-        const f = fileURLToPath(obj.url)
-        if (!processInfo.files.includes(f) || exclude.test(f)) {
-          return false
-        }
-        // see if it has a source map
-        const s = findSourceMap(f)
-        if (s) {
-          const { payload } = s
-          sourceMapCache[obj.url] = Object.assign(Object.create(null), {
-            lineLengths: lineLengths(f),
-            data: payload,
-          })
-        }
-        return true
-      })
-
-      writeFileSync(f, JSON.stringify(cov, 0, 2) + '\n', 'utf8')
-    })
-  }
-
-  module.exports = { coverageOnProcessEnd }
-} else {
-  module.exports = { coverageOnProcessEnd: () => {} }
-}

package/lib/register-env.cjs

@@ -1,21 +0,0 @@
-const processOnSpawn = require('process-on-spawn')
-const hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k)
-
-processOnSpawn.addListener(obj => {
-  const env = obj.env || {}
-  obj.env = Object.assign(env, getEnvs(env))
-  return obj
-})
-
-const envRE = /^_TAPJS_PROCESSINFO_/
-
-const getEnvs = env => {
-  // load it here so that it isn't cached before the loader attaches
-  // in self-test scenario.
-  const { nodeOptionsEnv } = require('./node-options-env.cjs')
-  return Object.fromEntries(
-    Object.entries(process.env)
-      .filter(([k, v]) => !hasOwn(env, k) && envRE.test(k))
-      .concat([['NODE_OPTIONS', nodeOptionsEnv(env, process.execArgv)]])
-  )
-}

package/lib/register-process-end.cjs

@@ -1,29 +0,0 @@
-const { onExit } = require('signal-exit')
-const { getProcessInfo } = require('./get-process-info.cjs')
-
-const { mkdirSync, writeFileSync } = require('fs')
-const cwd = process.cwd()
-const globals = new Set(Object.keys(global))
-const { coverageOnProcessEnd } = require('./register-coverage.cjs')
-
-onExit(
-  (code, signal) => {
-    const processInfo = getProcessInfo()
-    processInfo.code = code
-    processInfo.signal = signal
-    const runtime = process.hrtime(processInfo.hrstart)
-    delete processInfo.hrstart
-    processInfo.files = [...new Set(processInfo.files)]
-    processInfo.runtime = runtime[0] * 1e3 + runtime[1] / 1e6
-    const globalsAdded = Object.keys(global).filter(k => !globals.has(k))
-    if (globalsAdded.length) {
-      processInfo.globalsAdded = globalsAdded
-    }
-
-    const f = `${cwd}/.tap/processinfo/${processInfo.uuid}.json`
-    mkdirSync(`${cwd}/.tap/processinfo`, { recursive: true })
-    writeFileSync(f, JSON.stringify(processInfo) + '\n', 'utf8')
-    coverageOnProcessEnd(cwd, processInfo)
-  },
-  { alwaysLast: true }
-)

package/lib/spawn-opts.cjs

@@ -1,16 +0,0 @@
-const { nodeOptionsEnv } = require('./node-options-env.cjs')
-
-const spawnOpts = (options = {}, exclude) => {
-  const { externalID } = options
-  const env = { ...(options.env || process.env) }
-  env.NODE_OPTIONS = nodeOptionsEnv(env, [])
-  if (externalID) {
-    env._TAPJS_PROCESSINFO_EXTERNAL_ID_ = externalID
-  }
-  if (exclude) {
-    env._TAPJS_PROCESSINFO_EXCLUDE_ = String(exclude)
-  }
-  return { ...options, env }
-}
-
-module.exports = { spawnOpts }