@modern-js/utils 2.22.0 → 2.22.1-alpha.0

package/dist/debug.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Create debug function with unified namespace prefix.
+ * @param scope - Custom module name of your debug function.
+ * @returns Debug function which namespace start with modern-js:.
+ */
+export declare const createDebugger: (scope: string) => import("../compiled/debug").Debugger;

package/dist/debug.js

@@ -0,0 +1,28 @@
+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 debug_exports = {};
+__export(debug_exports, {
+  createDebugger: () => createDebugger
+});
+module.exports = __toCommonJS(debug_exports);
+var import_debug = require("../compiled/debug");
+const createDebugger = (scope) => (0, import_debug.debug)(`modern-js:${scope}`);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDebugger
+});

package/dist/emptyDir.d.ts

@@ -0,0 +1 @@
+export declare const emptyDir: (dir: string) => Promise<void>;

package/dist/emptyDir.js

@@ -0,0 +1,52 @@
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var emptyDir_exports = {};
+__export(emptyDir_exports, {
+  emptyDir: () => emptyDir
+});
+module.exports = __toCommonJS(emptyDir_exports);
+var import_compiled = require("./compiled");
+const emptyDir = (dir) => __async(void 0, null, function* () {
+  if (yield import_compiled.fs.pathExists(dir)) {
+    yield import_compiled.fs.emptyDir(dir);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  emptyDir
+});

package/dist/ensureAbsolutePath.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ensure absolute file path.
+ * @param base - Base path to resolve relative from.
+ * @param filePath - Absolute or relative file path.
+ * @returns Resolved absolute file path.
+ */
+export declare const ensureAbsolutePath: (base: string, filePath: string) => string;

package/dist/ensureAbsolutePath.js

@@ -0,0 +1,38 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ensureAbsolutePath_exports = {};
+__export(ensureAbsolutePath_exports, {
+  ensureAbsolutePath: () => ensureAbsolutePath
+});
+module.exports = __toCommonJS(ensureAbsolutePath_exports);
+var import_path = __toESM(require("path"));
+const ensureAbsolutePath = (base, filePath) => import_path.default.isAbsolute(filePath) ? filePath : import_path.default.resolve(base, filePath);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureAbsolutePath
+});

package/dist/ensureArray.d.ts

@@ -0,0 +1 @@
+export declare const ensureArray: <T>(params: T | T[]) => T[];

package/dist/ensureArray.js

@@ -0,0 +1,32 @@
+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 ensureArray_exports = {};
+__export(ensureArray_exports, {
+  ensureArray: () => ensureArray
+});
+module.exports = __toCommonJS(ensureArray_exports);
+const ensureArray = (params) => {
+  if (Array.isArray(params)) {
+    return params;
+  }
+  return [params];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureArray
+});

package/dist/findExists.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Find first already exists file.
+ * @param files - Absolute file paths with extension.
+ * @returns The file path if exists, or false if no file exists.
+ */
+export declare const findExists: (files: string[]) => string | false;

package/dist/findExists.js

@@ -0,0 +1,45 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var findExists_exports = {};
+__export(findExists_exports, {
+  findExists: () => findExists
+});
+module.exports = __toCommonJS(findExists_exports);
+var import_fs = __toESM(require("fs"));
+const findExists = (files) => {
+  for (const file of files) {
+    if (import_fs.default.existsSync(file) && import_fs.default.statSync(file).isFile()) {
+      return file;
+    }
+  }
+  return false;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findExists
+});

package/dist/generateMetaTags.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright JS Foundation and other contributors.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/jantimon/html-webpack-plugin/blob/main/LICENSE
+ *
+ * Modified from https://github.com/jantimon/html-webpack-plugin/blob/2f5de7ab9e8bca60e9e200f2e4b4cfab90db28d4/index.js#L800
+ */
+export type MetaAttributes = {
+  [attributeName: string]: string | boolean;
+};
+export interface MetaOptions {
+  [name: string]: string | false | MetaAttributes;
+}
+export declare const generateMetaTags: (metaOptions?: MetaOptions) => string;

package/dist/generateMetaTags.js

