advanced-js-kit/dist/node/network/index.cjs

Modern TypeScript utility library with tree-shaking support - Array, String, Number, Network, Sleep, and JWT utilities for JavaScript and TypeScript projects

'use strict';

var isPortReachable = require('is-port-reachable');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var isPortReachable__default = /*#__PURE__*/_interopDefault(isPortReachable);

// src/node/network/index.ts

// src/universal/utils/index.ts
function isNodeEnvironment() {
  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
}
function isBrowserEnvironment() {
  return typeof window !== "undefined" && typeof document !== "undefined";
}
function isWebWorkerEnvironment() {
  return typeof globalThis.importScripts === "function" && typeof window === "undefined";
}
function getEnvironment() {
  if (isNodeEnvironment()) return "node";
  if (isBrowserEnvironment()) return "browser";
  if (isWebWorkerEnvironment()) return "webworker";
  return "unknown";
}
var EnvironmentError = class extends Error {
  constructor(message, requiredEnvironment, currentEnvironment) {
    super(message);
    this.requiredEnvironment = requiredEnvironment;
    this.currentEnvironment = currentEnvironment;
    this.name = "EnvironmentError";
  }
};
function assertNodeEnvironment() {
  if (!isNodeEnvironment()) {
    throw new EnvironmentError(
      "This functionality requires Node.js environment",
      "node",
      getEnvironment()
    );
  }
}

// src/node/network/index.ts
var PortError = class extends Error {
  constructor(message, port, host) {
    super(message);
    this.port = port;
    this.host = host;
    this.name = "PortError";
  }
};
var validatePort = (port) => {
  if (!Number.isInteger(port) || port < 1 || port > 65535) {
    throw new PortError(`Invalid port number: ${port}. Must be an integer between 1 and 65535.`, port);
  }
};
var isPortInUse = async (port, options = {}) => {
  assertNodeEnvironment();
  validatePort(port);
  const { host = "localhost", timeout = 5e3 } = options;
  try {
    return await isPortReachable__default.default(port, { host, timeout });
  } catch (error) {
    throw new PortError(
      `Failed to check port ${port} on ${host}: ${error instanceof Error ? error.message : "Unknown error"}`,
      port,
      host
    );
  }
};
var isPortAvailable = async (port, options = {}) => {
  return !await isPortInUse(port, options);
};
var findAvailablePort = async (options = {}) => {
  const {
    startPort = 3e3,
    endPort = 65535,
    maxTries = 100,
    host = "localhost",
    timeout = 5e3
  } = options;
  validatePort(startPort);
  validatePort(endPort);
  if (startPort > endPort) {
    throw new PortError(`Start port (${startPort}) cannot be greater than end port (${endPort})`);
  }
  let currentPort = startPort;
  let attempts = 0;
  while (currentPort <= endPort && attempts < maxTries) {
    try {
      const available = await isPortAvailable(currentPort, { host, timeout });
      if (available) {
        return currentPort;
      }
    } catch (error) {
      console.warn(`Error checking port ${currentPort}: ${error instanceof Error ? error.message : "Unknown error"}`);
    }
    currentPort++;
    attempts++;
  }
  throw new PortError(
    `No available port found in range ${startPort}-${endPort} after ${attempts} attempts`,
    void 0,
    host
  );
};
var checkMultiplePorts = async (ports, options = {}) => {
  const results = /* @__PURE__ */ new Map();
  ports.forEach(validatePort);
  const checks = ports.map(async (port) => {
    try {
      const available = await isPortAvailable(port, options);
      return { port, available };
    } catch (error) {
      console.warn(`Error checking port ${port}: ${error instanceof Error ? error.message : "Unknown error"}`);
      return { port, available: false };
    }
  });
  const checkResults = await Promise.all(checks);
  checkResults.forEach(({ port, available }) => {
    results.set(port, available);
  });
  return results;
};
var waitForPort = async (port, targetState, options = {}) => {
  validatePort(port);
  const {
    host = "localhost",
    timeout = 5e3,
    pollInterval = 1e3,
    overallTimeout = 3e4
  } = options;
  const startTime = Date.now();
  while (Date.now() - startTime < overallTimeout) {
    try {
      const inUse = await isPortInUse(port, { host, timeout });
      const currentState = inUse ? "in-use" : "available";
      if (currentState === targetState) {
        return;
      }
    } catch (error) {
      console.warn(`Error checking port ${port}: ${error instanceof Error ? error.message : "Unknown error"}`);
    }
    await new Promise((resolve) => setTimeout(resolve, pollInterval));
  }
  throw new PortError(
    `Timeout waiting for port ${port} to become ${targetState} after ${overallTimeout}ms`,
    port,
    host
  );
};

exports.PortError = PortError;
exports.checkMultiplePorts = checkMultiplePorts;
exports.findAvailablePort = findAvailablePort;
exports.isPortAvailable = isPortAvailable;
exports.isPortInUse = isPortInUse;
exports.waitForPort = waitForPort;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=index.cjs.map