@rsdoctor/utils 1.1.10 → 1.2.0-beta.1

package/dist/cjs/rule-utils/parser/types.js

@@ -1,33 +1,41 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-__export(types_exports, {
-  ECMAVersion: () => ECMAVersion
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ECMAVersion: ()=>ECMAVersion
 });
-module.exports = __toCommonJS(types_exports);
-var ECMAVersion = /* @__PURE__ */ ((ECMAVersion2) => {
-  ECMAVersion2["ES5"] = "ES5";
-  ECMAVersion2["ES6"] = "ES6";
-  ECMAVersion2["ES7P"] = "ES7+";
-  return ECMAVersion2;
-})(ECMAVersion || {});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ECMAVersion
+var ECMAVersion = /*#__PURE__*/ function(ECMAVersion) {
+    ECMAVersion["ES5"] = "ES5";
+    ECMAVersion["ES6"] = "ES6";
+    ECMAVersion["ES7P"] = "ES7+";
+    return ECMAVersion;
+}({});
+exports.ECMAVersion = __webpack_exports__.ECMAVersion;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ECMAVersion"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/cjs/rule-utils/parser/utils.js

@@ -1,197 +1,170 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var utils_exports = {};
-__export(utils_exports, {
-  canParse: () => canParse,
-  detectECMAVersion: () => detectECMAVersion,
-  getDefaultImports: () => getDefaultImports,
-  getIdentifierInDeclaration: () => getIdentifierInDeclaration,
-  getIdentifierInExport: () => getIdentifierInExport,
-  getIdentifierInImport: () => getIdentifierInImport,
-  getIdentifierInPattern: () => getIdentifierInPattern,
-  isES5: () => isES5,
-  isES6: () => isES6,
-  isSameSemantics: () => isSameSemantics
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    isES6: ()=>isES6,
+    getIdentifierInDeclaration: ()=>getIdentifierInDeclaration,
+    getIdentifierInExport: ()=>getIdentifierInExport,
+    isSameSemantics: ()=>isSameSemantics,
+    getIdentifierInImport: ()=>getIdentifierInImport,
+    canParse: ()=>canParse,
+    getIdentifierInPattern: ()=>getIdentifierInPattern,
+    getDefaultImports: ()=>getDefaultImports,
+    isES5: ()=>isES5,
+    detectECMAVersion: ()=>detectECMAVersion
 });
