nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_chunks/_deps/c12.mjs

@@ -0,0 +1,510 @@
+import { existsSync, statSync, promises } from 'node:fs';
+import { rm, readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { homedir } from 'node:os';
+import { r as resolveModulePath } from './exsolve.mjs';
+import { createJiti } from 'jiti';
+import { r as read, a as readUser } from './rc9.mjs';
+import { defu } from 'defu';
+import { f as findWorkspaceDir, r as readPackageJSON } from './pkg-types.mjs';
+import { m as mainExports } from './dotenv.mjs';
+import { r as resolve, j as join, d as dirname, b as basename, e as extname, n as normalize } from './pathe.mjs';
+import { d as debounce } from './perfect-debounce.mjs';
+
+async function setupDotenv(options) {
+  const targetEnvironment = options.env ?? process.env;
+  const environment = await loadDotenv({
+    cwd: options.cwd,
+    fileName: options.fileName ?? ".env",
+    env: targetEnvironment,
+    interpolate: options.interpolate ?? true
+  });
+  const dotenvVars = getDotEnvVars(targetEnvironment);
+  for (const key in environment) {
+    if (key.startsWith("_")) {
+      continue;
+    }
+    if (targetEnvironment[key] === void 0 || dotenvVars.has(key)) {
+      targetEnvironment[key] = environment[key];
+    }
+  }
+  return environment;
+}
+async function loadDotenv(options) {
+  const environment = /* @__PURE__ */ Object.create(null);
+  const cwd = resolve(options.cwd || ".");
+  const _fileName = options.fileName || ".env";
+  const dotenvFiles = typeof _fileName === "string" ? [_fileName] : _fileName;
+  const dotenvVars = getDotEnvVars(options.env || {});
+  Object.assign(environment, options.env);
+  for (const file of dotenvFiles) {
+    const dotenvFile = resolve(cwd, file);
+    if (!statSync(dotenvFile, { throwIfNoEntry: false })?.isFile()) {
+      continue;
+    }
+    const parsed = mainExports.parse(await promises.readFile(dotenvFile, "utf8"));
+    for (const key in parsed) {
+      if (key in environment && !dotenvVars.has(key)) {
+        continue;
+      }
+      environment[key] = parsed[key];
+      dotenvVars.add(key);
+    }
+  }
+  if (options.interpolate) {
+    interpolate(environment);
+  }
+  return environment;
+}
+function interpolate(target, source = {}, parse = (v) => v) {
+  function getValue(key) {
+    return source[key] === void 0 ? target[key] : source[key];
+  }
+  function interpolate2(value, parents = []) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    const matches = value.match(/(.?\${?(?:[\w:]+)?}?)/g) || [];
+    return parse(
+      // eslint-disable-next-line unicorn/no-array-reduce
+      matches.reduce((newValue, match) => {
+        const parts = /(.?)\${?([\w:]+)?}?/g.exec(match) || [];
+        const prefix = parts[1];
+        let value2, replacePart;
+        if (prefix === "\\") {
+          replacePart = parts[0] || "";
+          value2 = replacePart.replace(String.raw`\$`, "$");
+        } else {
+          const key = parts[2];
+          replacePart = (parts[0] || "").slice(prefix.length);
+          if (parents.includes(key)) {
+            console.warn(
+              `Please avoid recursive environment variables ( loop: ${parents.join(
+                " > "
+              )} > ${key} )`
+            );
+            return "";
+          }
+          value2 = getValue(key);
+          value2 = interpolate2(value2, [...parents, key]);
+        }
+        return value2 === void 0 ? newValue : newValue.replace(replacePart, value2);
+      }, value)
+    );
+  }
+  for (const key in target) {
+    target[key] = interpolate2(getValue(key));
+  }
+}
+function getDotEnvVars(targetEnvironment) {
+  const globalRegistry = globalThis.__c12_dotenv_vars__ ||= /* @__PURE__ */ new Map();
+  if (!globalRegistry.has(targetEnvironment)) {
+    globalRegistry.set(targetEnvironment, /* @__PURE__ */ new Set());
+  }
+  return globalRegistry.get(targetEnvironment);
+}
+
+const _normalize = (p) => p?.replace(/\\/g, "/");
+const ASYNC_LOADERS = {
+  ".yaml": () => import('./confbox.mjs').then(function (n) { return n.y; }).then((r) => r.parseYAML),
+  ".yml": () => import('./confbox.mjs').then(function (n) { return n.y; }).then((r) => r.parseYAML),
+  ".jsonc": () => import('./confbox.mjs').then(function (n) { return n.c; }).then((r) => r.parseJSONC),
+  ".json5": () => import('./confbox.mjs').then(function (n) { return n.j; }).then((r) => r.parseJSON5),
+  ".toml": () => import('./confbox.mjs').then(function (n) { return n.t; }).then((r) => r.parseTOML)
+};
+const SUPPORTED_EXTENSIONS = Object.freeze([
+  // with jiti
+  ".js",
+  ".ts",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".json",
+  // with confbox
+  ".jsonc",
+  ".json5",
+  ".yaml",
+  ".yml",
+  ".toml"
+]);
+async function loadConfig(options) {
+  options.cwd = resolve(process.cwd(), options.cwd || ".");
+  options.name = options.name || "config";
+  options.envName = options.envName ?? process.env.NODE_ENV;
+  options.configFile = options.configFile ?? (options.name === "config" ? "config" : `${options.name}.config`);
+  options.rcFile = options.rcFile ?? `.${options.name}rc`;
+  if (options.extend !== false) {
+    options.extend = {
+      extendKey: "extends",
+      ...options.extend
+    };
+  }
+  const _merger = options.merger || defu;
+  options.jiti = options.jiti || createJiti(join(options.cwd, options.configFile), {
+    interopDefault: true,
+    moduleCache: false,
+    extensions: [...SUPPORTED_EXTENSIONS],
+    ...options.jitiOptions
+  });
+  const r = {
+    config: {},
+    cwd: options.cwd,
+    configFile: resolve(options.cwd, options.configFile),
+    layers: [],
+    _configFile: void 0
+  };
+  const rawConfigs = {
+    overrides: options.overrides,
+    main: void 0,
+    rc: void 0,
+    packageJson: void 0,
+    defaultConfig: options.defaultConfig
+  };
+  if (options.dotenv) {
+    await setupDotenv({
+      cwd: options.cwd,
+      ...options.dotenv === true ? {} : options.dotenv
+    });
+  }
+  const _mainConfig = await resolveConfig(".", options);
+  if (_mainConfig.configFile) {
+    rawConfigs.main = _mainConfig.config;
+    r.configFile = _mainConfig.configFile;
+    r._configFile = _mainConfig._configFile;
+  }
+  if (_mainConfig.meta) {
+    r.meta = _mainConfig.meta;
+  }
+  if (options.rcFile) {
+    const rcSources = [];
+    rcSources.push(read({ name: options.rcFile, dir: options.cwd }));
+    if (options.globalRc) {
+      const workspaceDir = await findWorkspaceDir(options.cwd).catch(() => {
+      });
+      if (workspaceDir) {
+        rcSources.push(read({ name: options.rcFile, dir: workspaceDir }));
+      }
+      rcSources.push(readUser({ name: options.rcFile, dir: options.cwd }));
+    }
+    rawConfigs.rc = _merger({}, ...rcSources);
+  }
+  if (options.packageJson) {
+    const keys = (Array.isArray(options.packageJson) ? options.packageJson : [
+      typeof options.packageJson === "string" ? options.packageJson : options.name
+    ]).filter((t) => t && typeof t === "string");
+    const pkgJsonFile = await readPackageJSON(options.cwd).catch(() => {
+    });
+    const values = keys.map((key) => pkgJsonFile?.[key]);
+    rawConfigs.packageJson = _merger({}, ...values);
+  }
+  const configs = {};
+  for (const key in rawConfigs) {
+    const value = rawConfigs[key];
+    configs[key] = await (typeof value === "function" ? value({ configs, rawConfigs }) : value);
+  }
+  if (Array.isArray(configs.main)) {
+    r.config = configs.main;
+  } else {
+    r.config = _merger(
+      configs.overrides,
+      configs.main,
+      configs.rc,
+      configs.packageJson,
+      configs.defaultConfig
+    );
+    if (options.extend) {
+      await extendConfig(r.config, options);
+      r.layers = r.config._layers;
+      delete r.config._layers;
+      r.config = _merger(r.config, ...r.layers.map((e) => e.config));
+    }
+  }
+  const baseLayers = [
+    configs.overrides && {
+      config: configs.overrides,
+      configFile: void 0,
+      cwd: void 0
+    },
+    { config: configs.main, configFile: options.configFile, cwd: options.cwd },
+    configs.rc && { config: configs.rc, configFile: options.rcFile },
+    configs.packageJson && {
+      config: configs.packageJson,
+      configFile: "package.json"
+    }
+  ].filter((l) => l && l.config);
+  r.layers = [...baseLayers, ...r.layers];
+  if (options.defaults) {
+    r.config = _merger(r.config, options.defaults);
+  }
+  if (options.omit$Keys) {
+    for (const key in r.config) {
+      if (key.startsWith("$")) {
+        delete r.config[key];
+      }
+    }
+  }
+  if (options.configFileRequired && !r._configFile) {
+    throw new Error(`Required config (${r.configFile}) cannot be resolved.`);
+  }
+  return r;
+}
+async function extendConfig(config, options) {
+  config._layers = config._layers || [];
+  if (!options.extend) {
+    return;
+  }
+  let keys = options.extend.extendKey;
+  if (typeof keys === "string") {
+    keys = [keys];
+  }
+  const extendSources = [];
+  for (const key of keys) {
+    extendSources.push(
+      ...(Array.isArray(config[key]) ? config[key] : [config[key]]).filter(
+        Boolean
+      )
+    );
+    delete config[key];
+  }
+  for (let extendSource of extendSources) {
+    const originalExtendSource = extendSource;
+    let sourceOptions = {};
+    if (extendSource.source) {
+      sourceOptions = extendSource.options || {};
+      extendSource = extendSource.source;
+    }
+    if (Array.isArray(extendSource)) {
+      sourceOptions = extendSource[1] || {};
+      extendSource = extendSource[0];
+    }
+    if (typeof extendSource !== "string") {
+      console.warn(
+        `Cannot extend config from \`${JSON.stringify(
+          originalExtendSource
+        )}\` in ${options.cwd}`
+      );
+      continue;
+    }
+    const _config = await resolveConfig(extendSource, options, sourceOptions);
+    if (!_config.config) {
+      console.warn(
+        `Cannot extend config from \`${extendSource}\` in ${options.cwd}`
+      );
+      continue;
+    }
+    await extendConfig(_config.config, { ...options, cwd: _config.cwd });
+    config._layers.push(_config);
+    if (_config.config._layers) {
+      config._layers.push(..._config.config._layers);
+      delete _config.config._layers;
+    }
+  }
+}
+const GIGET_PREFIXES = [
+  "gh:",
+  "github:",
+  "gitlab:",
+  "bitbucket:",
+  "https://",
+  "http://"
+];
+const NPM_PACKAGE_RE = /^(@[\da-z~-][\d._a-z~-]*\/)?[\da-z~-][\d._a-z~-]*($|\/.*)/;
+async function resolveConfig(source, options, sourceOptions = {}) {
+  if (options.resolve) {
+    const res2 = await options.resolve(source, options);
+    if (res2) {
+      return res2;
+    }
+  }
+  const _merger = options.merger || defu;
+  const customProviderKeys = Object.keys(
+    sourceOptions.giget?.providers || {}
+  ).map((key) => `${key}:`);
+  const gigetPrefixes = customProviderKeys.length > 0 ? [.../* @__PURE__ */ new Set([...customProviderKeys, ...GIGET_PREFIXES])] : GIGET_PREFIXES;
+  if (options.giget !== false && gigetPrefixes.some((prefix) => source.startsWith(prefix))) {
+    const { downloadTemplate } = await import('./giget.mjs');
+    const { digest } = await import('ohash');
+    const cloneName = source.replace(/\W+/g, "_").split("_").splice(0, 3).join("_") + "_" + digest(source).slice(0, 10).replace(/[-_]/g, "");
+    let cloneDir;
+    const localNodeModules = resolve(options.cwd, "node_modules");
+    const parentDir = dirname(options.cwd);
+    if (basename(parentDir) === ".c12") {
+      cloneDir = join(parentDir, cloneName);
+    } else if (existsSync(localNodeModules)) {
+      cloneDir = join(localNodeModules, ".c12", cloneName);
+    } else {
+      cloneDir = process.env.XDG_CACHE_HOME ? resolve(process.env.XDG_CACHE_HOME, "c12", cloneName) : resolve(homedir(), ".cache/c12", cloneName);
+    }
+    if (existsSync(cloneDir) && !sourceOptions.install) {
+      await rm(cloneDir, { recursive: true });
+    }
+    const cloned = await downloadTemplate(source, {
+      dir: cloneDir,
+      install: sourceOptions.install,
+      force: sourceOptions.install,
+      auth: sourceOptions.auth,
+      ...options.giget,
+      ...sourceOptions.giget
+    });
+    source = cloned.dir;
+  }
+  if (NPM_PACKAGE_RE.test(source)) {
+    source = tryResolve(source, options) || source;
+  }
+  const ext = extname(source);
+  const isDir = !ext || ext === basename(source);
+  const cwd = resolve(options.cwd, isDir ? source : dirname(source));
+  if (isDir) {
+    source = options.configFile;
+  }
+  const res = {
+    config: void 0,
+    configFile: void 0,
+    cwd,
+    source,
+    sourceOptions
+  };
+  res.configFile = tryResolve(resolve(cwd, source), options) || tryResolve(
+    resolve(cwd, ".config", source.replace(/\.config$/, "")),
+    options
+  ) || tryResolve(resolve(cwd, ".config", source), options) || source;
+  if (!existsSync(res.configFile)) {
+    return res;
+  }
+  res._configFile = res.configFile;
+  const configFileExt = extname(res.configFile) || "";
+  if (configFileExt in ASYNC_LOADERS) {
+    const asyncLoader = await ASYNC_LOADERS[configFileExt]();
+    const contents = await readFile(res.configFile, "utf8");
+    res.config = asyncLoader(contents);
+  } else {
+    res.config = await options.jiti.import(res.configFile, {
+      default: true
+    });
+  }
+  if (typeof res.config === "function") {
+    res.config = await res.config(options.context);
+  }
+  if (options.envName) {
+    const envConfig = {
+      ...res.config["$" + options.envName],
+      ...res.config.$env?.[options.envName]
+    };
+    if (Object.keys(envConfig).length > 0) {
+      res.config = _merger(envConfig, res.config);
+    }
+  }
+  res.meta = defu(res.sourceOptions.meta, res.config.$meta);
+  delete res.config.$meta;
+  if (res.sourceOptions.overrides) {
+    res.config = _merger(res.sourceOptions.overrides, res.config);
+  }
+  res.configFile = _normalize(res.configFile);
+  res.source = _normalize(res.source);
+  return res;
+}
+function tryResolve(id, options) {
+  const res = resolveModulePath(id, {
+    try: true,
+    from: pathToFileURL(join(options.cwd || ".", options.configFile || "/")),
+    suffixes: ["", "/index"],
+    extensions: SUPPORTED_EXTENSIONS,
+    cache: false
+  });
+  return res ? normalize(res) : void 0;
+}
+
+const eventMap = {
+  add: "created",
+  change: "updated",
+  unlink: "removed"
+};
+async function watchConfig(options) {
+  let config = await loadConfig(options);
+  const configName = options.name || "config";
+  const configFileName = options.configFile ?? (options.name === "config" ? "config" : `${options.name}.config`);
+  const watchingFiles = [
+    ...new Set(
+      (config.layers || []).filter((l) => l.cwd).flatMap((l) => [
+        ...SUPPORTED_EXTENSIONS.flatMap((ext) => [
+          resolve(l.cwd, configFileName + ext),
+          resolve(l.cwd, ".config", configFileName + ext),
+          resolve(
+            l.cwd,
+            ".config",
+            configFileName.replace(/\.config$/, "") + ext
+          )
+        ]),
+        l.source && resolve(l.cwd, l.source),
+        // TODO: Support watching rc from home and workspace
+        options.rcFile && resolve(
+          l.cwd,
+          typeof options.rcFile === "string" ? options.rcFile : `.${configName}rc`
+        ),
+        options.packageJson && resolve(l.cwd, "package.json")
+      ]).filter(Boolean)
+    )
+  ];
+  const watch = await import('./chokidar.mjs').then((r) => r.watch || r.default || r);
+  const { diff } = await import('ohash/utils');
+  const _fswatcher = watch(watchingFiles, {
+    ignoreInitial: true,
+    ...options.chokidarOptions
+  });
+  const onChange = async (event, path) => {
+    const type = eventMap[event];
+    if (!type) {
+      return;
+    }
+    if (options.onWatch) {
+      await options.onWatch({
+        type,
+        path
+      });
+    }
+    const oldConfig = config;
+    try {
+      config = await loadConfig(options);
+    } catch (error) {
+      console.warn(`Failed to load config ${path}
+${error}`);
+      return;
+    }
+    const changeCtx = {
+      newConfig: config,
+      oldConfig,
+      getDiff: () => diff(oldConfig.config, config.config)
+    };
+    if (options.acceptHMR) {
+      const changeHandled = await options.acceptHMR(changeCtx);
+      if (changeHandled) {
+        return;
+      }
+    }
+    if (options.onUpdate) {
+      await options.onUpdate(changeCtx);
+    }
+  };
+  if (options.debounce === false) {
+    _fswatcher.on("all", onChange);
+  } else {
+    _fswatcher.on("all", debounce(onChange, options.debounce ?? 100));
+  }
+  const utils = {
+    watchingFiles,
+    unwatch: async () => {
+      await _fswatcher.close();
+    }
+  };
+  return new Proxy(utils, {
+    get(_, prop) {
+      if (prop in utils) {
+        return utils[prop];
+      }
+      return config[prop];
+    }
+  });
+}
+
+export { loadConfig as l, watchConfig as w };