@veecode-platform/backstage-plugin-about-backend-dynamic 1.0.1

package/node_modules/logform/dist/splat.js

@@ -0,0 +1,143 @@
+'use strict';
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var util = require('util');
+var _require = require('triple-beam'),
+  SPLAT = _require.SPLAT;
+
+/**
+ * Captures the number of format (i.e. %s strings) in a given string.
+ * Based on `util.format`, see Node.js source:
+ * https://github.com/nodejs/node/blob/b1c8f15c5f169e021f7c46eb7b219de95fe97603/lib/util.js#L201-L230
+ * @type {RegExp}
+ */
+var formatRegExp = /%[scdjifoO%]/g;
+
+/**
+ * Captures the number of escaped % signs in a format string (i.e. %s strings).
+ * @type {RegExp}
+ */
+var escapedPercent = /%%/g;
+var Splatter = /*#__PURE__*/function () {
+  function Splatter(opts) {
+    _classCallCheck(this, Splatter);
+    this.options = opts;
+  }
+
+  /**
+     * Check to see if tokens <= splat.length, assign { splat, meta } into the
+     * `info` accordingly, and write to this instance.
+     *
+     * @param  {Info} info Logform info message.
+     * @param  {String[]} tokens Set of string interpolation tokens.
+     * @returns {Info} Modified info message
+     * @private
+     */
+  return _createClass(Splatter, [{
+    key: "_splat",
+    value: function _splat(info, tokens) {
+      var msg = info.message;
+      var splat = info[SPLAT] || info.splat || [];
+      var percents = msg.match(escapedPercent);
+      var escapes = percents && percents.length || 0;
+
+      // The expected splat is the number of tokens minus the number of escapes
+      // e.g.
+      // - { expectedSplat: 3 } '%d %s %j'
+      // - { expectedSplat: 5 } '[%s] %d%% %d%% %s %j'
+      //
+      // Any "meta" will be arugments in addition to the expected splat size
+      // regardless of type. e.g.
+      //
+      // logger.log('info', '%d%% %s %j', 100, 'wow', { such: 'js' }, { thisIsMeta: true });
+      // would result in splat of four (4), but only three (3) are expected. Therefore:
+      //
+      // extraSplat = 3 - 4 = -1
+      // metas = [100, 'wow', { such: 'js' }, { thisIsMeta: true }].splice(-1, -1 * -1);
+      // splat = [100, 'wow', { such: 'js' }]
+      var expectedSplat = tokens.length - escapes;
+      var extraSplat = expectedSplat - splat.length;
+      var metas = extraSplat < 0 ? splat.splice(extraSplat, -1 * extraSplat) : [];
+
+      // Now that { splat } has been separated from any potential { meta }. we
+      // can assign this to the `info` object and write it to our format stream.
+      // If the additional metas are **NOT** objects or **LACK** enumerable properties
+      // you are going to have a bad time.
+      var metalen = metas.length;
+      if (metalen) {
+        for (var i = 0; i < metalen; i++) {
+          Object.assign(info, metas[i]);
+        }
+      }
+      info.message = util.format.apply(util, [msg].concat(_toConsumableArray(splat)));
+      return info;
+    }
+
+    /**
+      * Transforms the `info` message by using `util.format` to complete
+      * any `info.message` provided it has string interpolation tokens.
+      * If no tokens exist then `info` is immutable.
+      *
+      * @param  {Info} info Logform info message.
+      * @param  {Object} opts Options for this instance.
+      * @returns {Info} Modified info message
+      */
+  }, {
+    key: "transform",
+    value: function transform(info) {
+      var msg = info.message;
+      var splat = info[SPLAT] || info.splat;
+
+      // No need to process anything if splat is undefined
+      if (!splat || !splat.length) {
+        return info;
+      }
+
+      // Extract tokens, if none available default to empty array to
+      // ensure consistancy in expected results
+      var tokens = msg && msg.match && msg.match(formatRegExp);
+
+      // This condition will take care of inputs with info[SPLAT]
+      // but no tokens present
+      if (!tokens && (splat || splat.length)) {
+        var metas = splat.length > 1 ? splat.splice(0) : splat;
+
+        // Now that { splat } has been separated from any potential { meta }. we
+        // can assign this to the `info` object and write it to our format stream.
+        // If the additional metas are **NOT** objects or **LACK** enumerable properties
+        // you are going to have a bad time.
+        var metalen = metas.length;
+        if (metalen) {
+          for (var i = 0; i < metalen; i++) {
+            Object.assign(info, metas[i]);
+          }
+        }
+        return info;
+      }
+      if (tokens) {
+        return this._splat(info, tokens);
+      }
+      return info;
+    }
+  }]);
+}();
+/*
+ * function splat (info)
+ * Returns a new instance of the splat format TransformStream
+ * which performs string interpolation from `info` objects. This was
+ * previously exposed implicitly in `winston < 3.0.0`.
+ */
+module.exports = function (opts) {
+  return new Splatter(opts);
+};

