neverpanic 0.0.5 → 1.0.0-beta.2

package/README.md

@@ -19,20 +19,23 @@ Create a safe function from an unsafe one:
 
 ```ts
 const getUser = n.safeFn(
-    async (id: string) => {
-        const res = await fetch(`https://example.com/users/${id}`);
-        if (!res.ok) return { success: false, error: "FAILED_TO_FETCH" };
-
-        return { success: true, data: await res.json() };
-    },
-    (err) => "FAILED_TO_GET_USER",
+  async (id: string) => {
+    const res = await fetch(
+      `https://example.com/users/${id}`,
+    );
+    if (!res.ok)
+      return { success: false, error: "FAILED_TO_FETCH" };
+
+    return { success: true, data: await res.json() };
+  },
+  (err) => "FAILED_TO_GET_USER",
 );
 
 const getUserResult = await getUser("some-user-id");
 if (!getUserResult.success) {
-    console.error(getUserResult.error);
+  console.error(getUserResult.error);
 } else {
-    console.log(getUserResult.data);
+  console.log(getUserResult.data);
 }
 ```
 
@@ -43,12 +46,12 @@ Runs the provided callback function, catching any thrown errors and returning a
 
 ```ts
 const user = await n.fromUnsafe(
-    () => db.findUser("some-user-id"),
-    (err) => "FAILED_T0_FIND_USER",
+  () => db.findUser("some-user-id"),
+  (err) => "FAILED_T0_FIND_USER",
 );
 if (!user.success) {
-    console.error(user.error);
+  console.error(user.error);
 } else {
-    console.log(user.data);
+  console.log(user.data);
 }
 ```

package/dist/index.d.ts

@@ -5,60 +5,37 @@ export type Result<T = unknown, E = unknown> = {
     success: false;
     error: E;
 };
-type DataOf<R extends Result> = R extends {
-    success: true;
-    data: infer D;
-} ? D : never;
-type ErrorOf<R extends Result> = R extends {
-    success: false;
-    error: infer E;
-} ? E : never;
-/**
- * Create a safe function from an unsafe one.
- *
- * @param cb - The async function to wrap.
- * @param [eh] - Optional fallback error handler.
- * @returns A new function that returns a typesafe Result.
- *
- * @example
- * const getUser = n.safeFn(
- *   async (id: string) => {
- *     const res = await fetch(`https://example.com/users/${id}`);
- *     if (!res.ok) return { success: false, error: "FAILED_TO_FETCH" };
- *
- *     return { success: true, data: await res.json() };
- *   },
- *   () => "FAILED_TO_GET_USER"
- * );
- *
- * const getUserResult = await getUser("some-user-id");
- * if (!getUserResult.success) {
- *   console.error(getUserResult.error);
- * } else {
- *   console.log(getUserResult.data);
- * }
- */
-declare function safeFn<T extends Result | Promise<Result>, A extends unknown[], E = null>(cb: (...args: A) => T, eh?: (e: unknown) => E): (...args: A) => T | Result<never, E>;
-/**
- * Run an unsafe function, handle any errors and return a Result.
- *
- * @param cb - The async function to call.
- * @param [eh] - Optional fallback error handler.
- * @returns The awaited return value of cb.
- *
- * @example
- * const user = await n.fromUnsafe(() => db.findUser('some-user-id'), () => 'FAILED_T0_FIND_USER')
- * if (!user.success) {
- * 	console.error(user.error)
- * } else {
- * 	console.log(user.data)
- * }
- */
-declare function fromUnsafe<T, E = null, R = T extends Promise<unknown> ? Promise<Result<Awaited<T>, E>> : Result<T, E>>(cb: () => T, eh?: (err: unknown) => E): R;
-declare function resultsToResult<R extends Result[]>(results: R): Result<DataOf<R[number]>[], ErrorOf<R[number]>[]>;
+export declare const createNeverpanic: <D = unknown, E = unknown>() => {
+    ok: <const T extends D>(data: T) => Result<T, never>;
+    err: <const T extends E>(error: T) => Result<never, T>;
+    safeFn: <T extends Result<D, E> | Promise<Result<D, E>>, A extends unknown[], EH extends Result<D, E>>(cb: (...args: A) => T, eh: (e: unknown) => EH) => ((...args: A) => T | EH);
+    fromUnsafe: <T extends D | Promise<D>, EH_1 extends Result<D, E>, R = T extends Promise<infer U> ? Promise<{
+        success: true;
+        data: U;
+    }> : {
+        success: true;
+        data: T;
+    }>(cb: () => T, eh: (err: unknown) => EH_1) => R | EH_1;
+    resultsToResult: <T extends Result<D, E>[], TD extends Extract<T[number], {
+        success: true;
+    }>, TE extends Extract<T[number], {
+        success: false;
+    }>>(results: T) => Result<TD[], TE[]>;
+};
 export declare const n: {
-    safeFn: typeof safeFn;
-    fromUnsafe: typeof fromUnsafe;
-    resultsToResult: typeof resultsToResult;
+    ok: <const T extends unknown>(data: T) => Result<T, never>;
+    err: <const T extends unknown>(error: T) => Result<never, T>;
+    safeFn: <T extends Result<unknown, unknown> | Promise<Result<unknown, unknown>>, A extends unknown[], EH extends Result<unknown, unknown>>(cb: (...args: A) => T, eh: (e: unknown) => EH) => (...args: A) => T | EH;
+    fromUnsafe: <T extends unknown, EH extends Result<unknown, unknown>, R = T extends Promise<infer U> ? Promise<{
+        success: true;
+        data: U;
+    }> : {
+        success: true;
+        data: T;
+    }>(cb: () => T, eh: (err: unknown) => EH) => EH | R;
+    resultsToResult: <T extends Result<unknown, unknown>[], TD extends Extract<T[number], {
+        success: true;
+    }>, TE extends Extract<T[number], {
+        success: false;
+    }>>(results: T) => Result<TD[], TE[]>;
 };
