style(core): apply consistent formatting across files and test cases

Author: tarnishablec

packages/core/__tests__/caller-trace.test.ts

@@ -1,16 +1,16 @@
 // noinspection ES6UnusedImports
 import { describe, expect, test } from "bun:test";
-import { That } from '@thaterror/core';
-import { ResultAsync } from 'neverthrow';
+import { That } from "@thaterror/core";
+import { ResultAsync } from "neverthrow";
 
 describe("ThatError Location Anchoring", () => {
     const AppError = That({
         SYNC_ERR: "Sync failure",
         ASYNC_ERR: (url: string) => `Async failure: ${url}`,
-        LOC_ERR: "Location test error"
+        LOC_ERR: "Location test error",
     });
 
-    const pathSegments = new URL(import.meta.url).pathname.split('/');
+    const pathSegments = new URL(import.meta.url).pathname.split("/");
     const currentFileName = pathSegments.at(-1) ?? "";
 
     // --- Scenario 1: The Native Way (Messy) ---
@@ -24,7 +24,7 @@ describe("ThatError Location Anchoring", () => {
                      * A standard 'new Error' is captured here, but the stack trace
                      * will be cluttered with neverthrow's internal dispatcher frames.
                      */
-                    new Error(`Native wrap: ${error}`)
+                    new Error(`Native wrap: ${error}`),
             ).andThen(() => {
                 throw new Error("Should not happen");
             });
@@ -71,7 +71,7 @@ describe("ThatError Location Anchoring", () => {
                 // The engine captures the stack during 'new', but without the
                 // explicit anchor, the trace quality depends purely on V8's mood.
                 return AppError.LOC_ERR();
-            }
+            },
         );
 
         if (result.isErr()) {
@@ -84,29 +84,27 @@ describe("ThatError Location Anchoring", () => {
 
     // --- Scenario 4: Synchronous Business Logic ---
     test("Sync: stack trace should anchor at the business caller via .at()", () => {
-            function businessFunction() {
-                /**
-                 * 💡 THE ANCHOR POINT
-                 * We call .at() here to explicitly mark this line as the "Crime Scene".
-                 */
-                return AppError.SYNC_ERR().with(void 0);
-            }
+        function businessFunction() {
+            /**
+             * 💡 THE ANCHOR POINT
+             * We call .at() here to explicitly mark this line as the "Crime Scene".
+             */
+            return AppError.SYNC_ERR().with(void 0);
+        }
 
-            const err = businessFunction();
-            const stack = err.stack ?? "";
-            const topFrame = stack.split("\n")[1];
+        const err = businessFunction();
+        const stack = err.stack ?? "";
+        const topFrame = stack.split("\n")[1];
 
-            // 🎯 Verification: The first frame must point to 'businessFunction' in THIS file.
-            expect(topFrame).toContain("businessFunction");
-            expect(topFrame).toContain(currentFileName);
+        // 🎯 Verification: The first frame must point to 'businessFunction' in THIS file.
+        expect(topFrame).toContain("businessFunction");
+        expect(topFrame).toContain(currentFileName);
 
-            // 🛡️ Noise Removal: The factory internals (define.ts) must be sliced off.
-            expect(topFrame).not.toContain("define.ts");
+        // 🛡️ Noise Removal: The factory internals (define.ts) must be sliced off.
+        expect(topFrame).not.toContain("define.ts");
 
-            console.log(stack.split("\n").slice(0, 4).join("\n"));
-        }
-    )
-    ;
+        console.log(stack.split("\n").slice(0, 4).join("\n"));
+    });
 
     // --- Scenario 5: Neverthrow Async Callback ---
     test("Async: stack trace should anchor inside neverthrow callback via .at()", async () => {
@@ -122,8 +120,8 @@ describe("ThatError Location Anchoring", () => {
                  * By calling .at() inside this anonymous closure, we lock the stack
                  * to this exact line in the business logic.
                  */
-                return AppError.ASYNC_ERR(url).with({cause: error});
-            }
+                return AppError.ASYNC_ERR(url).with({ cause: error });
+            },
         );
 
         if (result.isErr()) {
@@ -152,4 +150,4 @@ describe("ThatError Location Anchoring", () => {
             throw new Error("Test failed: Result should be an Err");
         }
     });
-});
+});

packages/core/__tests__/define-error.test.ts

