@fesjs/utils/dist/index.mjs

@fesjs/utils

var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// src/index.ts
import { generate } from "@babel/generator";
import * as parser from "@babel/parser";
import traverse from "@babel/traverse";
import createDebug from "debug";
import deepmerge from "deepmerge";
import mkdirp from "mkdirp";
import Mustache from "mustache";
import portfinder2 from "portfinder";
import resolve from "resolve";
import rimraf from "rimraf";
import semver from "semver";
import yParser from "yargs-parser";

// src/changePort.ts
import process from "process";
var changePort_default = (port) => {
  process.send?.({
    type: "UPDATE_PORT",
    port
  });
};

// src/compatESModuleRequire.ts
function compatESModuleRequire(m) {
  if (m.__esModule && m.default?.default) {
    return m.default.default;
  }
  return m.default ?? m;
}

// src/delay.ts
var delay_default = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));

// src/getAppPath.ts
import { existsSync } from "fs";
import { join } from "path";

// src/winPath.ts
function winPath(path) {
  const isExtendedLengthPath = /^\\\\\?\\/.test(path);
  if (isExtendedLengthPath) {
    return path;
  }
  return path.replace(/\\/g, "/");
}

// src/getAppPath.ts
function getAppPath(absSrcPath) {
  for (const suffix of [".js", ".ts", ".jsm", ".jsx", ".tsx"]) {
    const p = winPath(join(absSrcPath, `app${suffix}`));
    if (existsSync(p)) {
      return p;
    }
  }
  return null;
}

// src/getHostName.ts
import process2 from "process";
var getHostName_default = (userHost) => process2.env.HOST || userHost || "0.0.0.0";

// src/getPort.ts
import portfinder from "portfinder";
async function getPort(defaultPort) {
  return portfinder.getPortPromise({
    port: defaultPort ? Number.parseInt(String(defaultPort), 10) : 8e3
  });
}

// src/getTargetsAndBrowsersList.ts
function getTargetsAndBrowsersList({ config }) {
  let targets = config.targets || {};
  targets = Object.keys(targets).reduce((memo, key) => {
    memo[key] = targets[key];
    return memo;
  }, {});
  let browserslist;
  if (Array.isArray(targets.browsers)) {
    browserslist = targets.browsers;
  } else {
    browserslist = Object.keys(targets).map((key) => `${key} >= ${targets[key]}`);
  }
  return {
    targets,
    browserslist
  };
}

// src/logger.ts
var logger_exports = {};
__export(logger_exports, {
  error: () => error,
  event: () => event,
  info: () => info,
  prefixes: () => prefixes,
  ready: () => ready,
  wait: () => wait,
  warn: () => warn
});
import pc from "picocolors";
var prefixes = {
  wait: `${pc.cyan("wait")}  -`,
  error: `${pc.red("error")} -`,
  warn: `${pc.yellow("warn")}  -`,
  ready: `${pc.green("ready")} -`,
  info: `${pc.cyan("info")}  -`,
  event: `${pc.magenta("event")} -`,
  debug: `${pc.gray("debug")} -`
};
function wait(...message) {
  console.log(prefixes.wait, ...message);
}
function error(...message) {
  console.error(prefixes.error, ...message);
}
function warn(...message) {
  console.warn(prefixes.warn, ...message);
}
function ready(...message) {
  console.log(prefixes.ready, ...message);
}
function info(...message) {
  console.log(prefixes.info, ...message);
}
function event(...message) {
  console.log(prefixes.event, ...message);
}

// src/mergeConfig.ts
function mergeConfig(defaultConfig, ...configs) {
  const ret = { ...defaultConfig };
  configs.forEach((config) => {
    if (!config) {
      return;
    }
    Object.keys(config).forEach((key) => {
      const val = config[key];
      if (typeof val === "function") {
        ret[key] = val(ret[key]);
      } else {
        ret[key] = val;
      }
    });
  });
  return ret;
}

// src/resolveRuntimeEnv.ts
import process3 from "process";
var prefixRE = /^FES_APP_/;
var ENV_SHOULD_PASS = ["NODE_ENV", "FES_ENV"];
var resolveRuntimeEnv_default = (publicPath) => {
  const env = {};
  Object.keys(process3.env).forEach((key) => {
    if (prefixRE.test(key) || ENV_SHOULD_PASS.includes(key)) {
      env[key] = process3.env[key];
    }
  });
  env.BASE_URL = publicPath;
  return env;
};

// src/stringifyObjValue.ts
import { cloneDeep } from "es-toolkit/compat";
var stringifyObjValue_default = (obj) => {
  const newObj = cloneDeep(obj);
  for (const key in newObj) {
    if (Object.prototype.hasOwnProperty.call(newObj, key)) {
      newObj[key] = JSON.stringify(newObj[key]);
    }
  }
  return newObj;
};
export {
  Mustache,
  changePort_default as changePort,
  compatESModuleRequire,
  createDebug,
  deepmerge,
  delay_default as delay,
  generate,
  getAppPath,
  getHostName_default as getHostName,
  getPort,
  getTargetsAndBrowsersList,
  logger_exports as logger,
  mergeConfig,
  mkdirp,
  parser,
  portfinder2 as portfinder,
  resolve,
  resolveRuntimeEnv_default as resolveRuntimeEnv,
  rimraf,
  semver,
  stringifyObjValue_default as stringifyObjValue,
  traverse,
  winPath,
  yParser
};