ui-thing 0.2.9 → 0.3.0

package/src/utils/fetchProseComponents.ts

@@ -1,4 +1,5 @@
 import axios from "axios";
+import { consola } from "consola";
 import dotenv from "dotenv";
 import ora from "ora";
 
@@ -6,16 +7,17 @@ import { ProseComponent } from "../types";
 
 dotenv.config();
 
-/**
- * Fetch prose components from UI Thing API.
- */
-export const fetchProseComponents = async () => {
+export const fetchProseComponents = async (): Promise<ProseComponent[]> => {
   const spinner = ora("Fetching prose components...").start();
-
-  const { data } = await axios.get<ProseComponent[]>(
-    process.env.PROSE_COMPONENTS_API || "https://uithing.com/api/prose"
-  );
-
-  spinner.succeed("Prose components fetched.");
-  return data;
+  try {
+    const { data } = await axios.get<ProseComponent[]>(
+      process.env.PROSE_COMPONENTS_API || "https://uithing.com/api/prose"
+    );
+    spinner.succeed("Prose components fetched.");
+    return data;
+  } catch {
+    spinner.fail("Failed to fetch prose components.");
+    consola.error("Could not reach the UI Thing API. Check your network connection.");
+    process.exit(1);
+  }
 };

package/src/utils/installPackages.ts

@@ -2,6 +2,26 @@ import { execa } from "execa";
 import _ from "lodash";
 import ora from "ora";
 
+const PM_ADD_CMD: Record<string, string> = {
+  yarn: "add",
+  bun: "add",
+  pnpm: "add",
+  npm: "install",
+  deno: "add",
+};
+
+const PM_DEV_FLAG: Record<string, string> = {
+  yarn: "-D",
+  bun: "-D",
+  pnpm: "-D",
+  npm: "-D",
+  deno: "--dev",
+};
+
+// Deno 2.x requires `npm:` prefix for npm packages
+const formatPkgs = (pm: string, pkgs: string[]) =>
+  pm === "deno" ? pkgs.map((p) => (p.startsWith("npm:") ? p : `npm:${p}`)) : pkgs;
+
 export const installPackages = async (
   packageManager: string,
   deps?: string[] | string,
@@ -14,18 +34,24 @@ export const installPackages = async (
     devDeps = [devDeps];
   }
 
+  const addCmd = PM_ADD_CMD[packageManager] ?? "install";
+  const devFlag = PM_DEV_FLAG[packageManager] ?? "-D";
+
   const depsSpinner = ora("Installing dependencies...").start();
   if (!_.isUndefined(deps) && !_.isEmpty(deps)) {
-    await execa(packageManager, [packageManager === "yarn" ? "add" : "install", ...deps]);
+    await execa(packageManager, [addCmd, ...formatPkgs(packageManager, deps)]);
   }
   depsSpinner.text = "Installing dev dependencies...";
   if (!_.isUndefined(devDeps) && !_.isEmpty(devDeps)) {
-    await execa(packageManager, [packageManager === "yarn" ? "add" : "install", "-D", ...devDeps]);
+    await execa(packageManager, [addCmd, devFlag, ...formatPkgs(packageManager, devDeps)]);
   }
 
-  // we should check to see if there is a postinstall script and run it
   depsSpinner.text = "Running nuxt prepare...";
-  await execa`npx -y nuxt prepare`;
+  if (packageManager === "deno") {
+    await execa("deno", ["run", "-A", "npm:nuxt", "prepare"]);
+  } else {
+    await execa`npx -y nuxt prepare`;
+  }
 
   depsSpinner.succeed("Installed dependencies!");
 };

package/src/utils/installValidator.ts

@@ -1,9 +1,9 @@
 import prompts from "prompts";
 
 import { installPackages } from "./installPackages";
+import { logger } from "./logger";
 
 export const installValidator = async (packageManager: string) => {
-  // Depending on the selected validator, install the corresponding packages
   const validatorPackages = {
     yup: ["yup", "@vee-validate/yup"],
     zod: ["zod", "@vee-validate/zod"],
@@ -23,10 +23,10 @@ export const installValidator = async (packageManager: string) => {
     ],
   });
   if (!validator) {
-    console.log("No validator package selected");
+    logger.warn("No validator package selected");
     return;
   }
-  console.log(`Selected ${validator} as the validator package`);
+  logger.info(`Selected ${validator} as the validator package`);
 
   if (validatorPackages[validator]) {
     await installPackages(packageManager, validatorPackages[validator]);

package/src/utils/logger.ts

@@ -0,0 +1,9 @@
+import { consola } from "consola";
+
+export const logger = {
+  info: (msg: string, ...args: unknown[]) => consola.info(msg, ...args),
+  error: (msg: string, ...args: unknown[]) => consola.error(msg, ...args),
+  warn: (msg: string, ...args: unknown[]) => consola.warn(msg, ...args),
+  success: (msg: string, ...args: unknown[]) => consola.success(msg, ...args),
+  log: (msg: string, ...args: unknown[]) => consola.log(msg, ...args),
+};

package/src/utils/uiConfigPrompt.ts

@@ -1,12 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import kleur from "kleur";
 import prompts from "prompts";
 
 import { CSS_THEME_OPTIONS, PACKAGE_MANAGER_CHOICES } from "./constants";
+import { logger } from "./logger";
 
-/**
- * Prompts the user for UI configuration values.
- */
 export const initPrompts = async (nuxtVersion: number) => {
   const response = await prompts([
     {
@@ -67,8 +64,8 @@ export const initPrompts = async (nuxtVersion: number) => {
   ]);
 
   if (!response || Object.keys(response).length < 9) {
-    console.log(kleur.red(kleur.bold("Incomplete configuration submitted. Exiting...")));
-    return process.exit(0);
+    logger.error("Incomplete configuration submitted. Exiting...");
+    return process.exit(1);
   }
   return response;
 };

package/tests/commands/list.test.ts

@@ -0,0 +1,111 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { runListCommand } from "../../src/commands/list";
+import { Component } from "../../src/types";
+
+vi.mock("../../src/utils/fetchComponents");
+vi.mock("../../src/utils/config");
+vi.mock("../../src/utils/fileExists");
+vi.mock("../../src/utils/logger");
+
+const mockComponents: Component[] = [
+  {
+    name: "Button",
+    value: "button",
+    files: [{ fileName: "Button.vue", dirPath: "app/components/Ui", fileContent: "" }],
+    utils: [],
+    composables: [],
+    plugins: [],
+  },
+  {
+    name: "Input",
+    value: "input",
+    files: [{ fileName: "Input.vue", dirPath: "app/components/Ui", fileContent: "" }],
+    utils: [],
+    composables: [],
+    plugins: [],
+  },
+  {
+    name: "Card",
+    value: "card",
+    files: [{ fileName: "Card/Card.vue", dirPath: "app/components/Ui", fileContent: "" }],
+    utils: [],
+    composables: [],
+    plugins: [],
+  },
+];
+
+describe("commands/list", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should list all components when --installed is not passed", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+
+    await runListCommand({ installed: false });
+
+    expect(vi.mocked(logger.log)).toHaveBeenCalledTimes(3);
+    expect(vi.mocked(logger.success)).toHaveBeenCalledWith("3 component(s) found.");
+  });
+
+  it("should filter to installed components when --installed is passed", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    // Only Button is "installed"
+    vi.mocked(fileExists)
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(false)
+      .mockResolvedValueOnce(false);
+
+    await runListCommand({ installed: true });
+
+    expect(vi.mocked(logger.log)).toHaveBeenCalledTimes(1);
+    expect(vi.mocked(logger.log)).toHaveBeenCalledWith("Button (button)");
+    expect(vi.mocked(logger.success)).toHaveBeenCalledWith("1 component(s) found.");
+  });
+
+  it("should show 'No components installed.' when --installed and none found", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValue(false);
+
+    await runListCommand({ installed: true });
+
+    expect(vi.mocked(logger.info)).toHaveBeenCalledWith("No components installed.");
+    expect(vi.mocked(logger.log)).not.toHaveBeenCalled();
+  });
+
+  it("should show 'No components available.' when API returns empty array", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue([]);
+
+    await runListCommand({ installed: false });
+
+    expect(vi.mocked(logger.info)).toHaveBeenCalledWith("No components available.");
+    expect(vi.mocked(logger.log)).not.toHaveBeenCalled();
+  });
+});

