@zuplo/cli 7.4.7 → 7.5.0

package/node_modules/@zuplo/editor/node_modules/pino/lib/transport.js

@@ -1,167 +0,0 @@
-'use strict'
-
-const { createRequire } = require('module')
-const getCallers = require('./caller')
-const { join, isAbsolute, sep } = require('node:path')
-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)
-  })
-}
-
-function buildStream (filename, workerData, workerOpts, sync) {
-  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 = '__bundlerPathsOverrides' in globalThis ? globalThis.__bundlerPathsOverrides : {}
-
-  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
-
-  return buildStream(fixTarget(target), options, worker, sync)
-
-  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/@zuplo/editor/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/@zuplo/editor/node_modules/pino/package.json

@@ -1,120 +0,0 @@
-{
-  "name": "pino",
-  "version": "10.0.0",
-  "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": "^24.0.8",
-    "airtap": "5.0.0",
-    "bole": "^5.0.5",
-    "borp": "^0.20.2",
-    "bunyan": "^1.8.14",
-    "debug": "^4.3.4",
-    "docsify-cli": "^4.4.4",
-    "eslint": "^8.17.0",
-    "eslint-config-standard": "^17.0.0",
-    "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-n": "15.7.0",
-    "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",
-    "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": "^2.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",
-    "slow-redact": "^0.3.0",
-    "sonic-boom": "^4.0.1",
-    "thread-stream": "^3.0.0"
-  },
-  "tsd": {
-    "directory": "test/types"
-  }
-}