@yunarch/config-web 0.2.1 → 0.2.2

package/dist/cli/bun-run-all/index.js

@@ -1,143 +1,6 @@
-import {
-  createBaseProgram
-} from "../chunk-ARUHQWVA.js";
-
-// src/cli/bun-run-all/index.ts
-import { styleText as styleText2 } from "util";
-
-// src/cli/bun-run-all/utils.ts
-import { styleText } from "util";
-var COLORS = ["blue", "green", "yellow", "grey", "white", "cyan"];
-var getExecutionTime = (start) => {
-  const durationMs = Number(Bun.nanoseconds() - start) / 1e6;
-  return `${(durationMs / 1e3).toFixed(2)}s`;
-};
-function reportExecutionLog({
-  start,
-  tasks,
-  failedTasks
-}) {
-  const successTasks = tasks - failedTasks;
-  const executionTime = getExecutionTime(start);
-  const failedTasksText = failedTasks > 0 ? styleText("red", `${failedTasks} failed`) : "";
-  const successTasksText = successTasks > 0 ? styleText("green", `${successTasks} successful`) : "";
-  console.log("");
-  console.log(
-    styleText("bold", "Tasks:	"),
-    `${failedTasksText}${successTasksText}`,
-    styleText("gray", `-- ${tasks} total`)
-  );
-  console.log(
-    styleText(["white", "bold"], "Time:	"),
-    styleText("gray", executionTime)
-  );
-}
-function spawnProc({
-  index,
-  script,
-  continueOnError,
-  reportTime
-}) {
-  const color = COLORS[index % COLORS.length];
-  const start = Bun.nanoseconds();
-  const proc = Bun.spawn(["bun", "run", script], {
-    stdout: "pipe",
-    stderr: "pipe",
-    env: {
-      ...Bun.env,
-      FORCE_COLOR: "1"
-    },
-    onExit(_, exitCode) {
-      if (exitCode === 1 && !continueOnError) process.exit(1);
-    }
-  });
-  proc.stdout.pipeTo(
-    new WritableStream({
-      write(chunk) {
-        const lines = new TextDecoder().decode(chunk).split("\n");
-        for (const line of lines) {
-          console.log(styleText([color, "bold"], `${script}:`), line);
-        }
-      }
-    })
-  );
-  proc.stderr.pipeTo(
-    new WritableStream({
-      write(chunk) {
-        const lines = new TextDecoder().decode(chunk).split("\n");
-        for (const line of lines) {
-          console.log(styleText([color, "bold"], `${script}:`), line);
-        }
-      }
-    })
-  );
-  proc.exited.then((code) => {
-    if (code === 0 && reportTime) {
-      console.log(
-        styleText([color, "bold"], `${script}:`),
-        styleText(["gray"], "Finished in"),
-        styleText(["white", "bold"], getExecutionTime(start))
-      );
-    }
-  });
-  return proc;
-}
-async function runParallel(scripts, options) {
-  const { continueOnError, reportTime } = options;
-  const start = Bun.nanoseconds();
-  const procs = scripts.map(
-    (script, index) => spawnProc({ index, script, continueOnError, reportTime })
-  );
-  const promises = await Promise.allSettled(procs.map((proc) => proc.exited));
-  reportExecutionLog({
-    start,
-    tasks: scripts.length,
-    failedTasks: promises.filter(
-      (promise) => promise.status === "rejected" || promise.value !== 0
-    ).length
-  });
-}
-async function runSequential(scripts, options) {
-  const { continueOnError, reportTime } = options;
-  const start = Bun.nanoseconds();
-  let failedTasks = 0;
-  for (const [index, script] of scripts.entries()) {
-    const proc = spawnProc({ index, script, continueOnError, reportTime });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) failedTasks++;
-  }
-  reportExecutionLog({ start, tasks: scripts.length, failedTasks });
-}
-
-// src/cli/bun-run-all/index.ts
-createBaseProgram().name("bun-run-all").description(
-  "Run given package scripts in parallel or sequential by using bun."
-).argument("<scripts...>", "A list of package scripts' names.").option(
-  "-c, --continue-on-error",
-  "Continue executing other/subsequent tasks even if a task threw an error"
-).option("-p, --parallel", "Run a group of tasks in parallel.").option("-s, --sequential", "Run a group of tasks sequentially.").option("-t, --time", "Report execution time for each task.").action(
-  async (scripts, options) => {
-    try {
-      console.log(styleText2("magenta", "\n\u{1F680} bun-run-all\n"));
-      const sequential = options.sequential ?? false;
-      const parallel = options.parallel ?? !sequential;
-      const continueOnError = options.continueOnError ?? false;
-      const reportTime = options.time ?? false;
-      if (parallel === sequential) {
-        console.error(
-          "You cannot use both --parallel and --sequential options at the same time."
-        );
-        process.exit(1);
-      }
-      if (sequential) {
-        await runSequential(scripts, { continueOnError, reportTime });
-        process.exit(0);
-      }
-      await runParallel(scripts, { continueOnError, reportTime });
-      process.exit(0);
-    } catch (error) {
-      console.error(error);
-      process.exit(1);
-    }
-  }
-).parseAsync(process.argv);
+#!/usr/bin/env bun
+import{c as p}from"../chunk-PWSW557X.js";import{styleText as h}from"util";import{styleText as a}from"util";var d=["blue","green","yellow","grey","white","cyan"],m=t=>`${(Number(Bun.nanoseconds()-t)/1e6/1e3).toFixed(2)}s`;function b({start:t,tasks:e,failedTasks:n}){let i=e-n,r=m(t),s=n>0?a("red",`${n} failed`):"",l=i>0?a("green",`${i} successful`):"";console.log(""),console.log(a("bold","Tasks:	"),`${s}${l}`,a("gray",`-- ${e} total`)),console.log(a(["white","bold"],"Time:	"),a("gray",r))}function g({index:t,script:e,continueOnError:n,reportTime:i}){let r=d[t%d.length],s=Bun.nanoseconds(),l=Bun.spawn(["bun","run",e],{stdout:"pipe",stderr:"pipe",env:{...Bun.env,FORCE_COLOR:"1"},onExit(o,c){c===1&&!n&&process.exit(1)}});return l.stdout.pipeTo(new WritableStream({write(o){let c=new TextDecoder().decode(o).split(`
+`);for(let u of c)console.log(a([r,"bold"],`${e}:`),u)}})),l.stderr.pipeTo(new WritableStream({write(o){let c=new TextDecoder().decode(o).split(`
+`);for(let u of c)console.log(a([r,"bold"],`${e}:`),u)}})),l.exited.then(o=>{o===0&&i&&console.log(a([r,"bold"],`${e}:`),a(["gray"],"Finished in"),a(["white","bold"],m(s)))}),l}async function f(t,e){let{continueOnError:n,reportTime:i}=e,r=Bun.nanoseconds(),s=t.map((o,c)=>g({index:c,script:o,continueOnError:n,reportTime:i})),l=await Promise.allSettled(s.map(o=>o.exited));b({start:r,tasks:t.length,failedTasks:l.filter(o=>o.status==="rejected"||o.value!==0).length})}async function x(t,e){let{continueOnError:n,reportTime:i}=e,r=Bun.nanoseconds(),s=0;for(let[l,o]of t.entries())await g({index:l,script:o,continueOnError:n,reportTime:i}).exited!==0&&s++;b({start:r,tasks:t.length,failedTasks:s})}p().name("bun-run-all").description("Run given package scripts in parallel or sequential by using bun.").argument("<scripts...>","A list of package scripts' names.").option("-c, --continue-on-error","Continue executing other/subsequent tasks even if a task threw an error").option("-p, --parallel","Run a group of tasks in parallel.").option("-s, --sequential","Run a group of tasks sequentially.").option("-t, --time","Report execution time for each task.").action(async(t,e)=>{try{console.log(h("magenta",`
+\u{1F680} bun-run-all
+`));let n=e.sequential??!1,i=e.parallel??!n,r=e.continueOnError??!1,s=e.time??!1;i===n&&(console.error("You cannot use both --parallel and --sequential options at the same time."),process.exit(1)),n&&(await x(t,{continueOnError:r,reportTime:s}),process.exit(0)),await f(t,{continueOnError:r,reportTime:s}),process.exit(0)}catch(n){console.error(n),process.exit(1)}}).parseAsync(process.argv);