package/tests/commands/remove.test.ts

@@ -0,0 +1,151 @@
+import fs from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { runRemoveCommand } from "../../src/commands/remove";
+import { Component } from "../../src/types";
+
+vi.mock("../../src/utils/fetchComponents");
+vi.mock("../../src/utils/config");
+vi.mock("../../src/utils/fileExists");
+vi.mock("../../src/utils/logger");
+vi.mock("../../src/utils/printFancyBoxMessage");
+vi.mock("prompts");
+vi.mock("node:fs/promises");
+
+const mockComponents: Component[] = [
+  {
+    name: "Button",
+    value: "button",
+    files: [{ fileName: "Button.vue", dirPath: "app/components/Ui", fileContent: "" }],
+    utils: [],
+    composables: [],
+    plugins: [],
+  },
+  {
+    name: "Input",
+    value: "input",
+    files: [{ fileName: "Input.vue", dirPath: "app/components/Ui", fileContent: "" }],
+    utils: [],
+    composables: [],
+    plugins: [],
+  },
+];
+
+describe("commands/remove", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should remove component files that exist", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { logger } = await import("../../src/utils/logger");
+    const prompts = await import("prompts");
+
+    vi.mocked(getUIConfig).mockResolvedValue({
+      componentsLocation: "app/components/Ui",
+      utilsLocation: "app/utils",
+      composablesLocation: "app/composables",
+    } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValue(true);
+    vi.mocked(prompts.default).mockResolvedValue({ confirmed: true });
+    vi.mocked(fs.unlink).mockResolvedValue(undefined);
+
+    await runRemoveCommand(["button"]);
+
+    expect(vi.mocked(fs.unlink)).toHaveBeenCalledWith(expect.stringContaining("Button.vue"));
+    expect(vi.mocked(logger.success)).toHaveBeenCalledWith("Removed: Button.vue");
+  });
+
+  it("should skip files that do not exist and warn", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { logger } = await import("../../src/utils/logger");
+    const prompts = await import("prompts");
+
+    vi.mocked(getUIConfig).mockResolvedValue({
+      componentsLocation: "app/components/Ui",
+      utilsLocation: "app/utils",
+      composablesLocation: "app/composables",
+    } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValue(false);
+    vi.mocked(prompts.default).mockResolvedValue({ confirmed: true });
+
+    await runRemoveCommand(["button"]);
+
+    expect(vi.mocked(fs.unlink)).not.toHaveBeenCalled();
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith(expect.stringContaining("Button.vue"));
+  });
+
+  it("should cancel when user declines confirmation", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { logger } = await import("../../src/utils/logger");
+    const prompts = await import("prompts");
+
+    vi.mocked(getUIConfig).mockResolvedValue({
+      componentsLocation: "app/components/Ui",
+      utilsLocation: "app/utils",
+      composablesLocation: "app/composables",
+    } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValue(true);
+    vi.mocked(prompts.default).mockResolvedValue({ confirmed: false });
+
+    await runRemoveCommand(["button"]);
+
+    expect(vi.mocked(fs.unlink)).not.toHaveBeenCalled();
+    expect(vi.mocked(logger.info)).toHaveBeenCalledWith("Cancelled.");
+  });
+
+  it("should exit with error when no specified names are found in registry", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { logger } = await import("../../src/utils/logger");
+
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+
+    vi.mocked(getUIConfig).mockResolvedValue({
+      componentsLocation: "app/components/Ui",
+      utilsLocation: "app/utils",
+      composablesLocation: "app/composables",
+    } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+
+    await runRemoveCommand(["nonexistent"]);
+
+    expect(vi.mocked(logger.error)).toHaveBeenCalledWith(
+      "None of the specified components were found in the registry."
+    );
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("should show info and return when no components are installed", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({
+      componentsLocation: "app/components/Ui",
+      utilsLocation: "app/utils",
+      composablesLocation: "app/composables",
+    } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValue(false);
+
+    await runRemoveCommand([]);
+
+    expect(vi.mocked(logger.info)).toHaveBeenCalledWith("No installed components found.");
+    expect(vi.mocked(fs.unlink)).not.toHaveBeenCalled();
+  });
+});

