@buding0904/vitepad 0.3.1 → 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) {
@@ -41,14 +41,11 @@ async function resolveFramework(spec, options) {
   }
   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);
   }
@@ -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,8 +445,8 @@ 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 resolvedFramework = await resolveFramework(framework, { forceInstall: false });
+  await setupEditorPackages(path3.dirname(entry), resolvedFramework.editorPackageLinks);
   const workspace = await createWorkspace({
     entry,
     mode,
@@ -438,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)}/`)
       },
@@ -446,7 +469,7 @@ async function run(argv) {
         allow: [
           rootDir,
           process2.cwd(),
-          path2.dirname(entry),
+          path3.dirname(entry),
           workspace,
           ...resolvedFramework.cacheDir ? [resolvedFramework.cacheDir] : []
         ]
@@ -458,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()
@@ -486,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=")) {
@@ -510,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=")) {
@@ -577,31 +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, "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);
     }
@@ -610,21 +629,35 @@ 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";
 }
+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;
+  }
+}
 function htmlTemplate() {
   return `<!doctype html>
 <html lang="en">
@@ -693,7 +726,7 @@ 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;
 }
@@ -757,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.
 `;