@buding0904/vitepad 0.3.0 → 0.3.2

package/dist/index.js

@@ -1,6 +1,6 @@
-import fs2 from 'fs/promises';
+import fs3 from 'fs/promises';
 import os from 'os';
-import path2 from 'path';
+import path3 from 'path';
 import process2 from 'process';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { createServer, mergeConfig, normalizePath, createLogger } from 'vite';
@@ -9,8 +9,8 @@ import { spawn } from 'child_process';
 import { createRequire } from 'module';
 
 // src/runtime/index.ts
-var packageRoot = path2.resolve(fileURLToPath(new URL("..", import.meta.url)));
-var requireFromPackage = createRequire(path2.join(packageRoot, "package.json"));
+var packageRoot = path3.resolve(fileURLToPath(new URL("..", import.meta.url)));
+var requireFromPackage = createRequire(path3.join(packageRoot, "package.json"));
 var linkedPeerPackages = ["vite"];
 var log = {
   framework(requested, resolved) {
@@ -35,20 +35,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.join(cacheDir, "node_modules");
+  const nodeModules = path3.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) {
+  if (!installed) {
     log.install(resolved.packages);
     await installFrameworkCache(cacheDir, resolved.packages);
   }
@@ -61,7 +58,7 @@ async function resolveFramework(spec, options) {
     cacheDir,
     aliases: [],
     packageLinks: [
-      ...packageLinks(["tailwindcss"]),
+      ...packageLinks(["unocss"]),
       ...packageLinks(nodeModules, frameworkRuntimePackages(spec.name))
     ],
     editorPackageLinks: packageLinks(nodeModules, frameworkEditorPackages(spec.name))
@@ -260,33 +257,33 @@ function packageLinks(nodeModulesOrPackageNames, maybePackageNames) {
   const packageNames = maybePackageNames ?? [];
   return packageNames.map((packageName) => ({
     name: packageName,
-    source: path2.join(nodeModules, packageName)
+    source: path3.join(nodeModules, packageName)
   }));
 }
 function resolveInstalledPackageDir(packageName) {
   const packageJson = requireFromPackage.resolve(`${packageName}/package.json`);
-  return path2.dirname(packageJson);
+  return path3.dirname(packageJson);
 }
 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)}`);
+  const base = process.env.VITEPAD_CACHE_DIR || (process.env.XDG_CACHE_HOME ? path3.join(process.env.XDG_CACHE_HOME, "vitepad") : path3.join(os.homedir(), ".cache", "vitepad"));
+  return path3.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;
+  if (!await pathExists(path3.join(cacheDir, "node_modules"))) return false;
   for (const pkg of packages) {
     const { name } = splitPackageSpec(pkg);
-    if (!await pathExists(path2.join(cacheDir, "node_modules", name))) {
+    if (!await pathExists(path3.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({
+  await fs3.mkdir(cacheDir, { recursive: true });
+  await fs3.writeFile(path3.join(cacheDir, "package.json"), JSON.stringify({
     private: true,
     type: "module",
     dependencies: Object.fromEntries(packages.map((pkg) => packageToDependency(pkg)))
@@ -326,12 +323,12 @@ ${output.trim()}`));
   });
 }
 async function linkPeerPackages(cacheDir) {
-  await fs2.mkdir(path2.join(cacheDir, "node_modules"), { recursive: true });
+  await fs3.mkdir(path3.join(cacheDir, "node_modules"), { recursive: true });
   for (const packageName of linkedPeerPackages) {
     try {
       await linkPackage({
         source: resolveInstalledPackageDir(packageName),
-        target: path2.join(cacheDir, "node_modules", packageName)
+        target: path3.join(cacheDir, "node_modules", packageName)
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -341,16 +338,16 @@ ${message}`);
   }
 }
 async function linkPackage(input) {
-  const source = await fs2.realpath(input.source);
-  const existing = await fs2.lstat(input.target).catch(() => null);
+  const source = await fs3.realpath(input.source);
+  const existing = await fs3.lstat(input.target).catch(() => null);
   if (existing) {
     if (existing.isSymbolicLink()) {
-      const current = await fs2.realpath(input.target).catch(() => null);
+      const current = await fs3.realpath(input.target).catch(() => null);
       if (current === source) return;
     }
-    await fs2.rm(input.target, { recursive: true, force: true });
+    await fs3.rm(input.target, { recursive: true, force: true });
   }
-  await fs2.symlink(source, input.target, "dir");
+  await fs3.symlink(source, input.target, "dir");
 }
 function createProgress(label) {
   const width = 18;
@@ -386,16 +383,37 @@ function splitPackageSpec(spec) {
   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 requireFromCache = createRequire(path3.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);
+  return fs3.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.dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const packageJsonPath = path3.join(current, "package.json");
+    const source = await fs3.readFile(packageJsonPath, "utf8").catch(() => null);
+    if (source) {
+      const packageJson = JSON.parse(source);
+      if (packageJson.name === "@buding0904/vitepad") return packageJson;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      throw new Error("Failed to locate vitepad package.json.");
+    }
+    current = parent;
+  }
 }
 
 // src/runtime/index.ts
-var rootDir = path2.resolve(fileURLToPath(new URL("..", import.meta.url)));
+var rootDir = path3.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"]);
@@ -405,17 +423,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.resolve(process2.cwd(), options.entry);
-  const stat = await fs2.stat(entry).catch(() => null);
+  const entry = path3.resolve(process2.cwd(), options.entry);
+  const stat = await fs3.stat(entry).catch(() => null);
   if (!stat?.isFile()) {
     throw new Error(`Entry file does not exist: ${entry}`);
   }
-  const extension = path2.extname(entry).toLowerCase();
+  const extension = path3.extname(entry).toLowerCase();
   const mode = inferMode(extension);
-  const source = await fs2.readFile(entry, "utf8");
+  const source = await fs3.readFile(entry, "utf8");
   const framework = inferFramework({
     extension,
     source,
@@ -423,15 +445,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.dirname(entry), resolvedFramework.editorPackageLinks);
-  const classTokens = await collectClassTokens(entry);
+  const resolvedFramework = await resolveFramework(framework, { forceInstall: false });
+  await setupEditorPackages(path3.dirname(entry), resolvedFramework.editorPackageLinks);
   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);
@@ -441,7 +460,8 @@ async function run(argv) {
     server: {
       host: options.host,
       port: options.port,
-      open: options.open,
+      strictPort: options.strictPort,
+      open: false,
       watch: {
         ignored: (file) => normalizePath(file).startsWith(`${normalizePath(workspace)}/`)
       },
@@ -449,7 +469,7 @@ async function run(argv) {
         allow: [
           rootDir,
           process2.cwd(),
-          path2.dirname(entry),
+          path3.dirname(entry),
           workspace,
           ...resolvedFramework.cacheDir ? [resolvedFramework.cacheDir] : []
         ]
@@ -461,13 +481,13 @@ async function run(argv) {
         ...resolvedFramework.aliases,
         {
           find: "@",
-          replacement: path2.dirname(entry)
+          replacement: path3.dirname(entry)
         }
       ],
       dedupe: frameworkDedupe(resolvedFramework.name)
     },
     optimizeDeps: {
-      entries: [path2.join(workspace, "src/main.js")],
+      entries: [path3.join(workspace, "src/main.js")],
       include: frameworkOptimizeDeps(resolvedFramework.name)
     },
     customLogger: createVitepadLogger()
@@ -489,22 +509,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=")) {
@@ -513,10 +535,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=")) {
@@ -580,32 +598,29 @@ function validateCombination(input) {
   }
 }
 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 });
+  const workspace = await fs3.mkdtemp(path3.join(await fs3.realpath(os.tmpdir()), "vitepad-"));
+  const srcDir = path3.join(workspace, "src");
+  const nodeModulesDir = path3.join(workspace, "node_modules");
+  await fs3.mkdir(srcDir, { recursive: true });
+  await fs3.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)),
+    fs3.writeFile(path3.join(workspace, "index.html"), htmlTemplate()),
+    fs3.writeFile(path3.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");
+  const source = await fs3.realpath(link.source);
+  const target = path3.join(nodeModulesDir, link.name);
+  await fs3.mkdir(path3.dirname(target), { recursive: true });
+  await fs3.symlink(source, target, "dir");
 }
 async function setupEditorPackages(projectDir, links) {
   if (links.length === 0) return;
-  const nodeModulesDir = path2.join(projectDir, "node_modules");
-  await fs2.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);
     }
@@ -614,81 +629,34 @@ async function setupEditorPackages(projectDir, links) {
     console.log(`${pc2.cyan("vitepad")} ${pc2.green("editor")} linked ${linked.map((name) => pc2.cyan(name)).join(pc2.gray(", "))}`);
   }
 }
-async function linkEditorPackage(nodeModulesDir, link) {
-  const source = await fs2.realpath(link.source);
-  const target = path2.join(nodeModulesDir, link.name);
-  await fs2.mkdir(path2.dirname(target), { recursive: true });
-  const existing = await fs2.lstat(target).catch(() => null);
+async function linkEditorPackage(projectDir, link) {
+  const source = await fs3.realpath(link.source);
+  const existingResolvablePackage = await findResolvablePackage(projectDir, link.name);
+  if (existingResolvablePackage) return "skipped";
+  const nodeModulesDir = path3.join(projectDir, "node_modules");
+  const target = path3.join(nodeModulesDir, link.name);
+  await fs3.mkdir(path3.dirname(target), { recursive: true });
+  const existing = await fs3.lstat(target).catch(() => null);
   if (existing) {
     if (existing.isSymbolicLink()) {
-      const current = await fs2.realpath(target).catch(() => null);
+      const current = await fs3.realpath(target).catch(() => null);
       if (current === source) return "skipped";
     }
     return "skipped";
   }
-  await fs2.symlink(source, target, "dir");
+  await fs3.symlink(source, target, "dir");
   return "linked";
 }
-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;
+async function findResolvablePackage(fromDir, packageName) {
+  let current = path3.resolve(fromDir);
+  while (true) {
+    const candidate = path3.join(current, "node_modules", packageName);
+    const existing = await fs3.lstat(candidate).catch(() => null);
+    if (existing) return candidate;
+    const parent = path3.dirname(current);
+    if (parent === current) return null;
+    current = parent;
   }
-  return void 0;
 }
 function htmlTemplate() {
   return `<!doctype html>
@@ -709,13 +677,13 @@ function mainTemplate(input) {
   const { entry, mode, framework } = input;
   const importPath = `/@fs/${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)}
@@ -723,28 +691,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)}
 
@@ -758,17 +726,18 @@ export default app
 }
 async function loadUserConfig(configFile) {
   if (!configFile) return {};
-  const resolved = path2.resolve(process2.cwd(), configFile);
+  const resolved = path3.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'),
+  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;
 }
@@ -821,10 +790,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.
 `;