package/dist/cli/chunk-PWSW557X.js

@@ -0,0 +1 @@
+import{exec as a}from"child_process";import{promisify as m,styleText as e,types as c}from"util";import{Command as p}from"commander";import u from"ora";var l=m(a);async function w(o){let{command:t,name:i}=o,s=u(i);s.spinner="aesthetic",s.start();try{let r=typeof t=="string"?await l(t):c.isPromise(t)?await t:await t();return s.succeed(),await new Promise(n=>{setTimeout(n,0)}),typeof r=="object"&&r&&"stdout"in r?r.stdout:r}catch(r){let n=r;throw s.fail(e("red",n.stderr??n.message??"")),r}}function P(){let o=new p;return o.configureHelp({styleTitle:t=>e("bold",t),styleCommandText:t=>e("cyan",t),styleCommandDescription:t=>e("magenta",t),styleDescriptionText:t=>e("italic",t),styleOptionText:t=>e("green",t),styleArgumentText:t=>e("yellow",t),styleSubcommandText:t=>e("blue",t)}).configureOutput({outputError:(t,i)=>{i(e("red",t))}}),o}export{l as a,w as b,P as c};

package/dist/cli/openapi-sync/index.js

@@ -1,27 +1,4 @@
-import {
-  asyncExec,
-  createBaseProgram,
-  runTask
-} from "../chunk-ARUHQWVA.js";
-
-// src/cli/openapi-sync/index.ts
-import { writeFile as writeFile3 } from "fs/promises";
-import { styleText } from "util";
-import confirm from "@inquirer/confirm";
-
-// src/cli/openapi-sync/codegen-models/index.ts
-async function run(input, outputDirectory) {
-  await runTask({
-    name: "Generating models",
-    command: `npx openapi-typescript-codegen --input ${input} --output ${outputDirectory} --client fetch`
-  });
-}
-
-// src/cli/openapi-sync/codegen-msw-utils/index.ts
-import { writeFile } from "fs/promises";
-
-// src/cli/openapi-sync/codegen-msw-utils/openapi-msw-http.ts
-var TEMPLATE = `
+import{a as l,b as o,c as y}from"../chunk-PWSW557X.js";import{writeFile as O}from"fs/promises";import{styleText as f}from"util";import S from"@inquirer/confirm";async function g(e,t){await o({name:"Generating models",command:`npx openapi-typescript-codegen --input ${e} --output ${t} --client fetch`})}import{writeFile as R}from"fs/promises";var w=`
 import {
   http as mswHttp,
   type DefaultBodyType,
@@ -143,186 +120,15 @@ export function http<P extends keyof paths, M extends Methods<P>>(
   }
   return handlers[method as keyof typeof handlers];
 }
