api_connect_nodejs 1.0.0 → 2.0.1

package/test/EdelCsvTestSuite/node_modules/log4js/lib/layouts.js

@@ -1,431 +0,0 @@
-const dateFormat = require('date-format');
-const os = require('os');
-const util = require('util');
-const path = require('path');
-const url = require('url');
-const debug = require('debug')('log4js:layouts');
-
-const styles = {
-  // styles
-  bold: [1, 22],
-  italic: [3, 23],
-  underline: [4, 24],
-  inverse: [7, 27],
-  // grayscale
-  white: [37, 39],
-  grey: [90, 39],
-  black: [90, 39],
-  // colors
-  blue: [34, 39],
-  cyan: [36, 39],
-  green: [32, 39],
-  magenta: [35, 39],
-  red: [91, 39],
-  yellow: [33, 39]
-};
-
-function colorizeStart(style) {
-  return style ? `\x1B[${styles[style][0]}m` : '';
-}
-
-function colorizeEnd(style) {
-  return style ? `\x1B[${styles[style][1]}m` : '';
-}
-
-/**
- * Taken from masylum's fork (https://github.com/masylum/log4js-node)
- */
-function colorize(str, style) {
-  return colorizeStart(style) + str + colorizeEnd(style);
-}
-
-function timestampLevelAndCategory(loggingEvent, colour) {
-  return colorize(
-    util.format(
-      '[%s] [%s] %s - ',
-      dateFormat.asString(loggingEvent.startTime),
-      loggingEvent.level.toString(),
-      loggingEvent.categoryName
-    ),
-    colour
-  );
-}
-
-/**
- * BasicLayout is a simple layout for storing the logs. The logs are stored
- * in following format:
- * <pre>
- * [startTime] [logLevel] categoryName - message\n
- * </pre>
- *
- * @author Stephan Strittmatter
- */
-function basicLayout(loggingEvent) {
-  return timestampLevelAndCategory(loggingEvent) + util.format(...loggingEvent.data);
-}
-
-/**
- * colouredLayout - taken from masylum's fork.
- * same as basicLayout, but with colours.
- */
-function colouredLayout(loggingEvent) {
-  return timestampLevelAndCategory(loggingEvent, loggingEvent.level.colour) + util.format(...loggingEvent.data);
-}
-
-function messagePassThroughLayout(loggingEvent) {
-  return util.format(...loggingEvent.data);
-}
-
-function dummyLayout(loggingEvent) {
-  return loggingEvent.data[0];
-}
-
-/**
- * PatternLayout
- * Format for specifiers is %[padding].[truncation][field]{[format]}
- * e.g. %5.10p - left pad the log level by 5 characters, up to a max of 10
- * both padding and truncation can be negative.
- * Negative truncation = trunc from end of string
- * Positive truncation = trunc from start of string
- * Negative padding = pad right
- * Positive padding = pad left
- *
- * Fields can be any of:
- *  - %r time in toLocaleTimeString format
- *  - %p log level
- *  - %c log category
- *  - %h hostname
- *  - %m log data
- *  - %d date in constious formats
- *  - %% %
- *  - %n newline
- *  - %z pid
- *  - %f filename
- *  - %l line number
- *  - %o column postion
- *  - %s call stack
- *  - %x{<tokenname>} add dynamic tokens to your log. Tokens are specified in the tokens parameter
- *  - %X{<tokenname>} add dynamic tokens to your log. Tokens are specified in logger context
- * You can use %[ and %] to define a colored block.
- *
- * Tokens are specified as simple key:value objects.
- * The key represents the token name whereas the value can be a string or function
- * which is called to extract the value to put in the log message. If token is not
- * found, it doesn't replace the field.
- *
- * A sample token would be: { 'pid' : function() { return process.pid; } }
- *
- * Takes a pattern string, array of tokens and returns a layout function.
- * @return {Function}
- * @param pattern
- * @param tokens
- * @param timezoneOffset
- *
- * @authors ['Stephan Strittmatter', 'Jan Schmidle']
- */
-function patternLayout(pattern, tokens) {
-  const TTCC_CONVERSION_PATTERN = '%r %p %c - %m%n';
-  const regex = /%(-?[0-9]+)?(\.?-?[0-9]+)?([[\]cdhmnprzxXyflos%])(\{([^}]+)\})?|([^%]+)/;
-
-  pattern = pattern || TTCC_CONVERSION_PATTERN;
-
-  function categoryName(loggingEvent, specifier) {
-    let loggerName = loggingEvent.categoryName;
-    if (specifier) {
-      const precision = parseInt(specifier, 10);
-      const loggerNameBits = loggerName.split('.');
-      if (precision < loggerNameBits.length) {
-        loggerName = loggerNameBits.slice(loggerNameBits.length - precision).join('.');
-      }
-    }
-    return loggerName;
-  }
-
-  function formatAsDate(loggingEvent, specifier) {
-    let format = dateFormat.ISO8601_FORMAT;
-    if (specifier) {
-      format = specifier;
-      // Pick up special cases
-      switch (format) {
-        case 'ISO8601':
-        case 'ISO8601_FORMAT':
-          format = dateFormat.ISO8601_FORMAT;
-          break;
-        case 'ISO8601_WITH_TZ_OFFSET':
-        case 'ISO8601_WITH_TZ_OFFSET_FORMAT':
-          format = dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT;
-          break;
-        case 'ABSOLUTE':
-          process.emitWarning(
-            "Pattern %d{ABSOLUTE} is deprecated in favor of %d{ABSOLUTETIME}. " +
-            "Please use %d{ABSOLUTETIME} instead.",
-            "DeprecationWarning", "log4js-node-DEP0003"
-          );
-          debug("[log4js-node-DEP0003]",
-            "DEPRECATION: Pattern %d{ABSOLUTE} is deprecated and replaced by %d{ABSOLUTETIME}.");
-          // falls through
-        case 'ABSOLUTETIME':
-        case 'ABSOLUTETIME_FORMAT':
-          format = dateFormat.ABSOLUTETIME_FORMAT;
-          break;
-        case 'DATE':
-          process.emitWarning(
-            "Pattern %d{DATE} is deprecated due to the confusion it causes when used. " +
-            "Please use %d{DATETIME} instead.",
-            "DeprecationWarning", "log4js-node-DEP0004"
-          );
-          debug("[log4js-node-DEP0004]",
-            "DEPRECATION: Pattern %d{DATE} is deprecated and replaced by %d{DATETIME}.");
-          // falls through
-        case 'DATETIME':
-        case 'DATETIME_FORMAT':
-          format = dateFormat.DATETIME_FORMAT;
-          break;
-        // no default
-      }
-    }
-    // Format the date
-    return dateFormat.asString(format, loggingEvent.startTime);
-  }
-
-  function hostname() {
-    return os.hostname().toString();
-  }
-
-  function formatMessage(loggingEvent) {
-    return util.format(...loggingEvent.data);
-  }
-
-  function endOfLine() {
-    return os.EOL;
-  }
-
-  function logLevel(loggingEvent) {
-    return loggingEvent.level.toString();
-  }
-
-  function startTime(loggingEvent) {
-    return dateFormat.asString('hh:mm:ss', loggingEvent.startTime);
-  }
-
-  function startColour(loggingEvent) {
-    return colorizeStart(loggingEvent.level.colour);
-  }
-
-  function endColour(loggingEvent) {
-    return colorizeEnd(loggingEvent.level.colour);
-  }
-
-  function percent() {
-    return '%';
-  }
-
-  function pid(loggingEvent) {
-    return loggingEvent && loggingEvent.pid ? loggingEvent.pid.toString() : process.pid.toString();
-  }
-
-  function clusterInfo() {
-    // this used to try to return the master and worker pids,
-    // but it would never have worked because master pid is not available to workers
-    // leaving this here to maintain compatibility for patterns
-    return pid();
-  }
-
-  function userDefined(loggingEvent, specifier) {
-    if (typeof tokens[specifier] !== 'undefined') {
-      return typeof tokens[specifier] === 'function' ? tokens[specifier](loggingEvent) : tokens[specifier];
-    }
-
-    return null;
-  }
-
-  function contextDefined(loggingEvent, specifier) {
-    const resolver = loggingEvent.context[specifier];
-
-    if (typeof resolver !== 'undefined') {
-      return typeof resolver === 'function' ? resolver(loggingEvent) : resolver;
-    }
-
-    return null;
-  }
-
-  function fileName(loggingEvent, specifier) {
-    let filename = loggingEvent.fileName || '';
-
-    // support for ESM as it uses url instead of path for file
-    /* istanbul ignore next: unsure how to simulate ESM for test coverage */
-    const convertFileURLToPath = function(filepath) {
-      const urlPrefix = 'file://';
-      if (filepath.startsWith(urlPrefix)) {
-        // https://nodejs.org/api/url.html#urlfileurltopathurl
-        if (typeof url.fileURLToPath === 'function') {
-          filepath = url.fileURLToPath(filepath);
-        }
-        // backward-compatible for nodejs pre-10.12.0 (without url.fileURLToPath method)
-        else {
-          // posix: file:///hello/world/foo.txt -> /hello/world/foo.txt -> /hello/world/foo.txt
-          // win32: file:///C:/path/foo.txt     -> /C:/path/foo.txt     -> \C:\path\foo.txt     -> C:\path\foo.txt
-          // win32: file://nas/foo.txt          -> //nas/foo.txt        -> nas\foo.txt          -> \\nas\foo.txt
-          filepath = path.normalize(filepath.replace(new RegExp(`^${urlPrefix}`), ''));
-          if (process.platform === 'win32') {
-            if (filepath.startsWith('\\')) {
-              filepath = filepath.slice(1);
-            } else {
-              filepath = path.sep + path.sep + filepath;
-            }
-          }
-        }
-      }
-      return filepath;
-    };
-    filename = convertFileURLToPath(filename);
-
-    if (specifier) {
-      const fileDepth = parseInt(specifier, 10);
-      const fileList = filename.split(path.sep);
-      if (fileList.length > fileDepth) {
-        filename = fileList.slice(-fileDepth).join(path.sep);
-      }
-    }
-
-    return filename;
-  }
-
-  function lineNumber(loggingEvent) {
-    return loggingEvent.lineNumber ? `${loggingEvent.lineNumber}` : '';
-  }
-
-  function columnNumber(loggingEvent) {
-    return loggingEvent.columnNumber ? `${loggingEvent.columnNumber}` : '';
-  }
-
-  function callStack(loggingEvent) {
-    return loggingEvent.callStack || '';
-  }
-
-  const replacers = {
-    c: categoryName,
-    d: formatAsDate,
-    h: hostname,
-    m: formatMessage,
-    n: endOfLine,
-    p: logLevel,
-    r: startTime,
-    '[': startColour,
-    ']': endColour,
-    y: clusterInfo,
-    z: pid,
-    '%': percent,
-    x: userDefined,
-    X: contextDefined,
-    f: fileName,
-    l: lineNumber,
-    o: columnNumber,
-    s: callStack
-  };
-
-  function replaceToken(conversionCharacter, loggingEvent, specifier) {
-    return replacers[conversionCharacter](loggingEvent, specifier);
-  }
-
-  function truncate(truncation, toTruncate) {
-    let len;
-    if (truncation) {
-      len = parseInt(truncation.slice(1), 10);
-      // negative truncate length means truncate from end of string
-      return len > 0 ? toTruncate.slice(0, len) : toTruncate.slice(len);
-    }
-
-    return toTruncate;
-  }
-
-  function pad(padding, toPad) {
-    let len;
-    if (padding) {
-      if (padding.charAt(0) === '-') {
-        len = parseInt(padding.slice(1), 10);
-        // Right pad with spaces
-        while (toPad.length < len) {
-          toPad += ' ';
-        }
-      } else {
-        len = parseInt(padding, 10);
-        // Left pad with spaces
-        while (toPad.length < len) {
-          toPad = ` ${toPad}`;
-        }
-      }
-    }
-    return toPad;
-  }
-
-  function truncateAndPad(toTruncAndPad, truncation, padding) {
-    let replacement = toTruncAndPad;
-    replacement = truncate(truncation, replacement);
-    replacement = pad(padding, replacement);
-    return replacement;
-  }
-
-  return function (loggingEvent) {
-    let formattedString = '';
-    let result;
-    let searchString = pattern;
-
-    while ((result = regex.exec(searchString)) !== null) {
-      // const matchedString = result[0];
-      const padding = result[1];
-      const truncation = result[2];
-      const conversionCharacter = result[3];
-      const specifier = result[5];
-      const text = result[6];
-
-      // Check if the pattern matched was just normal text
-      if (text) {
-        formattedString += text.toString();
-      } else {
-        // Create a raw replacement string based on the conversion
-        // character and specifier
-        const replacement = replaceToken(conversionCharacter, loggingEvent, specifier);
-        formattedString += truncateAndPad(replacement, truncation, padding);
-      }
-      searchString = searchString.slice(result.index + result[0].length);
-    }
-    return formattedString;
-  };
-}
-
-const layoutMakers = {
-  messagePassThrough () {
-    return messagePassThroughLayout;
-  },
-  basic () {
-    return basicLayout;
-  },
-  colored () {
-    return colouredLayout;
-  },
-  coloured () {
-    return colouredLayout;
-  },
-  pattern (config) {
-    return patternLayout(config && config.pattern, config && config.tokens);
-  },
-  dummy () {
-    return dummyLayout;
-  }
-};
-
-module.exports = {
-  basicLayout,
-  messagePassThroughLayout,
-  patternLayout,
-  colouredLayout,
-  coloredLayout: colouredLayout,
-  dummyLayout,
-  addLayout (name, serializerGenerator) {
-    layoutMakers[name] = serializerGenerator;
-  },
-  layout (name, config) {
-    return layoutMakers[name] && layoutMakers[name](config);
-  }
-};

