@buding0904/vitepad 0.2.0

package/dist/cli.js

@@ -0,0 +1,774 @@
+#!/usr/bin/env node
+import fs2 from 'fs/promises';
+import os from 'os';
+import path2 from 'path';
+import process2 from 'process';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { createServer, mergeConfig, normalizePath, createLogger } from 'vite';
+import pc2 from 'picocolors';
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+
+var packageRoot = path2.resolve(fileURLToPath(new URL("..", import.meta.url)));
+var linkedPeerPackages = ["vite"];
+var log = {
+  framework(requested, resolved) {
+    console.log(`
+${pc2.cyan("vitepad")} ${pc2.bold("framework")} ${pc2.gray(requested)} ${pc2.gray("->")} ${pc2.green(resolved)}`);
+  },
+  install(packages) {
+    console.log(`  ${pc2.gray("install")} ${packages.map((pkg) => pc2.cyan(pkg)).join(pc2.gray(", "))}`);
+  },
+  done(message) {
+    console.log(`  ${pc2.green(message)}`);
+  }
+};
+async function resolveFramework(spec, options) {
+  if (spec.name === "auto") {
+    throw new Error("Internal error: unresolved framework auto.");
+  }
+  if (spec.name === "vanilla") {
+    return {
+      name: "vanilla",
+      version: "local",
+      requested: "vanilla",
+      cacheStatus: "local",
+      aliases: [],
+      packageLinks: packageLinks(packageNodeModules(), ["tailwindcss"])
+    };
+  }
+  const resolved = await resolveFrameworkPackages(spec.name, spec.version);
+  const cacheDir = frameworkCacheDir(spec.name, resolved.version);
+  const nodeModules = path2.join(cacheDir, "node_modules");
+  const installed = await isInstalled(cacheDir, resolved.packages);
+  if (options.forceInstall && await pathExists(cacheDir)) {
+    await fs2.rm(cacheDir, { recursive: true, force: true });
+  }
+  log.framework(`${spec.name}@${spec.version}`, `${spec.name}@${resolved.version}`);
+  const cacheStatus = options.forceInstall ? "miss" : installed ? "hit" : "miss";
+  if (options.forceInstall || !installed) {
+    log.install(resolved.packages);
+    await installFrameworkCache(cacheDir, resolved.packages);
+  }
+  await linkPeerPackages(cacheDir);
+  return {
+    name: spec.name,
+    version: resolved.version,
+    requested: `${spec.name}@${spec.version}`,
+    cacheStatus,
+    cacheDir,
+    aliases: [],
+    packageLinks: [
+      ...packageLinks(packageNodeModules(), ["tailwindcss"]),
+      ...packageLinks(nodeModules, frameworkRuntimePackages(spec.name))
+    ]
+  };
+}
+async function resolveFrameworkPackages(framework, version) {
+  const specs = frameworkPackageSpecs(framework, version);
+  const resolved = await Promise.all(specs.map(async (spec) => {
+    const parsed = splitPackageSpec(spec);
+    const resolvedVersion = await resolvePackageVersion(parsed.name, parsed.version);
+    return {
+      name: parsed.name,
+      version: resolvedVersion,
+      spec: `${parsed.name}@${resolvedVersion}`
+    };
+  }));
+  const primary = splitPackageSpec(specs[0]).name;
+  const primaryVersion = resolved.find((pkg) => pkg.name === primary)?.version;
+  if (!primaryVersion) {
+    throw new Error(`Failed to resolve ${framework}@${version}.`);
+  }
+  return {
+    version: primaryVersion,
+    packages: resolved.map((pkg) => pkg.spec)
+  };
+}
+function frameworkDedupe(framework) {
+  return frameworkRuntimePackages(framework);
+}
+function frameworkOptimizeDeps(framework) {
+  switch (framework) {
+    case "react":
+      return ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"];
+    case "preact":
+      return ["preact", "preact/jsx-runtime", "preact/hooks"];
+    case "solid":
+      return ["solid-js", "solid-js/web"];
+    case "vue":
+      return ["vue"];
+    case "svelte":
+    case "vanilla":
+      return [];
+  }
+}
+async function loadFrameworkPlugins(framework) {
+  if (framework.name === "vanilla") {
+    return [];
+  }
+  if (!framework.cacheDir) {
+    throw new Error(`Missing framework cache for ${framework.name}.`);
+  }
+  const plugins = [];
+  for (const pluginPackage of frameworkPluginPackages(framework.name)) {
+    const mod = await importCachePackage(framework.cacheDir, pluginPackage);
+    appendPlugin(plugins, createFrameworkPlugin(pluginPackage, mod));
+  }
+  return plugins;
+}
+function createFrameworkPlugin(pluginPackage, mod) {
+  const factory = frameworkPluginFactory(pluginPackage, mod);
+  return factory();
+}
+function frameworkPluginFactory(pluginPackage, mod) {
+  if (pluginPackage === "@sveltejs/vite-plugin-svelte" && typeof mod.svelte === "function") {
+    return mod.svelte;
+  }
+  if (pluginPackage === "@preact/preset-vite" && typeof mod.preact === "function") {
+    return mod.preact;
+  }
+  if (typeof mod.default === "function") {
+    return mod.default;
+  }
+  if (mod.default && typeof mod.default.default === "function") {
+    return mod.default.default;
+  }
+  throw new Error(`Failed to load Vite plugin ${pluginPackage}: no callable plugin export found.`);
+}
+function appendPlugin(plugins, plugin) {
+  if (Array.isArray(plugin)) {
+    plugins.push(...plugin);
+  } else {
+    plugins.push(plugin);
+  }
+}
+function frameworkPackageSpecs(framework, version) {
+  switch (framework) {
+    case "react":
+      return [`react@${version}`, `react-dom@${version}`, "@vitejs/plugin-react@latest"];
+    case "preact":
+      return [`preact@${version}`, "@preact/preset-vite@latest"];
+    case "solid":
+      return [`solid-js@${version}`, "vite-plugin-solid@latest"];
+    case "vue":
+      return [`vue@${version}`, "@vitejs/plugin-vue@latest", "@vitejs/plugin-vue-jsx@latest"];
+    case "svelte":
+      return [`svelte@${version}`, "@sveltejs/vite-plugin-svelte@latest"];
+    case "vanilla":
+      return [];
+  }
+}
+function resolvePackageVersion(name, range) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("npm", ["view", `${name}@${range}`, "version", "--json"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        reject(new Error(`npm view failed for ${name}@${range}
+${stderr.trim()}`));
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout.trim());
+        const version = Array.isArray(parsed) ? parsed[parsed.length - 1] : parsed;
+        if (typeof version !== "string" || !version) {
+          throw new Error(`Unexpected npm view output: ${stdout}`);
+        }
+        resolve(version);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+function frameworkRuntimePackages(framework) {
+  switch (framework) {
+    case "react":
+      return ["react", "react-dom"];
+    case "preact":
+      return ["preact"];
+    case "solid":
+      return ["solid-js"];
+    case "vue":
+      return ["vue"];
+    case "svelte":
+      return ["svelte"];
+    case "vanilla":
+      return [];
+  }
+}
+function frameworkPluginPackages(framework) {
+  switch (framework) {
+    case "react":
+      return ["@vitejs/plugin-react"];
+    case "preact":
+      return ["@preact/preset-vite"];
+    case "solid":
+      return ["vite-plugin-solid"];
+    case "vue":
+      return ["@vitejs/plugin-vue", "@vitejs/plugin-vue-jsx"];
+    case "svelte":
+      return ["@sveltejs/vite-plugin-svelte"];
+    case "vanilla":
+      return [];
+  }
+}
+function packageLinks(nodeModules, packageNames) {
+  return packageNames.map((packageName) => ({
+    name: packageName,
+    source: path2.join(nodeModules, packageName)
+  }));
+}
+function packageNodeModules() {
+  return path2.join(packageRoot, "node_modules");
+}
+function frameworkCacheDir(framework, version) {
+  const base = process.env.VITEPAD_CACHE_DIR || (process.env.XDG_CACHE_HOME ? path2.join(process.env.XDG_CACHE_HOME, "vitepad") : path2.join(os.homedir(), ".cache", "vitepad"));
+  return path2.join(base, "frameworks", `${framework}-${sanitizeCacheKey(version)}`);
+}
+function sanitizeCacheKey(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+async function isInstalled(cacheDir, packages) {
+  if (!await pathExists(path2.join(cacheDir, "node_modules"))) return false;
+  for (const pkg of packages) {
+    const { name } = splitPackageSpec(pkg);
+    if (!await pathExists(path2.join(cacheDir, "node_modules", name))) {
+      return false;
+    }
+  }
+  return true;
+}
+async function installFrameworkCache(cacheDir, packages) {
+  await fs2.mkdir(cacheDir, { recursive: true });
+  await fs2.writeFile(path2.join(cacheDir, "package.json"), JSON.stringify({
+    private: true,
+    type: "module",
+    dependencies: Object.fromEntries(packages.map((pkg) => packageToDependency(pkg)))
+  }, null, 2));
+  await runInstall(cacheDir);
+}
+function runInstall(cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("npm", ["install", "--legacy-peer-deps", "--no-audit", "--no-fund", "--loglevel=notice"], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const progress = createProgress("vitepad: installing framework packages");
+    let output = "";
+    child.stdout.on("data", (chunk) => {
+      output += chunk;
+      progress.tick();
+    });
+    child.stderr.on("data", (chunk) => {
+      output += chunk;
+      progress.tick();
+    });
+    child.on("error", (error) => {
+      progress.stop();
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      progress.stop();
+      if (code === 0) {
+        log.done("install complete");
+        resolve();
+      } else {
+        reject(new Error(`npm install failed with exit code ${code}
+${output.trim()}`));
+      }
+    });
+  });
+}
+async function linkPeerPackages(cacheDir) {
+  await fs2.mkdir(path2.join(cacheDir, "node_modules"), { recursive: true });
+  for (const packageName of linkedPeerPackages) {
+    try {
+      await linkPackage({
+        source: path2.join(packageNodeModules(), packageName),
+        target: path2.join(cacheDir, "node_modules", packageName)
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to link ${packageName} into vitepad cache at ${cacheDir}.
+${message}`);
+    }
+  }
+}
+async function linkPackage(input) {
+  const source = await fs2.realpath(input.source);
+  const existing = await fs2.lstat(input.target).catch(() => null);
+  if (existing) {
+    if (existing.isSymbolicLink()) {
+      const current = await fs2.realpath(input.target).catch(() => null);
+      if (current === source) return;
+    }
+    await fs2.rm(input.target, { recursive: true, force: true });
+  }
+  await fs2.symlink(source, input.target, "dir");
+}
+function createProgress(label) {
+  const width = 18;
+  let frame = 0;
+  const render = () => {
+    const position = frame % width;
+    const bar = Array.from({ length: width }, (_, index) => index === position ? "=" : "-").join("");
+    process.stderr.write(`\r${label} [${bar}]`);
+    frame += 1;
+  };
+  const timer = setInterval(render, 120);
+  render();
+  return {
+    tick: render,
+    stop() {
+      clearInterval(timer);
+      process.stderr.write(`\r${" ".repeat(label.length + width + 4)}\r`);
+    }
+  };
+}
+function packageToDependency(pkg) {
+  const parsed = splitPackageSpec(pkg);
+  return [parsed.name, parsed.version];
+}
+function splitPackageSpec(spec) {
+  if (spec.startsWith("@")) {
+    const secondAt = spec.indexOf("@", 1);
+    if (secondAt === -1) return { name: spec, version: "latest" };
+    return { name: spec.slice(0, secondAt), version: spec.slice(secondAt + 1) };
+  }
+  const at = spec.indexOf("@");
+  if (at === -1) return { name: spec, version: "latest" };
+  return { name: spec.slice(0, at), version: spec.slice(at + 1) };
+}
+async function importCachePackage(cacheDir, packageName) {
+  const requireFromCache = createRequire(path2.join(cacheDir, "package.json"));
+  const resolved = requireFromCache.resolve(packageName);
+  return import(pathToFileURL(resolved).href);
+}
+async function pathExists(file) {
+  return fs2.access(file).then(() => true, () => false);
+}
+
+// src/runtime/index.ts
+var rootDir = path2.resolve(fileURLToPath(new URL("..", import.meta.url)));
+var supportedComponentExts = /* @__PURE__ */ new Set([".jsx", ".tsx", ".vue", ".svelte"]);
+var supportedMainExts = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]);
+var frameworkValues = /* @__PURE__ */ new Set(["auto", "react", "preact", "solid", "vue", "svelte", "vanilla"]);
+async function run(argv) {
+  const options = parseArgs(argv);
+  if (options.help) {
+    console.log(helpText());
+    return;
+  }
+  if (!options.entry) {
+    throw new Error(helpText("Missing entry file."));
+  }
+  const entry = path2.resolve(process2.cwd(), options.entry);
+  const stat = await fs2.stat(entry).catch(() => null);
+  if (!stat?.isFile()) {
+    throw new Error(`Entry file does not exist: ${entry}`);
+  }
+  const extension = path2.extname(entry).toLowerCase();
+  const mode = inferMode(extension);
+  const source = await fs2.readFile(entry, "utf8");
+  const framework = inferFramework({
+    extension,
+    source,
+    requested: options.framework,
+    version: options.frameworkVersion
+  });
+  validateCombination({ mode, framework: framework.name, extension });
+  const resolvedFramework = await resolveFramework(framework, { forceInstall: options.forceInstall });
+  const classTokens = await collectClassTokens(entry);
+  const workspace = await createWorkspace({
+    entry,
+    mode,
+    framework: resolvedFramework.name,
+    sourceDirs: uniquePaths([process2.cwd(), path2.dirname(entry)]),
+    classTokens,
+    packageLinks: resolvedFramework.packageLinks
+  });
+  const config = await loadUserConfig(options.config);
+  const server = await createServer(mergeConfig({
+    root: workspace,
+    configFile: false,
+    server: {
+      host: options.host,
+      port: options.port,
+      open: options.open,
+      watch: {
+        ignored: (file) => normalizePath(file).startsWith(`${normalizePath(workspace)}/`)
+      },
+      fs: {
+        allow: [
+          rootDir,
+          process2.cwd(),
+          path2.dirname(entry),
+          workspace,
+          ...resolvedFramework.cacheDir ? [resolvedFramework.cacheDir] : []
+        ]
+      }
+    },
+    plugins: await loadPlugins(resolvedFramework),
+    resolve: {
+      alias: [
+        ...resolvedFramework.aliases,
+        {
+          find: "@",
+          replacement: path2.dirname(entry)
+        }
+      ],
+      dedupe: frameworkDedupe(resolvedFramework.name)
+    },
+    optimizeDeps: {
+      entries: [path2.join(workspace, "src/main.js")],
+      include: frameworkOptimizeDeps(resolvedFramework.name)
+    },
+    customLogger: createVitepadLogger()
+  }, config));
+  await server.listen();
+  printReady({
+    entry,
+    framework: resolvedFramework,
+    urls: server.resolvedUrls
+  });
+  const close = async () => {
+    await server.close();
+    process2.exit(0);
+  };
+  process2.once("SIGINT", close);
+  process2.once("SIGTERM", close);
+}
+function parseArgs(argv) {
+  const options = {
+    framework: "auto",
+    frameworkVersion: "latest",
+    forceInstall: false,
+    port: 8e3,
+    host: "0.0.0.0",
+    open: "/",
+    help: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+    } else if (arg === "--framework" || arg === "-f") {
+      Object.assign(options, parseFramework(readValue(argv, ++index, arg)));
+    } else if (arg.startsWith("--framework=")) {
+      Object.assign(options, parseFramework(arg.slice("--framework=".length)));
+    } else if (arg === "--force-install") {
+      options.forceInstall = true;
+    } else if (arg === "--port" || arg === "-p") {
+      options.port = Number(readValue(argv, ++index, arg));
+    } else if (arg.startsWith("--port=")) {
+      options.port = Number(arg.slice("--port=".length));
+    } else if (arg === "--host") {
+      options.host = readValue(argv, ++index, arg);
+    } else if (arg.startsWith("--host=")) {
+      options.host = arg.slice("--host=".length);
+    } else if (arg === "--no-open") {
+      options.open = false;
+    } else if (arg === "--open") {
+      options.open = "/";
+    } else if (arg === "--config" || arg === "-c") {
+      options.config = readValue(argv, ++index, arg);
+    } else if (arg.startsWith("--config=")) {
+      options.config = arg.slice("--config=".length);
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    } else if (!options.entry) {
+      options.entry = arg;
+    } else {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+  if (!Number.isInteger(options.port) || options.port < 0 || options.port > 65535) {
+    throw new Error(`Invalid port: ${options.port}`);
+  }
+  return options;
+}
+function parseFramework(value) {
+  const match = value.match(/^([^@]+)(?:@(.+))?$/);
+  const name = match?.[1];
+  const version = match?.[2] || "latest";
+  if (name && frameworkValues.has(name)) {
+    return { framework: name, frameworkVersion: version };
+  }
+  throw new Error(`Unsupported framework "${value}". Use one of: ${[...frameworkValues].join(", ")}, optionally with @version.`);
+}
+function readValue(argv, index, option) {
+  const value = argv[index];
+  if (!value || value.startsWith("-")) {
+    throw new Error(`Missing value for ${option}`);
+  }
+  return value;
+}
+function inferMode(extension) {
+  if (supportedMainExts.has(extension)) return "main";
+  if (supportedComponentExts.has(extension)) return "component";
+  throw new Error(`Unsupported entry extension "${extension}". Supported: js, ts, jsx, tsx, vue, svelte.`);
+}
+function inferFramework(input) {
+  const { extension, source, requested, version } = input;
+  if (requested !== "auto") return { name: requested, version };
+  if (extension === ".vue") return { name: "vue", version };
+  if (extension === ".svelte") return { name: "svelte", version };
+  if (/\bfrom\s+['"]solid-js\b|\bfrom\s+['"]solid-js\/web\b|\bsolid-js\b/.test(source)) return { name: "solid", version };
+  if (/\bfrom\s+['"]preact\b|\bfrom\s+['"]preact\/compat\b|\bfrom\s+['"]preact\/hooks\b/.test(source)) return { name: "preact", version };
+  if (/\bfrom\s+['"]vue\b/.test(source)) return { name: "vue", version };
+  if (/\bfrom\s+['"]svelte\b|\bfrom\s+['"]svelte\//.test(source)) return { name: "svelte", version };
+  if (extension === ".jsx" || extension === ".tsx") return { name: "react", version };
+  return { name: "vanilla", version: "local" };
+}
+function validateCombination(input) {
+  const { mode, framework, extension } = input;
+  if (mode === "component" && framework === "vanilla") {
+    throw new Error(`Component entry ${extension} needs a framework. Try --framework react, vue, svelte, preact, or solid.`);
+  }
+  if (extension === ".vue" && framework !== "vue") {
+    throw new Error(".vue entries must use --framework vue.");
+  }
+  if (extension === ".svelte" && framework !== "svelte") {
+    throw new Error(".svelte entries must use --framework svelte.");
+  }
+}
+async function createWorkspace(input) {
+  const workspace = await fs2.mkdtemp(path2.join(await fs2.realpath(os.tmpdir()), "vitepad-"));
+  const srcDir = path2.join(workspace, "src");
+  const nodeModulesDir = path2.join(workspace, "node_modules");
+  await fs2.mkdir(srcDir, { recursive: true });
+  await fs2.mkdir(nodeModulesDir, { recursive: true });
+  await Promise.all([
+    fs2.writeFile(path2.join(workspace, "index.html"), htmlTemplate()),
+    fs2.writeFile(path2.join(srcDir, "style.css"), styleTemplate(input.sourceDirs, input.classTokens)),
+    fs2.writeFile(path2.join(srcDir, "main.js"), mainTemplate(input)),
+    ...input.packageLinks.map((link) => linkWorkspacePackage(nodeModulesDir, link))
+  ]);
+  return workspace;
+}
+async function linkWorkspacePackage(nodeModulesDir, link) {
+  const source = await fs2.realpath(link.source);
+  const target = path2.join(nodeModulesDir, link.name);
+  await fs2.mkdir(path2.dirname(target), { recursive: true });
+  await fs2.symlink(source, target, "dir");
+}
+function uniquePaths(paths) {
+  return [...new Set(paths.map((item) => normalizePath(path2.resolve(item))))];
+}
+function styleTemplate(sourceDirs, classTokens) {
+  return [
+    '@import "tailwindcss";',
+    ...sourceDirs.map((sourceDir) => `@source ${JSON.stringify(sourceDir)};`),
+    classTokens.length ? `/* vitepad safelist: ${classTokens.join(" ")} */` : "",
+    ""
+  ].join("\n");
+}
+async function collectClassTokens(entry) {
+  const visited = /* @__PURE__ */ new Set();
+  const tokens = /* @__PURE__ */ new Set();
+  await collectFileClassTokens(entry, visited, tokens);
+  return [...tokens].sort();
+}
+async function collectFileClassTokens(file, visited, tokens) {
+  const resolved = path2.resolve(file);
+  if (visited.has(resolved)) return;
+  visited.add(resolved);
+  const source = await fs2.readFile(resolved, "utf8").catch(() => "");
+  for (const match of source.matchAll(/\b(?:class|className)\s*=\s*(?:"([^"]+)"|'([^']+)'|{`([^`]+)`})/g)) {
+    const value = match[1] || match[2] || match[3] || "";
+    for (const token of value.split(/\s+/)) {
+      if (token && !/[${}]/.test(token)) tokens.add(token);
+    }
+  }
+  for (const specifier of localImportSpecifiers(source)) {
+    const imported = await resolveLocalImport(resolved, specifier);
+    if (imported) {
+      await collectFileClassTokens(imported, visited, tokens);
+    }
+  }
+}
+function localImportSpecifiers(source) {
+  const specifiers = /* @__PURE__ */ new Set();
+  for (const match of source.matchAll(/\bimport\s+(?:[^'"]+?\s+from\s+)?['"]([^'"]+)['"]/g)) {
+    if (isLocalSpecifier(match[1])) specifiers.add(match[1]);
+  }
+  for (const match of source.matchAll(/\bexport\s+[^'"]+?\s+from\s+['"]([^'"]+)['"]/g)) {
+    if (isLocalSpecifier(match[1])) specifiers.add(match[1]);
+  }
+  return [...specifiers];
+}
+function isLocalSpecifier(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../");
+}
+async function resolveLocalImport(importer, specifier) {
+  const base = path2.resolve(path2.dirname(importer), specifier);
+  const candidates = [
+    base,
+    ...[".ts", ".tsx", ".js", ".jsx", ".vue", ".svelte"].map((ext) => `${base}${ext}`),
+    ...["index.ts", "index.tsx", "index.js", "index.jsx", "index.vue", "index.svelte"].map((file) => path2.join(base, file))
+  ];
+  for (const candidate of candidates) {
+    const stat = await fs2.stat(candidate).catch(() => null);
+    if (stat?.isFile()) return candidate;
+  }
+  return void 0;
+}
+function htmlTemplate() {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>vitepad</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>
+`;
+}
+function mainTemplate(input) {
+  const { entry, mode, framework } = input;
+  const importPath = `/@fs/${normalizePath(entry)}`;
+  if (mode === "main") {
+    return `import './style.css'
+import ${JSON.stringify(importPath)}
+`;
+  }
+  switch (framework) {
+    case "react":
+      return `import './style.css'
+import React from 'react'
+import { createRoot } from 'react-dom/client'
+import App from ${JSON.stringify(importPath)}
+
+createRoot(document.getElementById('root')).render(React.createElement(App))
+`;
+    case "preact":
+      return `import './style.css'
+import { h, render } from 'preact'
+import App from ${JSON.stringify(importPath)}
+
+render(h(App, null), document.getElementById('root'))
+`;
+    case "solid":
+      return `import './style.css'
+import { render } from 'solid-js/web'
+import App from ${JSON.stringify(importPath)}
+
+render(() => App({}), document.getElementById('root'))
+`;
+    case "vue":
+      return `import './style.css'
+import { createApp } from 'vue'
+import App from ${JSON.stringify(importPath)}
+
+createApp(App).mount('#root')
+`;
+    case "svelte":
+      return `import './style.css'
+import { mount } from 'svelte'
+import App from ${JSON.stringify(importPath)}
+
+const target = document.getElementById('root')
+const app = mount(App, { target })
+export default app
+`;
+    case "vanilla":
+      throw new Error("Vanilla entries cannot be used as component entries.");
+  }
+}
+async function loadUserConfig(configFile) {
+  if (!configFile) return {};
+  const resolved = path2.resolve(process2.cwd(), configFile);
+  const configModule = await import(pathToFileURL(resolved).href);
+  return configModule.default ?? configModule;
+}
+async function loadPlugins(framework) {
+  const [{ default: tailwindcss }, frameworkPlugins] = await Promise.all([
+    import('@tailwindcss/vite'),
+    loadFrameworkPlugins(framework)
+  ]);
+  const plugins = [];
+  appendPlugin(plugins, tailwindcss());
+  plugins.push(...frameworkPlugins);
+  return plugins;
+}
+function printReady(input) {
+  const { entry, framework, urls } = input;
+  const frameworkLabel = `${framework.name}@${framework.version}`;
+  console.log(`${pc2.cyan("vitepad")} ${pc2.green("ready")} ${pc2.green(frameworkLabel)}`);
+  console.log(`  ${pc2.gray("entry")}     ${pc2.gray(entry)}`);
+  if (framework.cacheDir) {
+    console.log(`  ${pc2.gray("cache")}     ${pc2.gray(framework.cacheDir)}`);
+  }
+  printUrls(urls);
+}
+function printUrls(urls) {
+  if (!urls) return;
+  for (const url of urls.local) {
+    console.log(`  ${pc2.green("\u279C")}  ${pc2.bold("Local:")}   ${pc2.bold(url)}`);
+  }
+  for (const url of urls.network) {
+    console.log(`  ${pc2.green("\u279C")}  ${pc2.bold("Network:")} ${pc2.bold(url)}`);
+  }
+}
+function createVitepadLogger() {
+  const logger = createLogger("info");
+  const info = logger.info.bind(logger);
+  return {
+    ...logger,
+    info(message, options) {
+      if (isNoisyViteInfo(message)) return;
+      info(message, options);
+    }
+  };
+}
+function isNoisyViteInfo(message) {
+  return /\[vite\]\s+\(client\)\s+(hmr update|page reload)\b/.test(stripAnsi(message));
+}
+function stripAnsi(value) {
+  return value.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+function helpText(prefix) {
+  return `${prefix ? `${prefix}
+
+` : ""}Usage:
+  vitepad <entry> [options]
+
+Entries:
+  .js, .ts                  Treated as main entry files.
+  .jsx, .tsx, .vue, .svelte Treated as App component files.
+
+Options:
+  -f, --framework <name>    auto, react, preact, solid, vue, svelte, vanilla
+                            Version specs are supported, e.g. react@18, vue@3.4.
+  --force-install           Reinstall the selected framework cache.
+  -p, --port <number>       Dev server port. Default: 8000
+  --host <host>             Dev server host. Default: 0.0.0.0
+  --no-open                 Do not open the browser automatically.
+  -c, --config <file>       Merge an extra Vite config file.
+  -h, --help                Show help.
+`;
+}
+
+// src/cli.ts
+run(process.argv.slice(2)).catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map