@dcc-bs/communication.bs.js 0.0.1

package/README.md

@@ -0,0 +1,15 @@
+# communication.bs.js
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.2.9. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/biome.json

@@ -0,0 +1,35 @@
+{
+    "$schema": "https://biomejs.dev/schemas/2.2.4/schema.json",
+    "vcs": {
+        "enabled": false,
+        "clientKind": "git",
+        "useIgnoreFile": false
+    },
+    "files": {
+        "ignoreUnknown": false
+    },
+    "formatter": {
+        "enabled": true,
+        "indentStyle": "space",
+        "indentWidth": 4
+    },
+    "linter": {
+        "enabled": true,
+        "rules": {
+            "recommended": true
+        }
+    },
+    "javascript": {
+        "formatter": {
+            "quoteStyle": "double"
+        }
+    },
+    "assist": {
+        "enabled": true,
+        "actions": {
+            "source": {
+                "organizeImports": "on"
+            }
+        }
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@dcc-bs/communication.bs.js",
+    "module": "index.ts",
+    "type": "module",
+    "version": "0.0.1",
+    "scripts": {
+        "check": "biome check --write",
+        "build": "vite build",
+        "test": "vitest"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "2.2.4",
+        "@types/bun": "latest",
+        "vitest": "^4.0.13"
+    },
+    "peerDependencies": {
+        "typescript": "^5"
+    },
+    "dependencies": {
+        "vite": "^7.1.6",
+        "vue": "^3.5.25",
+        "zod": "^4.1.9"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/src/apiFetch.ts

@@ -0,0 +1,208 @@
+import type { ZodType, z } from "zod";
+import { ApiError } from "./models/api_error";
+import { ApiErrorResponse } from "./models/api_error_response.js";
+import type {
+    ApiFetchOptions,
+    ApiFetchOptionsWithSchema,
+} from "./models/api_fetch_options.js";
+
+export type ErrorId = "unexpected_error" | "fetch_failed" | string;
+export type ApiResponse<T> = T | ApiError;
+
+export function isApiError(response: unknown): response is ApiError {
+    return (
+        typeof response === "object" &&
+        response !== null &&
+        "$type" in response &&
+        response.$type === "ApiError"
+    );
+}
+
+async function extractApiError(response: Response): Promise<ApiError> {
+    try {
+        const data = ApiErrorResponse.parse(await response.json());
+
+        return new ApiError(
+            data.errorId,
+            response.status,
+            data.debugMessage ?? JSON.stringify(data),
+        );
+    } catch (_) {
+        return new ApiError("unexpected_error", response.status);
+    }
+}
+
+async function extractApiErrorFormError(error: unknown) {
+    if (error instanceof ApiError) {
+        return error;
+    }
+
+    if (
+        error &&
+        typeof error === "object" &&
+        "name" in error &&
+        error.name === "AbortError"
+    ) {
+        return new ApiError("request_aborted", 499);
+    }
+
+    if (
+        error &&
+        typeof error === "object" &&
+        "cause" in error &&
+        error.cause === "aborted"
+    ) {
+        return new ApiError("request_aborted", 499);
+    }
+
+    if (typeof error === "string" && error === "aborted") {
+        return new ApiError("request_aborted", 499);
+    }
+
+    const message = error instanceof Error ? error.message : String(error);
+    return new ApiError("fetch_failed", 500, message);
+}
+
+async function _fetch(url: string, options: ApiFetchOptions) {
+    const isFormData = options.body instanceof FormData;
+
+    // Define headers with an index signature so properties are optional
+    const headers: Record<string, string> = {
+        "Content-Type": "application/json",
+        ...(options.headers as Record<string, string>),
+    };
+
+    // Remove Content-Type if body is FormData
+    if (isFormData) {
+        delete headers["Content-Type"];
+    }
+
+    return await fetch(url, {
+        ...options,
+        body: isFormData
+            ? (options.body as FormData)
+            : JSON.stringify(options.body),
+        headers: headers,
+    });
+}
+
+// overloads
+export async function apiFetch<T extends ZodType>(
+    url: string,
+    options: ApiFetchOptionsWithSchema<T>,
+): Promise<ApiResponse<z.infer<T>>>;
+export async function apiFetch<T extends object>(
+    url: string,
+    options?: ApiFetchOptions,
+): Promise<ApiResponse<T>>;
+
+// implementation
+export async function apiFetch(
+    url: string,
+    options?: ApiFetchOptions | ApiFetchOptionsWithSchema<ZodType>,
+): Promise<ApiResponse<unknown>> {
+    try {
+        const response = await _fetch(url, options ?? {});
+
+        if (response.ok) {
+            const data = await response.json();
+            if (options && "schema" in options) {
+                const schema = options.schema as ZodType;
+
+                const parsed = schema.safeParse(data);
+
+                if (!parsed.success) {
+                    return new ApiError(
+                        "schema_validation_failed",
+                        500,
+                        `Response validation failed: ${parsed.error.message}`,
+                    );
+                }
+
+                return parsed.data;
+            }
+
+            return data;
+        }
+
+        return extractApiError(response);
+    } catch (error) {
+        return extractApiErrorFormError(error);
+    }
+}
+
+export async function apiStreamFetch(
+    url: string,
+    options?: ApiFetchOptions,
+): Promise<ApiResponse<ReadableStream<Uint8Array>>> {
+    try {
+        const response = await _fetch(url, options ?? {});
+
+        if (response.ok) {
+            return response.body as ReadableStream<Uint8Array>;
+        }
+
+        return extractApiError(response);
+    } catch (error) {
+        return extractApiErrorFormError(error);
+    }
+}
+
+export async function* apiFetchTextMany(
+    url: string,
+    options?: ApiFetchOptions,
+): AsyncGenerator<string, void, void> {
+    try {
+        const response = await _fetch(url, options ?? {});
+
+        if (response.ok) {
+            const reader = response.body?.getReader();
+            const decoder = new TextDecoder();
+
+            if (!reader) {
+                throw new ApiError(
+                    "unexpected_error",
+                    500,
+                    "Response body is null",
+                );
+            }
+
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                const chunk = decoder.decode(value, {
+                    stream: true,
+                });
+                yield chunk;
+            }
+        } else {
+            throw extractApiError(response);
+        }
+    } catch (error) {
+        throw extractApiErrorFormError(error);
+    }
+}
+
+export async function* apiFetchMany<T extends ZodType>(
+    url: string,
+    options: ApiFetchOptionsWithSchema<T>,
+): AsyncGenerator<z.infer<T>, void, void> {
+    try {
+        for await (const chunk of apiFetchTextMany(url, options)) {
+            const json = JSON.parse(chunk);
+            const parsed = options.schema.safeParse(json);
+
+            if (!parsed.success) {
+                throw new ApiError(
+                    "schema_validation_failed",
+                    500,
+                    `Chunk validation failed: ${parsed.error.message}`,
+                );
+            }
+
+            yield parsed.data;
+        }
+    } catch (error) {
+        throw extractApiErrorFormError(error);
+    }
+}

package/src/composables/apiFetch.composable.ts

@@ -0,0 +1,43 @@
+import { type Ref, ref } from "vue";
+import { apiFetch, isApiError } from "../apiFetch";
+import type { ApiErrorResponse } from "../models/api_error_response";
+import type { ApiFetchOptions } from "../models/api_fetch_options";
+
+export type UseApiFetchOutput<T> = {
+    data: Ref<T | undefined>;
+    error: Ref<ApiErrorResponse | undefined>;
+    pending: Ref<boolean>;
+};
+
+export function useApiFetch<T extends object>(
+    url: string,
+    options?: ApiFetchOptions,
+) {
+    const data = ref<T>();
+    const error = ref<ApiErrorResponse>();
+    const pending = ref(true);
+
+    apiFetch<T>(url, options)
+        .then((response) => {
+            if (isApiError(response)) {
+                error.value = response;
+            } else {
+                data.value = response;
+            }
+        })
+        .catch((err) => {
+            error.value = {
+                errorId: "fetch_failed",
+                debugMessage: String(err),
+            };
+        })
+        .finally(() => {
+            pending.value = false;
+        });
+
+    return {
+        data: data,
+        error: error,
+        pending,
+    };
+}

package/src/composables/useApiFetchWithSchema.ts

@@ -0,0 +1,39 @@
+import { ref } from "vue";
+import type { ZodType, z } from "zod";
+import { apiFetch, isApiError } from "../apiFetch";
+import type { ApiErrorResponse } from "../models/api_error_response";
+import type { ApiFetchOptionsWithSchema } from "../models/api_fetch_options";
+import type { UseApiFetchOutput } from "./apiFetch.composable";
+
+export function useApiFetchWithSchema<T extends ZodType>(
+    url: string,
+    options: ApiFetchOptionsWithSchema<T>,
+): UseApiFetchOutput<z.infer<T>> {
+    const data = ref<z.infer<T>>();
+    const error = ref<ApiErrorResponse>();
+    const pending = ref(true);
+
+    apiFetch(url, options)
+        .then((response) => {
+            if (isApiError(response)) {
+                error.value = response;
+            } else {
+                data.value = response;
+            }
+        })
+        .catch((err) => {
+            error.value = {
+                errorId: "fetch_failed",
+                debugMessage: String(err),
+            };
+        })
+        .finally(() => {
+            pending.value = false;
+        });
+
+    return {
+        data,
+        error,
+        pending,
+    };
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export {
+    apiFetch,
+    apiFetchMany,
+    apiFetchTextMany,
+    apiStreamFetch,
+    isApiError,
+} from "./apiFetch";
+export { ApiError } from "./models/api_error";
+export type { ApiErrorResponse } from "./models/api_error_response";
+export type {
+    ApiFetchOptions,
+    ApiFetchOptionsWithSchema,
+} from "./models/api_fetch_options";

package/src/models/api_error.ts

@@ -0,0 +1,15 @@
+import type { ErrorId } from "../apiFetch";
+
+export class ApiError extends Error {
+    $type = "ApiError" as const;
+    errorId: ErrorId;
+    debugMessage?: string;
+    status: number;
+
+    constructor(errorId: ErrorId, status: number, debugMessage?: string) {
+        super(`API Error: ${errorId} (status: ${status})`);
+        this.errorId = errorId;
+        this.status = status;
+        this.debugMessage = debugMessage;
+    }
+}

package/src/models/api_error_response.ts

@@ -0,0 +1,8 @@
+import zod from "zod";
+
+export const ApiErrorResponse = zod.object({
+    errorId: zod.string().optional().default("unexpected_error"),
+    debugMessage: zod.string().optional(),
+});
+
+export type ApiErrorResponse = zod.infer<typeof ApiErrorResponse>;

package/src/models/api_fetch_options.ts

@@ -0,0 +1,9 @@
+import type { ZodType } from "zod";
+
+export type ApiFetchOptions = Omit<RequestInit, "body"> & {
+    body?: object | FormData;
+};
+
+export type ApiFetchOptionsWithSchema<T extends ZodType> = ApiFetchOptions & {
+    schema: T;
+};

package/tests/apiFetch.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test, vi } from "vitest";
+import { z } from "zod";
+import { apiFetch } from "../src";
+
+type User = {
+    id: string;
+    name: string;
+};
+
+const UserSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+});
+
+describe("apiFetch", () => {
+    test("success fetch", async () => {
+        const dummyBody: User = { id: "1", name: "Alice" };
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200,
+                json: () => Promise.resolve(dummyBody),
+            } as Response),
+        );
+
+        const response = await apiFetch<User>("https://api.example.com/user/1");
+
+        expect(response).toEqual(dummyBody);
+    });
+
+    test("error fetch", async () => {
+        const dummyError = {
+            errorId: "not_found",
+            debugMessage: "User not found",
+        };
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: false,
+                status: 404,
+                json: () => Promise.resolve(dummyError),
+            } as Response),
+        );
+
+        const response = await apiFetch<User>(
+            "https://api.example.com/user/999",
+        );
+
+        expect(response).toHaveProperty("errorId", "not_found");
+        expect(response).toHaveProperty("debugMessage", "User not found");
+    });
+
+    test("network error fetch", async () => {
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockRejectedValue(new Error("Network error")),
+        );
+
+        const response = await apiFetch<User>("https://api.example.com/user/1");
+
+        expect(response).toHaveProperty("errorId", "fetch_failed");
+        expect(response).toHaveProperty("debugMessage", "Network error");
+    });
+});
+
+describe("apiFetch with schema", () => {
+    test("success fetch", async () => {
+        const dummyBody = { id: "1", name: "Alice" };
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200,
+                json: () => Promise.resolve(dummyBody),
+            } as Response),
+        );
+
+        const response = await apiFetch("https://api.example.com/user/1", {
+            schema: UserSchema,
+        });
+
+        expect(response).toEqual(dummyBody);
+    });
+
+    test("invalid data", async () => {
+        const invalidBody = { id: 1, fullName: "Alice" };
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200,
+                json: () => Promise.resolve(invalidBody),
+            } as Response),
+        );
+
+        const response = await apiFetch("https://api.example.com/user/1", {
+            schema: UserSchema,
+        });
+
+        expect(response).toHaveProperty("errorId", "schema_validation_failed");
+        expect(response).toHaveProperty(
+            "debugMessage",
+            expect.stringContaining("Invalid input"),
+        );
+    });
+
+    test("error fetch", async () => {
+        const dummyError = {
+            errorId: "not_found",
+            debugMessage: "User not found",
+        };
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: false,
+                status: 404,
+                json: () => Promise.resolve(dummyError),
+            } as Response),
+        );
+
+        const response = await apiFetch("https://api.example.com/user/999", {
+            schema: UserSchema,
+        });
+
+        expect(response).toHaveProperty("errorId", "not_found");
+        expect(response).toHaveProperty("debugMessage", "User not found");
+    });
+
+    test("network error fetch", async () => {
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockRejectedValue(new Error("Network error")),
+        );
+
+        const response = await apiFetch("https://api.example.com/user/1", {
+            schema: UserSchema,
+        });
+
+        expect(response).toHaveProperty("errorId", "fetch_failed");
+        expect(response).toHaveProperty("debugMessage", "Network error");
+    });
+});

