@zuplo/cli 7.4.7 → 7.5.0

package/node_modules/@zuplo/editor/node_modules/pino-pretty/help/help.txt

@@ -1,68 +0,0 @@
-  Usage: pino-pretty [options] [command]
-  
-  Commands:
-    help     Display help
-    version  Display version
-  
-  Options:
-    -c, --colorize              Force adding color sequences to the output
-    -C, --config                specify a path to a json file containing the pino-pretty options
-    -f, --crlf                  Append CRLF instead of LF to formatted lines
-    -X, --customColors          Override default colors using names from https://www.npmjs.com/package/colorette (`-X err:red,info:blue`)
-    -x, --customLevels          Override default levels (`-x err:99,info:1`)
-    -k, --errorLikeObjectKeys   Define which keys contain error objects (`-k err,error`) (defaults to `err,error`)
-    -e, --errorProps            Comma separated list of properties on error objects to show (`*` for all properties) (defaults to ``)
-    -h, --help                  Output usage information
-    -H, --hideObject            Hide objects from output (but not error object)
-    -i, --ignore                Ignore one or several keys: (`-i time,hostname`)
-    -I, --include               The opposite of `--ignore`, only include one or several keys: (`-I level,time`)
-    -l, --levelFirst            Display the log level as the first output field
-    -L, --levelKey [value]      Detect the log level under the specified key (defaults to "level")
-    -b, --levelLabel [value]    Output the log level using the specified label (defaults to "levelLabel")
-    -o, --messageFormat         Format output of message
-    -m, --messageKey [value]    Highlight the message under the specified key (defaults to "msg")
-    -L, --minimumLevel          Hide messages below the specified log level
-    -S, --singleLine            Print all non-error objects on a single line
-    -a, --timestampKey [value]  Display the timestamp from the specified key (defaults to "time")
-    -t, --translateTime         Display epoch timestamps as UTC ISO format or according to an optional format string (default ISO 8601)
-    -U, --useOnlyCustomProps    Only use custom levels and colors (if provided); don't fallback to default levels and colors (-U false)
-    -v, --version               Output the version number
-  
-  Examples:
-    - To prettify logs, simply pipe a log file through
-    $ cat log | pino-pretty
-
-    - To highlight a string at a key other than 'msg'
-    $ cat log | pino-pretty -m fooMessage
-
-    - To detect the log level at a key other than 'level'
-    $ cat log | pino-pretty --levelKey fooLevel
-
-    - To output the log level label using a key other than 'levelLabel'
-    $ cat log | pino-pretty --levelLabel LVL -o "{LVL}"
-
-    - To display timestamp from a key other than 'time'
-    $ cat log | pino-pretty -a fooTimestamp
-
-    - To convert Epoch timestamps to ISO timestamps use the -t option
-    $ cat log | pino-pretty -t
-
-    - To convert Epoch timestamps to local timezone format use the -t option with "SYS:" prefixed format string
-    $ cat log | pino-pretty -t "SYS:yyyy-mm-dd HH:MM:ss"
-
-    - To flip level and time/date in standard output use the -l option
-    $ cat log | pino-pretty -l
-
-    - Only prints messages with a minimum log level of info
-    $ cat log | pino-pretty -L info
-
-    - Prettify logs but don't print pid and hostname
-    $ cat log | pino-pretty -i pid,hostname
-    
-    - Prettify logs but only print time and level
-    $ cat log | pino-pretty -I time,level
-
-    - Loads options from a config file
-    $ cat log | pino-pretty --config=/path/to/config.json
-
-  

package/node_modules/@zuplo/editor/node_modules/pino-pretty/index.d.ts

