neverpanic 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/index.d.ts

@@ -5,55 +5,37 @@ export type Result<T = unknown, E = unknown> = {
     success: false;
     error: E;
 };
-/**
- * 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;
+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: <T extends Result[], D extends Extract<T[number], {
+    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;
-    }>, E extends Extract<T[number], {
+    }>, TE extends Extract<T[number], {
         success: false;
-    }>>(results: T) => Result<D[], E[]>;
+    }>>(results: T) => Result<TD[], TE[]>;
 };
-export {};

package/dist/index.js

@@ -1,108 +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);
-    }
-}
-/**
- * Convert a list of results into a single result.
- *
- * @param results - A list of Results.
- * @returns A single result containing the data / errors of the input results.
- *
- * @example
- * const findUserResults = userIds.map((userId) =>
- *   n.fromUnsafe(
- *     () => db.findUser(userId),
- *     () => "FAILED_TO_FIND_USER" as const,
- *   ),
- * );
- *
- * const result = n.resultsToResult(findUserResults)
- */
-const resultsToResult = (results) => {
-    const errors = results.filter((result) => !result.success);
-    if (errors.length)
+    const fromUnsafe = (cb, eh) => {
+        try {
+            const result = cb();
+            if (result instanceof Promise)
+                return result.then(ok).catch(eh);
+            return ok(result);
+        }
+        catch (e) {
+            return eh(e);
+        }
+    };
+    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: false,
-            error: errors,
+            success: true,
+            data: successes,
         };
-    const successes = results.filter((result) => result.success);
+    };
     return {
-        success: true,
-        data: successes,
+        ok,
+        err,
+        safeFn,
+        fromUnsafe,
+        resultsToResult,
     };
 };
-export const n = { safeFn, fromUnsafe, resultsToResult };
+export const n = createNeverpanic();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neverpanic",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.2",
   "repository": {
     "url": "https://github.com/bgrcs/neverpanic"
   },