package/tests/apiFetchTextMany.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, test, vi } from "vitest";
+import { z } from "zod";
+import { apiFetchMany, apiFetchTextMany, isApiError } from "../src";
+
+const MessageSchema = z.object({
+    id: z.number(),
+    text: z.string(),
+});
+
+describe("apiFetchTextMany", () => {
+    test("success text many fetch", async () => {
+        const chunks = ["Hello", " ", "World"];
+
+        const mockStream = new ReadableStream({
+            start(controller) {
+                for (const chunk of chunks) {
+                    controller.enqueue(new TextEncoder().encode(chunk));
+                }
+                controller.close();
+            },
+        });
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200,
+                body: mockStream,
+            } as Response),
+        );
+
+        const result: string[] = [];
+        for await (const chunk of apiFetchTextMany(
+            "https://api.example.com/stream",
+        )) {
+            if (isApiError(chunk)) {
+                throw new Error("Should not return error");
+            }
+            result.push(chunk);
+        }
+
+        expect(result).toEqual(chunks);
+    });
+
+    test("error text many fetch", async () => {
+        const dummyError = {
+            errorId: "not_found",
+            debugMessage: "Stream not found",
+        };
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: false,
+                status: 404,
+                json: () => Promise.resolve(dummyError),
+            } as Response),
+        );
+
+        const generator = apiFetchTextMany(
+            "https://api.example.com/stream/999",
+        );
+
+        await expect(async () => {
+            for await (const _chunk of generator) {
+                // Should throw error
+            }
+        }).rejects.toThrow();
+    });
+
+    test("network error text many fetch", async () => {
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockRejectedValue(new Error("Network error")),
+        );
+
+        const generator = apiFetchTextMany("https://api.example.com/stream");
+
+        await expect(async () => {
+            for await (const _chunk of generator) {
+                // Should throw error
+            }
+        }).rejects.toThrow();
+    });
+
+    test("null body error", async () => {
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200,
+                body: null,
+            } as Response),
+        );
+
+        const generator = apiFetchTextMany("https://api.example.com/stream");
+
+        await expect(async () => {
+            for await (const _chunk of generator) {
+                // Should throw error for null body
+            }
+        }).rejects.toThrow();
+    });
+});
+
+describe("apiFetchMany", () => {
+    test("success fetch many", async () => {
+        const messages = [
+            { id: 1, text: "First" },
+            { id: 2, text: "Second" },
+            { id: 3, text: "Third" },
+        ];
+
+        const mockStream = new ReadableStream({
+            start(controller) {
+                for (const message of messages) {
+                    controller.enqueue(
+                        new TextEncoder().encode(
+                            `${JSON.stringify(message)}\n`,
+                        ),
+                    );
+                }
+                controller.close();
+            },
+        });
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200,
+                body: mockStream,
+            } as Response),
+        );
+
+        const result = [];
+        const generator = apiFetchMany("https://api.example.com/stream", {
+            schema: MessageSchema,
+        });
+
+        for await (const chunk of generator) {
+            result.push(chunk);
+        }
+
+        expect(result).toEqual(messages);
+    });
+
+    test("error fetch many", async () => {
+        const dummyError = {
+            errorId: "not_found",
+            debugMessage: "Stream not found",
+        };
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: false,
+                status: 404,
+                json: () => Promise.resolve(dummyError),
+            } as Response),
+        );
+
+        const generator = apiFetchMany("https://api.example.com/stream/999", {
+            schema: MessageSchema,
+        });
+
+        await expect(async () => {
+            for await (const _chunk of generator) {
+                // Should throw error
+            }
+        }).rejects.toThrow();
+    });
+
+    test("network error fetch many", async () => {
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockRejectedValue(new Error("Network error")),
+        );
+
+        const generator = apiFetchMany("https://api.example.com/stream", {
+            schema: MessageSchema,
+        });
+
+        await expect(async () => {
+            for await (const _chunk of generator) {
+                // Should throw error
+            }
+        }).rejects.toThrow();
+    });
+
+    test("invalid schema data", async () => {
+        const invalidData = [{ id: "not-a-number", text: "First" }];
+
+        const mockStream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(
+                    new TextEncoder().encode(JSON.stringify(invalidData[0])),
+                );
+                controller.close();
+            },
+        });
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200,
+                body: mockStream,
+            } as Response),
+        );
+
+        const generator = apiFetchMany("https://api.example.com/stream", {
+            schema: MessageSchema,
+        });
+
+        await expect(async () => {
+            for await (const _chunk of generator) {
+                // Should throw validation error
+            }
+        }).rejects.toThrow();
+    });
+});