-module.exports = __toCommonJS(utils_exports);
-var import_acorn = require("acorn");
-var import_types = require("./types");
-var import_asserts = require("./asserts");
+const external_acorn_namespaceObject = require("acorn");
+const external_types_js_namespaceObject = require("./types.js");
+const external_asserts_js_namespaceObject = require("./asserts.js");
 function isSameSemantics(node1, node2) {
-  if (node1.type !== node2.type) {
-    return false;
-  }
-  switch (node1.type) {
-    case "CallExpression": {
-      const next = node2;
-      return node1.arguments.length === next.arguments.length && Boolean(node1.optional) === Boolean(next.optional) && isSameSemantics(node1.callee, next.callee) && node1.arguments.every(
-        (node, i) => isSameSemantics(node, next.arguments[i])
-      );
+    if (node1.type !== node2.type) return false;
+    switch(node1.type){
+        case 'CallExpression':
+            {
+                const next = node2;
+                return node1.arguments.length === next.arguments.length && Boolean(node1.optional) === Boolean(next.optional) && isSameSemantics(node1.callee, next.callee) && node1.arguments.every((node, i)=>isSameSemantics(node, next.arguments[i]));
+            }
+        case 'MemberExpression':
+            {
+                const next = node2;
+                return node1.computed === next.computed && Boolean(node1.optional) === Boolean(next.optional) && isSameSemantics(node1.object, next.object) && isSameSemantics(node1.property, next.property);
+            }
+        case 'Identifier':
+            return node1.name === node2.name;
+        case 'Literal':
+            if (external_asserts_js_namespaceObject.asserts.isSimpleLiteral(node1) && external_asserts_js_namespaceObject.asserts.isSimpleLiteral(node2)) return node1.value === node2.value;
+            return node1.raw === node2.raw;
+        case 'ObjectExpression':
+            {
+                const next = node2;
+                return node1.properties.length === next.properties.length && node1.properties.every((prop, i)=>isSameSemantics(prop, next.properties[i]));
+            }
+        case 'Property':
+            {
+                const next = node2;
+                return node1.computed === next.computed && node1.kind === next.kind && node1.method === next.method && isSameSemantics(node1.key, next.key) && isSameSemantics(node1.value, next.value);
+            }
+        default:
+            throw new Error(`Unknown node type: ${node1.type}`);
     }
-    case "MemberExpression": {
-      const next = node2;
-      return node1.computed === next.computed && Boolean(node1.optional) === Boolean(next.optional) && isSameSemantics(node1.object, next.object) && isSameSemantics(node1.property, next.property);
-    }
-    case "Identifier": {
-      return node1.name === node2.name;
-    }
-    case "Literal": {
-      if (import_asserts.asserts.isSimpleLiteral(node1) && import_asserts.asserts.isSimpleLiteral(node2)) {
-        return node1.value === node2.value;
-      }
-      return node1.raw === node2.raw;
-    }
-    case "ObjectExpression": {
-      const next = node2;
-      return node1.properties.length === next.properties.length && node1.properties.every(
-        (prop, i) => isSameSemantics(prop, next.properties[i])
-      );
-    }
-    case "Property": {
-      const next = node2;
-      return node1.computed === next.computed && node1.kind === next.kind && node1.method === next.method && isSameSemantics(node1.key, next.key) && isSameSemantics(node1.value, next.value);
-    }
-    default: {
-      throw new Error(`Unknown node type: ${node1.type}`);
-    }
-  }
 }
 function getDefaultImports(node) {
-  return node.body.filter((statement) => {
-    if (statement.type !== "ImportDeclaration") {
-      return false;
-    }
-    const specifier = statement?.specifiers?.[0];
-    if (specifier?.type === "ImportDefaultSpecifier") {
-      return true;
-    }
-    return false;
-  });
+    return node.body.filter((statement)=>{
+        var _statement_specifiers;
+        if ('ImportDeclaration' !== statement.type) return false;
+        const specifier = null == statement ? void 0 : null == (_statement_specifiers = statement.specifiers) ? void 0 : _statement_specifiers[0];
+        if ((null == specifier ? void 0 : specifier.type) === 'ImportDefaultSpecifier') return true;
+        return false;
+    });
 }
 function getIdentifierInPattern(name, node) {
-  if (import_asserts.asserts.isIdentifier(node) && node.name === name) {
-    return node;
-  }
-  if (import_asserts.asserts.isObjectPattern(node)) {
-    for (const prop of node.properties) {
-      if (import_asserts.asserts.isAssignmentProperty(prop)) {
-        return getIdentifierInPattern(name, prop.value);
-      }
-      if (import_asserts.asserts.isRestElement(prop)) {
-        return getIdentifierInPattern(name, prop);
-      }
+    if (external_asserts_js_namespaceObject.asserts.isIdentifier(node) && node.name === name) return node;
+    if (external_asserts_js_namespaceObject.asserts.isObjectPattern(node)) for (const prop of node.properties){
+        if (external_asserts_js_namespaceObject.asserts.isAssignmentProperty(prop)) return getIdentifierInPattern(name, prop.value);
+        if (external_asserts_js_namespaceObject.asserts.isRestElement(prop)) return getIdentifierInPattern(name, prop);
     }
-  }
-  if (import_asserts.asserts.isArrayPattern(node)) {
-    for (const el of node.elements) {
-      if (el) {
-        const result = getIdentifierInPattern(name, el);
-        if (result) {
-          return result;
+    if (external_asserts_js_namespaceObject.asserts.isArrayPattern(node)) {
+        for (const el of node.elements)if (el) {
+            const result = getIdentifierInPattern(name, el);
+            if (result) return result;
         }
-      }
     }
-  }
-  if (import_asserts.asserts.isRestElement(node)) {
-    return getIdentifierInPattern(name, node.argument);
-  }
-  if (import_asserts.asserts.isAssignmentPattern(node)) {
-    return getIdentifierInPattern(name, node.left);
-  }
+    if (external_asserts_js_namespaceObject.asserts.isRestElement(node)) return getIdentifierInPattern(name, node.argument);
+    if (external_asserts_js_namespaceObject.asserts.isAssignmentPattern(node)) return getIdentifierInPattern(name, node.left);
 }
 function getIdentifierInDeclaration(name, node) {
-  function getId(node2) {
-    return import_asserts.asserts.isIdentifier(node2.id) && node2.id.name === name ? node2.id : void 0;
-  }
-  if (import_asserts.asserts.isFunctionDeclaration(node)) {
-    return getId(node);
-  }
-  if (import_asserts.asserts.isClassDeclaration(node)) {
-    return getId(node);
-  }
-  if (import_asserts.asserts.isVariableDeclaration(node)) {
-    return node.declarations.find(
-      (item) => getIdentifierInPattern(name, item.id)
-    )?.id;
-  }
+    function getId(node) {
+        return external_asserts_js_namespaceObject.asserts.isIdentifier(node.id) && node.id.name === name ? node.id : void 0;
+    }
+    if (external_asserts_js_namespaceObject.asserts.isFunctionDeclaration(node)) return getId(node);
+    if (external_asserts_js_namespaceObject.asserts.isClassDeclaration(node)) return getId(node);
+    if (external_asserts_js_namespaceObject.asserts.isVariableDeclaration(node)) {
+        var _node_declarations_find;
+        return null == (_node_declarations_find = node.declarations.find((item)=>getIdentifierInPattern(name, item.id))) ? void 0 : _node_declarations_find.id;
+    }
 }
 function getIdentifierInImport(name, node) {
-  if (import_asserts.asserts.isImportDeclaration(node)) {
-    for (const specifier of node.specifiers ?? []) {
-      if (specifier.local.name === name) {
-        return specifier.local;
-      }
+    if (external_asserts_js_namespaceObject.asserts.isImportDeclaration(node)) {
+        for (const specifier of node.specifiers ?? [])if (specifier.local.name === name) return specifier.local;
     }
-  }
 }
 function getIdentifierInExport(name, node) {
-  if (import_asserts.asserts.isExportNamedDeclaration(node)) {
-    if (node.declaration) {
-      return getIdentifierInDeclaration(name, node.declaration);
-    }
-    for (const specifier of node.specifiers ?? []) {
-      if (specifier.exported.name === name) {
-        return specifier.exported;
-      }
+    if (external_asserts_js_namespaceObject.asserts.isExportNamedDeclaration(node)) {
+        if (node.declaration) return getIdentifierInDeclaration(name, node.declaration);
+        for (const specifier of node.specifiers ?? [])if (specifier.exported.name === name) return specifier.exported;
     }
-  }
-  if (import_asserts.asserts.isExportAllDeclaration(node) && node.exported) {
-    if (node.exported.name === name) {
-      return node.exported;
+    if (external_asserts_js_namespaceObject.asserts.isExportAllDeclaration(node) && node.exported) {
+        if (node.exported.name === name) return node.exported;
     }
-  }
 }
-function canParse(code, ecmaVersion2) {
-  try {
-    (0, import_acorn.parse)(code, {
-      ecmaVersion: ecmaVersion2,
-      sourceType: typeof ecmaVersion2 === "number" && ecmaVersion2 <= 5 ? "script" : "module"
-    });
-    return true;
-  } catch (err) {
-    return false;
-  }
+function canParse(code, ecmaVersion) {
+    try {
+        (0, external_acorn_namespaceObject.parse)(code, {
+            ecmaVersion,
+            sourceType: 'number' == typeof ecmaVersion && ecmaVersion <= 5 ? "script" : 'module'
+        });
+        return true;
+    } catch (err) {
+        return false;
+    }
 }
 function isES5(code) {
-  return canParse(code, 5);
+    return canParse(code, 5);
 }
 function isES6(code) {
-  return canParse(code, 6);
+    return canParse(code, 6);
 }
 function detectECMAVersion(code) {
-  if (isES6(code)) {
-    if (isES5(code))
-      return import_types.ECMAVersion.ES5;
-    return import_types.ECMAVersion.ES6;
-  }
-  return import_types.ECMAVersion.ES7P;
+    if (isES6(code)) {
+        if (isES5(code)) return external_types_js_namespaceObject.ECMAVersion.ES5;
+        return external_types_js_namespaceObject.ECMAVersion.ES6;
+    }
+    return external_types_js_namespaceObject.ECMAVersion.ES7P;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  canParse,
-  detectECMAVersion,
-  getDefaultImports,
-  getIdentifierInDeclaration,
-  getIdentifierInExport,
-  getIdentifierInImport,
-  getIdentifierInPattern,
-  isES5,
-  isES6,
-  isSameSemantics
+exports.canParse = __webpack_exports__.canParse;
+exports.detectECMAVersion = __webpack_exports__.detectECMAVersion;
+exports.getDefaultImports = __webpack_exports__.getDefaultImports;
+exports.getIdentifierInDeclaration = __webpack_exports__.getIdentifierInDeclaration;
+exports.getIdentifierInExport = __webpack_exports__.getIdentifierInExport;
+exports.getIdentifierInImport = __webpack_exports__.getIdentifierInImport;
+exports.getIdentifierInPattern = __webpack_exports__.getIdentifierInPattern;
+exports.isES5 = __webpack_exports__.isES5;
+exports.isES6 = __webpack_exports__.isES6;
+exports.isSameSemantics = __webpack_exports__.isSameSemantics;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "canParse",
+    "detectECMAVersion",
+    "getDefaultImports",
+    "getIdentifierInDeclaration",
+    "getIdentifierInExport",
+    "getIdentifierInImport",
+    "getIdentifierInPattern",
+    "isES5",
+    "isES6",
+    "isSameSemantics"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });

package/dist/esm/build/envinfo.mjs

@@ -0,0 +1,57 @@
+import { helpers, run } from "envinfo";
+import { exec } from "child_process";
+const getCPUInfo = ()=>helpers.getCPUInfo().then((res)=>res[1]);
+const getOSInfo = ()=>helpers.getOSInfo().then((res)=>res[1]);
+const getMemoryInfo = ()=>helpers.getMemoryInfo().then((res)=>res[1]);
+const getNodeVersion = ()=>helpers.getNodeInfo().then((res)=>res[1]);
+const getYarnVersion = ()=>helpers.getYarnInfo().then((res)=>res[1]);
+const getNpmVersion = ()=>helpers.getnpmInfo().then((res)=>res[1]);
+const getPnpmVersion = ()=>helpers.getpnpmInfo().then((res)=>res[1]);
+function getNpmPackageVersion(pkg) {
+    const isArray = Array.isArray(pkg);
+    return run({
+        npmPackages: isArray ? pkg : [
+            pkg
+        ]
+    }, {
+        json: true,
+        showNotFound: true
+    }).then((res)=>{
+        const { npmPackages = {} } = JSON.parse(res) || {};
+        return isArray ? pkg.map((e)=>npmPackages[e] || 'Not Found') : npmPackages[pkg];
+    });
+}
+function getGlobalNpmPackageVersion(pkg) {
+    const isArray = Array.isArray(pkg);
+    return run({
+        npmGlobalPackages: isArray ? pkg : [
+            pkg
+        ]
+    }, {
+        json: true,
+        showNotFound: true
+    }).then((res)=>{
+        const { npmGlobalPackages = {} } = JSON.parse(res) || {};
+        return isArray ? pkg.map((e)=>npmGlobalPackages[e] || 'Not Found') : npmGlobalPackages[pkg];
+    });
+}
+function getGitBranch() {
+    return new Promise((resolve, reject)=>{
+        exec('git branch --show-current', (err, stdout)=>{
+            if (err) exec('git branch', (err, stdout)=>{
+                if (err) reject(err);
+                else resolve(stdout.split('\n').map((e)=>e.replace('* ', '')).join('').trim());
+            });
+            else resolve(stdout.trim());
+        });
+    });
+}
+function getGitRepo() {
+    return new Promise((resolve, reject)=>{
+        exec('git config --get remote.origin.url', (err, stdout)=>{
+            if (err) reject(err);
+            else resolve(stdout.trim());
+        });
+    });
+}
+export { getCPUInfo, getGitBranch, getGitRepo, getGlobalNpmPackageVersion, getMemoryInfo, getNodeVersion, getNpmPackageVersion, getNpmVersion, getOSInfo, getPnpmVersion, getYarnVersion };

package/dist/esm/build/file/cache.mjs

@@ -0,0 +1,23 @@
+import fs_extra from "fs-extra";
+const cache = new Map();
+async function readFile(path) {
+    if (cache.has(path)) return cache.get(path);
+    const res = await fs_extra.readFile(path, 'utf-8');
+    cache.set(path, res);
+    return res;
+}
+function readFileSync(path) {
+    if (cache.has(path)) return cache.get(path);
+    const res = fs_extra.readFileSync(path, 'utf-8');
+    cache.set(path, res);
+    return res;
+}
+async function readJSON(path) {
+    const str = await readFile(path);
+    return JSON.parse(str);
+}
+function readJSONSync(path) {
+    const str = readFileSync(path);
+    return JSON.parse(str);
+}
+export { readFile, readFileSync, readJSON, readJSONSync };

package/dist/esm/build/file/index.mjs

@@ -0,0 +1,4 @@
+export * from "./sharding.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE_fs_extra_ce68a66b__ from "fs-extra";
+import * as __WEBPACK_EXTERNAL_MODULE__cache_mjs_b6df9da1__ from "./cache.mjs";
+export { __WEBPACK_EXTERNAL_MODULE__cache_mjs_b6df9da1__ as cache, __WEBPACK_EXTERNAL_MODULE_fs_extra_ce68a66b__ as fse };

package/dist/esm/build/file/sharding.mjs

@@ -0,0 +1,50 @@
+import fs_extra from "fs-extra";
+import fs from "fs";
+import path from "path";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class FileSharding {
+    createVirtualShardingFiles(ext = '', index = 0) {
+        const bf = Buffer.from(this.content, this.encoding);
+        const res = [];
+        const threshold = this.limitBytes;
+        let tmpBytes = 0;
+        while(bf.byteLength > tmpBytes){
+            res.push(bf.subarray(tmpBytes, tmpBytes + threshold));
+            tmpBytes += threshold;
+        }
+        return res.map((e, i)=>({
+                filename: `${i + index}${ext}`,
+                content: e
+            }));
+    }
+    async writeStringToFolder(folder, ext = '', index) {
+        const dist = path.resolve(folder);
+        await fs_extra.ensureDir(dist);
+        const res = this.createVirtualShardingFiles(ext, index);
+        await Promise.all(res.map((e)=>new Promise((resolve, reject)=>{
+                const stream = fs.createWriteStream(path.join(dist, e.filename), this.encoding);
+                stream.end(e.content);
+                stream.once('close', ()=>resolve(void 0));
+                stream.once('error', (err)=>reject(err));
+            })));
+        return res;
+    }
+    constructor(content, limitBytes = 10485760, encoding = 'utf-8'){
+        _define_property(this, "content", void 0);
+        _define_property(this, "limitBytes", void 0);
+        _define_property(this, "encoding", void 0);
+        this.content = content;
+        this.limitBytes = limitBytes;
+        this.encoding = encoding;
+    }
+}
+export { FileSharding };

package/dist/esm/build/index.mjs

@@ -0,0 +1,6 @@
+import * as __WEBPACK_EXTERNAL_MODULE__file_index_mjs_bb48710d__ from "./file/index.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__json_mjs_4d5c7582__ from "./json.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__server_mjs_d774bffd__ from "./server.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__envinfo_mjs_e2a5d4a8__ from "./envinfo.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__process_mjs_2ae7d58e__ from "./process.mjs";
+export { __WEBPACK_EXTERNAL_MODULE__envinfo_mjs_e2a5d4a8__ as EnvInfo, __WEBPACK_EXTERNAL_MODULE__file_index_mjs_bb48710d__ as File, __WEBPACK_EXTERNAL_MODULE__json_mjs_4d5c7582__ as Json, __WEBPACK_EXTERNAL_MODULE__process_mjs_2ae7d58e__ as Process, __WEBPACK_EXTERNAL_MODULE__server_mjs_d774bffd__ as Server };

package/dist/esm/build/json.mjs

@@ -0,0 +1,66 @@
+import { JsonStreamStringify } from "json-stream-stringify";
+import { dirname, join } from "path";
+import { Package } from "../common/index.mjs";
+import { Transform } from "stream";
+const maxFileSize = 419430400;
+function stringify(json, replacer, space, cycle) {
+    const jsonList = [];
+    if (json && 'object' == typeof json) return new Promise((resolve, reject)=>{
+        const stream = new JsonStreamStringify(json, replacer, space, cycle);
+        let currentLength = 0;
+        let currentContent = '';
+        const batchProcessor = new Transform({
+            readableObjectMode: true,
+            transform (chunk, _encoding, callback) {
+                const lines = chunk.toString().split('\\n');
+                lines.forEach((line)=>{
+                    if (currentLength + line.length > maxFileSize) {
+                        jsonList.push(currentContent);
+                        currentContent = '';
+                        currentLength = 0;
+                    }
+                    if (line.length) {
+                        currentContent += line;
+                        currentLength += line.length;
+                    }
+                });
+                callback();
+            }
+        });
+        stream.pipe(batchProcessor).on('data', (line)=>{
+            if (currentLength + line.length > maxFileSize) {
+                jsonList.push(currentContent);
+                currentContent = '';
+                currentLength = 0;
+            }
+            if (line.length) {
+                currentContent += line;
+                currentLength += line.length;
+            }
+        }).on('end', ()=>{
+            if (jsonList.length < 1) jsonList.push(currentContent);
+            resolve(jsonList);
+        }).on('error', (err)=>reject(err));
+    });
+    return Promise.resolve(JSON.stringify(json, replacer, space));
+}
+const readPackageJson = (file, readFile)=>{
+    let result;
+    let current = file;
+    while('/' !== current && !result){
+        const parent = dirname(current);
+        if (parent === current) break;
+        current = parent;
+        if (readFile) result = readFile(join(current, 'package.json'));
+        if (readFile) {
+            if (!(null == result ? void 0 : result.name)) result = void 0;
+        } else result = Package.getPackageMetaFromModulePath(file);
+    }
+    if (!result) return;
+    if (readFile && (!result.name || !result.version)) return readPackageJson(dirname(current), readFile);
+    return {
+        ...result,
+        root: current
+    };
+};
+export { readPackageJson, stringify };

package/dist/esm/build/process.mjs

@@ -0,0 +1,17 @@
+import { filesize } from "filesize";
+import { memoryUsage, pid } from "process";
+function getMemoryUsage() {
+    return memoryUsage();
+}
+function getMemoryUsageMessage() {
+    const usage = getMemoryUsage();
+    const msgs = [
+        `RSS: ${filesize(usage.rss)}`,
+        `Heap Total: ${filesize(usage.heapTotal)}`,
+        `Heap Used: ${filesize(usage.heapUsed)}`
+    ];
+    if (usage.arrayBuffers) msgs.push(`ArrayBuffers: ${filesize(usage.arrayBuffers)}`);
+    if (usage.external) msgs.push(`External: ${filesize(usage.external)}`);
+    return `["${pid}" Memory Usage] ${msgs.join(', ')}`;
+}
+export { getMemoryUsage, getMemoryUsageMessage };