@farthershore/cli 0.3.10 → 0.3.11

package/node_modules/pino/lib/transport-stream.js

@@ -1,56 +0,0 @@
-'use strict'
-
-const { realImport, realRequire } = require('real-require')
-
-module.exports = loadTransportStreamBuilder
-
-/**
- * Loads & returns a function to build transport streams
- * @param {string} target
- * @returns {Promise<function(object): Promise<import('node:stream').Writable>>}
- * @throws {Error} In case the target module does not export a function
- */
-async function loadTransportStreamBuilder (target) {
-  let fn
-  try {
-    const toLoad = target.startsWith('file://') ? target : 'file://' + target
-
-    if (toLoad.endsWith('.ts') || toLoad.endsWith('.cts')) {
-      // TODO: add support for the TSM modules loader ( https://github.com/lukeed/tsm ).
-      if (process[Symbol.for('ts-node.register.instance')]) {
-        realRequire('ts-node/register')
-      } else if (process.env && process.env.TS_NODE_DEV) {
-        realRequire('ts-node-dev')
-      }
-      // TODO: Support ES imports once tsc, tap & ts-node provide better compatibility guarantees.
-      fn = realRequire(decodeURIComponent(target))
-    } else {
-      fn = (await realImport(toLoad))
-    }
-  } catch (error) {
-    // See this PR for details: https://github.com/pinojs/thread-stream/pull/34
-    if ((error.code === 'ENOTDIR' || error.code === 'ERR_MODULE_NOT_FOUND')) {
-      fn = realRequire(target)
-    } else if (error.code === undefined || error.code === 'ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING') {
-      // When bundled with pkg, an undefined error is thrown when called with realImport
-      // When bundled with pkg and using node v20, an ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING error is thrown when called with realImport
-      // More info at: https://github.com/pinojs/thread-stream/issues/143
-      try {
-        fn = realRequire(decodeURIComponent(target))
-      } catch {
-        throw error
-      }
-    } else {
-      throw error
-    }
-  }
-
-  // Depending on how the default export is performed, and on how the code is
-  // transpiled, we may find cases of two nested "default" objects.
-  // See https://github.com/pinojs/pino/issues/1243#issuecomment-982774762
-  if (typeof fn === 'object') fn = fn.default
-  if (typeof fn === 'object') fn = fn.default
-  if (typeof fn !== 'function') throw Error('exported worker is not a function')
-
-  return fn
-}

package/node_modules/pino/lib/transport.js