package/tests/apiStreamFetch.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test, vi } from "vitest";
+import { apiStreamFetch, isApiError } from "../src";
+
+describe("apiStreamFetch", () => {
+    test("success stream fetch", async () => {
+        const mockStream = new ReadableStream({
+            start(controller) {
+                controller.enqueue(new Uint8Array([1, 2, 3]));
+                controller.close();
+            },
+        });
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: true,
+                status: 200,
+                body: mockStream,
+            } as Response),
+        );
+
+        const response = await apiStreamFetch("https://api.example.com/stream");
+
+        expect(isApiError(response)).toBe(false);
+        expect(response).toBeInstanceOf(ReadableStream);
+
+        // Verify we can read from the stream
+        const reader = (response as ReadableStream<Uint8Array>).getReader();
+        const { value, done } = await reader.read();
+        expect(value).toEqual(new Uint8Array([1, 2, 3]));
+        expect(done).toBe(false);
+    });
+
+    test("error stream fetch", async () => {
+        const dummyError = {
+            errorId: "not_found",
+            debugMessage: "Stream not found",
+        };
+
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockResolvedValue({
+                ok: false,
+                status: 404,
+                json: () => Promise.resolve(dummyError),
+            } as Response),
+        );
+
+        const response = await apiStreamFetch(
+            "https://api.example.com/stream/999",
+        );
+
+        expect(isApiError(response)).toBe(true);
+        expect(response).toHaveProperty("errorId", "not_found");
+        expect(response).toHaveProperty("debugMessage", "Stream not found");
+    });
+
+    test("network error stream fetch", async () => {
+        vi.stubGlobal(
+            "fetch",
+            vi.fn().mockRejectedValue(new Error("Network error")),
+        );
+
+        const response = await apiStreamFetch("https://api.example.com/stream");
+
+        expect(isApiError(response)).toBe(true);
+        expect(response).toHaveProperty("errorId", "fetch_failed");
+        expect(response).toHaveProperty("debugMessage", "Network error");
+    });
+});