package/test/EdelCsvTestSuite/node_modules/log4js/lib/levels.js

@@ -1,150 +0,0 @@
-
-
-const configuration = require('./configuration');
-
-const validColours = [
-  'white', 'grey', 'black',
-  'blue', 'cyan', 'green',
-  'magenta', 'red', 'yellow'
-];
-
-class Level {
-  constructor(level, levelStr, colour) {
-    this.level = level;
-    this.levelStr = levelStr;
-    this.colour = colour;
-  }
-
-  toString() {
-    return this.levelStr;
-  }
-
-  /**
-   * converts given String to corresponding Level
-   * @param {(Level|string)} sArg -- String value of Level OR Log4js.Level
-   * @param {Level} [defaultLevel] -- default Level, if no String representation
-   * @return {Level}
-   */
-  static getLevel(sArg, defaultLevel) {
-    if (!sArg) {
-      return defaultLevel;
-    }
-
-    if (sArg instanceof Level) {
-      return sArg;
-    }
-
-    // a json-serialised level won't be an instance of Level (see issue #768)
-    if (sArg instanceof Object && sArg.levelStr) {
-      sArg = sArg.levelStr;
-    }
-
-    return Level[sArg.toString().toUpperCase()] || defaultLevel;
-  }
-
-  static addLevels(customLevels) {
-    if (customLevels) {
-      const levels = Object.keys(customLevels);
-      levels.forEach((l) => {
-        const levelStr = l.toUpperCase();
-        Level[levelStr] = new Level(
-          customLevels[l].value,
-          levelStr,
-          customLevels[l].colour
-        );
-        const existingLevelIndex = Level.levels.findIndex(lvl => lvl.levelStr === levelStr);
-        if (existingLevelIndex > -1) {
-          Level.levels[existingLevelIndex] = Level[levelStr];
-        } else {
-          Level.levels.push(Level[levelStr]);
-        }
-      });
-      Level.levels.sort((a, b) => a.level - b.level);
-    }
-  }
-
-
-  isLessThanOrEqualTo(otherLevel) {
-    if (typeof otherLevel === 'string') {
-      otherLevel = Level.getLevel(otherLevel);
-    }
-    return this.level <= otherLevel.level;
-  }
-
-  isGreaterThanOrEqualTo(otherLevel) {
-    if (typeof otherLevel === 'string') {
-      otherLevel = Level.getLevel(otherLevel);
-    }
-    return this.level >= otherLevel.level;
-  }
-
-  isEqualTo(otherLevel) {
-    if (typeof otherLevel === 'string') {
-      otherLevel = Level.getLevel(otherLevel);
-    }
-    return this.level === otherLevel.level;
-  }
-}
-
-Level.levels = [];
-Level.addLevels({
-  ALL: { value: Number.MIN_VALUE, colour: 'grey' },
-  TRACE: { value: 5000, colour: 'blue' },
-  DEBUG: { value: 10000, colour: 'cyan' },
-  INFO: { value: 20000, colour: 'green' },
-  WARN: { value: 30000, colour: 'yellow' },
-  ERROR: { value: 40000, colour: 'red' },
-  FATAL: { value: 50000, colour: 'magenta' },
-  MARK: { value: 9007199254740992, colour: 'grey' }, // 2^53
-  OFF: { value: Number.MAX_VALUE, colour: 'grey' }
-});
-
-configuration.addListener((config) => {
-  const levelConfig = config.levels;
-  if (levelConfig) {
-    configuration.throwExceptionIf(
-      config,
-      configuration.not(configuration.anObject(levelConfig)),
-      'levels must be an object'
-    );
-    const newLevels = Object.keys(levelConfig);
-    newLevels.forEach((l) => {
-      configuration.throwExceptionIf(
-        config,
-        configuration.not(configuration.validIdentifier(l)),
-        `level name "${l}" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)`
-      );
-      configuration.throwExceptionIf(
-        config,
-        configuration.not(configuration.anObject(levelConfig[l])),
-        `level "${l}" must be an object`
-      );
-      configuration.throwExceptionIf(
-        config,
-        configuration.not(levelConfig[l].value),
-        `level "${l}" must have a 'value' property`
-      );
-      configuration.throwExceptionIf(
-        config,
-        configuration.not(configuration.anInteger(levelConfig[l].value)),
-        `level "${l}".value must have an integer value`
-      );
-      configuration.throwExceptionIf(
-        config,
-        configuration.not(levelConfig[l].colour),
-        `level "${l}" must have a 'colour' property`
-      );
-      configuration.throwExceptionIf(
-        config,
-        configuration.not(validColours.indexOf(levelConfig[l].colour) > -1),
-        `level "${l}".colour must be one of ${validColours.join(', ')}`
-      );
-    });
-  }
-});
-
-configuration.addListener((config) => {
-  Level.addLevels(config.levels);
-});
-
-module.exports = Level;