@@ -1,289 +0,0 @@
-'use strict'
-
-const { createRequire } = require('module')
-const { existsSync } = require('node:fs')
-const getCallers = require('./caller')
-const { join, isAbsolute, sep } = require('node:path')
-const { fileURLToPath } = require('node:url')
-const sleep = require('atomic-sleep')
-const onExit = require('on-exit-leak-free')
-const ThreadStream = require('thread-stream')
-
-function setupOnExit (stream) {
-  // This is leak free, it does not leave event handlers
-  onExit.register(stream, autoEnd)
-  onExit.registerBeforeExit(stream, flush)
-
-  stream.on('close', function () {
-    onExit.unregister(stream)
-  })
-}
-
-// Check if preload flags exist in execArgv.
-// During preload phase (require.main undefined), we pass empty execArgv to prevent infinite worker spawning.
-// We don't try to filter and pass other flags because many (like --stack-trace-limit, --tls-cipher-list)
-// aren't valid for worker threads and would cause ERR_WORKER_INVALID_EXEC_ARGV.
-function hasPreloadFlags () {
-  const execArgv = process.execArgv
-  for (let i = 0; i < execArgv.length; i++) {
-    const arg = execArgv[i]
-    if (arg === '--import' || arg === '--require' || arg === '-r') {
-      return true
-    }
-    if (arg.startsWith('--import=') || arg.startsWith('--require=') || arg.startsWith('-r=')) {
-      return true
-    }
-  }
-  return false
-}
-
-function sanitizeNodeOptions (nodeOptions) {
-  const tokens = nodeOptions.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)
-  if (!tokens) {
-    return nodeOptions
-  }
-
-  const sanitized = []
-  let changed = false
-
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i]
-
-    if (token === '--require' || token === '-r' || token === '--import') {
-      const next = tokens[i + 1]
-      if (next && shouldDropPreload(next)) {
-        changed = true
-        i++
-        continue
-      }
-
-      sanitized.push(token)
-      if (next) {
-        sanitized.push(next)
-        i++
-      }
-      continue
-    }
-
-    if (token.startsWith('--require=') || token.startsWith('-r=') || token.startsWith('--import=')) {
-      const value = token.slice(token.indexOf('=') + 1)
-      if (shouldDropPreload(value)) {
-        changed = true
-        continue
-      }
-    }
-
-    sanitized.push(token)
-  }
-
-  return changed ? sanitized.join(' ') : nodeOptions
-}
-
-function shouldDropPreload (value) {
-  const unquoted = stripQuotes(value)
-  if (!unquoted) {
-    return false
-  }
-
-  let path = unquoted
-  if (path.startsWith('file://')) {
-    try {
-      path = fileURLToPath(path)
-    } catch {
-      return false
-    }
-  }
-
-  return isAbsolute(path) && !existsSync(path)
-}
-
-function stripQuotes (value) {
-  const first = value[0]
-  const last = value[value.length - 1]
-
-  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
-    return value.slice(1, -1)
-  }
-
-  return value
-}
-
-function buildStream (filename, workerData, workerOpts, sync, name) {
-  // When pino is loaded during a preload phase (via --import or --require),
-  // pass empty execArgv to prevent infinite spawning. Each worker would
-  // otherwise re-run the preload, creating another transport.
-  if (!workerOpts.execArgv && hasPreloadFlags() && require.main === undefined) {
-    workerOpts = {
-      ...workerOpts,
-      execArgv: []
-    }
-  }
-
-  if (!workerOpts.env && process.env.NODE_OPTIONS) {
-    const nodeOptions = sanitizeNodeOptions(process.env.NODE_OPTIONS)
-    if (nodeOptions !== process.env.NODE_OPTIONS) {
-      workerOpts = {
-        ...workerOpts,
-        env: {
-          ...process.env,
-          NODE_OPTIONS: nodeOptions
-        }
-      }
-    }
-  }
-
-  workerOpts = { ...workerOpts, name }
-
-  const stream = new ThreadStream({
-    filename,
-    workerData,
-    workerOpts,
-    sync
-  })
-
-  stream.on('ready', onReady)
-  stream.on('close', function () {
-    process.removeListener('exit', onExit)
-  })
-
-  process.on('exit', onExit)
-
-  function onReady () {
-    process.removeListener('exit', onExit)
-    stream.unref()
-
-    if (workerOpts.autoEnd !== false) {
-      setupOnExit(stream)
-    }
-  }
-
-  function onExit () {
-    /* istanbul ignore next */
-    if (stream.closed) {
-      return
-    }
-    stream.flushSync()
-    // Apparently there is a very sporadic race condition
-    // that in certain OS would prevent the messages to be flushed
-    // because the thread might not have been created still.
-    // Unfortunately we need to sleep(100) in this case.
-    sleep(100)
-    stream.end()
-  }
-
-  return stream
-}
-
-function autoEnd (stream) {
-  stream.ref()
-  stream.flushSync()
-  stream.end()
-  stream.once('close', function () {
-    stream.unref()
-  })
-}
-
-function flush (stream) {
-  stream.flushSync()
-}
-
-function transport (fullOptions) {
-  const { pipeline, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions
-
-  const options = {
-    ...fullOptions.options
-  }
-
-  // Backwards compatibility
-  const callers = typeof caller === 'string' ? [caller] : caller
-
-  // This will be eventually modified by bundlers
-  const bundlerOverrides = (typeof globalThis === 'object' &&
-    Object.prototype.hasOwnProperty.call(globalThis, '__bundlerPathsOverrides') &&
-    globalThis.__bundlerPathsOverrides &&
-    typeof globalThis.__bundlerPathsOverrides === 'object')
-    ? globalThis.__bundlerPathsOverrides
-    : Object.create(null)
-
-  let target = fullOptions.target
-
-  if (target && targets) {
-    throw new Error('only one of target or targets can be specified')
-  }
-
-  if (targets) {
-    target = bundlerOverrides['pino-worker'] || join(__dirname, 'worker.js')
-    options.targets = targets.filter(dest => dest.target).map((dest) => {
-      return {
-        ...dest,
-        target: fixTarget(dest.target)
-      }
-    })
-    options.pipelines = targets.filter(dest => dest.pipeline).map((dest) => {
-      return dest.pipeline.map((t) => {
-        return {
-          ...t,
-          level: dest.level, // duplicate the pipeline `level` property defined in the upper level
-          target: fixTarget(t.target)
-        }
-      })
-    })
-  } else if (pipeline) {
-    target = bundlerOverrides['pino-worker'] || join(__dirname, 'worker.js')
-    options.pipelines = [pipeline.map((dest) => {
-      return {
-        ...dest,
-        target: fixTarget(dest.target)
-      }
-    })]
-  }
-
-  if (levels) {
-    options.levels = levels
-  }
-
-  if (dedupe) {
-    options.dedupe = dedupe
-  }
-
-  options.pinoWillSendConfig = true
-
-  const name = (targets || pipeline) ? 'pino.transport' : target
-  return buildStream(fixTarget(target), options, worker, sync, name)
-
-  function fixTarget (origin) {
-    origin = bundlerOverrides[origin] || origin
-
-    if (isAbsolute(origin) || origin.indexOf('file://') === 0) {
-      return origin
-    }
-
-    if (origin === 'pino/file') {
-      return join(__dirname, '..', 'file.js')
-    }
-
-    let fixTarget
-
-    for (const filePath of callers) {
-      try {
-        const context = filePath === 'node:repl'
-          ? process.cwd() + sep
-          : filePath
-
-        fixTarget = createRequire(context).resolve(origin)
-        break
-      } catch (err) {
-        // Silent catch
-        continue
-      }
-    }
-
-    if (!fixTarget) {
-      throw new Error(`unable to determine transport target for "${origin}"`)
-    }
-
-    return fixTarget
-  }
-}
-
-module.exports = transport

package/node_modules/pino/lib/worker.js

@@ -1,194 +0,0 @@
-'use strict'
-
-const EE = require('node:events')
-const { pipeline, PassThrough } = require('node:stream')
-const pino = require('../pino.js')
-const build = require('pino-abstract-transport')
-const loadTransportStreamBuilder = require('./transport-stream')
-
-// This file is not checked by the code coverage tool,
-// as it is not reliable.
-
-/* istanbul ignore file */
-
-/*
- * > Multiple targets & pipelines
- *
- *
- * ┌─────────────────────────────────────────────────┐    ┌─────┐
- * │                                                 │    │  p  │
- * │                                                 │    │  i  │
- * │                   target                        │    │  n  │
- * │               │ ────────────────────────────────┼────┤  o  │
- * │   targets     │   target                        │    │  .  │
- * │ ────────────► │ ────────────────────────────────┼────┤  m  │       source
- * │               │   target                        │    │  u  │         │
- * │               │ ────────────────────────────────┼────┤  l  │         │write
- * │               │                                 │    │  t  │         ▼
- * │               │  pipeline   ┌───────────────┐   │    │  i  │      ┌────────┐
- * │               │ ──────────► │  PassThrough  ├───┼────┤  s  ├──────┤        │
- * │               │             └───────────────┘   │    │  t  │ write│ Thread │
- * │               │                                 │    │  r  │◄─────┤ Stream │
- * │               │  pipeline   ┌───────────────┐   │    │  e  │      │        │
- * │               │ ──────────► │  PassThrough  ├───┼────┤  a  │      └────────┘
- * │                             └───────────────┘   │    │  m  │
- * │                                                 │    │     │
- * └─────────────────────────────────────────────────┘    └─────┘
- *
- *
- *
- *  > One single pipeline or target
- *
- *
- *                                                           source
- *                                                             │
- * ┌────────────────────────────────────────────────┐          │write
- * │                                                │          ▼
- * │                                                │      ┌────────┐
- * │   targets     │   target                       │      │        │
- * │ ────────────► │  ──────────────────────────────┤      │        │
- * │               │                                │      │        │
- * │                                                ├──────┤        │
- * │                                                │      │        │
- * │                                                │      │        │
- * │                     OR                         │      │        │
- * │                                                │      │        │
- * │                                                │      │        │
- * │                               ┌──────────────┐ │      │        │
- * │   targets     │   pipeline    │              │ │      │ Thread │
- * │ ────────────► │  ────────────►│ PassThrough  ├─┤      │ Stream │
- * │               │               │              │ │      │        │
- * │                               └──────────────┘ │      │        │
- * │                                                │      │        │
- * │                     OR                         │ write│        │
- * │                                                │◄─────┤        │
- * │                                                │      │        │
- * │                ┌──────────────┐                │      │        │
- * │    pipeline    │              │                │      │        │
- * │ ──────────────►│ PassThrough  ├────────────────┤      │        │
- * │                │              │                │      │        │
- * │                └──────────────┘                │      └────────┘
- * │                                                │
- * │                                                │
- * └────────────────────────────────────────────────┘
- */
-
-module.exports = async function ({ targets, pipelines, levels, dedupe }) {
-  const targetStreams = []
-
-  // Process targets
-  if (targets && targets.length) {
-    targets = await Promise.all(targets.map(async (t) => {
-      const fn = await loadTransportStreamBuilder(t.target)
-      const stream = await fn(t.options)
-      return {
-        level: t.level,
-        stream
-      }
-    }))
-
-    targetStreams.push(...targets)
-  }
-
-  // Process pipelines
-  if (pipelines && pipelines.length) {
-    pipelines = await Promise.all(
-      pipelines.map(async (p) => {
-        let level
-        const pipeDests = await Promise.all(
-          p.map(async (t) => {
-            // level assigned to pipeline is duplicated over all its targets, just store it
-            level = t.level
-            const fn = await loadTransportStreamBuilder(t.target)
-            const stream = await fn(t.options)
-            return stream
-          }
-          ))
-
-        return {
-          level,
-          stream: createPipeline(pipeDests)
-        }
-      })
-    )
-    targetStreams.push(...pipelines)
-  }
-
-  // Skip building the multistream step if either one single pipeline or target is defined and
-  // return directly the stream instance back to TreadStream.
-  // This is equivalent to define either:
-  //
-  // pino.transport({ target: ... })
-  //
-  // OR
-  //
-  // pino.transport({ pipeline: ... })
-  if (targetStreams.length === 1) {
-    return targetStreams[0].stream
-  } else {
-    return build(process, {
-      parse: 'lines',
-      metadata: true,
-      close (err, cb) {
-        let expected = 0
-        for (const transport of targetStreams) {
-          expected++
-          transport.stream.on('close', closeCb)
-          transport.stream.end()
-        }
-
-        function closeCb () {
-          if (--expected === 0) {
-            cb(err)
-          }
-        }
-      }
-    })
-  }
-
-  // TODO: Why split2 was not used for pipelines?
-  function process (stream) {
-    const multi = pino.multistream(targetStreams, { levels, dedupe })
-    // TODO manage backpressure
-    stream.on('data', function (chunk) {
-      const { lastTime, lastMsg, lastObj, lastLevel } = this
-      multi.lastLevel = lastLevel
-      multi.lastTime = lastTime
-      multi.lastMsg = lastMsg
-      multi.lastObj = lastObj
-
-      // TODO handle backpressure
-      multi.write(chunk + '\n')
-    })
-  }
-
-  /**
- * Creates a pipeline using the provided streams and return an instance of `PassThrough` stream
- * as a source for the pipeline.
- *
- * @param {(TransformStream|WritableStream)[]} streams An array of streams.
- *   All intermediate streams in the array *MUST* be `Transform` streams and only the last one `Writable`.
- * @returns A `PassThrough` stream instance representing the source stream of the pipeline
- */
-  function createPipeline (streams) {
-    const ee = new EE()
-    const stream = new PassThrough({
-      autoDestroy: true,
-      destroy (_, cb) {
-        ee.on('error', cb)
-        ee.on('closed', cb)
-      }
-    })
-
-    pipeline(stream, ...streams, function (err) {
-      if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
-        ee.emit('error', err)
-        return
-      }
-
-      ee.emit('closed')
-    })
-
-    return stream
-  }
-}