@@ -1,234 +0,0 @@
-// Type definitions for pino-pretty 7.0
-// Project: https://github.com/pinojs/pino-pretty#readme
-// Definitions by: Adam Vigneaux <https://github.com/AdamVig>
-//                 tearwyx <https://github.com/tearwyx>
-// Minimum TypeScript Version: 3.0
-
-/// <reference types="node" />
-
-import { Transform } from 'stream';
-import { OnUnknown } from 'pino-abstract-transport';
-// @ts-ignore fall back to any if pino is not available, i.e. when running pino tests
-import { DestinationStream, Level } from 'pino';
-import * as Colorette from "colorette";
-
-type LogDescriptor = Record<string, unknown>;
-
-declare function PinoPretty(options?: PinoPretty.PrettyOptions): PinoPretty.PrettyStream;
-declare namespace PinoPretty {
-
-  function colorizerFactory(
-    useColors?: boolean,
-    customColors?: [number, string][],
-    useOnlyCustomProps?: boolean,
-  ): {
-    (
-      level?: number | string,
-      opts?: {
-        customLevels?: { [level: number]: string };
-        customLevelNames?: { [name: string]: number };
-      },
-    ): string,
-    message: (input: string | number) => string,
-    greyMessage: (input: string | number) => string,
-  }
-
-  function prettyFactory(options: PrettyOptions): (inputData: any) => string
-
-  interface PrettyOptions {
-    /**
-     * Hide objects from output (but not error object).
-     * @default false
-     */
-    hideObject?: boolean;
-    /**
-     * Translate the epoch time value into a human readable date and time string. This flag also can set the format
-     * string to apply when translating the date to human readable format. For a list of available pattern letters
-     * see the {@link https://www.npmjs.com/package/dateformat|dateformat documentation}.
-     * - The default format is `yyyy-mm-dd HH:MM:ss.l o` in UTC.
-     * - Requires a `SYS:` prefix to translate time to the local system's timezone. Use the shortcut `SYS:standard`
-     *   to translate time to `yyyy-mm-dd HH:MM:ss.l o` in system timezone.
-     * @default false
-     */
-    translateTime?: boolean | string;
-    /**
-     * If set to true, it will print the name of the log level as the first field in the log line.
-     * @default false
-     */
-    levelFirst?: boolean;
-    /**
-     * Define the key that contains the level of the log.
-     * @default "level"
-     */
-    levelKey?: string;
-    /**
-     * Output the log level using the specified label.
-     * @default "levelLabel"
-     */
-    levelLabel?: string;
-    /**
-     * The key in the JSON object to use as the highlighted message.
-     * @default "msg"
-     *
-     * Not required when used with pino >= 8.21.0
-     */
-    messageKey?: string;
-    /**
-     * Print each log message on a single line (errors will still be multi-line).
-     * @default false
-     */
-    singleLine?: boolean;
-    /**
-     * The key in the JSON object to use for timestamp display.
-     * @default "time"
-     */
-    timestampKey?: string;
-    /**
-     * The minimum log level to include in the output.
-     * @default "trace"
-     */
-    minimumLevel?: Level;
-    /**
-     * Format output of message, e.g. {level} - {pid} will output message: INFO - 1123
-     * @default false
-     *
-     * @example
-     * ```typescript
-     * {
-     *   messageFormat: (log, messageKey) => {
-     *     const message = log[messageKey];
-     *     if (log.requestId) return `[${log.requestId}] ${message}`;
-     *     return message;
-     *   }
-     * }
-     * ```
-     */
-    messageFormat?: false | string | MessageFormatFunc;
-    /**
-     * If set to true, will add color information to the formatted output message.
-     * @default false
-     */
-    colorize?: boolean;
-    /**
-     * If set to false while `colorize` is `true`, will output JSON objects without color.
-     * @default true
-     */
-    colorizeObjects?: boolean;
-    /**
-     * Appends carriage return and line feed, instead of just a line feed, to the formatted log line.
-     * @default false
-     */
-    crlf?: boolean;
-    /**
-     * Define the log keys that are associated with error like objects.
-     * @default ["err", "error"]
-     *
-     * Not required to handle custom errorKey when used with pino >= 8.21.0
-     */
-    errorLikeObjectKeys?: string[];
-    /**
-     *  When formatting an error object, display this list of properties.
-     *  The list should be a comma separated list of properties.
-     * @default ""
-     */
-    errorProps?: string;
-    /**
-     * Ignore one or several keys.
-     * Will be overridden by the option include if include is presented.
-     * @example "time,hostname"
-     */
-    ignore?: string;
-    /**
-     * Include one or several keys.
-     * @example "time,level"
-     */
-    include?: string;
-    /**
-     * Makes messaging synchronous.
-     * @default false
-     */
-    sync?: boolean;
-    /**
-     * The file, file descriptor, or stream to write to.  Defaults to 1 (stdout).
-     * @default 1
-     */
-    destination?: string | number | DestinationStream | NodeJS.WritableStream;
-    /**
-     * Opens the file with the 'a' flag.
-     * @default true
-     */
-    append?: boolean;
-    /**
-     * Ensure directory for destination file exists.
-     * @default false
-     */
-    mkdir?: boolean;
-    /**
-     * Provides the ability to add a custom prettify function for specific log properties.
-     * `customPrettifiers` is an object, where keys are log properties that will be prettified
-     * and value is the prettify function itself.
-     * For example, if a log line contains a query property, you can specify a prettifier for it:
-     * @default {}
-     *
-     * @example
-     * ```typescript
-     * {
-     *   customPrettifiers: {
-     *     query: prettifyQuery
-     *   }
-     * }
-     * //...
-     * const prettifyQuery = value => {
-     *  // do some prettify magic
-     * }
-     * ```
-     */
-    customPrettifiers?: Record<string, Prettifier> &
-      {
-        level?: Prettifier<LevelPrettifierExtras>
-      };
-    /**
-     * Change the level names and values to an user custom preset.
-     *
-     * Can be a CSV string in 'level_name:level_value' format or an object.
-     *
-     * @example ( CSV ) customLevels: 'info:10,some_level:40'
-     * @example ( Object ) customLevels: { info: 10, some_level: 40 }
-     *
-     * Not required when used with pino >= 8.21.0
-     */
-    customLevels?: string|object;
-    /**
-     * Change the level colors to an user custom preset.
-     *
-     * Can be a CSV string in 'level_name:color_value' format or an object.
-     * Also supports 'default' as level_name for fallback color.
-     *
-     * @example ( CSV ) customColors: 'info:white,some_level:red'
-     * @example ( Object ) customColors: { info: 'white', some_level: 'red' }
-     */
-    customColors?: string|object;
-    /**
-     * Only use custom levels and colors (if provided); else fallback to default levels and colors.
-     *
-     * @default true
-     */
-    useOnlyCustomProps?: boolean;
-  }
-
-  function build(options: PrettyOptions): PrettyStream;
-
-  type Prettifier<T = object> = (inputData: string | object, key: string, log: object, extras: PrettifierExtras<T>) => string;
-  type PrettifierExtras<T = object> = {colors: Colorette.Colorette} & T;
-  type LevelPrettifierExtras = {label: string, labelColorized: string}
-  type MessageFormatFunc = (log: LogDescriptor, messageKey: string, levelLabel: string, extras: PrettifierExtras) => string;
-  type PrettyStream = Transform & OnUnknown;
-  type ColorizerFactory = typeof colorizerFactory;
-  type PrettyFactory = typeof prettyFactory;
-  type Build = typeof build;
-  type isColorSupported = typeof Colorette.isColorSupported;
-
-  export { build, PinoPretty, PrettyOptions, PrettyStream, colorizerFactory, prettyFactory, isColorSupported };
-}
-
-export = PinoPretty;

