iles/dist/node/chunk-ROUSHGC2.js

Vite & Vue powered static site generator with partial hydration

import {
  importModule
} from "./chunk-HKPEBJDI.js";

// src/node/plugin/utils.ts
import { promises as fs, constants as fsConstants } from "node:fs";
import process from "node:process";
import { resolve } from "node:path";
import childProcess from "node:child_process";
import util from "node:util";
import createDebugger from "debug";
import newSpinner from "mico-spinner";
import { detectPackageManager } from "@antfu/install-pkg";
import { default as default2 } from "@nuxt/devalue";
var exec = util.promisify(childProcess.exec);
var debug = {
  config: createDebugger("iles:config"),
  documents: createDebugger("iles:documents"),
  mdx: createDebugger("iles:mdx"),
  layout: createDebugger("iles:layout"),
  detect: createDebugger("iles:detect"),
  resolve: createDebugger("iles:resolve"),
  build: createDebugger("iles:build")
};
function sleep(ms) {
  return new Promise((resolve2) => {
    setTimeout(resolve2, ms);
  });
}
async function installPackage(names, options = {}) {
  const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm";
  const [agent] = detectedAgent.split("@");
  if (!Array.isArray(names)) {
    names = [names];
  }
  const args = options.additionalArgs || [];
  if (options.preferOffline) {
    if (detectedAgent === "yarn@berry") {
      args.unshift("--cached");
    } else {
      args.unshift("--prefer-offline");
    }
  }
  if (agent === "pnpm" && await exists(resolve(options.cwd ?? process.cwd(), "pnpm-workspace.yaml"))) {
    args.unshift("-w");
  }
  const command = `${agent} ${agent === "yarn" ? "add" : "install"} ${options.dev ? "-D" : ""} ${names.join(" ")} ${args.join(" ")}`;
  try {
    await exec(command, {
      cwd: options.cwd || process.cwd()
    });
  } catch (error) {
    const { stderr, stdout } = error;
    if (stdout) {
      console.log(stdout);
    }
    if (stderr) {
      console.error(stderr);
    }
    throw new Error(`Auto-install of ${names.join(" ")} failed, install manually and try again!`);
  }
}
async function tryImportOrInstallModule(name) {
  try {
    return await importModule(name);
  } catch (error) {
    if (error.code !== "MODULE_NOT_FOUND")
      throw error;
    console.info(`
${name} not found. Proceeding to auto-install.
`);
    await withSpinner(`Installing ${name}`, async () => await installPackage(name, { dev: true, preferOffline: true, silent: true }));
    return await importModule(name);
  }
}
async function importLibrary(pkgName) {
  return await tryImportOrInstallModule(pkgName);
}
async function withSpinner(message, fn) {
  const spinner = newSpinner(message).start();
  try {
    const result = await fn();
    spinner.succeed();
    return result;
  } catch (e) {
    spinner.fail();
    throw e;
  }
}
function isString(val) {
  return typeof val === "string";
}
function isStringPlugin(val) {
  return Array.isArray(val) && isString(val[0]);
}
function uniq(arr) {
  return [...new Set(arr.filter((x) => x))];
}
function escapeRegex(str) {
  return str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
}
function pascalCase(str) {
  return capitalize(camelCase(str));
}
function camelCase(str) {
  return str.replace(/[^\w_]+(\w)/g, (_, c) => c ? c.toUpperCase() : "");
}
function uncapitalize(str) {
  return str.charAt(0).toLowerCase() + str.slice(1);
}
function capitalize(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
}
async function replaceAsync(str, regex, asyncFn) {
  const promises = Array.from(str.matchAll(regex)).map(([match, ...args]) => asyncFn(match, ...args));
  const replacements = await Promise.all(promises);
  return str.replace(regex, () => replacements.shift());
}
async function exists(filePath) {
  return await fs.access(filePath, fsConstants.F_OK).then(() => true, () => false);
}
function compact(val) {
  return val.filter((x) => x);
}

export {
  debug,
  sleep,
  installPackage,
  tryImportOrInstallModule,
  importLibrary,
  isString,
  isStringPlugin,
  uniq,
  escapeRegex,
  pascalCase,
  camelCase,
  uncapitalize,
  capitalize,
  replaceAsync,
  exists,
  compact,
  default2 as default
};