-`;
-
-// src/cli/openapi-sync/codegen-msw-utils/index.ts
-async function run2(outputDirectory) {
-  await runTask({
-    name: "Generating openapi MSW utils",
-    command: async () => {
-      await writeFile(`${outputDirectory}/openapi-msw-http.ts`, TEMPLATE);
-    }
-  });
-}
-
-// src/cli/openapi-sync/codegen-schema-typedef/index.ts
-import { readFile, writeFile as writeFile2 } from "fs/promises";
-async function run3(input, output) {
-  await runTask({
-    name: "Generating schema types",
-    command: async () => {
-      await asyncExec(`npx openapi-typescript ${input} -o ${output}`);
-      const content = await readFile(output, "utf8");
-      await writeFile2(
-        output,
-        `/* eslint-disable -- Autogenerated file */
-${content}`
-      );
-    }
-  });
-}
-
-// src/cli/openapi-sync/utils.ts
-import { existsSync } from "fs";
-import { mkdir, readFile as readFile2 } from "fs/promises";
-import path from "path";
-async function prepareOutputDirectory(output) {
-  if (path.extname(output) !== "") {
-    throw new Error("Output must be a directory.");
-  }
-  const cwdPath = process.cwd();
-  const absolutePath = path.resolve(output);
-  const isInsideCwd = absolutePath.startsWith(cwdPath);
-  const dir = isInsideCwd ? absolutePath : path.resolve(cwdPath, path.relative(path.parse(output).root, output));
-  if (!existsSync(dir)) {
-    await runTask({
-      name: "Generating output directory",
-      command: async () => {
-        await mkdir(dir, { recursive: true });
-      }
-    });
-  }
-  return dir;
-}
-async function readOpenapiSchemas(inputSchemaPath, outputSchemaPath) {
-  const [inputSchema, outputSchema] = await Promise.all([
-    runTask({
-      name: "Reading input openapi schema",
-      command: async () => {
-        if (!inputSchemaPath.endsWith(".json")) {
-          throw new Error(`Input file must be a JSON file: ${inputSchemaPath}`);
-        }
-        if (inputSchemaPath.startsWith("http")) {
-          try {
-            const { stdout } = await asyncExec(
-              `curl -s ${inputSchemaPath} --fail`
-            );
-            return stdout;
-          } catch {
-            throw new Error(
-              `Failed to fetch remote OpenAPI file: ${inputSchemaPath}`
-            );
-          }
-        }
-        if (!existsSync(inputSchemaPath)) {
-          throw new Error(`Input file does not exist: ${inputSchemaPath}`);
-        }
-        return await readFile2(inputSchemaPath, "utf8");
-      }
-    }),
-    runTask({
-      name: "Reading output openapi schema",
-      command: async () => {
-        if (!outputSchemaPath.endsWith(".json")) {
-          throw new Error(
-            `Output file must be a JSON file: ${outputSchemaPath}`
-          );
-        }
-        if (!existsSync(outputSchemaPath)) return false;
-        return await readFile2(outputSchemaPath, "utf8");
-      }
-    })
-  ]);
-  return [
-    JSON.stringify(JSON.parse(inputSchema)),
-    outputSchema ? JSON.stringify(JSON.parse(outputSchema)) : false
-  ];
-}
-
-// src/cli/openapi-sync/index.ts
-createBaseProgram().name("openapi-sync").description(
-  "A CLI tool to convert OpenAPI 3.0/3.1 schemas to TypeScript types and create type-safe fetching based on a openapi file and keep them in sync."
-).requiredOption(
-  "-i, --input <path>",
-  "The input (local or remote) openapi schema (JSON)."
-).requiredOption(
-  "-o, --output <folder>",
-  "The output folder to save the generated models and openapi schema and type definitions."
-).option(
-  "-f, --force-gen",
-  "Force generation of typescript schemas and fetching code even if the input and output schemas are identical."
-).option(
-  "--include-msw-utils",
-  "Include MSW mocking utilities based on the generated typescript types."
-).option(
-  "--post-script <script>",
-  "A package.json script to run after the code generation."
-).action(
-  async ({
-    input,
-    output,
-    forceGen,
-    includeMswUtils,
-    postScript
-  }) => {
-    try {
-      console.log(styleText("magenta", "\n\u{1F680} openapi-sync\n"));
-      const outputDirectory = await prepareOutputDirectory(output);
-      const outputSchemaPath = `${outputDirectory}/openapi.json`;
-      const outputSchemaTypeDefs = `${outputDirectory}/schema.d.ts`;
-      const [inputSchema, outputSchema] = await readOpenapiSchemas(
-        input,
-        outputSchemaPath
-      );
-      if (outputSchema && inputSchema === outputSchema && !forceGen) {
-        console.log(styleText("blue", "\nNo updates required.\n"));
-        process.exit(0);
-      } else if (!outputSchema) {
-        await runTask({
-          name: "Creating local schema",
-          command: writeFile3(outputSchemaPath, inputSchema)
-        });
-      } else if (outputSchema && inputSchema !== outputSchema) {
-        console.log(
-          styleText(
-            "yellow",
-            "\n\u26A0\uFE0F  Local and remote schemas does not match!\n"
-          )
-        );
-        const confirmed = await confirm({
-          message: "Do you want to use the remote schema? (y/n)?"
-        });
-        if (confirmed) {
-          await runTask({
-            name: "Replacing local schema with input schema",
-            command: writeFile3(outputSchemaPath, inputSchema)
-          });
-        } else {
-          console.log(
-            styleText("yellow", "\n\u26A0\uFE0F  Sync remote schemas skipped.\n")
-          );
-          if (!forceGen) process.exit(0);
-        }
-      }
-      await Promise.all([
-        run3(outputSchemaPath, outputSchemaTypeDefs),
-        run(outputSchemaPath, outputDirectory)
-      ]);
-      if (includeMswUtils) {
-        await run2(outputDirectory);
-      }
-      if (postScript) {
-        await runTask({
-          name: "Running post script",
-          command: `node --run ${postScript}`
-        });
-      }
-      console.log(
-        styleText("green", "\n\u2705 openapi-sync process completed!\n")
-      );
-    } catch (error) {
-      console.error(error);
-      process.exit(1);
-    }
-  }
-).parseAsync(process.argv);
+`;async function x(e){await o({name:"Generating openapi MSW utils",command:async()=>{await R(`${e}/openapi-msw-http.ts`,w)}})}import{readFile as H,writeFile as B}from"fs/promises";async function P(e,t){await o({name:"Generating schema types",command:async()=>{await l(`npx openapi-typescript ${e} -o ${t}`);let n=await H(t,"utf8");await B(t,`/* eslint-disable -- Autogenerated file */
+${n}`)}})}import{existsSync as u}from"fs";import{mkdir as E,readFile as T}from"fs/promises";import m from"path";async function M(e){if(m.extname(e)!=="")throw new Error("Output must be a directory.");let t=process.cwd(),n=m.resolve(e),a=n.startsWith(t)?n:m.resolve(t,m.relative(m.parse(e).root,e));return u(a)||await o({name:"Generating output directory",command:async()=>{await E(a,{recursive:!0})}}),a}async function k(e,t){let[n,s]=await Promise.all([o({name:"Reading input openapi schema",command:async()=>{if(!e.endsWith(".json"))throw new Error(`Input file must be a JSON file: ${e}`);if(e.startsWith("http"))try{let{stdout:a}=await l(`curl -s ${e} --fail`);return a}catch{throw new Error(`Failed to fetch remote OpenAPI file: ${e}`)}if(!u(e))throw new Error(`Input file does not exist: ${e}`);return await T(e,"utf8")}}),o({name:"Reading output openapi schema",command:async()=>{if(!t.endsWith(".json"))throw new Error(`Output file must be a JSON file: ${t}`);return u(t)?await T(t,"utf8"):!1}})]);return[JSON.stringify(JSON.parse(n)),s?JSON.stringify(JSON.parse(s)):!1]}y().name("openapi-sync").description("A CLI tool to convert OpenAPI 3.0/3.1 schemas to TypeScript types and create type-safe fetching based on a openapi file and keep them in sync.").requiredOption("-i, --input <path>","The input (local or remote) openapi schema (JSON).").requiredOption("-o, --output <folder>","The output folder to save the generated models and openapi schema and type definitions.").option("-f, --force-gen","Force generation of typescript schemas and fetching code even if the input and output schemas are identical.").option("--include-msw-utils","Include MSW mocking utilities based on the generated typescript types.").option("--post-script <script>","A package.json script to run after the code generation.").action(async({input:e,output:t,forceGen:n,includeMswUtils:s,postScript:a})=>{try{console.log(f("magenta",`
+\u{1F680} openapi-sync
+`));let r=await M(t),p=`${r}/openapi.json`,v=`${r}/schema.d.ts`,[h,i]=await k(e,p);i&&h===i&&!n?(console.log(f("blue",`
+No updates required.
+`)),process.exit(0)):i?i&&h!==i&&(console.log(f("yellow",`
+\u26A0\uFE0F  Local and remote schemas does not match!
+`)),await S({message:"Do you want to use the remote schema? (y/n)?"})?await o({name:"Replacing local schema with input schema",command:O(p,h)}):(console.log(f("yellow",`
+\u26A0\uFE0F  Sync remote schemas skipped.
+`)),n||process.exit(0))):await o({name:"Creating local schema",command:O(p,h)}),await Promise.all([P(p,v),g(p,r)]),s&&await x(r),a&&await o({name:"Running post script",command:`node --run ${a}`}),console.log(f("green",`
+\u2705 openapi-sync process completed!
+`))}catch(r){console.error(r),process.exit(1)}}).parseAsync(process.argv);