package/node_modules/logform/dist/timestamp.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var fecha = require('fecha');
+var format = require('./format');
+
+/*
+ * function timestamp (info)
+ * Returns a new instance of the timestamp Format which adds a timestamp
+ * to the info. It was previously available in winston < 3.0.0 as:
+ *
+ * - { timestamp: true }             // `new Date.toISOString()`
+ * - { timestamp: function:String }  // Value returned by `timestamp()`
+ */
+module.exports = format(function (info) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (opts.format) {
+    info.timestamp = typeof opts.format === 'function' ? opts.format() : fecha.format(new Date(), opts.format);
+  }
+  if (!info.timestamp) {
+    info.timestamp = new Date().toISOString();
+  }
+  if (opts.alias) {
+    info[opts.alias] = info.timestamp;
+  }
+  return info;
+});

package/node_modules/logform/dist/uncolorize.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var colors = require('@colors/colors/safe');
+var format = require('./format');
+var _require = require('triple-beam'),
+  MESSAGE = _require.MESSAGE;
+
+/*
+ * function uncolorize (info)
+ * Returns a new instance of the uncolorize Format that strips colors
+ * from `info` objects. This was previously exposed as { stripColors: true }
+ * to transports in `winston < 3.0.0`.
+ */
+module.exports = format(function (info, opts) {
+  if (opts.level !== false) {
+    info.level = colors.strip(info.level);
+  }
+  if (opts.message !== false) {
+    info.message = colors.strip(String(info.message));
+  }
+  if (opts.raw !== false && info[MESSAGE]) {
+    info[MESSAGE] = colors.strip(String(info[MESSAGE]));
+  }
+  return info;
+});

package/node_modules/logform/errors.js

@@ -0,0 +1,41 @@
+/* eslint no-undefined: 0 */
+'use strict';
+
+const format = require('./format');
+const { LEVEL, MESSAGE } = require('triple-beam');
+
+/*
+ * function errors (info)
+ * If the `message` property of the `info` object is an instance of `Error`,
+ * replace the `Error` object its own `message` property.
+ *
+ * Optionally, the Error's `stack` and/or `cause` properties can also be appended to the `info` object.
+ */
+module.exports = format((einfo, { stack, cause }) => {
+  if (einfo instanceof Error) {
+    const info = Object.assign({}, einfo, {
+      level: einfo.level,
+      [LEVEL]: einfo[LEVEL] || einfo.level,
+      message: einfo.message,
+      [MESSAGE]: einfo[MESSAGE] || einfo.message
+    });
+
+    if (stack) info.stack = einfo.stack;
+    if (cause) info.cause = einfo.cause;
+    return info;
+  }
+
+  if (!(einfo.message instanceof Error)) return einfo;
+
+  // Assign all enumerable properties and the
+  // message property from the error provided.
+  const err = einfo.message;
+  Object.assign(einfo, err);
+  einfo.message = err.message;
+  einfo[MESSAGE] = err.message;
+
+  // Assign the stack and/or cause if requested.
+  if (stack) einfo.stack = err.stack;
+  if (cause) einfo.cause = err.cause;
+  return einfo;
+});

package/node_modules/logform/format.js