package/tests/commands/update.test.ts

@@ -0,0 +1,127 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { runUpdateCommand } from "../../src/commands/update";
+import { Component } from "../../src/types";
+
+vi.mock("../../src/utils/fetchComponents");
+vi.mock("../../src/utils/config");
+vi.mock("../../src/utils/fileExists");
+vi.mock("../../src/utils/writeFile");
+vi.mock("../../src/utils/logger");
+vi.mock("../../src/utils/printFancyBoxMessage");
+vi.mock("prompts");
+
+const mockComponents: Component[] = [
+  {
+    name: "Button",
+    value: "button",
+    files: [{ fileName: "Button.vue", dirPath: "app/components/Ui", fileContent: "<button />" }],
+    utils: [],
+    composables: [],
+    plugins: [],
+  },
+  {
+    name: "Input",
+    value: "input",
+    files: [{ fileName: "Input.vue", dirPath: "app/components/Ui", fileContent: "<input />" }],
+    utils: [],
+    composables: [],
+    plugins: [],
+  },
+];
+
+describe("commands/update", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should update a named component and overwrite its files", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { writeFile } = await import("../../src/utils/writeFile");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+
+    await runUpdateCommand(["button"]);
+
+    expect(vi.mocked(writeFile)).toHaveBeenCalledWith(
+      expect.stringContaining("Button.vue"),
+      "<button />"
+    );
+    expect(vi.mocked(logger.success)).toHaveBeenCalledWith("Updated: Button.vue");
+  });
+
+  it("should warn for unknown component names", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+
+    await runUpdateCommand(["nonexistent"]);
+
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith(expect.stringContaining("nonexistent"));
+  });
+
+  it("should prompt for selection when no names given and components are installed", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { writeFile } = await import("../../src/utils/writeFile");
+    const prompts = await import("prompts");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+    vi.mocked(prompts.default).mockResolvedValue({ selected: ["button"] });
+
+    await runUpdateCommand([]);
+
+    expect(vi.mocked(writeFile)).toHaveBeenCalledWith(
+      expect.stringContaining("Button.vue"),
+      "<button />"
+    );
+  });
+
+  it("should exit cleanly when user cancels the prompt", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { writeFile } = await import("../../src/utils/writeFile");
+    const prompts = await import("prompts");
+
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValue(true);
+    vi.mocked(prompts.default).mockResolvedValue({ selected: [] });
+
+    await runUpdateCommand([]);
+
+    expect(exitSpy).toHaveBeenCalledWith(0);
+    expect(vi.mocked(writeFile)).not.toHaveBeenCalled();
+  });
+
+  it("should show info message when no installed components found", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValue(false);
+
+    await runUpdateCommand([]);
+
+    expect(vi.mocked(logger.info)).toHaveBeenCalledWith("No installed components found.");
+  });
+});

