@highstate/designer 0.4.5 → 0.4.6

package/.output/server/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/.output/server/node_modules/pino/package.json

@@ -1,120 +0,0 @@
-{
-  "name": "pino",
-  "version": "9.6.0",
-  "description": "super fast, all natural json logger",
-  "main": "pino.js",
-  "type": "commonjs",
-  "types": "pino.d.ts",
-  "browser": "./browser.js",
-  "scripts": {
-    "docs": "docsify serve",
-    "browser-test": "airtap --local 8080 test/browser*test.js",
-    "lint": "eslint .",
-    "prepublishOnly": "tap --no-check-coverage test/internals/version.test.js",
-    "test": "npm run lint && npm run transpile && tap --ts && jest test/jest && npm run test-types",
-    "test-ci": "npm run lint && npm run transpile && tap --ts --no-check-coverage --coverage-report=lcovonly && npm run test-types",
-    "test-ci-pnpm": "pnpm run lint && npm run transpile && tap --ts --no-coverage --no-check-coverage && pnpm run test-types",
-    "test-ci-yarn-pnp": "yarn run lint && npm run transpile && tap --ts --no-check-coverage --coverage-report=lcovonly",
-    "test-types": "tsc && tsd && ts-node test/types/pino.ts",
-    "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-longs-tring": "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": {
-    "@types/flush-write-stream": "^1.0.0",
-    "@types/node": "^22.0.0",
-    "@types/tap": "^15.0.6",
-    "@yao-pkg/pkg": "6.1.1",
-    "airtap": "5.0.0",
-    "benchmark": "^2.1.4",
-    "bole": "^5.0.5",
-    "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": "^29.0.3",
-    "log": "^6.0.0",
-    "loglevel": "^1.6.7",
-    "midnight-smoker": "1.1.1",
-    "pino-pretty": "^11.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",
-    "tap": "^16.2.0",
-    "tape": "^5.5.3",
-    "through2": "^4.0.0",
-    "ts-node": "^10.9.1",
-    "tsd": "^0.31.0",
-    "typescript": "~5.7.2",
-    "winston": "^3.7.2"
-  },
-  "dependencies": {
-    "atomic-sleep": "^1.0.0",
-    "fast-redact": "^3.1.1",
-    "on-exit-leak-free": "^2.1.0",
-    "pino-abstract-transport": "^2.0.0",
-    "pino-std-serializers": "^7.0.0",
-    "process-warning": "^4.0.0",
-    "quick-format-unescaped": "^4.0.3",
-    "real-require": "^0.2.0",
-    "safe-stable-stringify": "^2.3.1",
-    "sonic-boom": "^4.0.1",
-    "thread-stream": "^3.0.0"
-  },
-  "tsd": {
-    "directory": "test/types"
-  }
-}

package/.output/server/node_modules/pino/pino.js

@@ -1,234 +0,0 @@
-'use strict'
-
-const os = require('node:os')
-const stdSerializers = require('pino-std-serializers')
-const caller = require('./lib/caller')
-const redaction = require('./lib/redaction')
-const time = require('./lib/time')
-const proto = require('./lib/proto')
-const symbols = require('./lib/symbols')
-const { configure } = require('safe-stable-stringify')
-const { assertDefaultLevelFound, mappings, genLsCache, genLevelComparison, assertLevelComparison } = require('./lib/levels')
-const { DEFAULT_LEVELS, SORTING_ORDER } = require('./lib/constants')
-const {
-  createArgsNormalizer,
-  asChindings,
-  buildSafeSonicBoom,
-  buildFormatters,
-  stringify,
-  normalizeDestFileDescriptor,
-  noop
-} = require('./lib/tools')
-const { version } = require('./lib/meta')
-const {
-  chindingsSym,
-  redactFmtSym,
-  serializersSym,
-  timeSym,
-  timeSliceIndexSym,
-  streamSym,
-  stringifySym,
-  stringifySafeSym,
-  stringifiersSym,
-  setLevelSym,
-  endSym,
-  formatOptsSym,
-  messageKeySym,
-  errorKeySym,
-  nestedKeySym,
-  mixinSym,
-  levelCompSym,
-  useOnlyCustomLevelsSym,
-  formattersSym,
-  hooksSym,
-  nestedKeyStrSym,
-  mixinMergeStrategySym,
-  msgPrefixSym
-} = symbols
-const { epochTime, nullTime } = time
-const { pid } = process
-const hostname = os.hostname()
-const defaultErrorSerializer = stdSerializers.err
-const defaultOptions = {
-  level: 'info',
-  levelComparison: SORTING_ORDER.ASC,
-  levels: DEFAULT_LEVELS,
-  messageKey: 'msg',
-  errorKey: 'err',
-  nestedKey: null,
-  enabled: true,
-  base: { pid, hostname },
-  serializers: Object.assign(Object.create(null), {
-    err: defaultErrorSerializer
-  }),
-  formatters: Object.assign(Object.create(null), {
-    bindings (bindings) {
-      return bindings
-    },
-    level (label, number) {
-      return { level: number }
-    }
-  }),
-  hooks: {
-    logMethod: undefined,
-    streamWrite: undefined
-  },
-  timestamp: epochTime,
-  name: undefined,
-  redact: null,
-  customLevels: null,
-  useOnlyCustomLevels: false,
-  depthLimit: 5,
-  edgeLimit: 100
-}
-
-const normalize = createArgsNormalizer(defaultOptions)
-
-const serializers = Object.assign(Object.create(null), stdSerializers)
-
-function pino (...args) {
-  const instance = {}
-  const { opts, stream } = normalize(instance, caller(), ...args)
-
-  if (opts.level && typeof opts.level === 'string' && DEFAULT_LEVELS[opts.level.toLowerCase()] !== undefined) opts.level = opts.level.toLowerCase()
-
-  const {
-    redact,
-    crlf,
-    serializers,
-    timestamp,
-    messageKey,
-    errorKey,
-    nestedKey,
-    base,
-    name,
-    level,
-    customLevels,
-    levelComparison,
-    mixin,
-    mixinMergeStrategy,
-    useOnlyCustomLevels,
-    formatters,
-    hooks,
-    depthLimit,
-    edgeLimit,
-    onChild,
-    msgPrefix
-  } = opts
-
-  const stringifySafe = configure({
-    maximumDepth: depthLimit,
-    maximumBreadth: edgeLimit
-  })
-
-  const allFormatters = buildFormatters(
-    formatters.level,
-    formatters.bindings,
-    formatters.log
-  )
-
-  const stringifyFn = stringify.bind({
-    [stringifySafeSym]: stringifySafe
-  })
-  const stringifiers = redact ? redaction(redact, stringifyFn) : {}
-  const formatOpts = redact
-    ? { stringify: stringifiers[redactFmtSym] }
-    : { stringify: stringifyFn }
-  const end = '}' + (crlf ? '\r\n' : '\n')
-  const coreChindings = asChindings.bind(null, {
-    [chindingsSym]: '',
-    [serializersSym]: serializers,
-    [stringifiersSym]: stringifiers,
-    [stringifySym]: stringify,
-    [stringifySafeSym]: stringifySafe,
-    [formattersSym]: allFormatters
-  })
-
-  let chindings = ''
-  if (base !== null) {
-    if (name === undefined) {
-      chindings = coreChindings(base)
-    } else {
-      chindings = coreChindings(Object.assign({}, base, { name }))
-    }
-  }
-
-  const time = (timestamp instanceof Function)
-    ? timestamp
-    : (timestamp ? epochTime : nullTime)
-  const timeSliceIndex = time().indexOf(':') + 1
-
-  if (useOnlyCustomLevels && !customLevels) throw Error('customLevels is required if useOnlyCustomLevels is set true')
-  if (mixin && typeof mixin !== 'function') throw Error(`Unknown mixin type "${typeof mixin}" - expected "function"`)
-  if (msgPrefix && typeof msgPrefix !== 'string') throw Error(`Unknown msgPrefix type "${typeof msgPrefix}" - expected "string"`)
-
-  assertDefaultLevelFound(level, customLevels, useOnlyCustomLevels)
-  const levels = mappings(customLevels, useOnlyCustomLevels)
-
-  if (typeof stream.emit === 'function') {
-    stream.emit('message', { code: 'PINO_CONFIG', config: { levels, messageKey, errorKey } })
-  }
-
-  assertLevelComparison(levelComparison)
-  const levelCompFunc = genLevelComparison(levelComparison)
-
-  Object.assign(instance, {
-    levels,
-    [levelCompSym]: levelCompFunc,
-    [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
-    [streamSym]: stream,
-    [timeSym]: time,
-    [timeSliceIndexSym]: timeSliceIndex,
-    [stringifySym]: stringify,
-    [stringifySafeSym]: stringifySafe,
-    [stringifiersSym]: stringifiers,
-    [endSym]: end,
-    [formatOptsSym]: formatOpts,
-    [messageKeySym]: messageKey,
-    [errorKeySym]: errorKey,
-    [nestedKeySym]: nestedKey,
-    // protect against injection
-    [nestedKeyStrSym]: nestedKey ? `,${JSON.stringify(nestedKey)}:{` : '',
-    [serializersSym]: serializers,
-    [mixinSym]: mixin,
-    [mixinMergeStrategySym]: mixinMergeStrategy,
-    [chindingsSym]: chindings,
-    [formattersSym]: allFormatters,
-    [hooksSym]: hooks,
-    silent: noop,
-    onChild,
-    [msgPrefixSym]: msgPrefix
-  })
-
-  Object.setPrototypeOf(instance, proto())
-
-  genLsCache(instance)
-
-  instance[setLevelSym](level)
-
-  return instance
-}
-
-module.exports = pino
-
-module.exports.destination = (dest = process.stdout.fd) => {
-  if (typeof dest === 'object') {
-    dest.dest = normalizeDestFileDescriptor(dest.dest || process.stdout.fd)
-    return buildSafeSonicBoom(dest)
-  } else {
-    return buildSafeSonicBoom({ dest: normalizeDestFileDescriptor(dest), minLength: 0 })
-  }
-}
-
-module.exports.transport = require('./lib/transport')
-module.exports.multistream = require('./lib/multistream')
-
-module.exports.levels = mappings()
-module.exports.stdSerializers = serializers
-module.exports.stdTimeFunctions = Object.assign({}, time)
-module.exports.symbols = symbols
-module.exports.version = version
-
-// Enables default and name export with TypeScript and Babel
-module.exports.default = pino
-module.exports.pino = pino

package/.output/server/node_modules/pino-abstract-transport/index.js

@@ -1,128 +0,0 @@
-'use strict'
-
-const metadata = Symbol.for('pino.metadata')
-const split = require('split2')
-const { Duplex } = require('stream')
-const { parentPort, workerData } = require('worker_threads')
-
-function createDeferred () {
-  let resolve
-  let reject
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  })
-  promise.resolve = resolve
-  promise.reject = reject
-  return promise
-}
-
-module.exports = function build (fn, opts = {}) {
-  const waitForConfig = opts.expectPinoConfig === true && workerData?.workerData?.pinoWillSendConfig === true
-  const parseLines = opts.parse === 'lines'
-  const parseLine = typeof opts.parseLine === 'function' ? opts.parseLine : JSON.parse
-  const close = opts.close || defaultClose
-  const stream = split(function (line) {
-    let value
-
-    try {
-      value = parseLine(line)
-    } catch (error) {
-      this.emit('unknown', line, error)
-      return
-    }
-
-    if (value === null) {
-      this.emit('unknown', line, 'Null value ignored')
-      return
-    }
-
-    if (typeof value !== 'object') {
-      value = {
-        data: value,
-        time: Date.now()
-      }
-    }
-
-    if (stream[metadata]) {
-      stream.lastTime = value.time
-      stream.lastLevel = value.level
-      stream.lastObj = value
-    }
-
-    if (parseLines) {
-      return line
-    }
-
-    return value
-  }, { autoDestroy: true })
-
-  stream._destroy = function (err, cb) {
-    const promise = close(err, cb)
-    if (promise && typeof promise.then === 'function') {
-      promise.then(cb, cb)
-    }
-  }
-
-  if (opts.expectPinoConfig === true && workerData?.workerData?.pinoWillSendConfig !== true) {
-    setImmediate(() => {
-      stream.emit('error', new Error('This transport is not compatible with the current version of pino. Please upgrade pino to the latest version.'))
-    })
-  }
-
-  if (opts.metadata !== false) {
-    stream[metadata] = true
-    stream.lastTime = 0
-    stream.lastLevel = 0
-    stream.lastObj = null
-  }
-
-  if (waitForConfig) {
-    let pinoConfig = {}
-    const configReceived = createDeferred()
-    parentPort.on('message', function handleMessage (message) {
-      if (message.code === 'PINO_CONFIG') {
-        pinoConfig = message.config
-        configReceived.resolve()
-        parentPort.off('message', handleMessage)
-      }
-    })
-
-    Object.defineProperties(stream, {
-      levels: {
-        get () { return pinoConfig.levels }
-      },
-      messageKey: {
-        get () { return pinoConfig.messageKey }
-      },
-      errorKey: {
-        get () { return pinoConfig.errorKey }
-      }
-    })
-
-    return configReceived.then(finish)
-  }
-
-  return finish()
-
-  function finish () {
-    let res = fn(stream)
-
-    if (res && typeof res.catch === 'function') {
-      res.catch((err) => {
-        stream.destroy(err)
-      })
-
-      // set it to null to not retain a reference to the promise
-      res = null
-    } else if (opts.enablePipelining && res) {
-      return Duplex.from({ writable: stream, readable: res })
-    }
-
-    return stream
-  }
-}
-
-function defaultClose (err, cb) {
-  process.nextTick(cb, err)
-}