@@ -0,0 +1,61 @@
+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 generateMetaTags_exports = {};
+__export(generateMetaTags_exports, {
+  generateMetaTags: () => generateMetaTags
+});
+module.exports = __toCommonJS(generateMetaTags_exports);
+const tagObjectToString = (tagDefinition) => {
+  const attributes = Object.keys(tagDefinition.attributes || {}).filter((attributeName) => tagDefinition.attributes[attributeName] !== false).map((attributeName) => {
+    if (tagDefinition.attributes[attributeName] === true) {
+      return attributeName;
+    }
+    return `${attributeName}="${tagDefinition.attributes[attributeName]}"`;
+  });
+  return `<${[tagDefinition.tagName].concat(attributes).join(" ")}>${tagDefinition.innerHTML || ""}${tagDefinition.voidTag ? "" : `</${tagDefinition.tagName}>`}`;
+};
+const generateMetaTags = (metaOptions) => {
+  if (!metaOptions) {
+    return "";
+  }
+  const metaTagAttributeObjects = Object.keys(metaOptions).map((metaName) => {
+    const metaTagContent = metaOptions[metaName];
+    return typeof metaTagContent === "string" ? {
+      name: metaName,
+      content: metaTagContent
+    } : metaTagContent;
+  }).filter((attribute) => attribute !== false);
+  return metaTagAttributeObjects.map((metaTagAttributes) => {
+    if (metaTagAttributes === false) {
+      throw new Error("Invalid meta tag");
+    }
+    return {
+      tagName: "meta",
+      voidTag: true,
+      attributes: metaTagAttributes
+    };
+  }).reduce(
+    (memo, tagObject) => `${memo}
+${tagObjectToString(tagObject)}`,
+    ""
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateMetaTags
+});

package/dist/getBrowserslist.d.ts

@@ -0,0 +1,2 @@
+export declare const defaults: string[];
+export declare const getBrowserslist: (appDirectory: string) => string[];

package/dist/getBrowserslist.js

@@ -0,0 +1,31 @@
+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 getBrowserslist_exports = {};
+__export(getBrowserslist_exports, {
+  defaults: () => defaults,
+  getBrowserslist: () => getBrowserslist
+});
+module.exports = __toCommonJS(getBrowserslist_exports);
+var import_compiled = require("./compiled");
+const defaults = ["> 0.01%", "not dead", "not op_mini all"];
+const getBrowserslist = (appDirectory) => import_compiled.browserslist.loadConfig({ path: appDirectory }) || defaults;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaults,
+  getBrowserslist
+});

package/dist/getCoreJsVersion.d.ts

@@ -0,0 +1 @@
+export declare const getCoreJsVersion: (corejsPkgPath: string) => string;

package/dist/getCoreJsVersion.js

@@ -0,0 +1,46 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getCoreJsVersion_exports = {};
+__export(getCoreJsVersion_exports, {
+  getCoreJsVersion: () => getCoreJsVersion
+});
+module.exports = __toCommonJS(getCoreJsVersion_exports);
+var fs = __toESM(require("../compiled/fs-extra"));
+const getCoreJsVersion = (corejsPkgPath) => {
+  try {
+    const { version } = fs.readJSONSync(corejsPkgPath);
+    const [major, minor] = version.split(".");
+    return `${major}.${minor}`;
+  } catch (err) {
+    return "3";
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCoreJsVersion
+});

package/dist/getEntryOptions.d.ts

@@ -0,0 +1 @@
+export declare const getEntryOptions: <T>(name: string, baseOptions?: T | undefined, optionsByEntries?: Record<string, T> | undefined, packageName?: string) => T | undefined;

package/dist/getEntryOptions.js

@@ -0,0 +1,54 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+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 getEntryOptions_exports = {};
+__export(getEntryOptions_exports, {
+  getEntryOptions: () => getEntryOptions
+});
+module.exports = __toCommonJS(getEntryOptions_exports);
+var import_is = require("./is");
+var import_constants = require("./constants");
+const getEntryOptions = (name, baseOptions, optionsByEntries, packageName) => {
+  if (optionsByEntries) {
+    let optionsByEntry = getOptionsByEntryName(name, optionsByEntries);
+    if (optionsByEntry === void 0 && name === import_constants.MAIN_ENTRY_NAME && packageName) {
+      optionsByEntry = getOptionsByEntryName(packageName, optionsByEntries);
+    }
+    return optionsByEntry !== void 0 ? (0, import_is.isPlainObject)(optionsByEntry) && (0, import_is.isPlainObject)(baseOptions) ? __spreadValues(__spreadValues({}, baseOptions), optionsByEntry) : optionsByEntry : baseOptions;
+  } else {
+    return baseOptions;
+  }
+};
+const getOptionsByEntryName = (name, optionsByEntries) => optionsByEntries.hasOwnProperty(name) ? optionsByEntries[name] : void 0;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEntryOptions
+});