@@ -0,0 +1,52 @@
+'use strict';
+
+/*
+ * Displays a helpful message and the source of
+ * the format when it is invalid.
+ */
+class InvalidFormatError extends Error {
+  constructor(formatFn) {
+    super(`Format functions must be synchronous taking a two arguments: (info, opts)
+Found: ${formatFn.toString().split('\n')[0]}\n`);
+
+    Error.captureStackTrace(this, InvalidFormatError);
+  }
+}
+
+/*
+ * function format (formatFn)
+ * Returns a create function for the `formatFn`.
+ */
+module.exports = formatFn => {
+  if (formatFn.length > 2) {
+    throw new InvalidFormatError(formatFn);
+  }
+
+  /*
+   * function Format (options)
+   * Base prototype which calls a `_format`
+   * function and pushes the result.
+   */
+  function Format(options = {}) {
+    this.options = options;
+  }
+
+  Format.prototype.transform = formatFn;
+
+  //
+  // Create a function which returns new instances of
+  // FormatWrap for simple syntax like:
+  //
+  // require('winston').formats.json();
+  //
+  function createFormatWrap(opts) {
+    return new Format(opts);
+  }
+
+  //
+  // Expose the FormatWrap through the create function
+  // for testability.
+  //
+  createFormatWrap.Format = Format;
+  return createFormatWrap;
+};

package/node_modules/logform/index.d.ts

