phecda-server/dist/chunk-URKOYTBU.mjs

server framework that provide IOC/type-reuse/http&rpc-adaptor

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

// src/common.ts
var ERROR_SYMBOL = "__PS_ERROR__";
var IS_DEV = process.env.NODE_ENV === "development";
var IS_ONLY_GENERATE = !!process.env.PS_GENERATE;
var IS_STRICT = !!process.env.PS_STRICT;
var IS_PURE = !!process.env.PS_PURE;
var LOG_LEVEL = Number(process.env.PS_LOG_LEVEL || 0);
var PS_EXIT_CODE = /* @__PURE__ */ (function(PS_EXIT_CODE2) {
  PS_EXIT_CODE2[PS_EXIT_CODE2["RELAUNCH"] = 4171] = "RELAUNCH";
  PS_EXIT_CODE2[PS_EXIT_CODE2["EXIT"] = 4172] = "EXIT";
  return PS_EXIT_CODE2;
})({});

// src/utils.ts
import pc from "picocolors";
import { Mixin } from "ts-mixer";
var isObject = /* @__PURE__ */ __name((fn) => fn !== null && typeof fn === "object", "isObject");
var isPlainObject = /* @__PURE__ */ __name((fn) => {
  if (!isObject(fn)) return false;
  const proto = Object.getPrototypeOf(fn);
  if (proto === null) return true;
  const ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
  return typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
}, "isPlainObject");
var InternalLogger = class InternalLogger2 {
  static {
    __name(this, "InternalLogger");
  }
  time;
  color = {
    debug: "bgMagenta",
    error: "red",
    info: "gray",
    warn: "yellow",
    log: "green"
  };
  dateFormatter = new Intl.DateTimeFormat(void 0, {
    year: "numeric",
    hour: "numeric",
    minute: "numeric",
    second: "numeric",
    day: "2-digit",
    month: "2-digit"
  });
  diffTimestamp() {
    const now = Date.now();
    if (!this.time) return "";
    const diff = now - this.time;
    this.time = now;
    return diff ? pc.yellow(` +${diff}`) : "";
  }
  colorize(message, logLevel) {
    return pc[this.color[logLevel]](message);
  }
  isAllowLog(level) {
    const logLevel = {
      debug: -1,
      info: 0,
      log: 1,
      warn: 2,
      error: 3
    }[level];
    if (logLevel < LOG_LEVEL) return false;
    return true;
  }
  stringifyMessage(message, logLevel) {
    if (typeof message === "function") {
      const messageAsStr = Function.prototype.toString.call(message);
      const isClass = messageAsStr.startsWith("class ");
      if (isClass) {
        return this.stringifyMessage(message.name, logLevel);
      }
      return this.stringifyMessage(message(), logLevel);
    }
    return isPlainObject(message) || Array.isArray(message) ? `${this.colorize("Object:", logLevel)}
${JSON.stringify(message, (key, value) => typeof value === "bigint" ? value.toString() : value, 2)}
` : this.colorize(message, logLevel);
  }
  log(msg, level, ctx) {
    if (!this.isAllowLog(level)) return;
    msg = this.stringifyMessage(msg, level);
    const pidMsg = this.colorize(`[${process.env.PS_APP_NAME || "phecda-server"}] ${process.pid}`, level);
    const ctxMsg = ctx ? this.colorize(pc.bold(`[${ctx}] `), level) : "";
    const timeDiff = this.diffTimestamp();
    const levelMsg = this.colorize(level.toUpperCase().padStart(7, " "), level);
    process.stdout.write(`${pidMsg} ${this.dateFormatter.format(Date.now())} ${levelMsg} ${ctxMsg}${msg}${timeDiff}
`);
  }
};
var _logger = new InternalLogger();
function setLogger(logger) {
  _logger = logger;
}
__name(setLogger, "setLogger");
function getLogger() {
  return _logger;
}
__name(getLogger, "getLogger");
function log(msg, level = "log", ctx) {
  _logger.log(msg, level, ctx);
}
__name(log, "log");
function runMiddleware(ctx, middleware) {
  return new Promise((resolve) => {
    middleware(ctx.getRequest(), ctx.getResponse(), resolve);
  });
}
__name(runMiddleware, "runMiddleware");

// src/hmr.ts
function HMR(cb) {
  if (IS_DEV) {
    if (!globalThis.__PS_HMR__) globalThis.__PS_HMR__ = [];
    globalThis.__PS_HMR__.push(cb);
  }
}
__name(HMR, "HMR");
async function RELOAD(oldModels, newModels) {
  if (IS_DEV) {
    log("reload module...");
    for (const cb of globalThis.__PS_HMR__) await cb(oldModels, newModels);
    log("reload done");
  }
}
__name(RELOAD, "RELOAD");
function RELAUNCH() {
  if (IS_DEV) {
    log("relaunch...");
    process.exit(PS_EXIT_CODE.RELAUNCH);
  }
}
__name(RELAUNCH, "RELAUNCH");
function EXIT() {
  if (IS_DEV) {
    log("exit...");
    process.exit(PS_EXIT_CODE.EXIT);
  }
}
__name(EXIT, "EXIT");

export {
  __name,
  ERROR_SYMBOL,
  IS_DEV,
  IS_ONLY_GENERATE,
  IS_STRICT,
  IS_PURE,
  LOG_LEVEL,
  PS_EXIT_CODE,
  setLogger,
  getLogger,
  log,
  runMiddleware,
  Mixin,
  HMR,
  RELOAD,
  RELAUNCH,
  EXIT
};