berget 2.2.7 → 2.2.8

package/src/commands/code/adapters/clack-prompter.ts

@@ -1,55 +1,57 @@
-import * as p from "@clack/prompts";
-import { CancelledError } from "../errors";
-import type { Prompter, Spinner } from "../ports/prompter";
+import * as p from '@clack/prompts';
 
-const unwrap = <T>(v: T | symbol): T => {
+import type { Prompter, Spinner } from '../ports/prompter';
+
+import { CancelledError } from '../errors';
+
+const unwrap = <T>(v: symbol | T): T => {
   if (p.isCancel(v)) throw new CancelledError();
   return v as T;
 };
 
 export class ClackPrompter implements Prompter {
+  async confirm(options: { initialValue?: boolean; message: string }): Promise<boolean> {
+    return unwrap(await p.confirm(options));
+  }
   intro(message: string): void {
     p.intro(message);
   }
-  outro(message: string): void {
-    p.outro(message);
+  async multiselect<T>(options: {
+    message: string;
+    options: ReadonlyArray<{
+      hint?: string;
+      label: string;
+      value: T;
+    }>;
+  }): Promise<T[]> {
+    return unwrap(await p.multiselect(options as any));
   }
   note(message: string, title?: string): void {
     p.note(message, title);
   }
-  spinner(): Spinner {
-    const s = p.spinner();
-    return {
-      start: (msg: string) => s.start(msg),
-      stop: (msg: string) => s.stop(msg),
-    };
+  outro(message: string): void {
+    p.outro(message);
   }
-  async select<T>(opts: {
+  async select<T>(options: {
     message: string;
     options: ReadonlyArray<{
-      value: T;
-      label: string;
       hint?: string;
+      label: string;
+      value: T;
     }>;
   }): Promise<T> {
-    return unwrap(await p.select(opts as any));
-  }
-  async confirm(opts: { message: string; initialValue?: boolean }): Promise<boolean> {
-    return unwrap(await p.confirm(opts));
+    return unwrap(await p.select(options as any));
   }
 
-  async text(opts: { message: string; placeholder?: string }): Promise<string> {
-    return unwrap(await p.text(opts));
+  spinner(): Spinner {
+    const s = p.spinner();
+    return {
+      start: (message: string) => s.start(message),
+      stop: (message: string) => s.stop(message),
+    };
   }
 
-  async multiselect<T>(opts: {
-    message: string;
-    options: ReadonlyArray<{
-      value: T;
-      label: string;
-      hint?: string;
-    }>;
-  }): Promise<T[]> {
-    return unwrap(await p.multiselect(opts as any));
+  async text(options: { message: string; placeholder?: string }): Promise<string> {
+    return unwrap(await p.text(options));
   }
 }

package/src/commands/code/adapters/fs-file-store.ts

@@ -1,8 +1,13 @@
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import type { FileStore } from "../ports/file-store";
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+
+import type { FileStore } from '../ports/file-store';
 
 export class FsFileStore implements FileStore {
+  async chmod(filePath: string, mode: number): Promise<void> {
+    await fs.chmod(filePath, mode);
+  }
+
   async exists(filePath: string): Promise<boolean> {
     try {
       await fs.access(filePath);
@@ -12,26 +17,22 @@ export class FsFileStore implements FileStore {
     }
   }
 
-  async readFile(filePath: string): Promise<string | null> {
+  async mkdir(dir: string): Promise<void> {
+    await fs.mkdir(dir, { recursive: true });
+  }
+
+  async readFile(filePath: string): Promise<null | string> {
     try {
-      return await fs.readFile(filePath, "utf8");
-    } catch (err: any) {
-      if (err.code === "ENOENT") return null;
-      throw err;
+      return await fs.readFile(filePath, 'utf8');
+    } catch (error: any) {
+      if (error.code === 'ENOENT') return null;
+      throw error;
     }
   }
 
   async writeFile(filePath: string, content: string): Promise<void> {
     const dir = path.dirname(filePath);
     await fs.mkdir(dir, { recursive: true });
-    await fs.writeFile(filePath, content, "utf8");
-  }
-
-  async mkdir(dir: string): Promise<void> {
-    await fs.mkdir(dir, { recursive: true });
-  }
-
-  async chmod(filePath: string, mode: number): Promise<void> {
-    await fs.chmod(filePath, mode);
+    await fs.writeFile(filePath, content, 'utf8');
   }
 }

package/src/commands/code/adapters/spawn-command-runner.ts

@@ -1,40 +1,45 @@
-import { spawn } from "node:child_process";
-import type { CommandRunner } from "../ports/command-runner";
+import { spawn } from 'node:child_process';
+
+import type { CommandRunner } from '../ports/command-runner';
 
 export class SpawnCommandRunner implements CommandRunner {
   async checkInstalled(binary: string): Promise<boolean> {
-    return new Promise(resolve => {
-      const child = spawn("which", [binary], { stdio: "pipe" });
-      child.on("close", code => resolve(code === 0));
-      child.on("error", () => resolve(false));
+    return new Promise((resolve) => {
+      const child = spawn('which', [binary], { stdio: 'pipe' });
+      child.on('close', (code) => resolve(code === 0));
+      child.on('error', () => resolve(false));
     });
   }
 
-  async run(command: string, args: readonly string[], options?: { cwd?: string }): Promise<string> {
+  async run(
+    command: string,
+    arguments_: readonly string[],
+    options?: { cwd?: string },
+  ): Promise<string> {
     return new Promise<string>((resolve, reject) => {
-      const child = spawn(command, args as string[], {
-        stdio: "pipe",
+      const child = spawn(command, arguments_ as string[], {
         cwd: options?.cwd || process.cwd(),
+        stdio: 'pipe',
       });
 
-      let stdout = "";
-      let stderr = "";
+      let stdout = '';
+      let stderr = '';
 
-      child.stdout?.on("data", d => {
+      child.stdout?.on('data', (d) => {
         stdout += d.toString();
       });
-      child.stderr?.on("data", d => {
+      child.stderr?.on('data', (d) => {
         stderr += d.toString();
       });
 
-      child.on("close", code => {
+      child.on('close', (code) => {
         if (code === 0) {
           resolve(stdout);
         } else {
           reject(new Error(stderr.trim() || `Command failed with exit code ${code}`));
         }
       });
-      child.on("error", err => reject(err));
+      child.on('error', (error) => reject(error));
     });
   }
 }