package/tests/utils/fetchBlockCategories.test.ts

@@ -42,10 +42,22 @@ describe("utils/fetchBlockCategories", () => {
     delete process.env.BLOCK_CATEGORIES_API;
   });
 
-  it("should handle API errors", async () => {
+  it("should call process.exit(1) on API error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
     mockAxios.onGet("https://uithing.com/api/blocks/categories").reply(404);
 
-    await expect(fetchBlockCategories()).rejects.toThrow();
+    await fetchBlockCategories();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("should call process.exit(1) on network error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+    mockAxios.onGet("https://uithing.com/api/blocks/categories").networkError();
+
+    await fetchBlockCategories();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
   });
 
   it("should return empty array when no categories exist", async () => {

package/tests/utils/fetchBlocks.test.ts

@@ -51,9 +51,21 @@ describe("utils/fetchBlocks", () => {
     delete process.env.BLOCKS_API;
   });
 
-  it("should handle API errors", async () => {
+  it("should call process.exit(1) on API error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
     mockAxios.onGet("https://uithing.com/api/blocks").reply(500);
 
-    await expect(fetchBlocks()).rejects.toThrow();
+    await fetchBlocks();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("should call process.exit(1) on network error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+    mockAxios.onGet("https://uithing.com/api/blocks").networkError();
+
+    await fetchBlocks();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
   });
 });

package/tests/utils/fetchComponents.test.ts

@@ -69,16 +69,22 @@ describe("utils/fetchComponents", () => {
     delete process.env.COMPONENTS_API;
   });
 
-  it("should handle API errors gracefully", async () => {
+  it("should call process.exit(1) on API error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
     mockAxios.onGet("https://uithing.com/api/components").reply(500);
 
-    await expect(fetchComponents()).rejects.toThrow();
+    await fetchComponents();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
   });
 
-  it("should handle network errors", async () => {
+  it("should call process.exit(1) on network error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
     mockAxios.onGet("https://uithing.com/api/components").networkError();
 
-    await expect(fetchComponents()).rejects.toThrow();
+    await fetchComponents();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
   });
 
   it("should return empty array when API returns no data", async () => {

package/tests/utils/fetchProseComponents.test.ts

@@ -54,9 +54,21 @@ describe("utils/fetchProseComponents", () => {
     delete process.env.PROSE_COMPONENTS_API;
   });
 
-  it("should handle API errors", async () => {
+  it("should call process.exit(1) on API error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
     mockAxios.onGet("https://uithing.com/api/prose").reply(500);
 
-    await expect(fetchProseComponents()).rejects.toThrow();
+    await fetchProseComponents();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("should call process.exit(1) on network error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+    mockAxios.onGet("https://uithing.com/api/prose").networkError();
+
+    await fetchProseComponents();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
   });
 });