@metamask-previews/snap-networks-utils 1.0.0-preview-e79d811 → 1.0.0-preview-8ff90d2f

package/CHANGELOG.md

@@ -10,7 +10,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Add `InFlightCoalescer`, exported from a new `./dedupe` entry point, which coalesces concurrent async operations by key so callers share one in-flight run ([#149](https://github.com/MetaMask/internal-snaps/pull/149))
-- Add shared async batching utilities. ([#211](https://github.com/MetaMask/internal-snaps/pull/211))
 - Add origin permission helpers ([#193](https://github.com/MetaMask/internal-snaps/pull/193))
   - `createOriginPermissions` for building origin-to-method maps
   - `validateOrigin` for checking an origin against a permission map

package/dist/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateOrigin = exports.DEFAULT_METAMASK_ORIGIN = exports.DEFAULT_DEV_ORIGINS = exports.DEFAULT_PROD_ORIGINS = exports.createOriginPermissions = exports.LogLevel = exports.Logger = exports.chunks = exports.batchesAllWithChunks = exports.batchesAllSettledWithChunks = exports.batchesAllSettled = exports.batchesAll = exports.UrlStruct = exports.sanitizeUri = exports.sanitizeControlCharacters = exports.buildUrl = exports.safeMerge = exports.RemoteFeatureFlagsProvider = exports.REMOTE_FEATURE_FLAGS_PROVIDER_NAME = exports.AssetsProvider = exports.ASSETS_PROVIDER_NAME = void 0;
+exports.validateOrigin = exports.DEFAULT_METAMASK_ORIGIN = exports.DEFAULT_DEV_ORIGINS = exports.DEFAULT_PROD_ORIGINS = exports.createOriginPermissions = exports.LogLevel = exports.Logger = exports.UrlStruct = exports.sanitizeUri = exports.sanitizeControlCharacters = exports.buildUrl = exports.safeMerge = exports.RemoteFeatureFlagsProvider = exports.REMOTE_FEATURE_FLAGS_PROVIDER_NAME = exports.AssetsProvider = exports.ASSETS_PROVIDER_NAME = void 0;
 var AssetsProvider_1 = require("./providers/assets/AssetsProvider.cjs");
 Object.defineProperty(exports, "ASSETS_PROVIDER_NAME", { enumerable: true, get: function () { return AssetsProvider_1.ASSETS_PROVIDER_NAME; } });
 Object.defineProperty(exports, "AssetsProvider", { enumerable: true, get: function () { return AssetsProvider_1.AssetsProvider; } });
@@ -16,12 +16,6 @@ Object.defineProperty(exports, "sanitizeControlCharacters", { enumerable: true,
 Object.defineProperty(exports, "sanitizeUri", { enumerable: true, get: function () { return sanitize_1.sanitizeUri; } });
 var urlStruct_1 = require("./urlStruct/urlStruct.cjs");
 Object.defineProperty(exports, "UrlStruct", { enumerable: true, get: function () { return urlStruct_1.UrlStruct; } });
-var async_1 = require("./async.cjs");
-Object.defineProperty(exports, "batchesAll", { enumerable: true, get: function () { return async_1.batchesAll; } });
-Object.defineProperty(exports, "batchesAllSettled", { enumerable: true, get: function () { return async_1.batchesAllSettled; } });
-Object.defineProperty(exports, "batchesAllSettledWithChunks", { enumerable: true, get: function () { return async_1.batchesAllSettledWithChunks; } });
-Object.defineProperty(exports, "batchesAllWithChunks", { enumerable: true, get: function () { return async_1.batchesAllWithChunks; } });
-Object.defineProperty(exports, "chunks", { enumerable: true, get: function () { return async_1.chunks; } });
 var logger_1 = require("./logger/index.cjs");
 Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
 Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_1.LogLevel; } });

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,wEAI2C;AAHzC,sHAAA,oBAAoB,OAAA;AACpB,gHAAA,cAAc,OAAA;AAGhB,8GAIqE;AAHnE,gJAAA,kCAAkC,OAAA;AAClC,wIAAA,0BAA0B,OAAA;AAG5B,uDAAkD;AAAzC,sGAAA,SAAS,OAAA;AAClB,oDAA+C;AAAtC,oGAAA,QAAQ,OAAA;AAEjB,2CAAoE;AAA3D,qHAAA,yBAAyB,OAAA;AAAE,uGAAA,WAAW,OAAA;AAC/C,uDAAkD;AAAzC,sGAAA,SAAS,OAAA;AAClB,qCAMiB;AALf,mGAAA,UAAU,OAAA;AACV,0GAAA,iBAAiB,OAAA;AACjB,oHAAA,2BAA2B,OAAA;AAC3B,6GAAA,oBAAoB,OAAA;AACpB,+FAAA,MAAM,OAAA;AAER,6CAA4C;AAAnC,gGAAA,MAAM,OAAA;AAAE,kGAAA,QAAQ,OAAA;AAQzB,2FAKqD;AAJnD,kIAAA,uBAAuB,OAAA;AACvB,+HAAA,oBAAoB,OAAA;AACpB,8HAAA,mBAAmB,OAAA;AACnB,kIAAA,uBAAuB,OAAA;AAGzB,yEAAoE;AAA3D,gHAAA,cAAc,OAAA","sourcesContent":["export {\n  ASSETS_PROVIDER_NAME,\n  AssetsProvider,\n  type AssetsProviderMessenger,\n} from './providers/assets/AssetsProvider';\nexport {\n  REMOTE_FEATURE_FLAGS_PROVIDER_NAME,\n  RemoteFeatureFlagsProvider,\n  type RemoteFeatureFlagsProviderMessenger,\n} from './providers/remote-feature-flags/RemoteFeatureFlagsProvider';\nexport { safeMerge } from './safeMerge/safeMerge';\nexport { buildUrl } from './buildUrl/buildUrl';\nexport type { BuildUrlParams } from './buildUrl/buildUrl';\nexport { sanitizeControlCharacters, sanitizeUri } from './sanitize';\nexport { UrlStruct } from './urlStruct/urlStruct';\nexport {\n  batchesAll,\n  batchesAllSettled,\n  batchesAllSettledWithChunks,\n  batchesAllWithChunks,\n  chunks,\n} from './async';\nexport { Logger, LogLevel } from './logger';\nexport type {\n  LoggerOptions,\n  LoggerMethod,\n  LogMethod,\n  LogMethodDecorator,\n  LoggerDecorators,\n} from './logger';\nexport {\n  createOriginPermissions,\n  DEFAULT_PROD_ORIGINS,\n  DEFAULT_DEV_ORIGINS,\n  DEFAULT_METAMASK_ORIGIN,\n} from './originPermissions/createOriginPermissions';\nexport type { CreateOriginPermissionsParams } from './originPermissions/createOriginPermissions';\nexport { validateOrigin } from './originPermissions/validateOrigin';\n"]}
+{"version":3,"file":"index.cjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,wEAI2C;AAHzC,sHAAA,oBAAoB,OAAA;AACpB,gHAAA,cAAc,OAAA;AAGhB,8GAIqE;AAHnE,gJAAA,kCAAkC,OAAA;AAClC,wIAAA,0BAA0B,OAAA;AAG5B,uDAAkD;AAAzC,sGAAA,SAAS,OAAA;AAClB,oDAA+C;AAAtC,oGAAA,QAAQ,OAAA;AAEjB,2CAAoE;AAA3D,qHAAA,yBAAyB,OAAA;AAAE,uGAAA,WAAW,OAAA;AAC/C,uDAAkD;AAAzC,sGAAA,SAAS,OAAA;AAClB,6CAA4C;AAAnC,gGAAA,MAAM,OAAA;AAAE,kGAAA,QAAQ,OAAA;AAQzB,2FAKqD;AAJnD,kIAAA,uBAAuB,OAAA;AACvB,+HAAA,oBAAoB,OAAA;AACpB,8HAAA,mBAAmB,OAAA;AACnB,kIAAA,uBAAuB,OAAA;AAGzB,yEAAoE;AAA3D,gHAAA,cAAc,OAAA","sourcesContent":["export {\n  ASSETS_PROVIDER_NAME,\n  AssetsProvider,\n  type AssetsProviderMessenger,\n} from './providers/assets/AssetsProvider';\nexport {\n  REMOTE_FEATURE_FLAGS_PROVIDER_NAME,\n  RemoteFeatureFlagsProvider,\n  type RemoteFeatureFlagsProviderMessenger,\n} from './providers/remote-feature-flags/RemoteFeatureFlagsProvider';\nexport { safeMerge } from './safeMerge/safeMerge';\nexport { buildUrl } from './buildUrl/buildUrl';\nexport type { BuildUrlParams } from './buildUrl/buildUrl';\nexport { sanitizeControlCharacters, sanitizeUri } from './sanitize';\nexport { UrlStruct } from './urlStruct/urlStruct';\nexport { Logger, LogLevel } from './logger';\nexport type {\n  LoggerOptions,\n  LoggerMethod,\n  LogMethod,\n  LogMethodDecorator,\n  LoggerDecorators,\n} from './logger';\nexport {\n  createOriginPermissions,\n  DEFAULT_PROD_ORIGINS,\n  DEFAULT_DEV_ORIGINS,\n  DEFAULT_METAMASK_ORIGIN,\n} from './originPermissions/createOriginPermissions';\nexport type { CreateOriginPermissionsParams } from './originPermissions/createOriginPermissions';\nexport { validateOrigin } from './originPermissions/validateOrigin';\n"]}

package/dist/index.d.cts

@@ -5,7 +5,6 @@ export { buildUrl } from "./buildUrl/buildUrl.cjs";
 export type { BuildUrlParams } from "./buildUrl/buildUrl.cjs";
 export { sanitizeControlCharacters, sanitizeUri } from "./sanitize.cjs";
 export { UrlStruct } from "./urlStruct/urlStruct.cjs";
-export { batchesAll, batchesAllSettled, batchesAllSettledWithChunks, batchesAllWithChunks, chunks, } from "./async.cjs";
 export { Logger, LogLevel } from "./logger/index.cjs";
 export type { LoggerOptions, LoggerMethod, LogMethod, LogMethodDecorator, LoggerDecorators, } from "./logger/index.cjs";
 export { createOriginPermissions, DEFAULT_PROD_ORIGINS, DEFAULT_DEV_ORIGINS, DEFAULT_METAMASK_ORIGIN, } from "./originPermissions/createOriginPermissions.cjs";

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,KAAK,uBAAuB,GAC7B,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,KAAK,mCAAmC,GACzC,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EAAE,QAAQ,EAAE,gCAA4B;AAC/C,YAAY,EAAE,cAAc,EAAE,gCAA4B;AAC1D,OAAO,EAAE,yBAAyB,EAAE,WAAW,EAAE,uBAAmB;AACpE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,MAAM,GACP,oBAAgB;AACjB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,2BAAiB;AAC5C,YAAY,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,gBAAgB,GACjB,2BAAiB;AAClB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,GACxB,wDAAoD;AACrD,YAAY,EAAE,6BAA6B,EAAE,wDAAoD;AACjG,OAAO,EAAE,cAAc,EAAE,+CAA2C"}
+{"version":3,"file":"index.d.cts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,KAAK,uBAAuB,GAC7B,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,KAAK,mCAAmC,GACzC,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EAAE,QAAQ,EAAE,gCAA4B;AAC/C,YAAY,EAAE,cAAc,EAAE,gCAA4B;AAC1D,OAAO,EAAE,yBAAyB,EAAE,WAAW,EAAE,uBAAmB;AACpE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,2BAAiB;AAC5C,YAAY,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,gBAAgB,GACjB,2BAAiB;AAClB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,GACxB,wDAAoD;AACrD,YAAY,EAAE,6BAA6B,EAAE,wDAAoD;AACjG,OAAO,EAAE,cAAc,EAAE,+CAA2C"}

package/dist/index.d.mts

@@ -5,7 +5,6 @@ export { buildUrl } from "./buildUrl/buildUrl.mjs";
 export type { BuildUrlParams } from "./buildUrl/buildUrl.mjs";
 export { sanitizeControlCharacters, sanitizeUri } from "./sanitize.mjs";
 export { UrlStruct } from "./urlStruct/urlStruct.mjs";
-export { batchesAll, batchesAllSettled, batchesAllSettledWithChunks, batchesAllWithChunks, chunks, } from "./async.mjs";
 export { Logger, LogLevel } from "./logger/index.mjs";
 export type { LoggerOptions, LoggerMethod, LogMethod, LogMethodDecorator, LoggerDecorators, } from "./logger/index.mjs";
 export { createOriginPermissions, DEFAULT_PROD_ORIGINS, DEFAULT_DEV_ORIGINS, DEFAULT_METAMASK_ORIGIN, } from "./originPermissions/createOriginPermissions.mjs";

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,KAAK,uBAAuB,GAC7B,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,KAAK,mCAAmC,GACzC,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EAAE,QAAQ,EAAE,gCAA4B;AAC/C,YAAY,EAAE,cAAc,EAAE,gCAA4B;AAC1D,OAAO,EAAE,yBAAyB,EAAE,WAAW,EAAE,uBAAmB;AACpE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,MAAM,GACP,oBAAgB;AACjB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,2BAAiB;AAC5C,YAAY,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,gBAAgB,GACjB,2BAAiB;AAClB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,GACxB,wDAAoD;AACrD,YAAY,EAAE,6BAA6B,EAAE,wDAAoD;AACjG,OAAO,EAAE,cAAc,EAAE,+CAA2C"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EACd,KAAK,uBAAuB,GAC7B,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,KAAK,mCAAmC,GACzC,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EAAE,QAAQ,EAAE,gCAA4B;AAC/C,YAAY,EAAE,cAAc,EAAE,gCAA4B;AAC1D,OAAO,EAAE,yBAAyB,EAAE,WAAW,EAAE,uBAAmB;AACpE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,2BAAiB;AAC5C,YAAY,EACV,aAAa,EACb,YAAY,EACZ,SAAS,EACT,kBAAkB,EAClB,gBAAgB,GACjB,2BAAiB;AAClB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,GACxB,wDAAoD;AACrD,YAAY,EAAE,6BAA6B,EAAE,wDAAoD;AACjG,OAAO,EAAE,cAAc,EAAE,+CAA2C"}

package/dist/index.mjs

@@ -4,7 +4,6 @@ export { safeMerge } from "./safeMerge/safeMerge.mjs";
 export { buildUrl } from "./buildUrl/buildUrl.mjs";
 export { sanitizeControlCharacters, sanitizeUri } from "./sanitize.mjs";
 export { UrlStruct } from "./urlStruct/urlStruct.mjs";
-export { batchesAll, batchesAllSettled, batchesAllSettledWithChunks, batchesAllWithChunks, chunks } from "./async.mjs";
 export { Logger, LogLevel } from "./logger/index.mjs";
 export { createOriginPermissions, DEFAULT_PROD_ORIGINS, DEFAULT_DEV_ORIGINS, DEFAULT_METAMASK_ORIGIN } from "./originPermissions/createOriginPermissions.mjs";
 export { validateOrigin } from "./originPermissions/validateOrigin.mjs";

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EAEf,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAE3B,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EAAE,QAAQ,EAAE,gCAA4B;AAE/C,OAAO,EAAE,yBAAyB,EAAE,WAAW,EAAE,uBAAmB;AACpE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,MAAM,EACP,oBAAgB;AACjB,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,2BAAiB;AAQ5C,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACxB,wDAAoD;AAErD,OAAO,EAAE,cAAc,EAAE,+CAA2C","sourcesContent":["export {\n  ASSETS_PROVIDER_NAME,\n  AssetsProvider,\n  type AssetsProviderMessenger,\n} from './providers/assets/AssetsProvider';\nexport {\n  REMOTE_FEATURE_FLAGS_PROVIDER_NAME,\n  RemoteFeatureFlagsProvider,\n  type RemoteFeatureFlagsProviderMessenger,\n} from './providers/remote-feature-flags/RemoteFeatureFlagsProvider';\nexport { safeMerge } from './safeMerge/safeMerge';\nexport { buildUrl } from './buildUrl/buildUrl';\nexport type { BuildUrlParams } from './buildUrl/buildUrl';\nexport { sanitizeControlCharacters, sanitizeUri } from './sanitize';\nexport { UrlStruct } from './urlStruct/urlStruct';\nexport {\n  batchesAll,\n  batchesAllSettled,\n  batchesAllSettledWithChunks,\n  batchesAllWithChunks,\n  chunks,\n} from './async';\nexport { Logger, LogLevel } from './logger';\nexport type {\n  LoggerOptions,\n  LoggerMethod,\n  LogMethod,\n  LogMethodDecorator,\n  LoggerDecorators,\n} from './logger';\nexport {\n  createOriginPermissions,\n  DEFAULT_PROD_ORIGINS,\n  DEFAULT_DEV_ORIGINS,\n  DEFAULT_METAMASK_ORIGIN,\n} from './originPermissions/createOriginPermissions';\nexport type { CreateOriginPermissionsParams } from './originPermissions/createOriginPermissions';\nexport { validateOrigin } from './originPermissions/validateOrigin';\n"]}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,cAAc,EAEf,8CAA0C;AAC3C,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAE3B,wEAAoE;AACrE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EAAE,QAAQ,EAAE,gCAA4B;AAE/C,OAAO,EAAE,yBAAyB,EAAE,WAAW,EAAE,uBAAmB;AACpE,OAAO,EAAE,SAAS,EAAE,kCAA8B;AAClD,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,2BAAiB;AAQ5C,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACxB,wDAAoD;AAErD,OAAO,EAAE,cAAc,EAAE,+CAA2C","sourcesContent":["export {\n  ASSETS_PROVIDER_NAME,\n  AssetsProvider,\n  type AssetsProviderMessenger,\n} from './providers/assets/AssetsProvider';\nexport {\n  REMOTE_FEATURE_FLAGS_PROVIDER_NAME,\n  RemoteFeatureFlagsProvider,\n  type RemoteFeatureFlagsProviderMessenger,\n} from './providers/remote-feature-flags/RemoteFeatureFlagsProvider';\nexport { safeMerge } from './safeMerge/safeMerge';\nexport { buildUrl } from './buildUrl/buildUrl';\nexport type { BuildUrlParams } from './buildUrl/buildUrl';\nexport { sanitizeControlCharacters, sanitizeUri } from './sanitize';\nexport { UrlStruct } from './urlStruct/urlStruct';\nexport { Logger, LogLevel } from './logger';\nexport type {\n  LoggerOptions,\n  LoggerMethod,\n  LogMethod,\n  LogMethodDecorator,\n  LoggerDecorators,\n} from './logger';\nexport {\n  createOriginPermissions,\n  DEFAULT_PROD_ORIGINS,\n  DEFAULT_DEV_ORIGINS,\n  DEFAULT_METAMASK_ORIGIN,\n} from './originPermissions/createOriginPermissions';\nexport type { CreateOriginPermissionsParams } from './originPermissions/createOriginPermissions';\nexport { validateOrigin } from './originPermissions/validateOrigin';\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamask-previews/snap-networks-utils",
-  "version": "1.0.0-preview-e79d811",
+  "version": "1.0.0-preview-8ff90d2f",
   "description": "Shared utilities for MetaMask network snaps",
   "keywords": [
     "Ethereum",

package/dist/async.cjs

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.chunks = chunks;
-exports.batchesAll = batchesAll;
-exports.batchesAllSettled = batchesAllSettled;
-exports.batchesAllSettledWithChunks = batchesAllSettledWithChunks;
-exports.batchesAllWithChunks = batchesAllWithChunks;
-/**
- * Splits items into chunks of a given size.
- *
- * @param items - Input items; order is preserved in the returned chunks.
- * @param chunkSize - Size of each chunk (must be ≥ 1).
- * @returns An array of chunks, each containing `chunkSize` items.
- */
-function chunks(items, chunkSize) {
-    if (chunkSize < 1) {
-        throw new RangeError('chunkSize must be at least 1');
-    }
-    const itemsChunks = [];
-    for (let index = 0; index < items.length; index += chunkSize) {
-        itemsChunks.push(items.slice(index, index + chunkSize));
-    }
-    return itemsChunks;
-}
-/**
- * Runs async work on items in fixed-size waves, using {@link Promise.all} per wave.
- * The next wave starts only after the current wave completes; any rejection fails the whole call.
- *
- * @param items - Input items; order is preserved in the returned results.
- * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).
- * @param mapper - Async function for each item; receives the global index in `items`.
- * @returns One result per item, in the same order as `items`.
- */
-async function batchesAll(items, batchSize, mapper) {
-    if (batchSize < 1) {
-        throw new RangeError('batchSize must be at least 1');
-    }
-    const results = [];
-    for (let index = 0; index < items.length; index += batchSize) {
-        const batch = items.slice(index, index + batchSize);
-        const batchResults = await Promise.all(batch.map(async (item, batchOffset) => mapper(item, index + batchOffset)));
-        results.push(...batchResults);
-    }
-    return results;
-}
-/**
- * Runs async work on items in fixed-size waves, using {@link Promise.allSettled} per wave.
- * The next wave starts only after the current one settles, limiting concurrency to `batchSize`.
- *
- * @param items - Input items; order is preserved in the returned results.
- * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).
- * @param mapper - Async function for each item; receives the global index in `items`.
- * @returns One settled result per item, in the same order as `items`.
- */
-async function batchesAllSettled(items, batchSize, mapper) {
-    if (batchSize < 1) {
-        throw new RangeError('batchSize must be at least 1');
-    }
-    const results = [];
-    for (let index = 0; index < items.length; index += batchSize) {
-        const batch = items.slice(index, index + batchSize);
-        const settled = await Promise.allSettled(batch.map(async (item, batchOffset) => mapper(item, index + batchOffset)));
-        results.push(...settled);
-    }
-    return results;
-}
-/**
- * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAllSettled} on those chunks.
- * Each mapper call receives one chunk; settled results are in chunk order (same order as {@link chunks}).
- *
- * @param items - Flat input items.
- * @param chunkSize - Items per chunk (must be ≥ 1).
- * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).
- * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).
- * @returns One settled result per chunk.
- */
-async function batchesAllSettledWithChunks(items, chunkSize, batchSize, mapper) {
-    const itemChunks = chunks(items, chunkSize);
-    return batchesAllSettled(itemChunks, batchSize, async (chunk, chunkIndex) => mapper(chunk, chunkIndex));
-}
-/**
- * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAll} on those chunks.
- * Each mapper call receives one chunk; results are in chunk order (same order as {@link chunks}).
- *
- * @param items - Flat input items.
- * @param chunkSize - Items per chunk (must be ≥ 1).
- * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).
- * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).
- * @returns One result per chunk.
- */
-async function batchesAllWithChunks(items, chunkSize, batchSize, mapper) {
-    const itemChunks = chunks(items, chunkSize);
-    return batchesAll(itemChunks, batchSize, async (chunk, chunkIndex) => mapper(chunk, chunkIndex));
-}
-//# sourceMappingURL=async.cjs.map

package/dist/async.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"async.cjs","sourceRoot":"","sources":["../src/async.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Splits items into chunks of a given size.\n *\n * @param items - Input items; order is preserved in the returned chunks.\n * @param chunkSize - Size of each chunk (must be ≥ 1).\n * @returns An array of chunks, each containing `chunkSize` items.\n */\nexport function chunks<TItem>(\n  items: readonly TItem[],\n  chunkSize: number,\n): TItem[][] {\n  if (chunkSize < 1) {\n    throw new RangeError('chunkSize must be at least 1');\n  }\n\n  const itemsChunks: TItem[][] = [];\n  for (let index = 0; index < items.length; index += chunkSize) {\n    itemsChunks.push(items.slice(index, index + chunkSize));\n  }\n  return itemsChunks;\n}\n\n/**\n * Runs async work on items in fixed-size waves, using {@link Promise.all} per wave.\n * The next wave starts only after the current wave completes; any rejection fails the whole call.\n *\n * @param items - Input items; order is preserved in the returned results.\n * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).\n * @param mapper - Async function for each item; receives the global index in `items`.\n * @returns One result per item, in the same order as `items`.\n */\nexport async function batchesAll<TItem, TResult>(\n  items: readonly TItem[],\n  batchSize: number,\n  mapper: (item: TItem, index: number) => Promise<TResult>,\n): Promise<TResult[]> {\n  if (batchSize < 1) {\n    throw new RangeError('batchSize must be at least 1');\n  }\n\n  const results: TResult[] = [];\n\n  for (let index = 0; index < items.length; index += batchSize) {\n    const batch = items.slice(index, index + batchSize);\n    const batchResults = await Promise.all(\n      batch.map(async (item, batchOffset) => mapper(item, index + batchOffset)),\n    );\n    results.push(...batchResults);\n  }\n\n  return results;\n}\n\n/**\n * Runs async work on items in fixed-size waves, using {@link Promise.allSettled} per wave.\n * The next wave starts only after the current one settles, limiting concurrency to `batchSize`.\n *\n * @param items - Input items; order is preserved in the returned results.\n * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).\n * @param mapper - Async function for each item; receives the global index in `items`.\n * @returns One settled result per item, in the same order as `items`.\n */\nexport async function batchesAllSettled<TItem, TResult>(\n  items: readonly TItem[],\n  batchSize: number,\n  mapper: (item: TItem, index: number) => Promise<TResult>,\n): Promise<PromiseSettledResult<TResult>[]> {\n  if (batchSize < 1) {\n    throw new RangeError('batchSize must be at least 1');\n  }\n\n  const results: PromiseSettledResult<TResult>[] = [];\n\n  for (let index = 0; index < items.length; index += batchSize) {\n    const batch = items.slice(index, index + batchSize);\n    const settled = await Promise.allSettled(\n      batch.map(async (item, batchOffset) => mapper(item, index + batchOffset)),\n    );\n    results.push(...settled);\n  }\n\n  return results;\n}\n\n/**\n * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAllSettled} on those chunks.\n * Each mapper call receives one chunk; settled results are in chunk order (same order as {@link chunks}).\n *\n * @param items - Flat input items.\n * @param chunkSize - Items per chunk (must be ≥ 1).\n * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).\n * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).\n * @returns One settled result per chunk.\n */\nexport async function batchesAllSettledWithChunks<TItem, TResult>(\n  items: readonly TItem[],\n  chunkSize: number,\n  batchSize: number,\n  mapper: (chunk: TItem[], chunkIndex: number) => Promise<TResult>,\n): Promise<PromiseSettledResult<TResult>[]> {\n  const itemChunks = chunks(items, chunkSize);\n  return batchesAllSettled(itemChunks, batchSize, async (chunk, chunkIndex) =>\n    mapper(chunk, chunkIndex),\n  );\n}\n\n/**\n * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAll} on those chunks.\n * Each mapper call receives one chunk; results are in chunk order (same order as {@link chunks}).\n *\n * @param items - Flat input items.\n * @param chunkSize - Items per chunk (must be ≥ 1).\n * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).\n * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).\n * @returns One result per chunk.\n */\nexport async function batchesAllWithChunks<TItem, TResult>(\n  items: readonly TItem[],\n  chunkSize: number,\n  batchSize: number,\n  mapper: (chunk: TItem[], chunkIndex: number) => Promise<TResult>,\n): Promise<TResult[]> {\n  const itemChunks = chunks(items, chunkSize);\n  return batchesAll(itemChunks, batchSize, async (chunk, chunkIndex) =>\n    mapper(chunk, chunkIndex),\n  );\n}\n"]}

package/dist/async.d.cts

@@ -1,51 +0,0 @@
-/**
- * Splits items into chunks of a given size.
- *
- * @param items - Input items; order is preserved in the returned chunks.
- * @param chunkSize - Size of each chunk (must be ≥ 1).
- * @returns An array of chunks, each containing `chunkSize` items.
- */
-export declare function chunks<TItem>(items: readonly TItem[], chunkSize: number): TItem[][];
-/**
- * Runs async work on items in fixed-size waves, using {@link Promise.all} per wave.
- * The next wave starts only after the current wave completes; any rejection fails the whole call.
- *
- * @param items - Input items; order is preserved in the returned results.
- * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).
- * @param mapper - Async function for each item; receives the global index in `items`.
- * @returns One result per item, in the same order as `items`.
- */
-export declare function batchesAll<TItem, TResult>(items: readonly TItem[], batchSize: number, mapper: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;
-/**
- * Runs async work on items in fixed-size waves, using {@link Promise.allSettled} per wave.
- * The next wave starts only after the current one settles, limiting concurrency to `batchSize`.
- *
- * @param items - Input items; order is preserved in the returned results.
- * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).
- * @param mapper - Async function for each item; receives the global index in `items`.
- * @returns One settled result per item, in the same order as `items`.
- */
-export declare function batchesAllSettled<TItem, TResult>(items: readonly TItem[], batchSize: number, mapper: (item: TItem, index: number) => Promise<TResult>): Promise<PromiseSettledResult<TResult>[]>;
-/**
- * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAllSettled} on those chunks.
- * Each mapper call receives one chunk; settled results are in chunk order (same order as {@link chunks}).
- *
- * @param items - Flat input items.
- * @param chunkSize - Items per chunk (must be ≥ 1).
- * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).
- * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).
- * @returns One settled result per chunk.
- */
-export declare function batchesAllSettledWithChunks<TItem, TResult>(items: readonly TItem[], chunkSize: number, batchSize: number, mapper: (chunk: TItem[], chunkIndex: number) => Promise<TResult>): Promise<PromiseSettledResult<TResult>[]>;
-/**
- * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAll} on those chunks.
- * Each mapper call receives one chunk; results are in chunk order (same order as {@link chunks}).
- *
- * @param items - Flat input items.
- * @param chunkSize - Items per chunk (must be ≥ 1).
- * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).
- * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).
- * @returns One result per chunk.
- */
-export declare function batchesAllWithChunks<TItem, TResult>(items: readonly TItem[], chunkSize: number, batchSize: number, mapper: (chunk: TItem[], chunkIndex: number) => Promise<TResult>): Promise<TResult[]>;
-//# sourceMappingURL=async.d.cts.map

package/dist/async.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"async.d.cts","sourceRoot":"","sources":["../src/async.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAC1B,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,SAAS,EAAE,MAAM,GAChB,KAAK,EAAE,EAAE,CAUX;AAED;;;;;;;;GAQG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,OAAO,EAC7C,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GACvD,OAAO,CAAC,OAAO,EAAE,CAAC,CAgBpB;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EACpD,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GACvD,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC,CAgB1C;AAED;;;;;;;;;GASG;AACH,wBAAsB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAC9D,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAC/D,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC,CAK1C;AAED;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EACvD,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAC/D,OAAO,CAAC,OAAO,EAAE,CAAC,CAKpB"}

package/dist/async.d.mts

@@ -1,51 +0,0 @@
-/**
- * Splits items into chunks of a given size.
- *
- * @param items - Input items; order is preserved in the returned chunks.
- * @param chunkSize - Size of each chunk (must be ≥ 1).
- * @returns An array of chunks, each containing `chunkSize` items.
- */
-export declare function chunks<TItem>(items: readonly TItem[], chunkSize: number): TItem[][];
-/**
- * Runs async work on items in fixed-size waves, using {@link Promise.all} per wave.
- * The next wave starts only after the current wave completes; any rejection fails the whole call.
- *
- * @param items - Input items; order is preserved in the returned results.
- * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).
- * @param mapper - Async function for each item; receives the global index in `items`.
- * @returns One result per item, in the same order as `items`.
- */
-export declare function batchesAll<TItem, TResult>(items: readonly TItem[], batchSize: number, mapper: (item: TItem, index: number) => Promise<TResult>): Promise<TResult[]>;
-/**
- * Runs async work on items in fixed-size waves, using {@link Promise.allSettled} per wave.
- * The next wave starts only after the current one settles, limiting concurrency to `batchSize`.
- *
- * @param items - Input items; order is preserved in the returned results.
- * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).
- * @param mapper - Async function for each item; receives the global index in `items`.
- * @returns One settled result per item, in the same order as `items`.
- */
-export declare function batchesAllSettled<TItem, TResult>(items: readonly TItem[], batchSize: number, mapper: (item: TItem, index: number) => Promise<TResult>): Promise<PromiseSettledResult<TResult>[]>;
-/**
- * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAllSettled} on those chunks.
- * Each mapper call receives one chunk; settled results are in chunk order (same order as {@link chunks}).
- *
- * @param items - Flat input items.
- * @param chunkSize - Items per chunk (must be ≥ 1).
- * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).
- * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).
- * @returns One settled result per chunk.
- */
-export declare function batchesAllSettledWithChunks<TItem, TResult>(items: readonly TItem[], chunkSize: number, batchSize: number, mapper: (chunk: TItem[], chunkIndex: number) => Promise<TResult>): Promise<PromiseSettledResult<TResult>[]>;
-/**
- * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAll} on those chunks.
- * Each mapper call receives one chunk; results are in chunk order (same order as {@link chunks}).
- *
- * @param items - Flat input items.
- * @param chunkSize - Items per chunk (must be ≥ 1).
- * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).
- * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).
- * @returns One result per chunk.
- */
-export declare function batchesAllWithChunks<TItem, TResult>(items: readonly TItem[], chunkSize: number, batchSize: number, mapper: (chunk: TItem[], chunkIndex: number) => Promise<TResult>): Promise<TResult[]>;
-//# sourceMappingURL=async.d.mts.map

package/dist/async.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"async.d.mts","sourceRoot":"","sources":["../src/async.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAC1B,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,SAAS,EAAE,MAAM,GAChB,KAAK,EAAE,EAAE,CAUX;AAED;;;;;;;;GAQG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,OAAO,EAC7C,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GACvD,OAAO,CAAC,OAAO,EAAE,CAAC,CAgBpB;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EACpD,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GACvD,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC,CAgB1C;AAED;;;;;;;;;GASG;AACH,wBAAsB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAC9D,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAC/D,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,EAAE,CAAC,CAK1C;AAED;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EACvD,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAC/D,OAAO,CAAC,OAAO,EAAE,CAAC,CAKpB"}

package/dist/async.mjs

@@ -1,88 +0,0 @@
-/**
- * Splits items into chunks of a given size.
- *
- * @param items - Input items; order is preserved in the returned chunks.
- * @param chunkSize - Size of each chunk (must be ≥ 1).
- * @returns An array of chunks, each containing `chunkSize` items.
- */
-export function chunks(items, chunkSize) {
-    if (chunkSize < 1) {
-        throw new RangeError('chunkSize must be at least 1');
-    }
-    const itemsChunks = [];
-    for (let index = 0; index < items.length; index += chunkSize) {
-        itemsChunks.push(items.slice(index, index + chunkSize));
-    }
-    return itemsChunks;
-}
-/**
- * Runs async work on items in fixed-size waves, using {@link Promise.all} per wave.
- * The next wave starts only after the current wave completes; any rejection fails the whole call.
- *
- * @param items - Input items; order is preserved in the returned results.
- * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).
- * @param mapper - Async function for each item; receives the global index in `items`.
- * @returns One result per item, in the same order as `items`.
- */
-export async function batchesAll(items, batchSize, mapper) {
-    if (batchSize < 1) {
-        throw new RangeError('batchSize must be at least 1');
-    }
-    const results = [];
-    for (let index = 0; index < items.length; index += batchSize) {
-        const batch = items.slice(index, index + batchSize);
-        const batchResults = await Promise.all(batch.map(async (item, batchOffset) => mapper(item, index + batchOffset)));
-        results.push(...batchResults);
-    }
-    return results;
-}
-/**
- * Runs async work on items in fixed-size waves, using {@link Promise.allSettled} per wave.
- * The next wave starts only after the current one settles, limiting concurrency to `batchSize`.
- *
- * @param items - Input items; order is preserved in the returned results.
- * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).
- * @param mapper - Async function for each item; receives the global index in `items`.
- * @returns One settled result per item, in the same order as `items`.
- */
-export async function batchesAllSettled(items, batchSize, mapper) {
-    if (batchSize < 1) {
-        throw new RangeError('batchSize must be at least 1');
-    }
-    const results = [];
-    for (let index = 0; index < items.length; index += batchSize) {
-        const batch = items.slice(index, index + batchSize);
-        const settled = await Promise.allSettled(batch.map(async (item, batchOffset) => mapper(item, index + batchOffset)));
-        results.push(...settled);
-    }
-    return results;
-}
-/**
- * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAllSettled} on those chunks.
- * Each mapper call receives one chunk; settled results are in chunk order (same order as {@link chunks}).
- *
- * @param items - Flat input items.
- * @param chunkSize - Items per chunk (must be ≥ 1).
- * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).
- * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).
- * @returns One settled result per chunk.
- */
-export async function batchesAllSettledWithChunks(items, chunkSize, batchSize, mapper) {
-    const itemChunks = chunks(items, chunkSize);
-    return batchesAllSettled(itemChunks, batchSize, async (chunk, chunkIndex) => mapper(chunk, chunkIndex));
-}
-/**
- * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAll} on those chunks.
- * Each mapper call receives one chunk; results are in chunk order (same order as {@link chunks}).
- *
- * @param items - Flat input items.
- * @param chunkSize - Items per chunk (must be ≥ 1).
- * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).
- * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).
- * @returns One result per chunk.
- */
-export async function batchesAllWithChunks(items, chunkSize, batchSize, mapper) {
-    const itemChunks = chunks(items, chunkSize);
-    return batchesAll(itemChunks, batchSize, async (chunk, chunkIndex) => mapper(chunk, chunkIndex));
-}
-//# sourceMappingURL=async.mjs.map

package/dist/async.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"async.mjs","sourceRoot":"","sources":["../src/async.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Splits items into chunks of a given size.\n *\n * @param items - Input items; order is preserved in the returned chunks.\n * @param chunkSize - Size of each chunk (must be ≥ 1).\n * @returns An array of chunks, each containing `chunkSize` items.\n */\nexport function chunks<TItem>(\n  items: readonly TItem[],\n  chunkSize: number,\n): TItem[][] {\n  if (chunkSize < 1) {\n    throw new RangeError('chunkSize must be at least 1');\n  }\n\n  const itemsChunks: TItem[][] = [];\n  for (let index = 0; index < items.length; index += chunkSize) {\n    itemsChunks.push(items.slice(index, index + chunkSize));\n  }\n  return itemsChunks;\n}\n\n/**\n * Runs async work on items in fixed-size waves, using {@link Promise.all} per wave.\n * The next wave starts only after the current wave completes; any rejection fails the whole call.\n *\n * @param items - Input items; order is preserved in the returned results.\n * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).\n * @param mapper - Async function for each item; receives the global index in `items`.\n * @returns One result per item, in the same order as `items`.\n */\nexport async function batchesAll<TItem, TResult>(\n  items: readonly TItem[],\n  batchSize: number,\n  mapper: (item: TItem, index: number) => Promise<TResult>,\n): Promise<TResult[]> {\n  if (batchSize < 1) {\n    throw new RangeError('batchSize must be at least 1');\n  }\n\n  const results: TResult[] = [];\n\n  for (let index = 0; index < items.length; index += batchSize) {\n    const batch = items.slice(index, index + batchSize);\n    const batchResults = await Promise.all(\n      batch.map(async (item, batchOffset) => mapper(item, index + batchOffset)),\n    );\n    results.push(...batchResults);\n  }\n\n  return results;\n}\n\n/**\n * Runs async work on items in fixed-size waves, using {@link Promise.allSettled} per wave.\n * The next wave starts only after the current one settles, limiting concurrency to `batchSize`.\n *\n * @param items - Input items; order is preserved in the returned results.\n * @param batchSize - Maximum concurrent mapper invocations per wave (must be ≥ 1).\n * @param mapper - Async function for each item; receives the global index in `items`.\n * @returns One settled result per item, in the same order as `items`.\n */\nexport async function batchesAllSettled<TItem, TResult>(\n  items: readonly TItem[],\n  batchSize: number,\n  mapper: (item: TItem, index: number) => Promise<TResult>,\n): Promise<PromiseSettledResult<TResult>[]> {\n  if (batchSize < 1) {\n    throw new RangeError('batchSize must be at least 1');\n  }\n\n  const results: PromiseSettledResult<TResult>[] = [];\n\n  for (let index = 0; index < items.length; index += batchSize) {\n    const batch = items.slice(index, index + batchSize);\n    const settled = await Promise.allSettled(\n      batch.map(async (item, batchOffset) => mapper(item, index + batchOffset)),\n    );\n    results.push(...settled);\n  }\n\n  return results;\n}\n\n/**\n * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAllSettled} on those chunks.\n * Each mapper call receives one chunk; settled results are in chunk order (same order as {@link chunks}).\n *\n * @param items - Flat input items.\n * @param chunkSize - Items per chunk (must be ≥ 1).\n * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).\n * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).\n * @returns One settled result per chunk.\n */\nexport async function batchesAllSettledWithChunks<TItem, TResult>(\n  items: readonly TItem[],\n  chunkSize: number,\n  batchSize: number,\n  mapper: (chunk: TItem[], chunkIndex: number) => Promise<TResult>,\n): Promise<PromiseSettledResult<TResult>[]> {\n  const itemChunks = chunks(items, chunkSize);\n  return batchesAllSettled(itemChunks, batchSize, async (chunk, chunkIndex) =>\n    mapper(chunk, chunkIndex),\n  );\n}\n\n/**\n * Splits `items` into consecutive chunks of `chunkSize`, then runs {@link batchesAll} on those chunks.\n * Each mapper call receives one chunk; results are in chunk order (same order as {@link chunks}).\n *\n * @param items - Flat input items.\n * @param chunkSize - Items per chunk (must be ≥ 1).\n * @param batchSize - Max concurrent chunk mappers per wave (must be ≥ 1).\n * @param mapper - Async work for a single chunk; second argument is the chunk index (0-based).\n * @returns One result per chunk.\n */\nexport async function batchesAllWithChunks<TItem, TResult>(\n  items: readonly TItem[],\n  chunkSize: number,\n  batchSize: number,\n  mapper: (chunk: TItem[], chunkIndex: number) => Promise<TResult>,\n): Promise<TResult[]> {\n  const itemChunks = chunks(items, chunkSize);\n  return batchesAll(itemChunks, batchSize, async (chunk, chunkIndex) =>\n    mapper(chunk, chunkIndex),\n  );\n}\n"]}