@tapjs/processinfo 1.0.12 → 2.0.0

package/lib/cjs.cjs

@@ -1,16 +0,0 @@
-// commonjs style loader hook
-const { getProcessInfo } = require('./get-process-info.cjs')
-const { getExclude } = require('./get-exclude.cjs')
-
-// have to make this a module-local, otherwise it reloads the info
-const processInfo = getProcessInfo()
-const exclude = getExclude('_TAPJS_PROCESSINFO_EXCLUDE_')
-
-const { addHook } = require('pirates')
-
-const matcher = filename => !exclude.test(filename)
-const hook = (code, filename) => {
-  processInfo.files.push(filename)
-  return code
-}
-addHook(hook, { exts: ['.js', '.cjs'], matcher })

package/lib/esm.mjs

@@ -1,74 +0,0 @@
-// usage: node '--loader=esm.mjs?other-loader&otherotherloader' foo.mjs
-import { fileURLToPath } from 'url'
-import { getProcessInfo } from './get-process-info.cjs'
-import { getExclude } from './get-exclude.cjs'
-import './cjs.cjs'
-
-// on Node v20, loaders are executed in a separate isolated environment
-// As a result, to register coverage and track files, we need to act in
-// the globalPreload function. The load() method posts a message with the
-// filename being loaded, because any registrations that happen in the
-// loader thread will not have any effect.
-// The check for the 'port' being undefined is to allow for support back to
-// 16.12, which had a globalPreload method, but did not have a sendMessage
-// port in that environment.
-let PORT = null
-export const globalPreload = context => {
-  const loader = fileURLToPath(import.meta.url)
-  const { port } = context || {}
-  PORT = port
-  return `
-if (typeof port !== 'undefined') {
-  const { createRequire } = getBuiltin('module')
-  const {pid, ppid} = getBuiltin('process')
-  const require = createRequire(${JSON.stringify(loader)})
-  const { getProcessInfo } = require('./get-process-info.cjs')
-  const { getExclude } = require('./get-exclude.cjs')
-  require('./cjs.cjs')
-  const processInfo = getProcessInfo()
-  port.onmessage = (e) => processInfo.files.push(e.data)
-  port.unref()
-}
-`
-}
-
-const processInfo = getProcessInfo()
-const exclude = getExclude('_TAPJS_PROCESSINFO_EXCLUDE_')
-
-let others = await Promise.all(
-  [...new URL(import.meta.url).searchParams.keys()].map(s =>
-    import(s).catch(() => ({}))
-  )
-)
-
-let hasLoad = others.filter(loader => typeof loader.load === 'function')
-let hasResolve = others.filter(loader => typeof loader.resolve === 'function')
-
-const myLoad = defaultFn => async (url, context) => {
-  if (/^file:/.test(url)) {
-    const filename = fileURLToPath(url)
-    if (!exclude.test(filename)) {
-      processInfo.files.push(filename)
-      if (PORT) {
-        PORT.postMessage(filename)
-      }
-    }
-  }
-  return defaultFn(url, context, defaultFn)
-}
-
-export const load = async (url, context, defaultFn) =>
-  runAll(hasLoad, 'load', url, context, myLoad(defaultFn))
-
-export const resolve = async (url, context, defaultFn) =>
-  runAll(hasResolve, 'resolve', url, context, defaultFn)
-
-const runAll = async (set, method, url, context, defaultFn, i = 0) => {
-  if (i >= set.length) {
-    return defaultFn(url, context, defaultFn)
-  } else {
-    return set[i][method](url, context, (url, context, _) =>
-      runAll(set, method, url, context, defaultFn, i + 1)
-    )
-  }
-}

package/lib/get-exclude.cjs

@@ -1,21 +0,0 @@
-const defaultExclude =
-  /(^|[\\/])(node_modules|\.tap|tap-testdir-.*?|tap-snapshots|tests?|[^\/]+\.test\.[cm]?js|__tests?__)([\\/]|$)/i
-
-const parseExclude = src => {
-  const parsed = src.match(/^\/(.*)\/([a-z]*)$/)
-  if (parsed) {
-    try {
-      return new RegExp(parsed[1], parsed[2])
-    } catch (e) {}
-  }
-}
-
-const getExclude = k => {
-  const src = process.env[k]
-  const exclude = (src && parseExclude(src)) || defaultExclude
-  process.env[k] = String(exclude)
-  return exclude
-}
-
-exports.defaultExclude = defaultExclude
-exports.getExclude = getExclude

package/lib/get-process-info.cjs