package/node_modules/pino/package.json

@@ -1,120 +0,0 @@
-{
-  "name": "pino",
-  "version": "10.3.1",
-  "description": "super fast, all natural json logger",
-  "main": "pino.js",
-  "type": "commonjs",
-  "types": "pino.d.ts",
-  "browser": "./browser.js",
-  "scripts": {
-    "borp": "borp --timeout 60000 --coverage --check-coverage --lines 95 --functions 95 --branches 95 --statements 95",
-    "docs": "docsify serve",
-    "browser-test": "airtap --local 8080 test/browser*test.js",
-    "lint": "eslint .",
-    "prepublishOnly": "node test/internals/version.test.js",
-    "test": "npm run lint && npm run transpile && npm run borp && jest test/jest && npm run test-types",
-    "test-ci": "npm run lint && npm run transpile && npm run borp && npm run test-types",
-    "test-ci-pnpm": "pnpm run lint && npm run transpile && borp --timeout 60000 && pnpm run test-types",
-    "test-ci-yarn-pnp": "yarn run lint && npm run transpile && borp --timeout 60000",
-    "test-types": "tsc && tsd && ts-node test/types/pino.ts && attw --pack .",
-    "test:smoke": "smoker smoke:pino && smoker smoke:browser && smoker smoke:file",
-    "smoke:pino": "node ./pino.js",
-    "smoke:browser": "node ./browser.js",
-    "smoke:file": "node ./file.js",
-    "transpile": "node ./test/fixtures/ts/transpile.cjs",
-    "cov-ui": "tap --ts --coverage-report=html",
-    "bench": "node benchmarks/utils/runbench all",
-    "bench-basic": "node benchmarks/utils/runbench basic",
-    "bench-object": "node benchmarks/utils/runbench object",
-    "bench-deep-object": "node benchmarks/utils/runbench deep-object",
-    "bench-multi-arg": "node benchmarks/utils/runbench multi-arg",
-    "bench-long-string": "node benchmarks/utils/runbench long-string",
-    "bench-child": "node benchmarks/utils/runbench child",
-    "bench-child-child": "node benchmarks/utils/runbench child-child",
-    "bench-child-creation": "node benchmarks/utils/runbench child-creation",
-    "bench-formatters": "node benchmarks/utils/runbench formatters",
-    "update-bench-doc": "node benchmarks/utils/generate-benchmark-doc > docs/benchmarks.md"
-  },
-  "bin": {
-    "pino": "./bin.js"
-  },
-  "precommit": "test",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/pinojs/pino.git"
-  },
-  "keywords": [
-    "fast",
-    "logger",
-    "stream",
-    "json"
-  ],
-  "author": "Matteo Collina <hello@matteocollina.com>",
-  "contributors": [
-    "David Mark Clements <huperekchuno@googlemail.com>",
-    "James Sumners <james.sumners@gmail.com>",
-    "Thomas Watson Steen <w@tson.dk> (https://twitter.com/wa7son)"
-  ],
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/pinojs/pino/issues"
-  },
-  "homepage": "https://getpino.io",
-  "devDependencies": {
-    "@arethetypeswrong/cli": "^0.18.1",
-    "@matteo.collina/tspl": "^0.2.0",
-    "@types/flush-write-stream": "^1.0.0",
-    "@types/node": "^25.0.3",
-    "airtap": "5.0.0",
-    "bole": "^5.0.5",
-    "borp": "^0.21.0",
-    "bunyan": "^1.8.14",
-    "debug": "^4.3.4",
-    "docsify-cli": "^4.4.4",
-    "eslint": "^9.37.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-n": "17.23.2",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^6.0.0",
-    "execa": "^5.0.0",
-    "fastbench": "^1.0.1",
-    "flush-write-stream": "^2.0.0",
-    "import-fresh": "^3.2.1",
-    "jest": "^30.0.3",
-    "log": "^6.0.0",
-    "loglevel": "^1.6.7",
-    "midnight-smoker": "1.1.1",
-    "neostandard": "^0.12.2",
-    "pino-pretty": "^13.0.0",
-    "pre-commit": "^1.2.2",
-    "proxyquire": "^2.1.3",
-    "pump": "^3.0.0",
-    "rimraf": "^6.0.1",
-    "semver": "^7.3.7",
-    "split2": "^4.0.0",
-    "steed": "^1.1.3",
-    "strip-ansi": "^6.0.0",
-    "tape": "^5.5.3",
-    "through2": "^4.0.0",
-    "ts-node": "^10.9.1",
-    "tsd": "^0.33.0",
-    "typescript": "~5.9.2",
-    "winston": "^3.7.2"
-  },
-  "dependencies": {
-    "atomic-sleep": "^1.0.0",
-    "on-exit-leak-free": "^2.1.0",
-    "pino-abstract-transport": "^3.0.0",
-    "pino-std-serializers": "^7.0.0",
-    "process-warning": "^5.0.0",
-    "quick-format-unescaped": "^4.0.3",
-    "real-require": "^0.2.0",
-    "safe-stable-stringify": "^2.3.1",
-    "@pinojs/redact": "^0.4.0",
-    "sonic-boom": "^4.0.1",
-    "thread-stream": "^4.0.0"
-  },
-  "tsd": {
-    "directory": "test/types"
-  }
-}