package/dist/getPackageManager.d.ts

@@ -0,0 +1 @@
+export declare function getPackageManager(cwd?: string): Promise<"npm" | "yarn" | "pnpm">;

package/dist/getPackageManager.js

@@ -0,0 +1,87 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var getPackageManager_exports = {};
+__export(getPackageManager_exports, {
+  getPackageManager: () => getPackageManager
+});
+module.exports = __toCommonJS(getPackageManager_exports);
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_compiled = require("./compiled");
+var import_nodeEnv = require("./nodeEnv");
+const MAX_TIMES = 5;
+function getPackageManager() {
+  return __async(this, arguments, function* (cwd = process.cwd()) {
+    let appDirectory = cwd;
+    let times = 0;
+    while (import_os.default.homedir() !== appDirectory && times < MAX_TIMES) {
+      times++;
+      if (import_compiled.fs.existsSync(import_path.default.resolve(appDirectory, "pnpm-lock.yaml"))) {
+        return "pnpm";
+      }
+      if (import_compiled.fs.existsSync(import_path.default.resolve(appDirectory, "yarn.lock"))) {
+        return "yarn";
+      }
+      if (import_compiled.fs.existsSync(import_path.default.resolve(appDirectory, "package-lock.json"))) {
+        return "npm";
+      }
+      appDirectory = import_path.default.join(appDirectory, "..");
+    }
+    if (yield (0, import_nodeEnv.canUsePnpm)()) {
+      return "pnpm";
+    }
+    if (yield (0, import_nodeEnv.canUseYarn)()) {
+      return "yarn";
+    }
+    return "npm";
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPackageManager
+});

package/dist/getPort.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Get available free port.
+ * @param port - Current port want to use.
+ * @param tryLimits - Maximum number of retries.
+ * @param strictPort - Whether to throw an error when the port is occupied.
+ * @returns Available port number.
+ */
+export declare const getPort: (port: string | number, {
+  tryLimits,
+  strictPort
+}?: {
+  tryLimits?: number | undefined;
+  strictPort?: boolean | undefined;
+}) => Promise<number>;

package/dist/getPort.js

@@ -0,0 +1,112 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var getPort_exports = {};
+__export(getPort_exports, {
+  getPort: () => getPort
+});
+module.exports = __toCommonJS(getPort_exports);
+var import_net = __toESM(require("net"));
+var import_compiled = require("./compiled");
+var import_logger = require("./logger");
+const getPort = (_0, ..._1) => __async(void 0, [_0, ..._1], function* (port, {
+  tryLimits = 20,
+  strictPort = false
+} = {}) {
+  if (typeof port === "string") {
+    port = parseInt(port, 10);
+  }
+  if (strictPort) {
+    tryLimits = 1;
+  }
+  const original = port;
+  let found = false;
+  let attempts = 0;
+  while (!found && attempts <= tryLimits) {
+    try {
+      yield new Promise((resolve, reject) => {
+        const server = import_net.default.createServer();
+        server.unref();
+        server.on("error", reject);
+        server.listen(
+          {
+            port,
+            host: "0.0.0.0"
+          },
+          () => {
+            found = true;
+            server.close(resolve);
+          }
+        );
+      });
+    } catch (e) {
+      if (e.code !== "EADDRINUSE") {
+        throw e;
+      }
+      port++;
+      attempts++;
+    }
+  }
+  if (port !== original) {
+    if (strictPort) {
+      throw new Error(
+        `Port "${original}" is occupied, please choose another one.`
+      );
+    } else {
+      import_logger.logger.info(
+        `Something is already running on port ${original}. ${import_compiled.chalk.yellow(
+          `Use port ${port} instead.`
+        )}`
+      );
+    }
+  }
+  return port;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPort
+});