@buding0904/vitepad 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-var fs2 = require('fs/promises');
+var fs3 = require('fs/promises');
 var os = require('os');
-var path2 = require('path');
+var path3 = require('path');
 var process2 = require('process');
 var url = require('url');
 var vite = require('vite');
@@ -13,15 +13,15 @@ var module$1 = require('module');
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 var os__default = /*#__PURE__*/_interopDefault(os);
-var path2__default = /*#__PURE__*/_interopDefault(path2);
+var path3__default = /*#__PURE__*/_interopDefault(path3);
 var process2__default = /*#__PURE__*/_interopDefault(process2);
 var pc2__default = /*#__PURE__*/_interopDefault(pc2);
 
 // src/runtime/index.ts
-var packageRoot = path2__default.default.resolve(url.fileURLToPath(new URL("..", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))));
-var requireFromPackage = module$1.createRequire(path2__default.default.join(packageRoot, "package.json"));
+var packageRoot = path3__default.default.resolve(url.fileURLToPath(new URL("..", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))));
+var requireFromPackage = module$1.createRequire(path3__default.default.join(packageRoot, "package.json"));
 var linkedPeerPackages = ["vite"];
 var log = {
   framework(requested, resolved) {
@@ -46,20 +46,17 @@ async function resolveFramework(spec, options) {
       requested: "vanilla",
       cacheStatus: "local",
       aliases: [],
-      packageLinks: packageLinks(["tailwindcss"]),
+      packageLinks: packageLinks(["unocss"]),
       editorPackageLinks: []
     };
   }
   const resolved = await resolveFrameworkPackages(spec.name, spec.version);
   const cacheDir = frameworkCacheDir(spec.name, resolved.version);
-  const nodeModules = path2__default.default.join(cacheDir, "node_modules");
+  const nodeModules = path3__default.default.join(cacheDir, "node_modules");
   const installed = await isInstalled(cacheDir, resolved.packages);
-  if (options.forceInstall && await pathExists(cacheDir)) {
-    await fs2__default.default.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) {
+  if (!installed) {
     log.install(resolved.packages);
     await installFrameworkCache(cacheDir, resolved.packages);
   }
@@ -72,7 +69,7 @@ async function resolveFramework(spec, options) {
     cacheDir,
     aliases: [],
     packageLinks: [
-      ...packageLinks(["tailwindcss"]),
+      ...packageLinks(["unocss"]),
       ...packageLinks(nodeModules, frameworkRuntimePackages(spec.name))
     ],
     editorPackageLinks: packageLinks(nodeModules, frameworkEditorPackages(spec.name))
@@ -271,33 +268,33 @@ function packageLinks(nodeModulesOrPackageNames, maybePackageNames) {
   const packageNames = maybePackageNames ?? [];
   return packageNames.map((packageName) => ({
     name: packageName,
-    source: path2__default.default.join(nodeModules, packageName)
+    source: path3__default.default.join(nodeModules, packageName)
   }));
 }
 function resolveInstalledPackageDir(packageName) {
   const packageJson = requireFromPackage.resolve(`${packageName}/package.json`);
-  return path2__default.default.dirname(packageJson);
+  return path3__default.default.dirname(packageJson);
 }
 function frameworkCacheDir(framework, version) {
-  const base = process.env.VITEPAD_CACHE_DIR || (process.env.XDG_CACHE_HOME ? path2__default.default.join(process.env.XDG_CACHE_HOME, "vitepad") : path2__default.default.join(os__default.default.homedir(), ".cache", "vitepad"));
-  return path2__default.default.join(base, "frameworks", `${framework}-${sanitizeCacheKey(version)}`);
+  const base = process.env.VITEPAD_CACHE_DIR || (process.env.XDG_CACHE_HOME ? path3__default.default.join(process.env.XDG_CACHE_HOME, "vitepad") : path3__default.default.join(os__default.default.homedir(), ".cache", "vitepad"));
+  return path3__default.default.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__default.default.join(cacheDir, "node_modules"))) return false;
+  if (!await pathExists(path3__default.default.join(cacheDir, "node_modules"))) return false;
   for (const pkg of packages) {
     const { name } = splitPackageSpec(pkg);
-    if (!await pathExists(path2__default.default.join(cacheDir, "node_modules", name))) {
+    if (!await pathExists(path3__default.default.join(cacheDir, "node_modules", name))) {
       return false;
     }
   }
   return true;
 }
 async function installFrameworkCache(cacheDir, packages) {
-  await fs2__default.default.mkdir(cacheDir, { recursive: true });
-  await fs2__default.default.writeFile(path2__default.default.join(cacheDir, "package.json"), JSON.stringify({
+  await fs3__default.default.mkdir(cacheDir, { recursive: true });
+  await fs3__default.default.writeFile(path3__default.default.join(cacheDir, "package.json"), JSON.stringify({
     private: true,
     type: "module",
     dependencies: Object.fromEntries(packages.map((pkg) => packageToDependency(pkg)))
@@ -337,12 +334,12 @@ ${output.trim()}`));
   });
 }
 async function linkPeerPackages(cacheDir) {
-  await fs2__default.default.mkdir(path2__default.default.join(cacheDir, "node_modules"), { recursive: true });
+  await fs3__default.default.mkdir(path3__default.default.join(cacheDir, "node_modules"), { recursive: true });
   for (const packageName of linkedPeerPackages) {
     try {
       await linkPackage({
         source: resolveInstalledPackageDir(packageName),
-        target: path2__default.default.join(cacheDir, "node_modules", packageName)
+        target: path3__default.default.join(cacheDir, "node_modules", packageName)
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -352,16 +349,16 @@ ${message}`);
   }
 }
 async function linkPackage(input) {
-  const source = await fs2__default.default.realpath(input.source);
-  const existing = await fs2__default.default.lstat(input.target).catch(() => null);
+  const source = await fs3__default.default.realpath(input.source);
+  const existing = await fs3__default.default.lstat(input.target).catch(() => null);
   if (existing) {
     if (existing.isSymbolicLink()) {
-      const current = await fs2__default.default.realpath(input.target).catch(() => null);
+      const current = await fs3__default.default.realpath(input.target).catch(() => null);
       if (current === source) return;
     }
-    await fs2__default.default.rm(input.target, { recursive: true, force: true });
+    await fs3__default.default.rm(input.target, { recursive: true, force: true });
   }
-  await fs2__default.default.symlink(source, input.target, "dir");
+  await fs3__default.default.symlink(source, input.target, "dir");
 }
 function createProgress(label) {
   const width = 18;
@@ -397,16 +394,37 @@ function splitPackageSpec(spec) {
   return { name: spec.slice(0, at), version: spec.slice(at + 1) };
 }
 async function importCachePackage(cacheDir, packageName) {
-  const requireFromCache = module$1.createRequire(path2__default.default.join(cacheDir, "package.json"));
+  const requireFromCache = module$1.createRequire(path3__default.default.join(cacheDir, "package.json"));
   const resolved = requireFromCache.resolve(packageName);
   return import(url.pathToFileURL(resolved).href);
 }
 async function pathExists(file) {
-  return fs2__default.default.access(file).then(() => true, () => false);
+  return fs3__default.default.access(file).then(() => true, () => false);
+}
+async function packageVersion() {
+  const packageJson = await readPackageJson();
+  if (typeof packageJson.version === "string") return packageJson.version;
+  throw new Error("Failed to read vitepad version from package.json.");
+}
+async function readPackageJson() {
+  let current = path3__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+  while (true) {
+    const packageJsonPath = path3__default.default.join(current, "package.json");
+    const source = await fs3__default.default.readFile(packageJsonPath, "utf8").catch(() => null);
+    if (source) {
+      const packageJson = JSON.parse(source);
+      if (packageJson.name === "@buding0904/vitepad") return packageJson;
+    }
+    const parent = path3__default.default.dirname(current);
+    if (parent === current) {
+      throw new Error("Failed to locate vitepad package.json.");
+    }
+    current = parent;
+  }
 }
 
 // src/runtime/index.ts
-var rootDir = path2__default.default.resolve(url.fileURLToPath(new URL("..", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))));
+var rootDir = path3__default.default.resolve(url.fileURLToPath(new URL("..", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)))));
 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"]);
@@ -416,17 +434,21 @@ async function run(argv) {
     console.log(helpText());
     return;
   }
+  if (options.version) {
+    console.log(await packageVersion());
+    return;
+  }
   if (!options.entry) {
     throw new Error(helpText("Missing entry file."));
   }
-  const entry = path2__default.default.resolve(process2__default.default.cwd(), options.entry);
-  const stat = await fs2__default.default.stat(entry).catch(() => null);
+  const entry = path3__default.default.resolve(process2__default.default.cwd(), options.entry);
+  const stat = await fs3__default.default.stat(entry).catch(() => null);
   if (!stat?.isFile()) {
     throw new Error(`Entry file does not exist: ${entry}`);
   }
-  const extension = path2__default.default.extname(entry).toLowerCase();
+  const extension = path3__default.default.extname(entry).toLowerCase();
   const mode = inferMode(extension);
-  const source = await fs2__default.default.readFile(entry, "utf8");
+  const source = await fs3__default.default.readFile(entry, "utf8");
   const framework = inferFramework({
     extension,
     source,
@@ -434,15 +456,12 @@ async function run(argv) {
     version: options.frameworkVersion
   });
   validateCombination({ mode, framework: framework.name, extension });
-  const resolvedFramework = await resolveFramework(framework, { forceInstall: options.forceInstall });
-  await setupEditorPackages(path2__default.default.dirname(entry), resolvedFramework.editorPackageLinks);
-  const classTokens = await collectClassTokens(entry);
+  const resolvedFramework = await resolveFramework(framework, { forceInstall: false });
+  await setupEditorPackages(path3__default.default.dirname(entry), resolvedFramework.editorPackageLinks);
   const workspace = await createWorkspace({
     entry,
     mode,
     framework: resolvedFramework.name,
-    sourceDirs: uniquePaths([process2__default.default.cwd(), path2__default.default.dirname(entry)]),
-    classTokens,
     packageLinks: resolvedFramework.packageLinks
   });
   const config = await loadUserConfig(options.config);
@@ -452,7 +471,8 @@ async function run(argv) {
     server: {
       host: options.host,
       port: options.port,
-      open: options.open,
+      strictPort: options.strictPort,
+      open: false,
       watch: {
         ignored: (file) => vite.normalizePath(file).startsWith(`${vite.normalizePath(workspace)}/`)
       },
@@ -460,7 +480,7 @@ async function run(argv) {
         allow: [
           rootDir,
           process2__default.default.cwd(),
-          path2__default.default.dirname(entry),
+          path3__default.default.dirname(entry),
           workspace,
           ...resolvedFramework.cacheDir ? [resolvedFramework.cacheDir] : []
         ]
@@ -472,13 +492,13 @@ async function run(argv) {
         ...resolvedFramework.aliases,
         {
           find: "@",
-          replacement: path2__default.default.dirname(entry)
+          replacement: path3__default.default.dirname(entry)
         }
       ],
       dedupe: frameworkDedupe(resolvedFramework.name)
     },
     optimizeDeps: {
-      entries: [path2__default.default.join(workspace, "src/main.js")],
+      entries: [path3__default.default.join(workspace, "src/main.js")],
       include: frameworkOptimizeDeps(resolvedFramework.name)
     },
     customLogger: createVitepadLogger()
@@ -500,22 +520,24 @@ function parseArgs(argv) {
   const options = {
     framework: "auto",
     frameworkVersion: "latest",
-    forceInstall: false,
     port: 8e3,
+    strictPort: false,
     host: "0.0.0.0",
-    open: "/",
-    help: false
+    help: false,
+    version: 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 === "-v" || arg === "--version") {
+      options.version = 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 === "--strictPort") {
+      options.strictPort = true;
     } else if (arg === "--port" || arg === "-p") {
       options.port = Number(readValue(argv, ++index, arg));
     } else if (arg.startsWith("--port=")) {
@@ -524,10 +546,6 @@ function parseArgs(argv) {
       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=")) {
@@ -591,32 +609,29 @@ function validateCombination(input) {
   }
 }
 async function createWorkspace(input) {
-  const workspace = await fs2__default.default.mkdtemp(path2__default.default.join(await fs2__default.default.realpath(os__default.default.tmpdir()), "vitepad-"));
-  const srcDir = path2__default.default.join(workspace, "src");
-  const nodeModulesDir = path2__default.default.join(workspace, "node_modules");
-  await fs2__default.default.mkdir(srcDir, { recursive: true });
-  await fs2__default.default.mkdir(nodeModulesDir, { recursive: true });
+  const workspace = await fs3__default.default.mkdtemp(path3__default.default.join(await fs3__default.default.realpath(os__default.default.tmpdir()), "vitepad-"));
+  const srcDir = path3__default.default.join(workspace, "src");
+  const nodeModulesDir = path3__default.default.join(workspace, "node_modules");
+  await fs3__default.default.mkdir(srcDir, { recursive: true });
+  await fs3__default.default.mkdir(nodeModulesDir, { recursive: true });
   await Promise.all([
-    fs2__default.default.writeFile(path2__default.default.join(workspace, "index.html"), htmlTemplate()),
-    fs2__default.default.writeFile(path2__default.default.join(srcDir, "style.css"), styleTemplate(input.sourceDirs, input.classTokens)),
-    fs2__default.default.writeFile(path2__default.default.join(srcDir, "main.js"), mainTemplate(input)),
+    fs3__default.default.writeFile(path3__default.default.join(workspace, "index.html"), htmlTemplate()),
+    fs3__default.default.writeFile(path3__default.default.join(srcDir, "main.js"), mainTemplate(input)),
     ...input.packageLinks.map((link) => linkWorkspacePackage(nodeModulesDir, link))
   ]);
   return workspace;
 }
 async function linkWorkspacePackage(nodeModulesDir, link) {
-  const source = await fs2__default.default.realpath(link.source);
-  const target = path2__default.default.join(nodeModulesDir, link.name);
-  await fs2__default.default.mkdir(path2__default.default.dirname(target), { recursive: true });
-  await fs2__default.default.symlink(source, target, "dir");
+  const source = await fs3__default.default.realpath(link.source);
+  const target = path3__default.default.join(nodeModulesDir, link.name);
+  await fs3__default.default.mkdir(path3__default.default.dirname(target), { recursive: true });
+  await fs3__default.default.symlink(source, target, "dir");
 }
 async function setupEditorPackages(projectDir, links) {
   if (links.length === 0) return;
-  const nodeModulesDir = path2__default.default.join(projectDir, "node_modules");
-  await fs2__default.default.mkdir(nodeModulesDir, { recursive: true });
   const linked = [];
   for (const link of links) {
-    const result = await linkEditorPackage(nodeModulesDir, link);
+    const result = await linkEditorPackage(projectDir, link);
     if (result === "linked") {
       linked.push(link.name);
     }
@@ -625,81 +640,34 @@ async function setupEditorPackages(projectDir, links) {
     console.log(`${pc2__default.default.cyan("vitepad")} ${pc2__default.default.green("editor")} linked ${linked.map((name) => pc2__default.default.cyan(name)).join(pc2__default.default.gray(", "))}`);
   }
 }
-async function linkEditorPackage(nodeModulesDir, link) {
-  const source = await fs2__default.default.realpath(link.source);
-  const target = path2__default.default.join(nodeModulesDir, link.name);
-  await fs2__default.default.mkdir(path2__default.default.dirname(target), { recursive: true });
-  const existing = await fs2__default.default.lstat(target).catch(() => null);
+async function linkEditorPackage(projectDir, link) {
+  const source = await fs3__default.default.realpath(link.source);
+  const existingResolvablePackage = await findResolvablePackage(projectDir, link.name);
+  if (existingResolvablePackage) return "skipped";
+  const nodeModulesDir = path3__default.default.join(projectDir, "node_modules");
+  const target = path3__default.default.join(nodeModulesDir, link.name);
+  await fs3__default.default.mkdir(path3__default.default.dirname(target), { recursive: true });
+  const existing = await fs3__default.default.lstat(target).catch(() => null);
   if (existing) {
     if (existing.isSymbolicLink()) {
-      const current = await fs2__default.default.realpath(target).catch(() => null);
+      const current = await fs3__default.default.realpath(target).catch(() => null);
       if (current === source) return "skipped";
     }
     return "skipped";
   }
-  await fs2__default.default.symlink(source, target, "dir");
+  await fs3__default.default.symlink(source, target, "dir");
   return "linked";
 }
-function uniquePaths(paths) {
-  return [...new Set(paths.map((item) => vite.normalizePath(path2__default.default.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__default.default.resolve(file);
-  if (visited.has(resolved)) return;
-  visited.add(resolved);
-  const source = await fs2__default.default.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__default.default.resolve(path2__default.default.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__default.default.join(base, file))
-  ];
-  for (const candidate of candidates) {
-    const stat = await fs2__default.default.stat(candidate).catch(() => null);
-    if (stat?.isFile()) return candidate;
+async function findResolvablePackage(fromDir, packageName) {
+  let current = path3__default.default.resolve(fromDir);
+  while (true) {
+    const candidate = path3__default.default.join(current, "node_modules", packageName);
+    const existing = await fs3__default.default.lstat(candidate).catch(() => null);
+    if (existing) return candidate;
+    const parent = path3__default.default.dirname(current);
+    if (parent === current) return null;
+    current = parent;
   }
-  return void 0;
 }
 function htmlTemplate() {
   return `<!doctype html>
@@ -720,13 +688,13 @@ function mainTemplate(input) {
   const { entry, mode, framework } = input;
   const importPath = `/@fs/${vite.normalizePath(entry)}`;
   if (mode === "main") {
-    return `import './style.css'
+    return `import 'virtual:uno.css'
 import ${JSON.stringify(importPath)}
 `;
   }
   switch (framework) {
     case "react":
-      return `import './style.css'
+      return `import 'virtual:uno.css'
 import React from 'react'
 import { createRoot } from 'react-dom/client'
 import App from ${JSON.stringify(importPath)}
@@ -734,28 +702,28 @@ import App from ${JSON.stringify(importPath)}
 createRoot(document.getElementById('root')).render(React.createElement(App))
 `;
     case "preact":
-      return `import './style.css'
+      return `import 'virtual:uno.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'
+      return `import 'virtual:uno.css'
 import { render } from 'solid-js/web'
 import App from ${JSON.stringify(importPath)}
 
 render(() => App({}), document.getElementById('root'))
 `;
     case "vue":
-      return `import './style.css'
+      return `import 'virtual:uno.css'
 import { createApp } from 'vue'
 import App from ${JSON.stringify(importPath)}
 
 createApp(App).mount('#root')
 `;
     case "svelte":
-      return `import './style.css'
+      return `import 'virtual:uno.css'
 import { mount } from 'svelte'
 import App from ${JSON.stringify(importPath)}
 
@@ -769,17 +737,18 @@ export default app
 }
 async function loadUserConfig(configFile) {
   if (!configFile) return {};
-  const resolved = path2__default.default.resolve(process2__default.default.cwd(), configFile);
+  const resolved = path3__default.default.resolve(process2__default.default.cwd(), configFile);
   const configModule = await import(url.pathToFileURL(resolved).href);
   return configModule.default ?? configModule;
 }
 async function loadPlugins(framework) {
-  const [{ default: tailwindcss }, frameworkPlugins] = await Promise.all([
-    import('@tailwindcss/vite'),
+  const [{ default: unocss }, { presetUno }, frameworkPlugins] = await Promise.all([
+    import('unocss/vite'),
+    import('unocss'),
     loadFrameworkPlugins(framework)
   ]);
   const plugins = [];
-  appendPlugin(plugins, tailwindcss());
+  appendPlugin(plugins, unocss({ presets: [presetUno()] }));
   plugins.push(...frameworkPlugins);
   return plugins;
 }
@@ -832,10 +801,9 @@ Entries:
 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
+  --strictPort              Exit if the configured port is already in use.
   --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.
 `;