@@ -8,33 +8,35 @@ import {
     ScopeField,
     scopeOf,
     That,
-} from "@thaterror/core"
+} from "@thaterror/core";
 
 export const AppError = That({
     NotFound: (id: number) => `Resource ${id} not found`,
     Unauthorized: "User is not logged in",
     DatabaseError: (query: string) => `Query failed: ${query}`,
-    ShardError: (characterId: number, shard: string) => `Character & shard unmatch ${characterId} : ${shard}`
+    ShardError: (characterId: number, shard: string) =>
+        `Character & shard unmatch ${characterId} : ${shard}`,
 });
 
 export type AppErrorUnion = ErrorUnionOf<typeof AppError>;
 
 describe("defineError strict type testing", () => {
-
     test("should be correctly scoped", () => {
         const err = AppError.Unauthorized();
         expect(scopeOf(AppError)).toBe(scopeOf(err));
         expect(scopeOf(AppError)).toBe(scopeOf(AppError.ShardError));
         expect(scopeOf(AppError)).toBe(scopeOf(AppError.NotFound));
         expect(scopeOf(AppError)).toBe(scopeOf(AppError.Unauthorized));
-    })
+    });
 
     test("static error should be correctly generated", () => {
         const err = AppError.Unauthorized();
 
         if (isDefinedError(err, scopeOf(AppError))) {
             expect(isDefinedError(err, scopeOf(AppError))).toBe(true);
-            switch ((err as AppErrorUnion)[CodeField]) { // type auto infer
+            switch (
+                (err as AppErrorUnion)[CodeField] // type auto infer
+            ) {
                 case "DatabaseError":
                     expect(false).toBe(true);
                     throw new Error("Should not happen");
@@ -44,7 +46,6 @@ describe("defineError strict type testing", () => {
                 case "Unauthorized":
                     break;
             }
-
         }
 
         expect(err[CodeField]).toBe("Unauthorized");
@@ -58,7 +59,7 @@ describe("defineError strict type testing", () => {
         expect(err[ScopeField]).toBe(scopeOf(AppError));
         expect(isDefinedError(err, scopeOf(AppError))).toBe(true);
         expect(isDefinedError(err, Symbol())).toBe(false);
-    })
+    });
 
     test("error with parameters should correctly capture payload", () => {
         const err = AppError.NotFound(404);
@@ -72,12 +73,14 @@ describe("defineError strict type testing", () => {
 
     test("should support native Error.cause (#[source])", () => {
         const original = new Error("Connection lost");
-        const err = AppError.Unauthorized().with({cause: original});
+        const err = AppError.Unauthorized().with({ cause: original });
 
         expect(err.cause).toBe(original);
 
         const shardOriginal = new Error("Shard not found");
-        const shardErr = AppError.ShardError(1, "shard-1").with({cause: shardOriginal});
+        const shardErr = AppError.ShardError(1, "shard-1").with({
+            cause: shardOriginal,
+        });
         expect(shardErr.cause).toBe(shardOriginal);
     });
 
@@ -96,7 +99,6 @@ describe("defineError strict type testing", () => {
         try {
             fn();
         } catch (e: unknown) {
-
             const isError = e instanceof Error;
             expect(isError).toBe(true);
 
@@ -118,4 +120,4 @@ describe("defineError strict type testing", () => {
             expect(err[PayloadField]).toEqual([1]);
         }
     });
-});
+});

packages/core/__tests__/from-error.test.ts

@@ -1,6 +1,6 @@
-import { describe, expect, test } from 'bun:test'
-import { HTTPException } from 'hono/http-exception'
-import { AppError } from './define-error.test'
+import { describe, expect, test } from "bun:test";
+import { HTTPException } from "hono/http-exception";
+import { AppError } from "./define-error.test";
 
 class MyCustomError extends Error {
     prop = 1;
@@ -12,52 +12,60 @@ class MyCustomError2 extends Error {
     }
 }
 
-
-describe('ErrorFamily from native error testing', () => {
+describe("ErrorFamily from native error testing", () => {
     const HttpBridgedError = AppError.bridge(HTTPException, (e, cases) => {
         return e.status === 404
             ? cases.NotFound(Number(e.message) || 0)
             : e.status === 401
-                ? cases.Unauthorized()
-                : e.status === 500
-                    ? cases.DatabaseError(e.message)
-                    : cases.ShardError(0, "FORBIDDEN_SHARD")
-
-    })
-
-    test('should chain up error family', () => {
-        const ExAppError = AppError.enroll(MyCustomError, AppError.Unauthorized);
+              ? cases.Unauthorized()
+              : e.status === 500
+                ? cases.DatabaseError(e.message)
+                : cases.ShardError(0, "FORBIDDEN_SHARD");
+    });
+
+    test("should chain up error family", () => {
+        const ExAppError = AppError.enroll(
+            MyCustomError,
+            AppError.Unauthorized,
+        );
         const InferErr = ExAppError.from(new MyCustomError());
         expect(InferErr.is(AppError.Unauthorized)).toBe(true);
 
-        const ExxAppError = ExAppError.enroll(HTTPException, AppError.NotFound, (e) => [e.status]);
-        expect(ExxAppError.from(new HTTPException(404)).is(AppError.NotFound)).toBe(true);
-
-
-        const ExrAppError = ExxAppError
-            .enroll(MyCustomError, AppError.NotFound, (e) => [e.prop])
-            .enroll(SyntaxError, AppError.ShardError, (_e) => [2, 'xx']);
-
-        expect(ExrAppError.from(new MyCustomError()).is(AppError.NotFound)).toBe(true)
+        const ExxAppError = ExAppError.enroll(
+            HTTPException,
+            AppError.NotFound,
+            (e) => [e.status],
+        );
+        expect(
+            ExxAppError.from(new HTTPException(404)).is(AppError.NotFound),
+        ).toBe(true);
+
+        const ExrAppError = ExxAppError.enroll(
+            MyCustomError,
+            AppError.NotFound,
+            (e) => [e.prop],
+        ).enroll(SyntaxError, AppError.ShardError, (_e) => [2, "xx"]);
+
+        expect(
+            ExrAppError.from(new MyCustomError()).is(AppError.NotFound),
+        ).toBe(true);
 
         const unenrolledError = new MyCustomError2();
         // @ts-expect-error
-        expect(() => ExrAppError.from(unenrolledError)).toThrowError(Error)
-    })
-
-    test('should bridge error correctly', () => {
-
+        expect(() => ExrAppError.from(unenrolledError)).toThrowError(Error);
+    });
 
-        const nfErr = HttpBridgedError.from(new HTTPException(404))
+    test("should bridge error correctly", () => {
+        const nfErr = HttpBridgedError.from(new HTTPException(404));
         expect(nfErr.is(AppError.NotFound)).toBe(true);
-    })
+    });
 
-    test('should handle cause correctly', () => {
+    test("should handle cause correctly", () => {
         const customError = new MyCustomError();
         const GenError = AppError.enroll(MyCustomError, AppError.Unauthorized);
         expect(GenError.from(customError).cause).toBe(customError);
 
         const not_found = new HTTPException(404);
         expect(HttpBridgedError.from(not_found).cause).toBe(not_found);
-    })
-})
+    });
+});

packages/core/__tests__/neverthrow.test.ts

@@ -1,11 +1,16 @@
 // noinspection ES6UnusedImports
 import { describe, expect, test } from "bun:test";
-import { codeOf, PayloadField, payloadOf, type ThatError } from "@thaterror/core";
-import { err, fromPromise } from 'neverthrow'
-import { AppError } from './define-error.test'
-
-describe('neverthrow test', () => {
-    test('should infer Error type', () => {
+import {
+    codeOf,
+    PayloadField,
+    payloadOf,
+    type ThatError,
+} from "@thaterror/core";
+import { err, fromPromise } from "neverthrow";
+import { AppError } from "./define-error.test";
+
+describe("neverthrow test", () => {
+    test("should infer Error type", () => {
         const getNotFoundResult = () => {
             const e = AppError.NotFound(404);
             return err<string, ThatError<typeof AppError, "NotFound">>(e);
@@ -20,16 +25,15 @@ describe('neverthrow test', () => {
             expect(error.is(AppError.NotFound)).toBe(true);
             expect(error[PayloadField]).toEqual([404]);
         }
-    })
+    });
 
-    test('should infer Error type from async call', async () => {
+    test("should infer Error type from async call", async () => {
         const id = 123;
         const fetchData = () => {
-            const promise = Promise.reject(new Error('fetchData'));
+            const promise = Promise.reject(new Error("fetchData"));
 
-            return fromPromise(
-                promise,
-                (e) => AppError.NotFound(id).with({cause: e})
+            return fromPromise(promise, (e) =>
+                AppError.NotFound(id).with({ cause: e }),
             );
         };
 
@@ -44,5 +48,5 @@ describe('neverthrow test', () => {
             const code = codeOf(result.error);
             expect(code).toBe("NotFound");
         }
-    })
-})
+    });
+});