@farthershore/cli 0.3.10 → 0.3.12

package/node_modules/pino/lib/levels.js

@@ -1,241 +0,0 @@
-'use strict'
-/* eslint no-prototype-builtins: 0 */
-const {
-  lsCacheSym,
-  levelValSym,
-  useOnlyCustomLevelsSym,
-  streamSym,
-  formattersSym,
-  hooksSym,
-  levelCompSym
-} = require('./symbols')
-const { noop, genLog } = require('./tools')
-const { DEFAULT_LEVELS, SORTING_ORDER } = require('./constants')
-
-const levelMethods = {
-  fatal: (hook) => {
-    const logFatal = genLog(DEFAULT_LEVELS.fatal, hook)
-    return function (...args) {
-      const stream = this[streamSym]
-      logFatal.call(this, ...args)
-      if (typeof stream.flushSync === 'function') {
-        try {
-          stream.flushSync()
-        } catch (e) {
-          // https://github.com/pinojs/pino/pull/740#discussion_r346788313
-        }
-      }
-    }
-  },
-  error: (hook) => genLog(DEFAULT_LEVELS.error, hook),
-  warn: (hook) => genLog(DEFAULT_LEVELS.warn, hook),
-  info: (hook) => genLog(DEFAULT_LEVELS.info, hook),
-  debug: (hook) => genLog(DEFAULT_LEVELS.debug, hook),
-  trace: (hook) => genLog(DEFAULT_LEVELS.trace, hook)
-}
-
-const nums = Object.keys(DEFAULT_LEVELS).reduce((o, k) => {
-  o[DEFAULT_LEVELS[k]] = k
-  return o
-}, {})
-
-const initialLsCache = Object.keys(nums).reduce((o, k) => {
-  o[k] = '{"level":' + Number(k)
-  return o
-}, {})
-
-function genLsCache (instance) {
-  const formatter = instance[formattersSym].level
-  const { labels } = instance.levels
-  const cache = {}
-  for (const label in labels) {
-    const level = formatter(labels[label], Number(label))
-    cache[label] = JSON.stringify(level).slice(0, -1)
-  }
-  instance[lsCacheSym] = cache
-  return instance
-}
-
-function isStandardLevel (level, useOnlyCustomLevels) {
-  if (useOnlyCustomLevels) {
-    return false
-  }
-
-  switch (level) {
-    case 'fatal':
-    case 'error':
-    case 'warn':
-    case 'info':
-    case 'debug':
-    case 'trace':
-      return true
-    default:
-      return false
-  }
-}
-
-function setLevel (level) {
-  const { labels, values } = this.levels
-  if (typeof level === 'number') {
-    if (labels[level] === undefined) throw Error('unknown level value' + level)
-    level = labels[level]
-  }
-  if (values[level] === undefined) throw Error('unknown level ' + level)
-  const preLevelVal = this[levelValSym]
-  const levelVal = this[levelValSym] = values[level]
-  const useOnlyCustomLevelsVal = this[useOnlyCustomLevelsSym]
-  const levelComparison = this[levelCompSym]
-  const hook = this[hooksSym].logMethod
-
-  for (const key in values) {
-    if (levelComparison(values[key], levelVal) === false) {
-      this[key] = noop
-      continue
-    }
-    this[key] = isStandardLevel(key, useOnlyCustomLevelsVal) ? levelMethods[key](hook) : genLog(values[key], hook)
-  }
-
-  this.emit(
-    'level-change',
-    level,
-    levelVal,
-    labels[preLevelVal],
-    preLevelVal,
-    this
-  )
-}
-
-function getLevel (level) {
-  const { levels, levelVal } = this
-  // protection against potential loss of Pino scope from serializers (edge case with circular refs - https://github.com/pinojs/pino/issues/833)
-  return (levels && levels.labels) ? levels.labels[levelVal] : ''
-}
-
-function isLevelEnabled (logLevel) {
-  const { values } = this.levels
-  const logLevelVal = values[logLevel]
-  return logLevelVal !== undefined && this[levelCompSym](logLevelVal, this[levelValSym])
-}
-
-/**
- * Determine if the given `current` level is enabled by comparing it
- * against the current threshold (`expected`).
- *
- * @param {SORTING_ORDER} direction comparison direction "ASC" or "DESC"
- * @param {number} current current log level number representation
- * @param {number} expected threshold value to compare with
- * @returns {boolean}
- */
-function compareLevel (direction, current, expected) {
-  if (direction === SORTING_ORDER.DESC) {
-    return current <= expected
-  }
-
-  return current >= expected
-}
-
-/**
- * Create a level comparison function based on `levelComparison`
- * it could a default function which compares levels either in "ascending" or "descending" order or custom comparison function
- *
- * @param {SORTING_ORDER | Function} levelComparison sort levels order direction or custom comparison function
- * @returns Function
- */
-function genLevelComparison (levelComparison) {
-  if (typeof levelComparison === 'string') {
-    return compareLevel.bind(null, levelComparison)
-  }
-
-  return levelComparison
-}
-
-function mappings (customLevels = null, useOnlyCustomLevels = false) {
-  const customNums = customLevels
-    /* eslint-disable */
-    ? Object.keys(customLevels).reduce((o, k) => {
-        o[customLevels[k]] = k
-        return o
-      }, {})
-    : null
-    /* eslint-enable */
-
-  const labels = Object.assign(
-    Object.create(Object.prototype, { Infinity: { value: 'silent' } }),
-    useOnlyCustomLevels ? null : nums,
-    customNums
-  )
-  const values = Object.assign(
-    Object.create(Object.prototype, { silent: { value: Infinity } }),
-    useOnlyCustomLevels ? null : DEFAULT_LEVELS,
-    customLevels
-  )
-  return { labels, values }
-}
-
-function assertDefaultLevelFound (defaultLevel, customLevels, useOnlyCustomLevels) {
-  if (typeof defaultLevel === 'number') {
-    const values = [].concat(
-      Object.keys(customLevels || {}).map(key => customLevels[key]),
-      useOnlyCustomLevels ? [] : Object.keys(nums).map(level => +level),
-      Infinity
-    )
-    if (!values.includes(defaultLevel)) {
-      throw Error(`default level:${defaultLevel} must be included in custom levels`)
-    }
-    return
-  }
-
-  const labels = Object.assign(
-    Object.create(Object.prototype, { silent: { value: Infinity } }),
-    useOnlyCustomLevels ? null : DEFAULT_LEVELS,
-    customLevels
-  )
-  if (!(defaultLevel in labels)) {
-    throw Error(`default level:${defaultLevel} must be included in custom levels`)
-  }
-}
-
-function assertNoLevelCollisions (levels, customLevels) {
-  const { labels, values } = levels
-  for (const k in customLevels) {
-    if (k in values) {
-      throw Error('levels cannot be overridden')
-    }
-    if (customLevels[k] in labels) {
-      throw Error('pre-existing level values cannot be used for new levels')
-    }
-  }
-}
-
-/**
- * Validates whether `levelComparison` is correct
- *
- * @throws Error
- * @param {SORTING_ORDER | Function} levelComparison - value to validate
- * @returns
- */
-function assertLevelComparison (levelComparison) {
-  if (typeof levelComparison === 'function') {
-    return
-  }
-
-  if (typeof levelComparison === 'string' && Object.values(SORTING_ORDER).includes(levelComparison)) {
-    return
-  }
-
-  throw new Error('Levels comparison should be one of "ASC", "DESC" or "function" type')
-}
-
-module.exports = {
-  initialLsCache,
-  genLsCache,
-  levelMethods,
-  getLevel,
-  setLevel,
-  isLevelEnabled,
-  mappings,
-  assertNoLevelCollisions,
-  assertDefaultLevelFound,
-  genLevelComparison,
-  assertLevelComparison
-}

