neverpanic 0.0.5 → 1.0.0-beta.1

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,14 +5,6 @@ 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.
  *
@@ -55,10 +47,13 @@ declare function safeFn<T extends Result | Promise<Result>, A extends unknown[],
  * }
  */
 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 n: {
     safeFn: typeof safeFn;
     fromUnsafe: typeof fromUnsafe;
-    resultsToResult: typeof resultsToResult;
+    resultsToResult: <T extends Result[], D extends Extract<T[number], {
+        success: true;
+    }>, E extends Extract<T[number], {
+        success: false;
+    }>>(results: T) => Result<D[], E[]>;
 };
 export {};

package/dist/index.js

@@ -67,26 +67,42 @@ function fromUnsafe(cb, eh) {
     try {
         const result = cb();
         if (result instanceof Promise)
-            return result.then(createSuccessResult).catch(createErrorResult);
+            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);
-        }
-        else {
-            data.push(result.data);
-        }
-    }
-    return success ? { success: true, data } : { success: false, error };
-}
+/**
+ * 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)
+        return {
+            success: false,
+            error: errors,
+        };
+    const successes = results.filter((result) => result.success);
+    return {
+        success: true,
+        data: successes,
+    };
+};
 export const n = { safeFn, fromUnsafe, resultsToResult };

package/package.json

@@ -1,21 +1,26 @@
 {
   "name": "neverpanic",
-  "module": "index.ts",
-  "version": "0.0.5",
-  "type": "module",
+  "version": "1.0.0-beta.1",
   "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"