berget 2.2.7 → 2.2.8

package/dist/src/commands/code/adapters/clack-prompter.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClackPrompter = void 0;
 const p = __importStar(require("@clack/prompts"));
@@ -41,41 +32,33 @@ const unwrap = (v) => {
     return v;
 };
 class ClackPrompter {
+    async confirm(options) {
+        return unwrap(await p.confirm(options));
+    }
     intro(message) {
         p.intro(message);
     }
-    outro(message) {
-        p.outro(message);
+    async multiselect(options) {
+        return unwrap(await p.multiselect(options));
     }
     note(message, title) {
         p.note(message, title);
     }
+    outro(message) {
+        p.outro(message);
+    }
+    async select(options) {
+        return unwrap(await p.select(options));
+    }
     spinner() {
         const s = p.spinner();
         return {
-            start: (msg) => s.start(msg),
-            stop: (msg) => s.stop(msg),
+            start: (message) => s.start(message),
+            stop: (message) => s.stop(message),
         };
     }
-    select(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return unwrap(yield p.select(opts));
-        });
-    }
-    confirm(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return unwrap(yield p.confirm(opts));
-        });
-    }
-    text(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return unwrap(yield p.text(opts));
-        });
-    }
-    multiselect(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return unwrap(yield p.multiselect(opts));
-        });
+    async text(options) {
+        return unwrap(await p.text(options));
     }
 }
 exports.ClackPrompter = ClackPrompter;

package/dist/src/commands/code/adapters/fs-file-store.js

@@ -22,59 +22,40 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FsFileStore = void 0;
 const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
 class FsFileStore {
-    exists(filePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield node_fs_1.promises.access(filePath);
-                return true;
-            }
-            catch (_a) {
-                return false;
-            }
-        });
+    async chmod(filePath, mode) {
+        await node_fs_1.promises.chmod(filePath, mode);
     }
-    readFile(filePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield node_fs_1.promises.readFile(filePath, "utf8");
-            }
-            catch (err) {
-                if (err.code === "ENOENT")
-                    return null;
-                throw err;
-            }
-        });
+    async exists(filePath) {
+        try {
+            await node_fs_1.promises.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    writeFile(filePath, content) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const dir = path.dirname(filePath);
-            yield node_fs_1.promises.mkdir(dir, { recursive: true });
-            yield node_fs_1.promises.writeFile(filePath, content, "utf8");
-        });
+    async mkdir(dir) {
+        await node_fs_1.promises.mkdir(dir, { recursive: true });
     }
-    mkdir(dir) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield node_fs_1.promises.mkdir(dir, { recursive: true });
-        });
+    async readFile(filePath) {
+        try {
+            return await node_fs_1.promises.readFile(filePath, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return null;
+            throw error;
+        }
     }
-    chmod(filePath, mode) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield node_fs_1.promises.chmod(filePath, mode);
-        });
+    async writeFile(filePath, content) {
+        const dir = path.dirname(filePath);
+        await node_fs_1.promises.mkdir(dir, { recursive: true });
+        await node_fs_1.promises.writeFile(filePath, content, 'utf8');
     }
 }
 exports.FsFileStore = FsFileStore;

package/dist/src/commands/code/adapters/spawn-command-runner.js

@@ -1,52 +1,38 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpawnCommandRunner = void 0;
 const node_child_process_1 = require("node:child_process");
 class SpawnCommandRunner {
-    checkInstalled(binary) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise(resolve => {
-                const child = (0, node_child_process_1.spawn)("which", [binary], { stdio: "pipe" });
-                child.on("close", code => resolve(code === 0));
-                child.on("error", () => resolve(false));
-            });
+    async checkInstalled(binary) {
+        return new Promise((resolve) => {
+            const child = (0, node_child_process_1.spawn)('which', [binary], { stdio: 'pipe' });
+            child.on('close', (code) => resolve(code === 0));
+            child.on('error', () => resolve(false));
         });
     }
-    run(command, args, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                var _a, _b;
-                const child = (0, node_child_process_1.spawn)(command, args, {
-                    stdio: "pipe",
-                    cwd: (options === null || options === void 0 ? void 0 : options.cwd) || process.cwd(),
-                });
-                let stdout = "";
-                let stderr = "";
-                (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on("data", d => {
-                    stdout += d.toString();
-                });
-                (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on("data", d => {
-                    stderr += d.toString();
-                });
-                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));
+    async run(command, arguments_, options) {
+        return new Promise((resolve, reject) => {
+            const child = (0, node_child_process_1.spawn)(command, arguments_, {
+                cwd: options?.cwd || process.cwd(),
+                stdio: 'pipe',
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (d) => {
+                stdout += d.toString();
+            });
+            child.stderr?.on('data', (d) => {
+                stderr += d.toString();
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve(stdout);
+                }
+                else {
+                    reject(new Error(stderr.trim() || `Command failed with exit code ${code}`));
+                }
             });
+            child.on('error', (error) => reject(error));
         });
     }
 }