package/node_modules/pino/lib/meta.js

@@ -1,3 +0,0 @@
-'use strict'
-
-module.exports = { version: '10.3.1' }

package/node_modules/pino/lib/multistream.js

@@ -1,203 +0,0 @@
-'use strict'
-
-const metadata = Symbol.for('pino.metadata')
-const { DEFAULT_LEVELS } = require('./constants')
-
-const DEFAULT_INFO_LEVEL = DEFAULT_LEVELS.info
-
-function multistream (streamsArray, opts) {
-  streamsArray = streamsArray || []
-  opts = opts || { dedupe: false }
-
-  const streamLevels = Object.create(DEFAULT_LEVELS)
-  streamLevels.silent = Infinity
-  if (opts.levels && typeof opts.levels === 'object') {
-    Object.keys(opts.levels).forEach(i => {
-      streamLevels[i] = opts.levels[i]
-    })
-  }
-
-  const res = {
-    write,
-    add,
-    remove,
-    emit,
-    flushSync,
-    end,
-    minLevel: 0,
-    lastId: 0,
-    streams: [],
-    clone,
-    [metadata]: true,
-    streamLevels
-  }
-
-  if (Array.isArray(streamsArray)) {
-    streamsArray.forEach(add, res)
-  } else {
-    add.call(res, streamsArray)
-  }
-
-  // clean this object up
-  // or it will stay allocated forever
-  // as it is closed on the following closures
-  streamsArray = null
-
-  return res
-
-  // we can exit early because the streams are ordered by level
-  function write (data) {
-    let dest
-    const level = this.lastLevel
-    const { streams } = this
-    // for handling situation when several streams has the same level
-    let recordedLevel = 0
-    let stream
-
-    // if dedupe set to true we send logs to the stream with the highest level
-    // therefore, we have to change sorting order
-    for (let i = initLoopVar(streams.length, opts.dedupe); checkLoopVar(i, streams.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe)) {
-      dest = streams[i]
-      if (dest.level <= level) {
-        if (recordedLevel !== 0 && recordedLevel !== dest.level) {
-          break
-        }
-        stream = dest.stream
-        if (stream[metadata]) {
-          const { lastTime, lastMsg, lastObj, lastLogger } = this
-          stream.lastLevel = level
-          stream.lastTime = lastTime
-          stream.lastMsg = lastMsg
-          stream.lastObj = lastObj
-          stream.lastLogger = lastLogger
-        }
-        stream.write(data)
-        if (opts.dedupe) {
-          recordedLevel = dest.level
-        }
-      } else if (!opts.dedupe) {
-        break
-      }
-    }
-  }
-
-  function emit (...args) {
-    for (const { stream } of this.streams) {
-      if (typeof stream.emit === 'function') {
-        stream.emit(...args)
-      }
-    }
-  }
-
-  function flushSync () {
-    for (const { stream } of this.streams) {
-      if (typeof stream.flushSync === 'function') {
-        stream.flushSync()
-      }
-    }
-  }
-
-  function add (dest) {
-    if (!dest) {
-      return res
-    }
-
-    // Check that dest implements either StreamEntry or DestinationStream
-    const isStream = typeof dest.write === 'function' || dest.stream
-    const stream_ = dest.write ? dest : dest.stream
-    // This is necessary to provide a meaningful error message, otherwise it throws somewhere inside write()
-    if (!isStream) {
-      throw Error('stream object needs to implement either StreamEntry or DestinationStream interface')
-    }
-
-    const { streams, streamLevels } = this
-
-    let level
-    if (typeof dest.levelVal === 'number') {
-      level = dest.levelVal
-    } else if (typeof dest.level === 'string') {
-      level = streamLevels[dest.level]
-    } else if (typeof dest.level === 'number') {
-      level = dest.level
-    } else {
-      level = DEFAULT_INFO_LEVEL
-    }
-
-    const dest_ = {
-      stream: stream_,
-      level,
-      levelVal: undefined,
-      id: ++res.lastId
-    }
-
-    streams.unshift(dest_)
-    streams.sort(compareByLevel)
-
-    this.minLevel = streams[0].level
-
-    return res
-  }
-
-  function remove (id) {
-    const { streams } = this
-    const index = streams.findIndex(s => s.id === id)
-
-    if (index >= 0) {
-      streams.splice(index, 1)
-      streams.sort(compareByLevel)
-      this.minLevel = streams.length > 0 ? streams[0].level : -1
-    }
-
-    return res
-  }
-
-  function end () {
-    for (const { stream } of this.streams) {
-      if (typeof stream.flushSync === 'function') {
-        stream.flushSync()
-      }
-      stream.end()
-    }
-  }
-
-  function clone (level) {
-    const streams = new Array(this.streams.length)
-
-    for (let i = 0; i < streams.length; i++) {
-      streams[i] = {
-        level,
-        stream: this.streams[i].stream
-      }
-    }
-
-    return {
-      write,
-      add,
-      remove,
-      minLevel: level,
-      streams,
-      clone,
-      emit,
-      flushSync,
-      [metadata]: true
-    }
-  }
-}
-
-function compareByLevel (a, b) {
-  return a.level - b.level
-}
-
-function initLoopVar (length, dedupe) {
-  return dedupe ? length - 1 : 0
-}
-
-function adjustLoopVar (i, dedupe) {
-  return dedupe ? i - 1 : i + 1
-}
-
-function checkLoopVar (i, length, dedupe) {
-  return dedupe ? i >= 0 : i < length
-}
-
-module.exports = multistream