@@ -0,0 +1,201 @@
+// Type definitions for logform 2.x
+// Project: https://github.com/winstonjs/logform
+// Definitions by: DABH <https://github.com/DABH>
+// Definitions: https://github.com/winstonjs/logform
+// TypeScript Version: 2.2
+import {LEVEL, MESSAGE, SPLAT} from 'triple-beam'
+
+export interface TransformableInfo {
+  level: string;
+  message: unknown;
+  [LEVEL]?: string;
+  [MESSAGE]?: unknown;
+  [SPLAT]?: unknown;
+  [key: string | symbol]: unknown;
+}
+
+export type TransformFunction = (info: TransformableInfo, opts?: unknown) => TransformableInfo | boolean;
+export type Colors = { [key: string]: string | string[] }; // tslint:disable-line interface-over-type-literal
+export type FormatWrap = (opts?: unknown) => Format;
+
+export class Format {
+  constructor(opts?: object);
+
+  options?: object;
+  transform: TransformFunction;
+}
+
+export class Colorizer extends Format {
+  constructor(opts?: object);
+
+  createColorize: (opts?: object) => Colorizer;
+  addColors: (colors: Colors) => Colors;
+  colorize: (level: string, message: string) => string;
+}
+
+export function format(transform: TransformFunction): FormatWrap;
+
+export function levels(config: object): object;
+
+export namespace format {
+  function align(): Format;
+  function cli(opts?: CliOptions): Format;
+  function colorize(opts?: ColorizeOptions): Colorizer;
+  function combine(...formats: Format[]): Format;
+  function errors(opts?: object): Format;
+  function json(opts?: JsonOptions): Format;
+  function label(opts?: LabelOptions): Format;
+  function logstash(): Format;
+  function metadata(opts?: MetadataOptions): Format;
+  function ms(): Format;
+  function padLevels(opts?: PadLevelsOptions): Format;
+  function prettyPrint(opts?: PrettyPrintOptions): Format;
+  function printf(templateFunction: (info: TransformableInfo) => string): Format;
+  function simple(): Format;
+  function splat(): Format;
+  function timestamp(opts?: TimestampOptions): Format;
+  function uncolorize(opts?: UncolorizeOptions): Format;
+}
+
+export interface CliOptions extends ColorizeOptions, PadLevelsOptions { }
+
+export interface ColorizeOptions {
+  /**
+   * If set to `true` the color will be applied to the `level`.
+   */
+  level?: boolean;
+  /**
+   * If set to `true` the color will be applied to the `message` and `level`.
+   */
+  all?: boolean;
+  /**
+   * If set to `true` the color will be applied to the `message`.
+   */
+  message?: boolean;
+  /**
+   * An object containing the colors for the log levels. For example: `{ info: 'blue', error: 'red' }`.
+   */
+  colors?: Record<string, string | string[]>;
+}
+
+export interface JsonOptions {
+  /**
+   * A function that influences how the `info` is stringified.
+   */
+  replacer?: (this: unknown, key: string, value: unknown) => unknown;
+  /**
+   * The number of white space used to format the json.
+   */
+  space?: number;
+
+  // The following options come from safe-stable-stringify
+  // https://github.com/BridgeAR/safe-stable-stringify/blob/main/index.d.ts
+
+  /**
+   * If `true`, bigint values are converted to a number. Otherwise, they are ignored.
+   * This option is ignored by default as Logform stringifies BigInt in the default replacer.
+   * @default true
+   */
+  bigint?: boolean,
+  /**
+   * Defines the value for circular references.
+   * Set to `undefined`, circular properties are not serialized (array entries are replaced with null).
+   * Set to `Error`, to throw on circular references.
+   * @default "[Circular]"
+   */
+  circularValue?: string | null | TypeErrorConstructor | ErrorConstructor,
+  /**
+   * If `true`, guarantee a deterministic key order instead of relying on the insertion order.
+   * @default true
+   */
+  deterministic?: boolean,
+  /**
+   * Maximum number of entries to serialize per object (at least one).
+   * The serialized output contains information about how many entries have not been serialized.
+   * Ignored properties are counted as well (e.g., properties with symbol values).
+   * Using the array replacer overrules this option.
+   * @default Infinity
+   */
+  maximumBreadth?: number,
+  /**
+   * Maximum number of object nesting levels (at least 1) that will be serialized.
+   * Objects at the maximum level are serialized as `"[Object]"` and arrays as `"[Array]"`.
+   * @default Infinity
+   */
+  maximumDepth?: number,
+}
+
+export interface LabelOptions {
+  /**
+   * A label to be added before the message.
+   */
+  label?: string;
+  /**
+   * If set to `true` the `label` will be added to `info.message`. If set to `false` the `label`
+   * will be added as `info.label`.
+   */
+  message?: boolean;
+}
+
+export interface MetadataOptions {
+  /**
+   * The name of the key used for the metadata object. Defaults to `metadata`.
+   */
+  key?: string;
+  /**
+   * An array of keys that should not be added to the metadata object.
+   */
+  fillExcept?: string[];
+  /**
+   * An array of keys that will be added to the metadata object.
+   */
+  fillWith?: string[];
+}
+
+export interface PadLevelsOptions {
+  /**
+   * Log levels. Defaults to `configs.npm.levels` from [triple-beam](https://github.com/winstonjs/triple-beam)
+   * module.
+   */
+  levels?: Record<string, number>;
+}
+
+export interface PrettyPrintOptions {
+  /**
+   * A `number` that specifies the maximum depth of the `info` object being stringified by
+   * `util.inspect`. Defaults to `2`.
+   */
+  depth?: number;
+  /**
+   * Colorizes the message if set to `true`. Defaults to `false`.
+   */
+  colorize?: boolean;
+}
+
+export interface TimestampOptions {
+  /**
+   * Either the format as a string accepted by the [fecha](https://github.com/taylorhakes/fecha)
+   * module or a function that returns a formatted date. If no format is provided `new
+   * Date().toISOString()` will be used.
+   */
+  format?: string | (() => string);
+  /**
+   * The name of an alias for the timestamp property, that will be added to the `info` object.
+   */
+  alias?: string;
+}
+
+export interface UncolorizeOptions {
+  /**
+   * Disables the uncolorize format for `info.level` if set to `false`.
+   */
+  level?: boolean;
+  /**
+   * Disables the uncolorize format for `info.message` if set to `false`.
+   */
+  message?: boolean;
+  /**
+   * Disables the uncolorize format for `info[MESSAGE]` if set to `false`.
+   */
+  raw?: boolean;
+}

package/node_modules/logform/index.js