package/node_modules/@zuplo/editor/node_modules/pino-pretty/index.js

@@ -1,189 +0,0 @@
-'use strict'
-
-const { isColorSupported } = require('colorette')
-const pump = require('pump')
-const { Transform } = require('stream')
-const abstractTransport = require('pino-abstract-transport')
-const colors = require('./lib/colors')
-const {
-  ERROR_LIKE_KEYS,
-  LEVEL_KEY,
-  LEVEL_LABEL,
-  MESSAGE_KEY,
-  TIMESTAMP_KEY
-} = require('./lib/constants')
-const {
-  buildSafeSonicBoom,
-  parseFactoryOptions
-} = require('./lib/utils')
-const pretty = require('./lib/pretty')
-
-/**
- * @typedef {object} PinoPrettyOptions
- * @property {boolean} [colorize] Indicates if colors should be used when
- * prettifying. The default will be determined by the terminal capabilities at
- * run time.
- * @property {boolean} [colorizeObjects=true] Apply coloring to rendered objects
- * when coloring is enabled.
- * @property {boolean} [crlf=false] End lines with `\r\n` instead of `\n`.
- * @property {string|null} [customColors=null] A comma separated list of colors
- * to use for specific level labels, e.g. `err:red,info:blue`.
- * @property {string|null} [customLevels=null] A comma separated list of user
- * defined level names and numbers, e.g. `err:99,info:1`.
- * @property {CustomPrettifiers} [customPrettifiers={}] A set of prettifier
- * functions to apply to keys defined in this object.
- * @property {K_ERROR_LIKE_KEYS} [errorLikeObjectKeys] A list of string property
- * names to consider as error objects.
- * @property {string} [errorProps=''] A comma separated list of properties on
- * error objects to include in the output.
- * @property {boolean} [hideObject=false] When `true`, data objects will be
- * omitted from the output (except for error objects).
- * @property {string} [ignore='hostname'] A comma separated list of log keys
- * to omit when outputting the prettified log information.
- * @property {undefined|string} [include=undefined] A comma separated list of
- * log keys to include in the prettified log information. Only the keys in this
- * list will be included in the output.
- * @property {boolean} [levelFirst=false] When true, the log level will be the
- * first field in the prettified output.
- * @property {string} [levelKey='level'] The key name in the log data that
- * contains the level value for the log.
- * @property {string} [levelLabel='levelLabel'] Token name to use in
- * `messageFormat` to represent the name of the logged level.
- * @property {null|MessageFormatString|MessageFormatFunction} [messageFormat=null]
- * When a string, defines how the prettified line should be formatted according
- * to defined tokens. When a function, a synchronous function that returns a
- * formatted string.
- * @property {string} [messageKey='msg'] Defines the key in incoming logs that
- * contains the message of the log, if present.
- * @property {undefined|string|number} [minimumLevel=undefined] The minimum
- * level for logs that should be processed. Any logs below this level will
- * be omitted.
- * @property {object} [outputStream=process.stdout] The stream to write
- * prettified log lines to.
- * @property {boolean} [singleLine=false] When `true` any objects, except error
- * objects, in the log data will be printed as a single line instead as multiple
- * lines.
- * @property {string} [timestampKey='time'] Defines the key in incoming logs
- * that contains the timestamp of the log, if present.
- * @property {boolean|string} [translateTime=true] When true, will translate a
- * JavaScript date integer into a human-readable string. If set to a string,
- * it must be a format string.
- * @property {boolean} [useOnlyCustomProps=true] When true, only custom levels
- * and colors will be used if they have been provided.
- */
-
-/**
- * The default options that will be used when prettifying log lines.
- *
- * @type {PinoPrettyOptions}
- */
-const defaultOptions = {
-  colorize: isColorSupported,
-  colorizeObjects: true,
-  crlf: false,
-  customColors: null,
-  customLevels: null,
-  customPrettifiers: {},
-  errorLikeObjectKeys: ERROR_LIKE_KEYS,
-  errorProps: '',
-  hideObject: false,
-  ignore: 'hostname',
-  include: undefined,
-  levelFirst: false,
-  levelKey: LEVEL_KEY,
-  levelLabel: LEVEL_LABEL,
-  messageFormat: null,
-  messageKey: MESSAGE_KEY,
-  minimumLevel: undefined,
-  outputStream: process.stdout,
-  singleLine: false,
-  timestampKey: TIMESTAMP_KEY,
-  translateTime: true,
-  useOnlyCustomProps: true
-}
-
-/**
- * Processes the supplied options and returns a function that accepts log data
- * and produces a prettified log string.
- *
- * @param {PinoPrettyOptions} options Configuration for the prettifier.
- * @returns {LogPrettifierFunc}
- */
-function prettyFactory (options) {
-  const context = parseFactoryOptions(Object.assign({}, defaultOptions, options))
-  return pretty.bind({ ...context, context })
-}
-
-/**
- * @typedef {PinoPrettyOptions} BuildStreamOpts
- * @property {object|number|string} [destination] A destination stream, file
- * descriptor, or target path to a file.
- * @property {boolean} [append]
- * @property {boolean} [mkdir]
- * @property {boolean} [sync=false]
- */
-
-/**
- * Constructs a {@link LogPrettifierFunc} and a stream to which the produced
- * prettified log data will be written.
- *
- * @param {BuildStreamOpts} opts
- * @returns {Transform | (Transform & OnUnknown)}
- */
-function build (opts = {}) {
-  let pretty = prettyFactory(opts)
-  let destination
-  return abstractTransport(function (source) {
-    source.on('message', function pinoConfigListener (message) {
-      if (!message || message.code !== 'PINO_CONFIG') return
-      Object.assign(opts, {
-        messageKey: message.config.messageKey,
-        errorLikeObjectKeys: Array.from(new Set([...(opts.errorLikeObjectKeys || ERROR_LIKE_KEYS), message.config.errorKey])),
-        customLevels: message.config.levels.values
-      })
-      pretty = prettyFactory(opts)
-      source.off('message', pinoConfigListener)
-    })
-    const stream = new Transform({
-      objectMode: true,
-      autoDestroy: true,
-      transform (chunk, enc, cb) {
-        const line = pretty(chunk)
-        cb(null, line)
-      }
-    })
-
-    if (typeof opts.destination === 'object' && typeof opts.destination.write === 'function') {
-      destination = opts.destination
-    } else {
-      destination = buildSafeSonicBoom({
-        dest: opts.destination || 1,
-        append: opts.append,
-        mkdir: opts.mkdir,
-        sync: opts.sync // by default sonic will be async
-      })
-    }
-
-    source.on('unknown', function (line) {
-      destination.write(line + '\n')
-    })
-
-    pump(source, stream, destination)
-    return stream
-  }, {
-    parse: 'lines',
-    close (err, cb) {
-      destination.on('close', () => {
-        cb(err)
-      })
-    }
-  })
-}
-
-module.exports = build
-module.exports.build = build
-module.exports.PinoPretty = build
-module.exports.prettyFactory = prettyFactory
-module.exports.colorizerFactory = colors
-module.exports.isColorSupported = isColorSupported
-module.exports.default = build