package/node_modules/pino/lib/proto.js

@@ -1,256 +0,0 @@
-'use strict'
-
-/* eslint no-prototype-builtins: 0 */
-
-const { EventEmitter } = require('node:events')
-const {
-  lsCacheSym,
-  levelValSym,
-  setLevelSym,
-  getLevelSym,
-  chindingsSym,
-  mixinSym,
-  asJsonSym,
-  writeSym,
-  mixinMergeStrategySym,
-  timeSym,
-  timeSliceIndexSym,
-  streamSym,
-  serializersSym,
-  formattersSym,
-  errorKeySym,
-  messageKeySym,
-  useOnlyCustomLevelsSym,
-  needsMetadataGsym,
-  redactFmtSym,
-  stringifySym,
-  formatOptsSym,
-  stringifiersSym,
-  msgPrefixSym,
-  hooksSym
-} = require('./symbols')
-const {
-  getLevel,
-  setLevel,
-  isLevelEnabled,
-  mappings,
-  initialLsCache,
-  genLsCache,
-  assertNoLevelCollisions
-} = require('./levels')
-const {
-  asChindings,
-  asJson,
-  buildFormatters,
-  stringify,
-  noop
-} = require('./tools')
-const {
-  version
-} = require('./meta')
-const redaction = require('./redaction')
-
-// note: use of class is satirical
-// https://github.com/pinojs/pino/pull/433#pullrequestreview-127703127
-const constructor = class Pino {}
-const prototype = {
-  constructor,
-  child,
-  bindings,
-  setBindings,
-  flush,
-  isLevelEnabled,
-  version,
-  get level () { return this[getLevelSym]() },
-  set level (lvl) { this[setLevelSym](lvl) },
-  get levelVal () { return this[levelValSym] },
-  set levelVal (n) { throw Error('levelVal is read-only') },
-  get msgPrefix () { return this[msgPrefixSym] },
-  get [Symbol.toStringTag] () { return 'Pino' },
-  [lsCacheSym]: initialLsCache,
-  [writeSym]: write,
-  [asJsonSym]: asJson,
-  [getLevelSym]: getLevel,
-  [setLevelSym]: setLevel
-}
-
-Object.setPrototypeOf(prototype, EventEmitter.prototype)
-
-// exporting and consuming the prototype object using factory pattern fixes scoping issues with getters when serializing
-module.exports = function () {
-  return Object.create(prototype)
-}
-
-const resetChildingsFormatter = bindings => bindings
-function child (bindings, options) {
-  if (!bindings) {
-    throw Error('missing bindings for child Pino')
-  }
-  const serializers = this[serializersSym]
-  const formatters = this[formattersSym]
-  const instance = Object.create(this)
-
-  // If an `options` object was not supplied, we can improve
-  // the performance of child creation by skipping
-  // the checks for set options and simply return
-  // a baseline instance.
-  if (options == null) {
-    if (instance[formattersSym].bindings !== resetChildingsFormatter) {
-      instance[formattersSym] = buildFormatters(
-        formatters.level,
-        resetChildingsFormatter,
-        formatters.log
-      )
-    }
-
-    instance[chindingsSym] = asChindings(instance, bindings)
-
-    if (this.onChild !== noop) {
-      this.onChild(instance)
-    }
-
-    return instance
-  }
-
-  if (options.hasOwnProperty('serializers') === true) {
-    instance[serializersSym] = Object.create(null)
-
-    for (const k in serializers) {
-      instance[serializersSym][k] = serializers[k]
-    }
-    const parentSymbols = Object.getOwnPropertySymbols(serializers)
-    /* eslint no-var: off */
-    for (var i = 0; i < parentSymbols.length; i++) {
-      const ks = parentSymbols[i]
-      instance[serializersSym][ks] = serializers[ks]
-    }
-
-    for (const bk in options.serializers) {
-      instance[serializersSym][bk] = options.serializers[bk]
-    }
-    const bindingsSymbols = Object.getOwnPropertySymbols(options.serializers)
-    for (var bi = 0; bi < bindingsSymbols.length; bi++) {
-      const bks = bindingsSymbols[bi]
-      instance[serializersSym][bks] = options.serializers[bks]
-    }
-  } else instance[serializersSym] = serializers
-  if (options.hasOwnProperty('formatters')) {
-    const { level, bindings: chindings, log } = options.formatters
-    instance[formattersSym] = buildFormatters(
-      level || formatters.level,
-      chindings || resetChildingsFormatter,
-      log || formatters.log
-    )
-  } else {
-    instance[formattersSym] = buildFormatters(
-      formatters.level,
-      resetChildingsFormatter,
-      formatters.log
-    )
-  }
-  if (options.hasOwnProperty('customLevels') === true) {
-    assertNoLevelCollisions(this.levels, options.customLevels)
-    instance.levels = mappings(options.customLevels, instance[useOnlyCustomLevelsSym])
-    genLsCache(instance)
-  }
-
-  // redact must place before asChindings and only replace if exist
-  if ((typeof options.redact === 'object' && options.redact !== null) || Array.isArray(options.redact)) {
-    instance.redact = options.redact // replace redact directly
-    const stringifiers = redaction(instance.redact, stringify)
-    const formatOpts = { stringify: stringifiers[redactFmtSym] }
-    instance[stringifySym] = stringify
-    instance[stringifiersSym] = stringifiers
-    instance[formatOptsSym] = formatOpts
-  }
-
-  if (typeof options.msgPrefix === 'string') {
-    instance[msgPrefixSym] = (this[msgPrefixSym] || '') + options.msgPrefix
-  }
-
-  instance[chindingsSym] = asChindings(instance, bindings)
-  if ((options.level !== undefined && options.level !== this.level) || options.hasOwnProperty('customLevels')) {
-    const childLevel = options.level || this.level
-    instance[setLevelSym](childLevel)
-  }
-  this.onChild(instance)
-  return instance
-}
-
-function bindings () {
-  const chindings = this[chindingsSym]
-  const chindingsJson = `{${chindings.substr(1)}}` // at least contains ,"pid":7068,"hostname":"myMac"
-  const bindingsFromJson = JSON.parse(chindingsJson)
-  delete bindingsFromJson.pid
-  delete bindingsFromJson.hostname
-  return bindingsFromJson
-}
-
-function setBindings (newBindings) {
-  const chindings = asChindings(this, newBindings)
-  this[chindingsSym] = chindings
-}
-
-/**
- * Default strategy for creating `mergeObject` from arguments and the result from `mixin()`.
- * Fields from `mergeObject` have higher priority in this strategy.
- *
- * @param {Object} mergeObject The object a user has supplied to the logging function.
- * @param {Object} mixinObject The result of the `mixin` method.
- * @return {Object}
- */
-function defaultMixinMergeStrategy (mergeObject, mixinObject) {
-  return Object.assign(mixinObject, mergeObject)
-}
-
-function write (_obj, msg, num) {
-  const t = this[timeSym]()
-  const mixin = this[mixinSym]
-  const errorKey = this[errorKeySym]
-  const messageKey = this[messageKeySym]
-  const mixinMergeStrategy = this[mixinMergeStrategySym] || defaultMixinMergeStrategy
-  let obj
-  const streamWriteHook = this[hooksSym].streamWrite
-
-  if (_obj === undefined || _obj === null) {
-    obj = {}
-  } else if (_obj instanceof Error) {
-    obj = { [errorKey]: _obj }
-    if (msg === undefined) {
-      msg = _obj.message
-    }
-  } else {
-    obj = _obj
-    if (msg === undefined && _obj[messageKey] === undefined && _obj[errorKey]) {
-      msg = _obj[errorKey].message
-    }
-  }
-
-  if (mixin) {
-    obj = mixinMergeStrategy(obj, mixin(obj, num, this))
-  }
-
-  const s = this[asJsonSym](obj, msg, num, t)
-
-  const stream = this[streamSym]
-  if (stream[needsMetadataGsym] === true) {
-    stream.lastLevel = num
-    stream.lastObj = obj
-    stream.lastMsg = msg
-    stream.lastTime = t.slice(this[timeSliceIndexSym])
-    stream.lastLogger = this // for child loggers
-  }
-  stream.write(streamWriteHook ? streamWriteHook(s) : s)
-}
-
-function flush (cb) {
-  if (cb != null && typeof cb !== 'function') {
-    throw Error('callback must be a function')
-  }
-
-  const stream = this[streamSym]
-
-  if (typeof stream.flush === 'function') {
-    stream.flush(cb || noop)
-  } else if (cb) cb()
-}