@@ -0,0 +1,52 @@
+'use strict';
+
+/*
+ * @api public
+ * @property {function} format
+ * Both the construction method and set of exposed
+ * formats.
+ */
+const format = exports.format = require('./format');
+
+/*
+ * @api public
+ * @method {function} levels
+ * Registers the specified levels with logform.
+ */
+exports.levels = require('./levels');
+
+/*
+ * @api private
+ * method {function} exposeFormat
+ * Exposes a sub-format on the main format object
+ * as a lazy-loaded getter.
+ */
+function exposeFormat(name, requireFormat) {
+  Object.defineProperty(format, name, {
+    get() {
+      return requireFormat();
+    },
+    configurable: true
+  });
+}
+
+//
+// Setup all transports as lazy-loaded getters.
+//
+exposeFormat('align', function () { return require('./align'); });
+exposeFormat('errors', function () { return require('./errors'); });
+exposeFormat('cli', function () { return require('./cli'); });
+exposeFormat('combine', function () { return require('./combine'); });
+exposeFormat('colorize', function () { return require('./colorize'); });
+exposeFormat('json', function () { return require('./json'); });
+exposeFormat('label', function () { return require('./label'); });
+exposeFormat('logstash', function () { return require('./logstash'); });
+exposeFormat('metadata', function () { return require('./metadata'); });
+exposeFormat('ms', function () { return require('./ms'); });
+exposeFormat('padLevels', function () { return require('./pad-levels'); });
+exposeFormat('prettyPrint', function () { return require('./pretty-print'); });
+exposeFormat('printf', function () { return require('./printf'); });
+exposeFormat('simple', function () { return require('./simple'); });
+exposeFormat('splat', function () { return require('./splat'); });
+exposeFormat('timestamp', function () { return require('./timestamp'); });
+exposeFormat('uncolorize', function () { return require('./uncolorize'); });

package/node_modules/logform/json.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const format = require('./format');
+const { MESSAGE } = require('triple-beam');
+const stringify = require('safe-stable-stringify');
+
+/*
+ * function replacer (key, value)
+ * Handles proper stringification of Buffer and bigint output.
+ */
+function replacer(key, value) {
+  // safe-stable-stringify does support BigInt, however, it doesn't wrap the value in quotes.
+  // Leading to a loss in fidelity if the resulting string is parsed.
+  // It would also be a breaking change for logform.
+  if (typeof value === 'bigint')
+    return value.toString();
+  return value;
+}
+
+/*
+ * function json (info)
+ * Returns a new instance of the JSON format that turns a log `info`
+ * object into pure JSON. This was previously exposed as { json: true }
+ * to transports in `winston < 3.0.0`.
+ */
+module.exports = format((info, opts) => {
+  const jsonStringify = stringify.configure(opts);
+  info[MESSAGE] = jsonStringify(info, opts.replacer || replacer, opts.space);
+  return info;
+});

package/node_modules/logform/label.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const format = require('./format');
+
+/*
+ * function label (info)
+ * Returns a new instance of the label Format which adds the specified
+ * `opts.label` before the message. This was previously exposed as
+ * { label: 'my label' } to transports in `winston < 3.0.0`.
+ */
+module.exports = format((info, opts) => {
+  if (opts.message) {
+    info.message = `[${opts.label}] ${info.message}`;
+    return info;
+  }
+
+  info.label = opts.label;
+  return info;
+});

package/node_modules/logform/levels.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const { Colorizer } = require('./colorize');
+
+/*
+ * Simple method to register colors with a simpler require
+ * path within the module.
+ */
+module.exports = config => {
+  Colorizer.addColors(config.colors || config);
+  return config;
+};

package/node_modules/logform/logstash.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const format = require('./format');
+const { MESSAGE } = require('triple-beam');
+const jsonStringify = require('safe-stable-stringify');
+
+/*
+ * function logstash (info)
+ * Returns a new instance of the LogStash Format that turns a
+ * log `info` object into pure JSON with the appropriate logstash
+ * options. This was previously exposed as { logstash: true }
+ * to transports in `winston < 3.0.0`.
+ */
+module.exports = format(info => {
+  const logstash = {};
+  if (info.message) {
+    logstash['@message'] = info.message;
+    delete info.message;
+  }
+
+  if (info.timestamp) {
+    logstash['@timestamp'] = info.timestamp;
+    delete info.timestamp;
+  }
+
+  logstash['@fields'] = info;
+  info[MESSAGE] = jsonStringify(logstash);
+  return info;
+});