package/dist/cli/turbo-select/index.js

@@ -1,59 +1,5 @@
-import {
-  createBaseProgram
-} from "../chunk-ARUHQWVA.js";
-
-// src/cli/turbo-select/index.ts
-import { execSync as execSync2 } from "child_process";
-import { styleText } from "util";
-
-// src/cli/turbo-select/utils.ts
-import { execSync } from "child_process";
-import select from "@inquirer/select";
-async function selectTurboPackages() {
-  const packages = execSync("npx turbo ls", {
-    encoding: "utf8",
-    stdio: "pipe"
-  });
-  const packageList = packages.split("\n").slice(1).map((line) => line.trim()).filter(Boolean).map((line) => line.split(" ")[0]);
-  return await select({
-    message: "Select a package to run the script:",
-    choices: packageList.map((opt) => ({ name: opt, value: opt }))
-  });
-}
-async function selectEnvironmentMode() {
-  return await select({
-    message: "Select a mode to load different env files:",
-    choices: [
-      { name: "development", value: "development" },
-      { name: "staging", value: "staging" },
-      { name: "production", value: "production" }
-    ]
-  });
-}
-
-// src/cli/turbo-select/index.ts
-createBaseProgram().name("turbo-select").description(
-  "A CLI tool to filter and select a single package from the Turborepo package list and run a script command.\nAdditionally, allow to prompt environment mode (development, staging, production), for example, when using Vite."
-).requiredOption(
-  "--run <script>",
-  "The package script command to execute (e.g., --run=dev)."
-).option(
-  "--select-env",
-  "An environment mode (development, staging, production) If using for example vite."
-).action(async ({ run, selectEnv }) => {
-  try {
-    console.log(styleText("magenta", "\n\u{1F680} Turbo-Select\n"));
-    const filter = await selectTurboPackages();
-    const environment = selectEnv ? await selectEnvironmentMode() : void 0;
-    execSync2(
-      `turbo run ${run} --ui stream ${filter ? `--filter=${filter}` : ""} ${environment ? `-- --mode ${environment}` : ""}`,
-      {
-        encoding: "utf8",
-        stdio: "inherit"
-      }
-    );
-  } catch (error) {
-    console.error(error);
-    process.exit(1);
-  }
-}).parseAsync(process.argv);
+import{c as r}from"../chunk-PWSW557X.js";import{execSync as p}from"child_process";import{styleText as u}from"util";import{execSync as l}from"child_process";import a from"@inquirer/select";async function i(){let t=l("npx turbo ls",{encoding:"utf8",stdio:"pipe"}).split(`
+`).slice(1).map(e=>e.trim()).filter(Boolean).map(e=>e.split(" ")[0]);return await a({message:"Select a package to run the script:",choices:t.map(e=>({name:e,value:e}))})}async function c(){return await a({message:"Select a mode to load different env files:",choices:[{name:"development",value:"development"},{name:"staging",value:"staging"},{name:"production",value:"production"}]})}r().name("turbo-select").description(`A CLI tool to filter and select a single package from the Turborepo package list and run a script command.
+Additionally, allow to prompt environment mode (development, staging, production), for example, when using Vite.`).requiredOption("--run <script>","The package script command to execute (e.g., --run=dev).").option("--select-env","An environment mode (development, staging, production) If using for example vite.").action(async({run:o,selectEnv:t})=>{try{console.log(u("magenta",`
+\u{1F680} Turbo-Select
+`));let e=await i(),n=t?await c():void 0;p(`turbo run ${o} --ui stream ${e?`--filter=${e}`:""} ${n?`-- --mode ${n}`:""}`,{encoding:"utf8",stdio:"inherit"})}catch(e){console.error(e),process.exit(1)}}).parseAsync(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "name": "@yunarch/config-web",
   "description": "Shared configurations for web projects.",
   "license": "MIT",

package/dist/cli/chunk-ARUHQWVA.js

@@ -1,47 +0,0 @@
-// src/cli/utils.ts
-import { exec } from "child_process";
-import { promisify, styleText, types } from "util";
-import { Command } from "commander";
-import ora from "ora";
-var asyncExec = promisify(exec);
-async function runTask(task) {
-  const { command, name } = task;
-  const spinner = ora(name);
-  spinner.spinner = "aesthetic";
-  spinner.start();
-  try {
-    const result = typeof command === "string" ? await asyncExec(command) : types.isPromise(command) ? await command : await command();
-    spinner.succeed();
-    await new Promise((resolve) => {
-      setTimeout(resolve, 0);
-    });
-    return typeof result === "object" && result && "stdout" in result ? result.stdout : result;
-  } catch (error) {
-    const e = error;
-    spinner.fail(styleText("red", e.stderr ?? e.message ?? ""));
-    throw error;
-  }
-}
-function createBaseProgram() {
-  const program = new Command();
-  program.configureHelp({
-    styleTitle: (str) => styleText("bold", str),
-    styleCommandText: (str) => styleText("cyan", str),
-    styleCommandDescription: (str) => styleText("magenta", str),
-    styleDescriptionText: (str) => styleText("italic", str),
-    styleOptionText: (str) => styleText("green", str),
-    styleArgumentText: (str) => styleText("yellow", str),
-    styleSubcommandText: (str) => styleText("blue", str)
-  }).configureOutput({
-    outputError: (str, write) => {
-      write(styleText("red", str));
-    }
-  });
-  return program;
-}
-
-export {
-  asyncExec,
-  runTask,
-  createBaseProgram
-};