mock-service-cli 3.7.0 → 4.0.0

package/dist/utils.js

@@ -0,0 +1,857 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/colors/lib/styles.js
+var require_styles = __commonJS({
+  "node_modules/colors/lib/styles.js"(exports2, module2) {
+    var styles = {};
+    module2["exports"] = styles;
+    var codes = {
+      reset: [0, 0],
+      bold: [1, 22],
+      dim: [2, 22],
+      italic: [3, 23],
+      underline: [4, 24],
+      inverse: [7, 27],
+      hidden: [8, 28],
+      strikethrough: [9, 29],
+      black: [30, 39],
+      red: [31, 39],
+      green: [32, 39],
+      yellow: [33, 39],
+      blue: [34, 39],
+      magenta: [35, 39],
+      cyan: [36, 39],
+      white: [37, 39],
+      gray: [90, 39],
+      grey: [90, 39],
+      brightRed: [91, 39],
+      brightGreen: [92, 39],
+      brightYellow: [93, 39],
+      brightBlue: [94, 39],
+      brightMagenta: [95, 39],
+      brightCyan: [96, 39],
+      brightWhite: [97, 39],
+      bgBlack: [40, 49],
+      bgRed: [41, 49],
+      bgGreen: [42, 49],
+      bgYellow: [43, 49],
+      bgBlue: [44, 49],
+      bgMagenta: [45, 49],
+      bgCyan: [46, 49],
+      bgWhite: [47, 49],
+      bgGray: [100, 49],
+      bgGrey: [100, 49],
+      bgBrightRed: [101, 49],
+      bgBrightGreen: [102, 49],
+      bgBrightYellow: [103, 49],
+      bgBrightBlue: [104, 49],
+      bgBrightMagenta: [105, 49],
+      bgBrightCyan: [106, 49],
+      bgBrightWhite: [107, 49],
+      // legacy styles for colors pre v1.0.0
+      blackBG: [40, 49],
+      redBG: [41, 49],
+      greenBG: [42, 49],
+      yellowBG: [43, 49],
+      blueBG: [44, 49],
+      magentaBG: [45, 49],
+      cyanBG: [46, 49],
+      whiteBG: [47, 49]
+    };
+    Object.keys(codes).forEach(function(key) {
+      var val = codes[key];
+      var style = styles[key] = [];
+      style.open = "\x1B[" + val[0] + "m";
+      style.close = "\x1B[" + val[1] + "m";
+    });
+  }
+});
+
+// node_modules/colors/lib/system/has-flag.js
+var require_has_flag = __commonJS({
+  "node_modules/colors/lib/system/has-flag.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function(flag, argv) {
+      argv = argv || process.argv;
+      var terminatorPos = argv.indexOf("--");
+      var prefix = /^-{1,2}/.test(flag) ? "" : "--";
+      var pos = argv.indexOf(prefix + flag);
+      return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+    };
+  }
+});
+
+// node_modules/colors/lib/system/supports-colors.js
+var require_supports_colors = __commonJS({
+  "node_modules/colors/lib/system/supports-colors.js"(exports2, module2) {
+    "use strict";
+    var os = require("os");
+    var hasFlag = require_has_flag();
+    var env = process.env;
+    var forceColor = void 0;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false")) {
+      forceColor = false;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = true;
+    }
+    if ("FORCE_COLOR" in env) {
+      forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(stream) {
+      if (forceColor === false) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (stream && !stream.isTTY && forceColor !== true) {
+        return 0;
+      }
+      var min = forceColor ? 1 : 0;
+      if (process.platform === "win32") {
+        var osRelease = os.release().split(".");
+        if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some(function(sign) {
+          return sign in env;
+        }) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if ("TERM_PROGRAM" in env) {
+        var version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Hyper":
+            return 3;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      var level = supportsColor(stream);
+      return translateLevel(level);
+    }
+    module2.exports = {
+      supportsColor: getSupportLevel,
+      stdout: getSupportLevel(process.stdout),
+      stderr: getSupportLevel(process.stderr)
+    };
+  }
+});
+
+// node_modules/colors/lib/custom/trap.js
+var require_trap = __commonJS({
+  "node_modules/colors/lib/custom/trap.js"(exports2, module2) {
+    module2["exports"] = function runTheTrap(text, options) {
+      var result = "";
+      text = text || "Run the trap, drop the bass";
+      text = text.split("");
+      var trap = {
+        a: ["@", "\u0104", "\u023A", "\u0245", "\u0394", "\u039B", "\u0414"],
+        b: ["\xDF", "\u0181", "\u0243", "\u026E", "\u03B2", "\u0E3F"],
+        c: ["\xA9", "\u023B", "\u03FE"],
+        d: ["\xD0", "\u018A", "\u0500", "\u0501", "\u0502", "\u0503"],
+        e: [
+          "\xCB",
+          "\u0115",
+          "\u018E",
+          "\u0258",
+          "\u03A3",
+          "\u03BE",
+          "\u04BC",
+          "\u0A6C"
+        ],
+        f: ["\u04FA"],
+        g: ["\u0262"],
+        h: ["\u0126", "\u0195", "\u04A2", "\u04BA", "\u04C7", "\u050A"],
+        i: ["\u0F0F"],
+        j: ["\u0134"],
+        k: ["\u0138", "\u04A0", "\u04C3", "\u051E"],
+        l: ["\u0139"],
+        m: ["\u028D", "\u04CD", "\u04CE", "\u0520", "\u0521", "\u0D69"],
+        n: ["\xD1", "\u014B", "\u019D", "\u0376", "\u03A0", "\u048A"],
+        o: [
+          "\xD8",
+          "\xF5",
+          "\xF8",
+          "\u01FE",
+          "\u0298",
+          "\u047A",
+          "\u05DD",
+          "\u06DD",
+          "\u0E4F"
+        ],
+        p: ["\u01F7", "\u048E"],
+        q: ["\u09CD"],
+        r: ["\xAE", "\u01A6", "\u0210", "\u024C", "\u0280", "\u042F"],
+        s: ["\xA7", "\u03DE", "\u03DF", "\u03E8"],
+        t: ["\u0141", "\u0166", "\u0373"],
+        u: ["\u01B1", "\u054D"],
+        v: ["\u05D8"],
+        w: ["\u0428", "\u0460", "\u047C", "\u0D70"],
+        x: ["\u04B2", "\u04FE", "\u04FC", "\u04FD"],
+        y: ["\xA5", "\u04B0", "\u04CB"],
+        z: ["\u01B5", "\u0240"]
+      };
+      text.forEach(function(c) {
+        c = c.toLowerCase();
+        var chars = trap[c] || [" "];
+        var rand = Math.floor(Math.random() * chars.length);
+        if (typeof trap[c] !== "undefined") {
+          result += trap[c][rand];
+        } else {
+          result += c;
+        }
+      });
+      return result;
+    };
+  }
+});
+
+// node_modules/colors/lib/custom/zalgo.js
+var require_zalgo = __commonJS({
+  "node_modules/colors/lib/custom/zalgo.js"(exports2, module2) {
+    module2["exports"] = function zalgo(text, options) {
+      text = text || "   he is here   ";
+      var soul = {
+        "up": [
+          "\u030D",
+          "\u030E",
+          "\u0304",
+          "\u0305",
+          "\u033F",
+          "\u0311",
+          "\u0306",
+          "\u0310",
+          "\u0352",
+          "\u0357",
+          "\u0351",
+          "\u0307",
+          "\u0308",
+          "\u030A",
+          "\u0342",
+          "\u0313",
+          "\u0308",
+          "\u034A",
+          "\u034B",
+          "\u034C",
+          "\u0303",
+          "\u0302",
+          "\u030C",
+          "\u0350",
+          "\u0300",
+          "\u0301",
+          "\u030B",
+          "\u030F",
+          "\u0312",
+          "\u0313",
+          "\u0314",
+          "\u033D",
+          "\u0309",
+          "\u0363",
+          "\u0364",
+          "\u0365",
+          "\u0366",
+          "\u0367",
+          "\u0368",
+          "\u0369",
+          "\u036A",
+          "\u036B",
+          "\u036C",
+          "\u036D",
+          "\u036E",
+          "\u036F",
+          "\u033E",
+          "\u035B",
+          "\u0346",
+          "\u031A"
+        ],
+        "down": [
+          "\u0316",
+          "\u0317",
+          "\u0318",
+          "\u0319",
+          "\u031C",
+          "\u031D",
+          "\u031E",
+          "\u031F",
+          "\u0320",
+          "\u0324",
+          "\u0325",
+          "\u0326",
+          "\u0329",
+          "\u032A",
+          "\u032B",
+          "\u032C",
+          "\u032D",
+          "\u032E",
+          "\u032F",
+          "\u0330",
+          "\u0331",
+          "\u0332",
+          "\u0333",
+          "\u0339",
+          "\u033A",
+          "\u033B",
+          "\u033C",
+          "\u0345",
+          "\u0347",
+          "\u0348",
+          "\u0349",
+          "\u034D",
+          "\u034E",
+          "\u0353",
+          "\u0354",
+          "\u0355",
+          "\u0356",
+          "\u0359",
+          "\u035A",
+          "\u0323"
+        ],
+        "mid": [
+          "\u0315",
+          "\u031B",
+          "\u0300",
+          "\u0301",
+          "\u0358",
+          "\u0321",
+          "\u0322",
+          "\u0327",
+          "\u0328",
+          "\u0334",
+          "\u0335",
+          "\u0336",
+          "\u035C",
+          "\u035D",
+          "\u035E",
+          "\u035F",
+          "\u0360",
+          "\u0362",
+          "\u0338",
+          "\u0337",
+          "\u0361",
+          " \u0489"
+        ]
+      };
+      var all = [].concat(soul.up, soul.down, soul.mid);
+      function randomNumber(range) {
+        var r = Math.floor(Math.random() * range);
+        return r;
+      }
+      function isChar(character) {
+        var bool = false;
+        all.filter(function(i) {
+          bool = i === character;
+        });
+        return bool;
+      }
+      function heComes(text2, options2) {
+        var result = "";
+        var counts;
+        var l;
+        options2 = options2 || {};
+        options2["up"] = typeof options2["up"] !== "undefined" ? options2["up"] : true;
+        options2["mid"] = typeof options2["mid"] !== "undefined" ? options2["mid"] : true;
+        options2["down"] = typeof options2["down"] !== "undefined" ? options2["down"] : true;
+        options2["size"] = typeof options2["size"] !== "undefined" ? options2["size"] : "maxi";
+        text2 = text2.split("");
+        for (l in text2) {
+          if (isChar(l)) {
+            continue;
+          }
+          result = result + text2[l];
+          counts = { "up": 0, "down": 0, "mid": 0 };
+          switch (options2.size) {
+            case "mini":
+              counts.up = randomNumber(8);
+              counts.mid = randomNumber(2);
+              counts.down = randomNumber(8);
+              break;
+            case "maxi":
+              counts.up = randomNumber(16) + 3;
+              counts.mid = randomNumber(4) + 1;
+              counts.down = randomNumber(64) + 3;
+              break;
+            default:
+              counts.up = randomNumber(8) + 1;
+              counts.mid = randomNumber(6) / 2;
+              counts.down = randomNumber(8) + 1;
+              break;
+          }
+          var arr = ["up", "mid", "down"];
+          for (var d in arr) {
+            var index = arr[d];
+            for (var i = 0; i <= counts[index]; i++) {
+              if (options2[index]) {
+                result = result + soul[index][randomNumber(soul[index].length)];
+              }
+            }
+          }
+        }
+        return result;
+      }
+      return heComes(text, options);
+    };
+  }
+});
+
+// node_modules/colors/lib/maps/america.js
+var require_america = __commonJS({
+  "node_modules/colors/lib/maps/america.js"(exports2, module2) {
+    module2["exports"] = function(colors2) {
+      return function(letter, i, exploded) {
+        if (letter === " ") return letter;
+        switch (i % 3) {
+          case 0:
+            return colors2.red(letter);
+          case 1:
+            return colors2.white(letter);
+          case 2:
+            return colors2.blue(letter);
+        }
+      };
+    };
+  }
+});
+
+// node_modules/colors/lib/maps/zebra.js
+var require_zebra = __commonJS({
+  "node_modules/colors/lib/maps/zebra.js"(exports2, module2) {
+    module2["exports"] = function(colors2) {
+      return function(letter, i, exploded) {
+        return i % 2 === 0 ? letter : colors2.inverse(letter);
+      };
+    };
+  }
+});
+
+// node_modules/colors/lib/maps/rainbow.js
+var require_rainbow = __commonJS({
+  "node_modules/colors/lib/maps/rainbow.js"(exports2, module2) {
+    module2["exports"] = function(colors2) {
+      var rainbowColors = ["red", "yellow", "green", "blue", "magenta"];
+      return function(letter, i, exploded) {
+        if (letter === " ") {
+          return letter;
+        } else {
+          return colors2[rainbowColors[i++ % rainbowColors.length]](letter);
+        }
+      };
+    };
+  }
+});
+
+// node_modules/colors/lib/maps/random.js
+var require_random = __commonJS({
+  "node_modules/colors/lib/maps/random.js"(exports2, module2) {
+    module2["exports"] = function(colors2) {
+      var available = [
+        "underline",
+        "inverse",
+        "grey",
+        "yellow",
+        "red",
+        "green",
+        "blue",
+        "white",
+        "cyan",
+        "magenta",
+        "brightYellow",
+        "brightRed",
+        "brightGreen",
+        "brightBlue",
+        "brightWhite",
+        "brightCyan",
+        "brightMagenta"
+      ];
+      return function(letter, i, exploded) {
+        return letter === " " ? letter : colors2[available[Math.round(Math.random() * (available.length - 2))]](letter);
+      };
+    };
+  }
+});
+
+// node_modules/colors/lib/colors.js
+var require_colors = __commonJS({
+  "node_modules/colors/lib/colors.js"(exports2, module2) {
+    var colors2 = {};
+    module2["exports"] = colors2;
+    colors2.themes = {};
+    var util = require("util");
+    var ansiStyles = colors2.styles = require_styles();
+    var defineProps = Object.defineProperties;
+    var newLineRegex = new RegExp(/[\r\n]+/g);
+    colors2.supportsColor = require_supports_colors().supportsColor;
+    if (typeof colors2.enabled === "undefined") {
+      colors2.enabled = colors2.supportsColor() !== false;
+    }
+    colors2.enable = function() {
+      colors2.enabled = true;
+    };
+    colors2.disable = function() {
+      colors2.enabled = false;
+    };
+    colors2.stripColors = colors2.strip = function(str) {
+      return ("" + str).replace(/\x1B\[\d+m/g, "");
+    };
+    var stylize = colors2.stylize = function stylize2(str, style) {
+      if (!colors2.enabled) {
+        return str + "";
+      }
+      var styleMap = ansiStyles[style];
+      if (!styleMap && style in colors2) {
+        return colors2[style](str);
+      }
+      return styleMap.open + str + styleMap.close;
+    };
+    var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+    var escapeStringRegexp = function(str) {
+      if (typeof str !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      return str.replace(matchOperatorsRe, "\\$&");
+    };
+    function build(_styles) {
+      var builder = function builder2() {
+        return applyStyle.apply(builder2, arguments);
+      };
+      builder._styles = _styles;
+      builder.__proto__ = proto;
+      return builder;
+    }
+    var styles = function() {
+      var ret = {};
+      ansiStyles.grey = ansiStyles.gray;
+      Object.keys(ansiStyles).forEach(function(key) {
+        ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), "g");
+        ret[key] = {
+          get: function() {
+            return build(this._styles.concat(key));
+          }
+        };
+      });
+      return ret;
+    }();
+    var proto = defineProps(function colors3() {
+    }, styles);
+    function applyStyle() {
+      var args = Array.prototype.slice.call(arguments);
+      var str = args.map(function(arg) {
+        if (arg != null && arg.constructor === String) {
+          return arg;
+        } else {
+          return util.inspect(arg);
+        }
+      }).join(" ");
+      if (!colors2.enabled || !str) {
+        return str;
+      }
+      var newLinesPresent = str.indexOf("\n") != -1;
+      var nestedStyles = this._styles;
+      var i = nestedStyles.length;
+      while (i--) {
+        var code = ansiStyles[nestedStyles[i]];
+        str = code.open + str.replace(code.closeRe, code.open) + code.close;
+        if (newLinesPresent) {
+          str = str.replace(newLineRegex, function(match) {
+            return code.close + match + code.open;
+          });
+        }
+      }
+      return str;
+    }
+    colors2.setTheme = function(theme) {
+      if (typeof theme === "string") {
+        console.log("colors.setTheme now only accepts an object, not a string.  If you are trying to set a theme from a file, it is now your (the caller's) responsibility to require the file.  The old syntax looked like colors.setTheme(__dirname + '/../themes/generic-logging.js'); The new syntax looks like colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));");
+        return;
+      }
+      for (var style in theme) {
+        (function(style2) {
+          colors2[style2] = function(str) {
+            if (typeof theme[style2] === "object") {
+              var out = str;
+              for (var i in theme[style2]) {
+                out = colors2[theme[style2][i]](out);
+              }
+              return out;
+            }
+            return colors2[theme[style2]](str);
+          };
+        })(style);
+      }
+    };
+    function init() {
+      var ret = {};
+      Object.keys(styles).forEach(function(name) {
+        ret[name] = {
+          get: function() {
+            return build([name]);
+          }
+        };
+      });
+      return ret;
+    }
+    var sequencer = function sequencer2(map2, str) {
+      var exploded = str.split("");
+      exploded = exploded.map(map2);
+      return exploded.join("");
+    };
+    colors2.trap = require_trap();
+    colors2.zalgo = require_zalgo();
+    colors2.maps = {};
+    colors2.maps.america = require_america()(colors2);
+    colors2.maps.zebra = require_zebra()(colors2);
+    colors2.maps.rainbow = require_rainbow()(colors2);
+    colors2.maps.random = require_random()(colors2);
+    for (map in colors2.maps) {
+      (function(map2) {
+        colors2[map2] = function(str) {
+          return sequencer(colors2.maps[map2], str);
+        };
+      })(map);
+    }
+    var map;
+    defineProps(colors2, init());
+  }
+});
+
+// node_modules/colors/safe.js
+var require_safe = __commonJS({
+  "node_modules/colors/safe.js"(exports2, module2) {
+    var colors2 = require_colors();
+    module2["exports"] = colors2;
+  }
+});
+
+// src/lib/utils.js
+var fs = require("fs");
+var colors = require_safe();
+var path = require("path");
+var getLogger = function(logFileDirPath) {
+  const options = {
+    flags: "a",
+    // append模式
+    encoding: "utf8"
+    // utf8编码
+  };
+  const output = fs.createWriteStream(
+    path.resolve(logFileDirPath ? logFileDirPath : path.resolve(process.cwd()), "./stdout.log"),
+    options
+  );
+  const errorOutput = fs.createWriteStream(
+    path.resolve(logFileDirPath ? logFileDirPath : path.resolve(process.cwd()), "./stderr.log"),
+    options
+  );
+  const logger2 = new console.Console(output, errorOutput);
+  return {
+    log: (...args) => logger2.log.call(null, `[${dateFormat("YYYY-mm-dd HH:MM:SS:fff")}]  - `, ...args),
+    error: (...args) => logger2.error.call(null, `[${dateFormat("YYYY-mm-dd HH:MM:SS:fff")}]  - `, ...args)
+  };
+};
+function dateFormat(fmt, date = /* @__PURE__ */ new Date()) {
+  let ret;
+  const opt = {
+    "Y+": date.getFullYear().toString(),
+    // 年
+    "m+": (date.getMonth() + 1).toString(),
+    // 月
+    "d+": date.getDate().toString(),
+    // 日
+    "H+": date.getHours().toString(),
+    // 时
+    "M+": date.getMinutes().toString(),
+    // 分
+    "S+": date.getSeconds().toString(),
+    // 秒
+    "f+": date.getMilliseconds().toString()
+    // 毫秒
+    // 有其他格式化字符需求可以继续添加，必须转化成字符串
+  };
+  for (const k in opt) {
+    ret = new RegExp("(" + k + ")").exec(fmt);
+    if (ret) {
+      fmt = fmt.replace(ret[1], ret[1].length === 1 ? opt[k] : opt[k].padStart(ret[1].length, "0"));
+    }
+  }
+  return fmt;
+}
+function logger(isSilent = false) {
+  let logObj = null;
+  if (!isSilent) {
+    logObj = {
+      info: console.log,
+      assert: console.assert
+    };
+  } else {
+    logObj = {
+      info: function() {
+      },
+      assert: function() {
+      }
+    };
+  }
+  return logObj;
+}
+var SupportMethods = ["GET", "POST", "PUT", "DELETE", "HEAD", "PATCH", "OPTIONS", "COPY", "LINK", "UNLINK", "PURGE"];
+var DefaultHeaders = "Authorization,Content-Type,Accept,Origin,User-Agent,DNT,Cache-Control,X-Mx-ReqToken,X-Data-Type,X-Requested-With,X-Data-Type,X-Auth-Token,Token";
+var isValidMethod = function(m) {
+  return SupportMethods.includes(String(m).toLocaleUpperCase());
+};
+var getFileLatestContent = function(filePath) {
+  try {
+    delete require.cache[require.resolve(filePath)];
+    return require(path.resolve(process.cwd(), filePath));
+  } catch (error) {
+    console.error(colors.red("[error]:"), error);
+    return "getFileLatestContent_ERROR";
+  }
+};
+var filePath2ApiUrl = function(filePath) {
+  return filePath.split(path.sep).join("/");
+};
+var getDataType = function(data) {
+  return Object.prototype.toString.call(data).slice(8, -1).toLowerCase();
+};
+var isEmptyObj = function(obj) {
+  return getDataType(obj) === "object" && Object.keys(obj).length === 0;
+};
+var writeStream = function(filePath, data) {
+  return new Promise((resolve, reject) => {
+    const writerStream = fs.createWriteStream(filePath);
+    writerStream.write(data, "utf-8");
+    writerStream.end();
+    writerStream.on("finish", () => {
+    });
+    writerStream.on("close", () => {
+      setTimeout(() => {
+        resolve(data);
+      });
+    });
+    writerStream.on("error", (err) => {
+      getLogger(path.resolve(process.cwd())).error(filePath, require.cache[require.resolve(filePath)], err);
+      reject(err);
+    });
+  });
+};
+var readStream = function(filePath) {
+  let data = "";
+  return new Promise((resovle, reject) => {
+    const readerStream = fs.createReadStream(filePath);
+    readerStream.setEncoding("UTF8");
+    readerStream.on("data", function(chunk) {
+      data += chunk;
+    });
+    readerStream.on("end", function() {
+      resovle(data);
+    });
+    readerStream.on("error", function(err) {
+      reject(err);
+      console.log(err.stack);
+    });
+  });
+};
+var debounce = (func, wait) => {
+  let timeout;
+  let canceled = false;
+  const f = function(...args) {
+    if (canceled) return;
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      func.call(this, ...args);
+    }, wait);
+  };
+  f.cancel = () => {
+    clearTimeout(timeout);
+    canceled = true;
+  };
+  return f;
+};
+var throttle = (func, wait, immediate) => {
+  let timeout;
+  let canceled = false;
+  let lastCalledTime = 0;
+  const f = function(...args) {
+    if (canceled) return;
+    const now = Date.now();
+    const call = () => {
+      lastCalledTime = now;
+      func.call(this, ...args);
+    };
+    if (lastCalledTime === 0) {
+      if (immediate) {
+        return call();
+      }
+      lastCalledTime = now;
+      return;
+    }
+    const remain = lastCalledTime + wait - now;
+    if (remain > 0) {
+      clearTimeout(timeout);
+      timeout = setTimeout(() => call(), wait);
+    } else {
+      call();
+    }
+  };
+  f.cancel = () => {
+    clearTimeout(timeout);
+    canceled = true;
+  };
+  return f;
+};
+module.exports = {
+  getLogger,
+  dateFormat,
+  logger,
+  SupportMethods,
+  DefaultHeaders,
+  isValidMethod,
+  getFileLatestContent,
+  filePath2ApiUrl,
+  getDataType,
+  isEmptyObj,
+  writeStream,
+  readStream,
+  debounce,
+  throttle
+};