package/tests/isApiError.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, test } from "vitest";
+import { ApiError, isApiError } from "../src";
+
+describe("isApiError", () => {
+    test("identifies ApiError instances correctly", () => {
+        const apiError = new ApiError("not_found", 404, "User not found");
+        const nonApiError = new Error("Some other error");
+        const someString = "Just a string";
+
+        expect(isApiError(apiError)).toBe(true);
+        expect(isApiError(nonApiError)).toBe(false);
+        expect(isApiError(someString)).toBe(false);
+    });
+});

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+    "compilerOptions": {
+        // Environment setup & latest features
+        "lib": ["ESNext"],
+        "target": "ESNext",
+        "module": "ESNext",
+        "moduleDetection": "force",
+        "jsx": "react-jsx",
+        "allowJs": true,
+
+        // Bundler mode
+        "moduleResolution": "bundler",
+        "allowImportingTsExtensions": true,
+        "verbatimModuleSyntax": true,
+        "noEmit": true,
+
+        // Best practices
+        "strict": true,
+        "skipLibCheck": true,
+        "noFallthroughCasesInSwitch": true,
+        "noUncheckedIndexedAccess": true,
+
+        // Some stricter flags (disabled by default)
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
+        "noPropertyAccessFromIndexSignature": false
+    }
+}

package/vite.config.ts

@@ -0,0 +1,25 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineConfig } from "vite";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+    build: {
+        lib: {
+            entry: resolve(__dirname, "src/index.ts"),
+            name: "@dcc-bs/commmunication.bs.js",
+            formats: ["es", "umd"], // Specify browser-compatible formats
+        },
+        // Include CSS in the build
+        cssCodeSplit: false,
+        // Copy CSS files to dist
+        copyPublicDir: false,
+        target: "esnext", // Target modern browsers
+        minify: true,
+    },
+    define: {
+        // Ensure browser environment
+        "process.env.NODE_ENV": JSON.stringify("production"),
+    },
+});