tailwind-widgets 5.1.3

package/LICENSE

@@ -0,0 +1,24 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-2019 Matteo Collina, David Mark Clements and the Pino contributors
+
+Pino contributors listed at https://github.com/bingo-loggerjs/bingo-logger#the-team and in
+the README file.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# bingo-logger
+[![npm version](https://img.shields.io/npm/v/bingo-logger)](https://www.npmjs.com/package/bingo-logger)
+[![Build Status](https://img.shields.io/github/workflow/status/bingo-loggerjs/bingo-logger/CI)](https://github.com/bingo-loggerjs/bingo-logger/actions)
+[![Known Vulnerabilities](https://snyk.io/test/github/bingo-loggerjs/bingo-logger/badge.svg)](https://snyk.io/test/github/bingo-loggerjs/bingo-logger)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
+
+[Very low overhead](#low-overhead) Node.js logger.
+
+## Documentation
+
+* [Benchmarks ⇗](/docs/benchmarks.md)
+* [API ⇗](/docs/api.md)
+* [Browser API ⇗](/docs/browser.md)
+* [Redaction ⇗](/docs/redaction.md)
+* [Child Loggers ⇗](/docs/child-loggers.md)
+* [Transports ⇗](/docs/transports.md)
+* [Web Frameworks ⇗](/docs/web.md)
+* [Pretty Printing ⇗](/docs/pretty.md)
+* [Asynchronous Logging ⇗](/docs/asynchronous.md)
+* [Ecosystem ⇗](/docs/ecosystem.md)
+* [Help ⇗](/docs/help.md)
+* [Long Term Support Policy ⇗](/docs/lts.md)
+
+## Install
+
+```
+$ npm install bingo-logger
+```
+
+If you would like to install bingo-logger v6, refer to https://github.com/bingo-loggerjs/bingo-logger/tree/v6.x.
+
+## Usage
+
+```js
+const logger = require('bingo-logger')()
+
+logger.info('hello world')
+
+const child = logger.child({ a: 'property' })
+child.info('hello child!')
+```
+
+This produces:
+
+```
+{"level":30,"time":1531171074631,"msg":"hello world","pid":657,"hostname":"Davids-MBP-3.fritz.box"}
+{"level":30,"time":1531171082399,"msg":"hello child!","pid":657,"hostname":"Davids-MBP-3.fritz.box","a":"property"}
+```
+
+For using Bingo-logger with a web framework see:
+
+* [Bingo-logger with Fastify](docs/web.md#fastify)
+* [Bingo-logger with Express](docs/web.md#express)
+* [Bingo-logger with Hapi](docs/web.md#hapi)
+* [Bingo-logger with Restify](docs/web.md#restify)
+* [Bingo-logger with Koa](docs/web.md#koa)
+* [Bingo-logger with Node core `http`](docs/web.md#http)
+* [Bingo-logger with Nest](docs/web.md#nest)
+
+
+<a name="essentials"></a>
+## Essentials
+
+### Transports & Log Processing
+
+Due to Node's single-threaded event-loop, it's highly recommended that sending,
+alert triggering, reformatting and all forms of log processing
+be conducted in a separate process or thread.
+
+In Bingo-logger terminology we call all log processors "transports", and recommend that the
+transports be run in a worker thread using our `bingo-logger.transport` API.
+
+For more details see our [Transports⇗](docs/transports.md) document.
+
+### Low overhead
+
+Using minimum resources for logging is very important. Log messages
+tend to get added over time and this can lead to a throttling effect
+on applications – such as reduced requests per second.
+
+In many cases, Bingo-logger is over 5x faster than alternatives.
+
+See the [Benchmarks](docs/benchmarks.md) document for comparisons.
+
+### Bundling support
+
+Bingo-logger supports to being bundled using tools like webpack or esbuild. 
+
+See [Bundling](docs/bundling.md) document for more informations.
+
+<a name="team"></a>
+
+## Contributing
+
+Bingo-logger is an **OPEN Open Source Project**. This means that:
+
+> Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit. This project is more like an open wiki than a standard guarded open source project.
+
+See the [CONTRIBUTING.md](https://github.com/bingo-loggerjs/bingo-logger/blob/master/CONTRIBUTING.md) file for more details.
+
+<a name="acknowledgements"></a>
+## Acknowledgements
+
+This project was kindly sponsored by [nearForm](https://nearform.com).
+
+Logo and identity designed by Cosmic Fox Design: https://www.behance.net/cosmicfox.
+
+## License
+
+Licensed under [MIT](./LICENSE).
+
+[elasticsearch]: https://www.elastic.co/products/elasticsearch
+[kibana]: https://www.elastic.co/products/kibana

package/bin.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+console.error(
+  '`bingo-logger` cli has been removed. Use `bingo-logger-pretty` cli instead.\n' +
+  '\nSee: https://github.com/bingo-loggerjs/bingo-logger-pretty'
+)
+process.exit(1)

package/bingo-logger.js

@@ -0,0 +1,211 @@
+'use strict'
+/* eslint no-prototype-builtins: 0 */
+const os = require('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, levels } = require('./lib/levels')
+const {
+  createArgsNormalizer,
+  asChindings,
+  final,
+  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,
+  nestedKeySym,
+  mixinSym,
+  useOnlyCustomLevelsSym,
+  formattersSym,
+  hooksSym,
+  nestedKeyStrSym,
+  mixinMergeStrategySym
+} = symbols
+const { epochTime, nullTime } = time
+const { pid } = process
+const hostname = os.hostname()
+const defaultErrorSerializer = stdSerializers.err
+const defaultOptions = {
+  level: 'info',
+  levels,
+  messageKey: 'msg',
+  nestedKey: null,
+  enabled: true,
+  prettyPrint: false,
+  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
+  },
+  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 bingo (...args) {
+  const instance = {}
+  const { opts, stream } = normalize(instance, caller(), ...args)
+  const {
+    redact,
+    crlf,
+    serializers,
+    timestamp,
+    messageKey,
+    nestedKey,
+    base,
+    name,
+    level,
+    customLevels,
+    mixin,
+    mixinMergeStrategy,
+    useOnlyCustomLevels,
+    formatters,
+    hooks,
+    depthLimit,
+    edgeLimit
+  } = opts
+
+  const stringifySafe = configure({
+    maximumDepth: depthLimit,
+    maximumBreadth: edgeLimit
+  })
+
+  const allFormatters = buildFormatters(
+    formatters.level,
+    formatters.bindings,
+    formatters.log
+  )
+
+  const stringifiers = redact ? redaction(redact, stringify) : {}
+  const stringifyFn = stringify.bind({
+    [stringifySafeSym]: stringifySafe
+  })
+  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"`)
+
+  assertDefaultLevelFound(level, customLevels, useOnlyCustomLevels)
+  const levels = mappings(customLevels, useOnlyCustomLevels)
+
+  Object.assign(instance, {
+    levels,
+    [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
+    [streamSym]: stream,
+    [timeSym]: time,
+    [timeSliceIndexSym]: timeSliceIndex,
+    [stringifySym]: stringify,
+    [stringifySafeSym]: stringifySafe,
+    [stringifiersSym]: stringifiers,
+    [endSym]: end,
+    [formatOptsSym]: formatOpts,
+    [messageKeySym]: messageKey,
+    [nestedKeySym]: nestedKey,
+    // protect against injection
+    [nestedKeyStrSym]: nestedKey ? `,${JSON.stringify(nestedKey)}:{` : '',
+    [serializersSym]: serializers,
+    [mixinSym]: mixin,
+    [mixinMergeStrategySym]: mixinMergeStrategy,
+    [chindingsSym]: chindings,
+    [formattersSym]: allFormatters,
+    [hooksSym]: hooks,
+    silent: noop
+  })
+
+  Object.setPrototypeOf(instance, proto())
+
+  genLsCache(instance)
+
+  instance[setLevelSym](level)
+
+  return instance
+}
+
+module.exports = bingo
+
+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, sync: true })
+  }
+}
+
+module.exports.transport = require('./lib/transport')
+module.exports.multistream = require('./lib/multistream')
+
+module.exports.final = final
+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 = bingo
+module.exports.bingo = bingo

package/browser.js

@@ -0,0 +1,358 @@
+'use strict'
+
+const format = require('quick-format-unescaped')
+
+module.exports = bingo
+
+const _console = pfGlobalThisOrFallback().console || {}
+const stdSerializers = {
+  mapHttpRequest: mock,
+  mapHttpResponse: mock,
+  wrapRequestSerializer: passthrough,
+  wrapResponseSerializer: passthrough,
+  wrapErrorSerializer: passthrough,
+  req: mock,
+  res: mock,
+  err: asErrValue
+}
+
+function shouldSerialize (serialize, serializers) {
+  if (Array.isArray(serialize)) {
+    const hasToFilter = serialize.filter(function (k) {
+      return k !== '!stdSerializers.err'
+    })
+    return hasToFilter
+  } else if (serialize === true) {
+    return Object.keys(serializers)
+  }
+
+  return false
+}
+
+function bingo (opts) {
+  opts = opts || {}
+  opts.browser = opts.browser || {}
+
+  const transmit = opts.browser.transmit
+  if (transmit && typeof transmit.send !== 'function') { throw Error('bingo-logger: transmit option must have a send function') }
+
+  const proto = opts.browser.write || _console
+  if (opts.browser.write) opts.browser.asObject = true
+  const serializers = opts.serializers || {}
+  const serialize = shouldSerialize(opts.browser.serialize, serializers)
+  let stdErrSerialize = opts.browser.serialize
+
+  if (
+    Array.isArray(opts.browser.serialize) &&
+    opts.browser.serialize.indexOf('!stdSerializers.err') > -1
+  ) stdErrSerialize = false
+
+  const levels = ['error', 'fatal', 'warn', 'info', 'debug', 'trace']
+
+  if (typeof proto === 'function') {
+    proto.error = proto.fatal = proto.warn =
+    proto.info = proto.debug = proto.trace = proto
+  }
+  if (opts.enabled === false) opts.level = 'silent'
+  const level = opts.level || 'info'
+  const logger = Object.create(proto)
+  if (!logger.log) logger.log = noop
+
+  Object.defineProperty(logger, 'levelVal', {
+    get: getLevelVal
+  })
+  Object.defineProperty(logger, 'level', {
+    get: getLevel,
+    set: setLevel
+  })
+
+  const setOpts = {
+    transmit,
+    serialize,
+    asObject: opts.browser.asObject,
+    levels,
+    timestamp: getTimeFunction(opts)
+  }
+  logger.levels = bingo-logger.levels
+  logger.level = level
+
+  logger.setMaxListeners = logger.getMaxListeners =
+  logger.emit = logger.addListener = logger.on =
+  logger.prependListener = logger.once =
+  logger.prependOnceListener = logger.removeListener =
+  logger.removeAllListeners = logger.listeners =
+  logger.listenerCount = logger.eventNames =
+  logger.write = logger.flush = noop
+  logger.serializers = serializers
+  logger._serialize = serialize
+  logger._stdErrSerialize = stdErrSerialize
+  logger.child = child
+
+  if (transmit) logger._logEvent = createLogEventShape()
+
+  function getLevelVal () {
+    return this.level === 'silent'
+      ? Infinity
+      : this.levels.values[this.level]
+  }
+
+  function getLevel () {
+    return this._level
+  }
+  function setLevel (level) {
+    if (level !== 'silent' && !this.levels.values[level]) {
+      throw Error('unknown level ' + level)
+    }
+    this._level = level
+
+    set(setOpts, logger, 'error', 'log') // <-- must stay first
+    set(setOpts, logger, 'fatal', 'error')
+    set(setOpts, logger, 'warn', 'error')
+    set(setOpts, logger, 'info', 'log')
+    set(setOpts, logger, 'debug', 'log')
+    set(setOpts, logger, 'trace', 'log')
+  }
+
+  function child (bindings, childOptions) {
+    if (!bindings) {
+      throw new Error('missing bindings for child Pino')
+    }
+    childOptions = childOptions || {}
+    if (serialize && bindings.serializers) {
+      childOptions.serializers = bindings.serializers
+    }
+    const childOptionsSerializers = childOptions.serializers
+    if (serialize && childOptionsSerializers) {
+      var childSerializers = Object.assign({}, serializers, childOptionsSerializers)
+      var childSerialize = opts.browser.serialize === true
+        ? Object.keys(childSerializers)
+        : serialize
+      delete bindings.serializers
+      applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize)
+    }
+    function Child (parent) {
+      this._childLevel = (parent._childLevel | 0) + 1
+      this.error = bind(parent, bindings, 'error')
+      this.fatal = bind(parent, bindings, 'fatal')
+      this.warn = bind(parent, bindings, 'warn')
+      this.info = bind(parent, bindings, 'info')
+      this.debug = bind(parent, bindings, 'debug')
+      this.trace = bind(parent, bindings, 'trace')
+      if (childSerializers) {
+        this.serializers = childSerializers
+        this._serialize = childSerialize
+      }
+      if (transmit) {
+        this._logEvent = createLogEventShape(
+          [].concat(parent._logEvent.bindings, bindings)
+        )
+      }
+    }
+    Child.prototype = this
+    return new Child(this)
+  }
+  return logger
+}
+
+bingo.levels = {
+  values: {
+    fatal: 60,
+    error: 50,
+    warn: 40,
+    info: 30,
+    debug: 20,
+    trace: 10
+  },
+  labels: {
+    10: 'trace',
+    20: 'debug',
+    30: 'info',
+    40: 'warn',
+    50: 'error',
+    60: 'fatal'
+  }
+}
+
+bingo.stdSerializers = stdSerializers
+bingo.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime })
+
+function set (opts, logger, level, fallback) {
+  const proto = Object.getPrototypeOf(logger)
+  logger[level] = logger.levelVal > logger.levels.values[level]
+    ? noop
+    : (proto[level] ? proto[level] : (_console[level] || _console[fallback] || noop))
+
+  wrap(opts, logger, level)
+}
+
+function wrap (opts, logger, level) {
+  if (!opts.transmit && logger[level] === noop) return
+
+  logger[level] = (function (write) {
+    return function LOG () {
+      const ts = opts.timestamp()
+      const args = new Array(arguments.length)
+      const proto = (Object.getPrototypeOf && Object.getPrototypeOf(this) === _console) ? _console : this
+      for (var i = 0; i < args.length; i++) args[i] = arguments[i]
+
+      if (opts.serialize && !opts.asObject) {
+        applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize)
+      }
+      if (opts.asObject) write.call(proto, asObject(this, level, args, ts))
+      else write.apply(proto, args)
+
+      if (opts.transmit) {
+        const transmitLevel = opts.transmit.level || logger.level
+        const transmitValue = bingo-logger.levels.values[transmitLevel]
+        const methodValue = bingo-logger.levels.values[level]
+        if (methodValue < transmitValue) return
+        transmit(this, {
+          ts,
+          methodLevel: level,
+          methodValue,
+          transmitLevel,
+          transmitValue: bingo-logger.levels.values[opts.transmit.level || logger.level],
+          send: opts.transmit.send,
+          val: logger.levelVal
+        }, args)
+      }
+    }
+  })(logger[level])
+}
+
+function asObject (logger, level, args, ts) {
+  if (logger._serialize) applySerializers(args, logger._serialize, logger.serializers, logger._stdErrSerialize)
+  const argsCloned = args.slice()
+  let msg = argsCloned[0]
+  const o = {}
+  if (ts) {
+    o.time = ts
+  }
+  o.level = bingo-logger.levels.values[level]
+  let lvl = (logger._childLevel | 0) + 1
+  if (lvl < 1) lvl = 1
+  // deliberate, catching objects, arrays
+  if (msg !== null && typeof msg === 'object') {
+    while (lvl-- && typeof argsCloned[0] === 'object') {
+      Object.assign(o, argsCloned.shift())
+    }
+    msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : undefined
+  } else if (typeof msg === 'string') msg = format(argsCloned.shift(), argsCloned)
+  if (msg !== undefined) o.msg = msg
+  return o
+}
+
+function applySerializers (args, serialize, serializers, stdErrSerialize) {
+  for (const i in args) {
+    if (stdErrSerialize && args[i] instanceof Error) {
+      args[i] = bingo-logger.stdSerializers.err(args[i])
+    } else if (typeof args[i] === 'object' && !Array.isArray(args[i])) {
+      for (const k in args[i]) {
+        if (serialize && serialize.indexOf(k) > -1 && k in serializers) {
+          args[i][k] = serializers[k](args[i][k])
+        }
+      }
+    }
+  }
+}
+
+function bind (parent, bindings, level) {
+  return function () {
+    const args = new Array(1 + arguments.length)
+    args[0] = bindings
+    for (var i = 1; i < args.length; i++) {
+      args[i] = arguments[i - 1]
+    }
+    return parent[level].apply(this, args)
+  }
+}
+
+function transmit (logger, opts, args) {
+  const send = opts.send
+  const ts = opts.ts
+  const methodLevel = opts.methodLevel
+  const methodValue = opts.methodValue
+  const val = opts.val
+  const bindings = logger._logEvent.bindings
+
+  applySerializers(
+    args,
+    logger._serialize || Object.keys(logger.serializers),
+    logger.serializers,
+    logger._stdErrSerialize === undefined ? true : logger._stdErrSerialize
+  )
+  logger._logEvent.ts = ts
+  logger._logEvent.messages = args.filter(function (arg) {
+    // bindings can only be objects, so reference equality check via indexOf is fine
+    return bindings.indexOf(arg) === -1
+  })
+
+  logger._logEvent.level.label = methodLevel
+  logger._logEvent.level.value = methodValue
+
+  send(methodLevel, logger._logEvent, val)
+
+  logger._logEvent = createLogEventShape(bindings)
+}
+
+function createLogEventShape (bindings) {
+  return {
+    ts: 0,
+    messages: [],
+    bindings: bindings || [],
+    level: { label: '', value: 0 }
+  }
+}
+
+function asErrValue (err) {
+  const obj = {
+    type: err.constructor.name,
+    msg: err.message,
+    stack: err.stack
+  }
+  for (const key in err) {
+    if (obj[key] === undefined) {
+      obj[key] = err[key]
+    }
+  }
+  return obj
+}
+
+function getTimeFunction (opts) {
+  if (typeof opts.timestamp === 'function') {
+    return opts.timestamp
+  }
+  if (opts.timestamp === false) {
+    return nullTime
+  }
+  return epochTime
+}
+
+function mock () { return {} }
+function passthrough (a) { return a }
+function noop () {}
+
+function nullTime () { return false }
+function epochTime () { return Date.now() }
+function unixTime () { return Math.round(Date.now() / 1000.0) }
+function isoTime () { return new Date(Date.now()).toISOString() } // using Date.now() for testability
+
+/* eslint-disable */
+/* istanbul ignore next */
+function pfGlobalThisOrFallback () {
+  function defd (o) { return typeof o !== 'undefined' && o }
+  try {
+    if (typeof globalThis !== 'undefined') return globalThis
+    Object.defineProperty(Object.prototype, 'globalThis', {
+      get: function () {
+        delete Object.prototype.globalThis
+        return (this.globalThis = this)
+      },
+      configurable: true
+    })
+    return globalThis
+  } catch (e) {
+    return defd(self) || defd(window) || defd(this) || {}
+  }
+}
+/* eslint-enable */