sv 0.5.6 → 0.5.8

package/dist/bin.js

@@ -25,7 +25,7 @@ import require$$0$3 from 'events';
 import { t as templates, c as create$2 } from './index-A89HFWzv.js';
 
 var name = "sv";
-var version = "0.5.6";
+var version = "0.5.8";
 var type = "module";
 var description = "A CLI for creating and updating SvelteKit projects";
 var license = "MIT";
@@ -48593,14 +48593,18 @@ var drizzle = defineAdder({
       }
     }
   ],
-  nextSteps: ({ options: options2, highlighter }) => {
+  nextSteps: ({ options: options2, highlighter, packageManager }) => {
     const steps = [
       `You will need to set ${highlighter.env("DATABASE_URL")} in your production environment`
     ];
     if (options2.docker) {
-      steps.push(`Run ${highlighter.command("npm run db:start")} to start the docker container`);
+      steps.push(
+        `Run ${highlighter.command(`${packageManager} run db:start`)} to start the docker container`
+      );
     }
-    steps.push(`Run ${highlighter.command("npm run db:push")} to update your database schema`);
+    steps.push(
+      `Run ${highlighter.command(`${packageManager} run db:push`)} to update your database schema`
+    );
     return steps;
   }
 });
@@ -50194,7 +50198,7 @@ const options$2 = defineAdderOptions({
 var lucia = defineAdder({
   id: "lucia",
   environments: { svelte: false, kit: true },
-  homepage: "https://lucia-next.pages.dev",
+  homepage: "https://lucia-auth.com",
   options: options$2,
   packages: [
     { name: "@oslojs/crypto", version: "^1.0.1", dev: false },
@@ -50700,8 +50704,10 @@ ${sessionType}`);
       }
     }
   ],
-  nextSteps: ({ highlighter, options: options2 }) => {
-    const steps = [`Run ${highlighter.command("npm run db:push")} to update your database schema`];
+  nextSteps: ({ highlighter, options: options2, packageManager }) => {
+    const steps = [
+      `Run ${highlighter.command(`${packageManager} run db:push`)} to update your database schema`
+    ];
     if (options2.demo) {
       steps.push(`Visit ${highlighter.route("/demo/lucia")} route to view the demo`);
     }
@@ -51687,55 +51693,40 @@ async function runCommand(action) {
     }
   }
 }
-async function formatFiles(cwd, paths) {
-  const pm = detectPackageManager(cwd);
-  const args = ["prettier", "--write", "--ignore-unknown", ...paths];
-  const cmd = resolveCommand(pm, "execute-local", args);
-  await be(cmd.command, cmd.args, {
-    nodeOptions: { cwd, stdio: "pipe" }
-  });
+async function formatFiles(options) {
+  const args = ["prettier", "--write", "--ignore-unknown", ...options.paths];
+  const cmd = resolveCommand(options.packageManager, "execute-local", args);
+  await be(cmd.command, cmd.args, { nodeOptions: { cwd: options.cwd, stdio: "pipe" } });
 }
-async function suggestInstallingDependencies(cwd) {
+const agents = AGENTS.filter((agent) => !agent.includes("@"));
+const agentOptions = agents.map((pm) => ({ value: pm, label: pm }));
+agentOptions.unshift({ label: "None", value: void 0 });
+async function packageManagerPrompt(cwd) {
   const detected = detectSync({ cwd });
-  const agent = detected?.agent ?? getUserAgent() ?? null;
-  const agents = AGENTS.filter((agent2) => !agent2.includes("@"));
-  const options = agents.map((pm2) => ({ value: pm2, label: pm2 }));
-  options.unshift({ label: "None", value: null });
+  const agent = detected?.name ?? getUserAgent();
   const pm = await select({
     message: "Which package manager do you want to install dependencies with?",
-    options,
+    options: agentOptions,
     initialValue: agent
   });
   if (isCancel(pm)) {
     cancel("Operation cancelled.");
     process$1$1.exit(1);
   }
-  if (!pm) {
-    return "skipped";
-  }
-  const { command, args } = constructCommand(COMMANDS[pm].install, []);
-  const loadingSpinner = spinner();
-  loadingSpinner.start("Installing dependencies...");
-  await installDependencies(command, args, cwd);
-  packageManager = command;
-  loadingSpinner.stop("Successfully installed dependencies");
-  return "installed";
+  return pm;
 }
-async function installDependencies(command, args, cwd) {
+async function installDependencies(agent, cwd) {
+  const spinner$1 = spinner();
+  spinner$1.start("Installing dependencies...");
   try {
+    const { command, args } = constructCommand(COMMANDS[agent].install, []);
     await be(command, args, { nodeOptions: { cwd } });
+    spinner$1.stop("Successfully installed dependencies");
   } catch (error) {
-    const typedError = error;
-    throw new Error(`Unable to install dependencies: ${typedError.message}`);
+    spinner$1.stop("Failed to install dependencies", 2);
+    throw error;
   }
 }
-let packageManager;
-function detectPackageManager(cwd) {
-  if (packageManager) return packageManager;
-  const pm = detectSync({ cwd });
-  if (pm?.name) packageManager = pm.name;
-  return pm?.name ?? getUserAgent() ?? "npm";
-}
 function getUserAgent() {
   const userAgent = process$1$1.env.npm_config_user_agent;
   if (!userAgent) return void 0;
@@ -55111,27 +55102,18 @@ function getHighlighter() {
   };
 }
 
-function createEmptyWorkspace() {
-  return {
-    options: {},
-    cwd: "",
-    dependencyVersion: (_pkg) => void 0,
-    typescript: false,
-    kit: void 0
-  };
-}
-function createWorkspace(cwd) {
-  const workspace = createEmptyWorkspace();
-  workspace.cwd = path$3.resolve(cwd);
-  let usesTypescript = fs$3.existsSync(path$3.join(cwd, commonFilePaths.viteConfigTS));
+function createWorkspace({ cwd, packageManager }) {
+  const resolvedCwd = path$3.resolve(cwd);
+  const viteConfigPath = path$3.join(resolvedCwd, commonFilePaths.viteConfigTS);
+  let usesTypescript = fs$3.existsSync(viteConfigPath);
   if (TESTING) {
-    usesTypescript || (usesTypescript = fs$3.existsSync(path$3.join(cwd, commonFilePaths.tsconfig)));
+    usesTypescript || (usesTypescript = fs$3.existsSync(path$3.join(resolvedCwd, commonFilePaths.tsconfig)));
   } else {
     usesTypescript || (usesTypescript = up$1(commonFilePaths.tsconfig, { cwd }) !== void 0);
   }
   let dependencies = {};
-  let directory = workspace.cwd;
-  const root = findRoot(workspace.cwd);
+  let directory = resolvedCwd;
+  const root = findRoot(resolvedCwd);
   while (directory && directory !== root) {
     if (fs$3.existsSync(path$3.join(directory, commonFilePaths.packageJson))) {
       const { data: packageJson } = getPackageJson(directory);
@@ -55146,13 +55128,14 @@ function createWorkspace(cwd) {
   for (const [key, value] of Object.entries(dependencies)) {
     dependencies[key] = value.replaceAll(/[^\d|.]/g, "");
   }
-  workspace.dependencyVersion = (pkg) => {
-    return dependencies[pkg];
+  return {
+    kit: dependencies["@sveltejs/kit"] ? parseKitOptions(resolvedCwd) : void 0,
+    packageManager: packageManager ?? getUserAgent() ?? "npm",
+    cwd: resolvedCwd,
+    dependencyVersion: (pkg) => dependencies[pkg],
+    typescript: usesTypescript,
+    options: {}
   };
-  workspace.typescript = usesTypescript;
-  workspace.packageManager = detectPackageManager(cwd);
-  if (workspace.dependencyVersion("@sveltejs/kit")) workspace.kit = parseKitOptions(workspace);
-  return workspace;
 }
 function findRoot(cwd) {
   const { root } = path$3.parse(cwd);
@@ -55171,8 +55154,8 @@ function findRoot(cwd) {
   }
   return root;
 }
-function parseKitOptions(workspace) {
-  const configSource = readFile(workspace.cwd, commonFilePaths.svelteConfig);
+function parseKitOptions(cwd) {
+  const configSource = readFile(cwd, commonFilePaths.svelteConfig);
   const { ast } = parseScript(configSource);
   const defaultExport = ast.body.find((s) => s.type === "ExportDefaultDeclaration");
   if (!defaultExport) throw Error("Missing default export in `svelte.config.js`");
@@ -55409,7 +55392,7 @@ Available options: ${communityAdderIds.join(", ")}`
     }
   }
   if (selectedAdders.length === 0) {
-    const workspace2 = createWorkspace(options.cwd);
+    const workspace2 = createWorkspace({ cwd: options.cwd });
     const projectType = workspace2.kit ? "kit" : "svelte";
     const adderOptions = officialAdders.map((adder) => {
       if (projectType === "kit" && !adder.environments.kit) return;
@@ -55421,7 +55404,7 @@ Available options: ${communityAdderIds.join(", ")}`
       };
     }).filter((a) => !!a);
     const selected = await multiselect({
-      message: "What would you like to add to your project?",
+      message: `What would you like to add to your project? ${pc.dim("(use arrow keys / space bar)")}`,
       options: adderOptions,
       required: false
     });
@@ -55433,7 +55416,7 @@ Available options: ${communityAdderIds.join(", ")}`
   }
   for (const { adder } of selectedAdders) {
     const dependents = adder.dependsOn?.filter((dep) => !selectedAdders.some((a) => a.adder.id === dep)) ?? [];
-    const workspace2 = createWorkspace(options.cwd);
+    const workspace2 = createWorkspace({ cwd: options.cwd });
     for (const depId of dependents) {
       const dependent = officialAdders.find((a) => a.id === depId);
       if (!dependent) throw new Error(`Adder '${adder.id}' depends on an invalid '${depId}'`);
@@ -55454,7 +55437,7 @@ Available options: ${communityAdderIds.join(", ")}`
     }
   }
   if (options.preconditions && selectedAdders.length > 0) {
-    const { kit } = createWorkspace(options.cwd);
+    const { kit } = createWorkspace({ cwd: options.cwd });
     const projectType = kit ? "kit" : "svelte";
     const adders = selectedAdders.map(({ adder }) => adder);
     const { preconditions } = getGlobalPreconditions(options.cwd, projectType, adders);
@@ -55529,21 +55512,22 @@ Available options: ${communityAdderIds.join(", ")}`
       values[questionId] = answer;
     }
   }
-  let filesToFormat = [];
-  if (Object.keys({ ...official, ...community }).length > 0) {
-    filesToFormat = await runAdders({ cwd: options.cwd, official, community });
-    log$1.success("Successfully setup integrations");
+  if (selectedAdders.length === 0) return { packageManager: null };
+  let packageManager;
+  if (options.install) {
+    packageManager = await packageManagerPrompt(options.cwd);
   }
-  let depsStatus = "skipped";
-  if (options.install && selectedAdders.length > 0) {
-    depsStatus = await suggestInstallingDependencies(options.cwd);
+  const filesToFormat = await runAdders({ cwd: options.cwd, packageManager, official, community });
+  log$1.success("Successfully setup integrations");
+  if (packageManager && options.install) {
+    await installDependencies(packageManager, options.cwd);
   }
-  const workspace = createWorkspace(options.cwd);
-  if (filesToFormat.length > 0 && depsStatus === "installed" && !!workspace.dependencyVersion("prettier")) {
+  const workspace = createWorkspace({ cwd: options.cwd, packageManager });
+  if (filesToFormat.length > 0 && packageManager && !!workspace.dependencyVersion("prettier")) {
     const { start, stop } = spinner();
     start("Formatting modified files");
     try {
-      await formatFiles(options.cwd, filesToFormat);
+      await formatFiles({ packageManager, cwd: options.cwd, paths: filesToFormat });
       stop("Successfully formatted modified files");
     } catch (e) {
       stop("Failed to format files");
@@ -55565,12 +55549,13 @@ Available options: ${communityAdderIds.join(", ")}`
     adderMessage += `- ${adderNextSteps.join("\n- ")}`;
     return adderMessage;
   }).join("\n\n") || void 0;
-  return { nextSteps };
+  return { nextSteps, packageManager };
 }
 async function runAdders({
   cwd,
   official = {},
-  community = {}
+  community = {},
+  packageManager
 }) {
   const adderDetails = Object.keys(official).map((id) => getAdderDetails(id));
   const commDetails = Object.keys(community).map(
@@ -55585,7 +55570,7 @@ async function runAdders({
   const filesToFormat = /* @__PURE__ */ new Set();
   for (const config of details) {
     const adderId = config.id;
-    const workspace = createWorkspace(cwd);
+    const workspace = createWorkspace({ cwd, packageManager });
     workspace.options = official[adderId] ?? community[adderId];
     await config.preInstall?.(workspace);
     const pkgPath = installPackages(config, workspace);
@@ -55707,14 +55692,17 @@ const create = new Command("create").description("scaffolds a new SvelteKit proj
   const cwd = parse$8(ProjectPathSchema, projectPath);
   const options = parse$8(OptionsSchema, opts);
   runCommand(async () => {
-    const { directory, integrationNextSteps } = await createProject(cwd, options);
+    const { directory, integrationNextSteps, packageManager } = await createProject(cwd, options);
     const highlight = (str) => pc.bold(pc.cyan(str));
     let i = 1;
     const initialSteps = [];
     const relative = path$3.relative(process$1$1.cwd(), directory);
-    const pm = detectPackageManager(cwd);
+    const pm = packageManager ?? detectSync({ cwd })?.name ?? getUserAgent() ?? "npm";
     if (relative !== "") {
-      initialSteps.push(`${i++}: ${highlight(`cd ${relative}`)}`);
+      const pathHasSpaces = relative.includes(" ");
+      initialSteps.push(
+        `${i++}: ${highlight(`cd ${pathHasSpaces ? `"${relative}"` : relative}`)}`
+      );
     }
     if (!packageManager) {
       initialSteps.push(`${i++}: ${highlight(`${pm} install`)}`);
@@ -55792,18 +55780,26 @@ async function createProject(cwd, options) {
     types: language
   });
   log$1.success("Project created");
+  let packageManager;
   let integrationNextSteps;
+  const installDeps = async () => {
+    packageManager = await packageManagerPrompt(projectPath);
+    if (packageManager) await installDependencies(packageManager, projectPath);
+  };
   if (options.integrations) {
-    const { nextSteps } = await runAddCommand(
-      { cwd: projectPath, install: false, preconditions: true, community: [] },
+    const { nextSteps, packageManager: pm } = await runAddCommand(
+      { cwd: projectPath, install: options.install, preconditions: true, community: [] },
       []
     );
+    packageManager = pm;
     integrationNextSteps = nextSteps;
+  } else if (options.install) {
+    await installDeps();
   }
-  if (options.install) {
-    await suggestInstallingDependencies(projectPath);
+  if (packageManager === null && options.install) {
+    await installDeps();
   }
-  return { directory: projectPath, integrationNextSteps };
+  return { directory: projectPath, integrationNextSteps, packageManager };
 }
 
 const migrate = new Command("migrate").description("a CLI for migrating Svelte(Kit) codebases").argument("<migration>", "migration to run").option("-C, --cwd <path>", "path to working directory", process$1$1.cwd()).configureHelp({