package/node_modules/@zuplo/editor/node_modules/pino-pretty/lib/colors.js

@@ -1,129 +0,0 @@
-'use strict'
-
-const nocolor = input => input
-const plain = {
-  default: nocolor,
-  60: nocolor,
-  50: nocolor,
-  40: nocolor,
-  30: nocolor,
-  20: nocolor,
-  10: nocolor,
-  message: nocolor,
-  greyMessage: nocolor
-}
-
-const { createColors } = require('colorette')
-const getLevelLabelData = require('./utils/get-level-label-data')
-const availableColors = createColors({ useColor: true })
-const { white, bgRed, red, yellow, green, blue, gray, cyan } = availableColors
-
-const colored = {
-  default: white,
-  60: bgRed,
-  50: red,
-  40: yellow,
-  30: green,
-  20: blue,
-  10: gray,
-  message: cyan,
-  greyMessage: gray
-}
-
-function resolveCustomColoredColorizer (customColors) {
-  return customColors.reduce(
-    function (agg, [level, color]) {
-      agg[level] = typeof availableColors[color] === 'function' ? availableColors[color] : white
-
-      return agg
-    },
-    { default: white, message: cyan, greyMessage: gray }
-  )
-}
-
-function colorizeLevel (useOnlyCustomProps) {
-  return function (level, colorizer, { customLevels, customLevelNames } = {}) {
-    const [levelStr, levelNum] = getLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames)(level)
-
-    return Object.prototype.hasOwnProperty.call(colorizer, levelNum) ? colorizer[levelNum](levelStr) : colorizer.default(levelStr)
-  }
-}
-
-function plainColorizer (useOnlyCustomProps) {
-  const newPlainColorizer = colorizeLevel(useOnlyCustomProps)
-  const customColoredColorizer = function (level, opts) {
-    return newPlainColorizer(level, plain, opts)
-  }
-  customColoredColorizer.message = plain.message
-  customColoredColorizer.greyMessage = plain.greyMessage
-  customColoredColorizer.colors = createColors({ useColor: false })
-  return customColoredColorizer
-}
-
-function coloredColorizer (useOnlyCustomProps) {
-  const newColoredColorizer = colorizeLevel(useOnlyCustomProps)
-  const customColoredColorizer = function (level, opts) {
-    return newColoredColorizer(level, colored, opts)
-  }
-  customColoredColorizer.message = colored.message
-  customColoredColorizer.greyMessage = colored.greyMessage
-  customColoredColorizer.colors = availableColors
-  return customColoredColorizer
-}
-
-function customColoredColorizerFactory (customColors, useOnlyCustomProps) {
-  const onlyCustomColored = resolveCustomColoredColorizer(customColors)
-  const customColored = useOnlyCustomProps ? onlyCustomColored : Object.assign({}, colored, onlyCustomColored)
-  const colorizeLevelCustom = colorizeLevel(useOnlyCustomProps)
-
-  const customColoredColorizer = function (level, opts) {
-    return colorizeLevelCustom(level, customColored, opts)
-  }
-  customColoredColorizer.colors = availableColors
-  customColoredColorizer.message = customColoredColorizer.message || customColored.message
-  customColoredColorizer.greyMessage = customColoredColorizer.greyMessage || customColored.greyMessage
-
-  return customColoredColorizer
-}
-
-/**
- * Applies colorization, if possible, to a string representing the passed in
- * `level`. For example, the default colorizer will return a "green" colored
- * string for the "info" level.
- *
- * @typedef {function} ColorizerFunc
- * @param {string|number} level In either case, the input will map to a color
- * for the specified level or to the color for `USERLVL` if the level is not
- * recognized.
- * @property {function} message Accepts one string parameter that will be
- * colorized to a predefined color.
- * @property {Colorette.Colorette} colors Available color functions based on `useColor` (or `colorize`) context
- */
-
-/**
- * Factory function get a function to colorized levels. The returned function
- * also includes a `.message(str)` method to colorize strings.
- *
- * @param {boolean} [useColors=false] When `true` a function that applies standard
- * terminal colors is returned.
- * @param {array[]} [customColors] Tuple where first item of each array is the
- * level index and the second item is the color
- * @param {boolean} [useOnlyCustomProps] When `true`, only use the provided
- * custom colors provided and not fallback to default
- *
- * @returns {ColorizerFunc} `function (level) {}` has a `.message(str)` method to
- * apply colorization to a string. The core function accepts either an integer
- * `level` or a `string` level. The integer level will map to a known level
- * string or to `USERLVL` if not known.  The string `level` will map to the same
- * colors as the integer `level` and will also default to `USERLVL` if the given
- * string is not a recognized level name.
- */
-module.exports = function getColorizer (useColors = false, customColors, useOnlyCustomProps) {
-  if (useColors && customColors !== undefined) {
-    return customColoredColorizerFactory(customColors, useOnlyCustomProps)
-  } else if (useColors) {
-    return coloredColorizer(useOnlyCustomProps)
-  }
-
-  return plainColorizer(useOnlyCustomProps)
-}