-export {};

package/dist/index.js

@@ -1,92 +1,53 @@
-/**
- * Create a safe function from an unsafe one.
- *
- * @param cb - The async function to wrap.
- * @param [eh] - Optional fallback error handler.
- * @returns A new function that returns a typesafe Result.
- *
- * @example
- * const getUser = n.safeFn(
- *   async (id: string) => {
- *     const res = await fetch(`https://example.com/users/${id}`);
- *     if (!res.ok) return { success: false, error: "FAILED_TO_FETCH" };
- *
- *     return { success: true, data: await res.json() };
- *   },
- *   () => "FAILED_TO_GET_USER"
- * );
- *
- * const getUserResult = await getUser("some-user-id");
- * if (!getUserResult.success) {
- *   console.error(getUserResult.error);
- * } else {
- *   console.log(getUserResult.data);
- * }
- */
-function safeFn(cb, eh) {
-    const createErrorResult = (e) => ({
+export const createNeverpanic = () => {
+    const ok = (data) => ({
+        success: true,
+        data,
+    });
+    const err = (error) => ({
         success: false,
-        error: eh?.(e) ?? null,
+        error,
     });
-    return (...args) => {
+    const safeFn = (cb, eh) => (...args) => {
         try {
             const result = cb(...args);
             if (result instanceof Promise)
-                return result.catch(createErrorResult);
+                return result.catch(eh);
             return result;
         }
         catch (e) {
-            return createErrorResult(e);
+            return eh(e);
         }
     };
-}
-/**
- * Run an unsafe function, handle any errors and return a Result.
- *
- * @param cb - The async function to call.
- * @param [eh] - Optional fallback error handler.
- * @returns The awaited return value of cb.
- *
- * @example
- * const user = await n.fromUnsafe(() => db.findUser('some-user-id'), () => 'FAILED_T0_FIND_USER')
- * if (!user.success) {
- * 	console.error(user.error)
- * } else {
- * 	console.log(user.data)
- * }
- */
-function fromUnsafe(cb, eh) {
-    const createErrorResult = (e) => ({
-        success: false,
-        error: eh?.(e) ?? null,
-    });
-    const createSuccessResult = (data) => ({
-        success: true,
-        data,
-    });
-    try {
-        const result = cb();
-        if (result instanceof Promise)
-            return result.then(createSuccessResult).catch(createErrorResult);
-        return createSuccessResult(result);
-    }
-    catch (e) {
-        return createErrorResult(e);
-    }
-}
-function resultsToResult(results) {
-    let success = true;
-    const error = [];
-    const data = [];
-    for (const result of results) {
-        if (!result.success) {
-            success = false;
-            error.push(result.error);
+    const fromUnsafe = (cb, eh) => {
+        try {
+            const result = cb();
+            if (result instanceof Promise)
+                return result.then(ok).catch(eh);
+            return ok(result);
         }
-        else {
-            data.push(result.data);
+        catch (e) {
+            return eh(e);
         }
-    }
-    return success ? { success: true, data } : { success: false, error };
-}
-export const n = { safeFn, fromUnsafe, resultsToResult };
+    };
+    const resultsToResult = (results) => {
+        const errors = results.filter((result) => !result.success);
+        if (errors.length)
+            return {
+                success: false,
+                error: errors,
+            };
+        const successes = results.filter((result) => result.success);
+        return {
+            success: true,
+            data: successes,
+        };
+    };
+    return {
+        ok,
+        err,
+        safeFn,
+        fromUnsafe,
+        resultsToResult,
+    };
+};
+export const n = createNeverpanic();

package/package.json

@@ -1,21 +1,26 @@
 {
   "name": "neverpanic",
-  "module": "index.ts",
-  "version": "0.0.5",
-  "type": "module",
+  "version": "1.0.0-beta.2",
   "repository": {
     "url": "https://github.com/bgrcs/neverpanic"
   },
-  "scripts": {
-    "build": "tsc",
-    "test": "bun test"
-  },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "module": "index.ts",
   "exports": {
     ".": "./dist/index.js"
   },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "fmt": "oxfmt --check",
+    "fmt:fix": "oxfmt --write"
+  },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "oxfmt": "0.32.0"
   },
   "peerDependencies": {
     "typescript": "5"