@@ -1,45 +0,0 @@
-const { v4: uuid } = require('uuid')
-
-const envKey = k => `_TAPJS_PROCESSINFO_${k.toUpperCase()}_`
-const getEnv = k => process.env[envKey(k)]
-const setEnv = (k, v) => (process.env[envKey(k)] = v)
-const delEnv = k => delete process.env[envKey(k)]
-
-let processInfo = null
-const getProcessInfo = () => {
-  if (!processInfo) {
-    require('./register-env.cjs')
-    require('./register-coverage.cjs')
-    require('./register-process-end.cjs')
-    processInfo = {
-      hrstart: process.hrtime(),
-      date: new Date().toISOString(),
-      argv: process.argv,
-      execArgv: process.execArgv,
-      NODE_OPTIONS: process.env.NODE_OPTIONS,
-      cwd: process.cwd(),
-      pid: process.pid,
-      ppid: process.ppid,
-      parent: getEnv('parent') || null,
-      uuid: uuid(),
-      files: [],
-    }
-
-    if (!processInfo.parent) {
-      processInfo.root = processInfo.uuid
-      setEnv('root', processInfo.uuid)
-    } else {
-      processInfo.root = getEnv('root')
-    }
-    // this is the parent of any further child processes
-    setEnv('parent', processInfo.uuid)
-    const externalID = getEnv('external_id')
-    if (externalID) {
-      processInfo.externalID = externalID
-      // externalID only applies to ONE process, not all its children.
-      delEnv('external_id')
-    }
-  }
-  return processInfo
-}
-module.exports = { getProcessInfo }

package/lib/index.cjs

@@ -1,163 +0,0 @@
-const {
-  spawn,
-  spawnSync,
-  exec,
-  execSync,
-  execFile,
-  execFileSync,
-} = require('./child_process.cjs')
-
-const { resolve, basename } = require('path')
-
-const { ProcessInfoNode } = require('./process-info-node.cjs')
-
-const {
-  writeFileSync,
-  readdirSync,
-  rmSync,
-  rmdirSync,
-  mkdirSync,
-} = require('fs')
-const { writeFile, readdir, rm, rmdir, mkdir } = require('fs/promises')
-
-const { safeJSONSync, safeJSON } = require('./json-file.cjs')
-
-class ProcessInfo {
-  constructor({
-    dir = resolve(process.cwd(), '.tap/processinfo'),
-    exclude = /(^|\\|\/)node_modules(\\|\/|$)/,
-  } = {}) {
-    this.dir = dir
-    this.exclude = exclude
-    this.roots = new Set()
-    this.files = new Map()
-    this.uuids = new Map()
-    this.pendingRoot = new Map()
-    this.pendingParent = new Map()
-    this.externalIDs = new Map()
-  }
-
-  clear() {
-    this.roots.clear()
-    this.files.clear()
-    this.uuids.clear()
-    this.externalIDs.clear()
-  }
-
-  async save() {
-    await mkdir(this.dir, { recursive: true })
-    const writes = []
-    for (const [uuid, info] of this.uuids.entries()) {
-      const f = `${this.dir}/${uuid}.json`
-      writes.push(writeFile(f, JSON.stringify(info) + '\n', 'utf8'))
-    }
-    await Promise.all(writes)
-  }
-
-  async saveSync() {
-    mkdirSync(this.dir, { recursive: true })
-    for (const [uuid, info] of this.uuids.entries()) {
-      const f = `${this.dir}/${uuid}.json`
-      writeFileSync(f, JSON.stringify(info) + '\n', 'utf8')
-    }
-  }
-
-  async erase() {
-    this.clear()
-    /* istanbul ignore next - node version compat */
-    try {
-      await rm(this.dir, { recursive: true })
-    } catch (e) {
-      await rmdir(this.dir, { recursive: true })
-    }
-  }
-
-  eraseSync() {
-    this.clear()
-    /* istanbul ignore next - node version compat */
-    try {
-      rmSync(this.dir, { recursive: true })
-    } catch (e) {
-      rmdirSync(this.dir, { recursive: true })
-    }
-  }
-
-  async load() {
-    const promises = []
-    for (const entry of await readdir(this.dir).catch(() => [])) {
-      const uuid = basename(entry, '.json')
-      if (this.uuids.has(uuid)) {
-        continue
-      }
-      const f = resolve(this.dir, entry)
-      promises.push(
-        safeJSON(f).then(data => {
-          if (!data.uuid || data.uuid !== uuid) {
-            return
-          }
-          new ProcessInfoNode(data).link(this)
-        })
-      )
-    }
-    await Promise.all(promises)
-
-    return this
-  }
-
-  loadSync() {
-    let entries
-    try {
-      entries = readdirSync(this.dir)
-    } catch (_) {
-      entries = []
-    }
-    for (const entry of entries) {
-      const uuid = basename(entry, '.json')
-      if (this.uuids.has(uuid)) {
-        continue
-      }
-      const f = resolve(this.dir, entry)
-      const data = safeJSONSync(f)
-      if (!data.uuid || data.uuid !== uuid) {
-        continue
-      }
-      new ProcessInfoNode(data).link(this)
-    }
-
-    return this
-  }
-
-  static get Node() {
-    return ProcessInfoNode
-  }
-
-  static get ProcessInfo() {
-    return ProcessInfo
-  }
-
-  static get spawn() {
-    return spawn
-  }
-
-  static get spawnSync() {
-    return spawnSync
-  }
-
-  static get exec() {
-    return exec
-  }
-
-  static get execSync() {
-    return execSync
-  }
-
-  static get execFile() {
-    return execFile
-  }
-
-  static get execFileSync() {
-    return execFileSync
-  }
-}
-
-module.exports = ProcessInfo

package/lib/index.d.cts

@@ -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