radashi 12.2.2 → 12.2.3

package/dist/radashi.cjs

@@ -371,27 +371,28 @@ var AggregateErrorOrPolyfill = /* @__PURE__ */ (() => globalThis.AggregateError
 })();
 
 // src/async/all.ts
-async function all(promises) {
-  const entries = isArray(promises) ? promises.map((p) => [null, p]) : Object.entries(promises);
-  const results = await Promise.all(
-    entries.map(
-      ([key, value]) => value.then((result) => ({ result, exc: null, key })).catch((exc) => ({ result: null, exc, key }))
-    )
-  );
-  const exceptions = results.filter((r) => r.exc);
-  if (exceptions.length > 0) {
-    throw new AggregateErrorOrPolyfill(exceptions.map((e) => e.exc));
+async function all(input) {
+  const errors = [];
+  const onError = (err) => {
+    errors.push(err);
+  };
+  let output;
+  if (isArray(input)) {
+    output = await Promise.all(
+      input.map((value) => Promise.resolve(value).catch(onError))
+    );
+  } else {
+    output = { ...input };
+    await Promise.all(
+      Object.keys(output).map(async (key) => {
+        output[key] = await Promise.resolve(output[key]).catch(onError);
+      })
+    );
   }
-  if (isArray(promises)) {
-    return results.map((r) => r.result);
+  if (errors.length > 0) {
+    throw new AggregateErrorOrPolyfill(errors);
   }
-  return results.reduce(
-    (acc, item) => {
-      acc[item.key] = item.result;
-      return acc;
-    },
-    {}
-  );
+  return output;
 }
 
 // src/async/defer.ts

package/dist/radashi.d.cts

@@ -551,13 +551,9 @@ interface AggregateErrorConstructor {
  */
 declare const AggregateErrorOrPolyfill: AggregateErrorConstructor;
 
-type PromiseValues<T extends Promise<any>[]> = {
-    [K in keyof T]: T[K] extends Promise<infer U> ? U : never;
-};
 /**
- * Functionally similar to `Promise.all` or `Promise.allSettled`. If
- * any errors are thrown, all errors are gathered and thrown in an
- * `AggregateError`.
+ * Wait for all promises to resolve. Errors from rejected promises are
+ * collected into an `AggregateError`.
  *
  * @see https://radashi.js.org/reference/async/all
  * @example
@@ -570,12 +566,20 @@ type PromiseValues<T extends Promise<any>[]> = {
  * ```
  * @version 12.1.0
  */
-declare function all<T extends [Promise<any>, ...Promise<any>[]]>(promises: T): Promise<PromiseValues<T>>;
-declare function all<T extends Promise<any>[]>(promises: T): Promise<PromiseValues<T>>;
+declare function all<T extends readonly [unknown, ...unknown[]]>(input: T): Promise<{
+    -readonly [I in keyof T]: Awaited<T[I]>;
+}>;
+declare function all<T extends readonly unknown[]>(input: T): Promise<{
+    -readonly [I in keyof T]: Awaited<T[I]>;
+}>;
 /**
- * Functionally similar to `Promise.all` or `Promise.allSettled`. If
- * any errors are thrown, all errors are gathered and thrown in an
- * `AggregateError`.
+ * Check each property in the given object for a promise value. Wait
+ * for all promises to resolve. Errors from rejected promises are
+ * collected into an `AggregateError`.
+ *
+ * The returned promise will resolve with an object whose keys are
+ * identical to the keys of the input object. The values are the
+ * resolved values of the promises.
  *
  * @see https://radashi.js.org/reference/async/all
  * @example
@@ -587,8 +591,8 @@ declare function all<T extends Promise<any>[]>(promises: T): Promise<PromiseValu
  * })
  * ```
  */
-declare function all<T extends Record<string, Promise<any>>>(promises: T): Promise<{
-    [K in keyof T]: Awaited<T[K]>;
+declare function all<T extends Record<string, unknown>>(input: T): Promise<{
+    -readonly [K in keyof T]: Awaited<T[K]>;
 }>;
 
 /**

package/dist/radashi.d.ts

@@ -551,13 +551,9 @@ interface AggregateErrorConstructor {
  */
 declare const AggregateErrorOrPolyfill: AggregateErrorConstructor;
 
-type PromiseValues<T extends Promise<any>[]> = {
-    [K in keyof T]: T[K] extends Promise<infer U> ? U : never;
-};
 /**
- * Functionally similar to `Promise.all` or `Promise.allSettled`. If
- * any errors are thrown, all errors are gathered and thrown in an
- * `AggregateError`.
+ * Wait for all promises to resolve. Errors from rejected promises are
+ * collected into an `AggregateError`.
  *
  * @see https://radashi.js.org/reference/async/all
  * @example
@@ -570,12 +566,20 @@ type PromiseValues<T extends Promise<any>[]> = {
  * ```
  * @version 12.1.0
  */
-declare function all<T extends [Promise<any>, ...Promise<any>[]]>(promises: T): Promise<PromiseValues<T>>;
-declare function all<T extends Promise<any>[]>(promises: T): Promise<PromiseValues<T>>;
+declare function all<T extends readonly [unknown, ...unknown[]]>(input: T): Promise<{
+    -readonly [I in keyof T]: Awaited<T[I]>;
+}>;
+declare function all<T extends readonly unknown[]>(input: T): Promise<{
+    -readonly [I in keyof T]: Awaited<T[I]>;
+}>;
 /**
- * Functionally similar to `Promise.all` or `Promise.allSettled`. If
- * any errors are thrown, all errors are gathered and thrown in an
- * `AggregateError`.
+ * Check each property in the given object for a promise value. Wait
+ * for all promises to resolve. Errors from rejected promises are
+ * collected into an `AggregateError`.
+ *
+ * The returned promise will resolve with an object whose keys are
+ * identical to the keys of the input object. The values are the
+ * resolved values of the promises.
  *
  * @see https://radashi.js.org/reference/async/all
  * @example
@@ -587,8 +591,8 @@ declare function all<T extends Promise<any>[]>(promises: T): Promise<PromiseValu
  * })
  * ```
  */
-declare function all<T extends Record<string, Promise<any>>>(promises: T): Promise<{
-    [K in keyof T]: Awaited<T[K]>;
+declare function all<T extends Record<string, unknown>>(input: T): Promise<{
+    -readonly [K in keyof T]: Awaited<T[K]>;
 }>;
 
 /**

package/dist/radashi.js

@@ -369,27 +369,28 @@ var AggregateErrorOrPolyfill = /* @__PURE__ */ (() => globalThis.AggregateError
 })();
 
 // src/async/all.ts
-async function all(promises) {
-  const entries = isArray(promises) ? promises.map((p) => [null, p]) : Object.entries(promises);
-  const results = await Promise.all(
-    entries.map(
-      ([key, value]) => value.then((result) => ({ result, exc: null, key })).catch((exc) => ({ result: null, exc, key }))
-    )
-  );
-  const exceptions = results.filter((r) => r.exc);
-  if (exceptions.length > 0) {
-    throw new AggregateErrorOrPolyfill(exceptions.map((e) => e.exc));
+async function all(input) {
+  const errors = [];
+  const onError = (err) => {
+    errors.push(err);
+  };
+  let output;
+  if (isArray(input)) {
+    output = await Promise.all(
+      input.map((value) => Promise.resolve(value).catch(onError))
+    );
+  } else {
+    output = { ...input };
+    await Promise.all(
+      Object.keys(output).map(async (key) => {
+        output[key] = await Promise.resolve(output[key]).catch(onError);
+      })
+    );
   }
-  if (isArray(promises)) {
-    return results.map((r) => r.result);
+  if (errors.length > 0) {
+    throw new AggregateErrorOrPolyfill(errors);
   }
-  return results.reduce(
-    (acc, item) => {
-      acc[item.key] = item.result;
-      return acc;
-    },
-    {}
-  );
+  return output;
 }
 
 // src/async/defer.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "radashi",
-  "version": "12.2.2",
+  "version": "12.2.3",
   "type": "module",
   "description": "The modern, community-first TypeScript toolkit with all of the fast, readable, and minimal utility functions you need. Type-safe, dependency-free, tree-shakeable, fully tested.",
   "repository": {
@@ -50,6 +50,7 @@
     "@types/node": "^22.7.5",
     "@vitest/coverage-v8": "2.0.5",
     "cspell": "^8.13.3",
+    "execa": "^9.5.1",
     "prettier": "^3.3.2",
     "prettier-plugin-pkg": "^0.18.1",
     "prettier-plugin-sh": "^0.14.0",