@tstdl/base 0.91.0-beta9 → 0.91.1

package/enumerable/async-enumerable.d.ts

@@ -2,7 +2,7 @@ import type { CancellationSignal } from '../cancellation/token.js';
 import type { AnyIterable } from '../utils/any-iterable-iterator.js';
 import type { AsyncComparator } from '../utils/sort.js';
 import type { Observable } from 'rxjs';
-import type { AsyncIteratorFunction, AsyncPredicate, AsyncReducer, AsyncRetryPredicate, ParallelizableIteratorFunction, ParallelizablePredicate, ThrottleFunction } from '../utils/async-iterable-helpers/index.js';
+import type { AsyncGroupSelectors, AsyncIteratorFunction, AsyncPredicate, AsyncReducer, AsyncRetryPredicate, ParallelizableIteratorFunction, ParallelizablePredicate, ThrottleFunction } from '../utils/async-iterable-helpers/index.js';
 import type { IterableItemMetadata, TypePredicate } from '../utils/iterable-helpers/index.js';
 import type { EnumerableMethods } from './enumerable-methods.js';
 import { Enumerable } from './enumerable.js';
@@ -33,9 +33,13 @@ export declare class AsyncEnumerable<T> implements EnumerableMethods, AsyncItera
     forceCast<TNew>(): AsyncEnumerable<TNew>;
     forEach(func: AsyncIteratorFunction<T, any>): Promise<void>;
     group<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): AsyncEnumerable<[TGroup, T[]]>;
+    group<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): AsyncEnumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]]>;
     groupSingle<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): AsyncEnumerable<[TGroup, T]>;
+    groupSingle<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): AsyncEnumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T]>;
     groupToMap<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): Promise<Map<TGroup, T[]>>;
+    groupToMap<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): Promise<Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]>>;
     groupToSingleMap<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): Promise<Map<TGroup, T>>;
+    groupToSingleMap<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): Promise<Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T>>;
     tap(tapper: AsyncIteratorFunction<T, any>): AsyncEnumerable<T>;
     interruptEvery(value: number): AsyncEnumerable<T>;
     interruptPerSecond(value: number): AsyncEnumerable<T>;

package/enumerable/async-enumerable.js

@@ -91,19 +91,19 @@ export class AsyncEnumerable {
     async forEach(func) {
         await forEachAsync(this.source, func);
     }
-    group(selector) {
-        const grouped = groupAsync(this.source, selector);
+    group(...selectors) {
+        const grouped = groupAsync(this.source, ...selectors);
         return new AsyncEnumerable(grouped);
     }
-    groupSingle(selector) {
-        const grouped = groupSingleAsync(this.source, selector);
+    groupSingle(...selectors) {
+        const grouped = groupSingleAsync(this.source, ...selectors);
         return new AsyncEnumerable(grouped);
     }
-    async groupToMap(selector) {
-        return groupToMapAsync(this.source, selector);
+    async groupToMap(...selectors) {
+        return groupToMapAsync(this.source, ...selectors);
     }
-    async groupToSingleMap(selector) {
-        return groupToSingleMapAsync(this.source, selector);
+    async groupToSingleMap(...selectors) {
+        return groupToSingleMapAsync(this.source, ...selectors);
     }
     tap(tapper) {
         const iterator = tapAsync(this.source, tapper);

package/enumerable/enumerable.d.ts

@@ -1,6 +1,6 @@
 import type { CancellationSignal } from '../cancellation/token.js';
 import type { Comparator } from '../utils/sort.js';
-import type { IterableItemMetadata, IteratorFunction, Predicate, Reducer, TypePredicate } from '../utils/iterable-helpers/index.js';
+import type { GroupSelectors, IterableItemMetadata, IteratorFunction, Predicate, Reducer, TypePredicate } from '../utils/iterable-helpers/index.js';
 import { AsyncEnumerable } from './async-enumerable.js';
 import type { EnumerableMethods } from './enumerable-methods.js';
 export declare class Enumerable<T> implements EnumerableMethods, Iterable<T> {
@@ -28,9 +28,13 @@ export declare class Enumerable<T> implements EnumerableMethods, Iterable<T> {
     forEach(func: IteratorFunction<T, void>): void;
     forceCast<TNew>(): Enumerable<TNew>;
     group<TGroup>(selector: IteratorFunction<T, TGroup>): Enumerable<[TGroup, T[]]>;
+    group<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Enumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]]>;
     groupSingle<TGroup>(selector: IteratorFunction<T, TGroup>): Enumerable<[TGroup, T]>;
+    groupSingle<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Enumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T]>;
     groupToMap<TGroup>(selector: IteratorFunction<T, TGroup>): Map<TGroup, T[]>;
+    groupToMap<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]>;
     groupToSingleMap<TGroup>(selector: IteratorFunction<T, TGroup>): Map<TGroup, T>;
+    groupToSingleMap<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T>;
     tap(tapper: IteratorFunction<T, any>): Enumerable<T>;
     last<TPredicate extends T = T>(predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate;
     lastOrDefault<D, TPredicate extends T = T>(defaultValue: D, predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate | D;

package/enumerable/enumerable.js

@@ -79,19 +79,19 @@ export class Enumerable {
     forceCast() {
         return this;
     }
-    group(selector) {
-        const grouped = group(this.source, selector);
+    group(...selectors) {
+        const grouped = group(this.source, ...selectors);
         return new Enumerable(grouped);
     }
-    groupSingle(selector) {
-        const grouped = groupSingle(this.source, selector);
+    groupSingle(...selectors) {
+        const grouped = groupSingle(this.source, ...selectors);
         return new Enumerable(grouped);
     }
-    groupToMap(selector) {
-        return groupToMap(this.source, selector);
+    groupToMap(...selectors) {
+        return groupToMap(this.source, ...selectors);
     }
-    groupToSingleMap(selector) {
-        return groupToSingleMap(this.source, selector);
+    groupToSingleMap(...selectors) {
+        return groupToSingleMap(this.source, ...selectors);
     }
     tap(tapper) {
         const iterator = tap(this.source, tapper);

package/intl/number-parser.d.ts

@@ -14,5 +14,5 @@ export declare class NumberParser {
      */
     parse(value: string, loose?: boolean): number;
 }
-export declare const getNumberParser: (locale: string) => InstanceType<typeof NumberParser>;
+export declare const getNumberParser: (locale: string) => NumberParser;
 export declare function parseNumber(locale: string, value: string, loose?: boolean): number;

package/object-storage/s3/s3.object-storage-provider.d.ts

@@ -2,27 +2,27 @@ import { ObjectStorageProvider } from '../../object-storage/index.js';
 import { S3ObjectStorage } from './s3.object-storage.js';
 export declare class S3ObjectStorageProviderConfig {
     /**
-     * s3 endpoint
+     * S3 endpoint
      */
     endpoint: string;
     /**
-     * s3 bucket, use a single bucket for all modules (which will become transparent key prefixes)
+     * S3 bucket, use a single bucket for all modules (which will become transparent key prefixes)
      *
      * mutually exclusive with bucketPerModule
      */
     bucket?: string;
     /**
-     * use an own bucket for every module
+     * Use an own bucket for every module
      *
      * mutually exclusive with bucket
      */
     bucketPerModule?: boolean;
     /**
-     * s3 access key
+     * S3 access key
      */
     accessKey: string;
     /**
-     * s3 secret key
+     * S3 secret key
      */
     secretKey: string;
 }
@@ -34,7 +34,7 @@ export declare class S3ObjectStorageProvider extends ObjectStorageProvider<S3Obj
     get(module: string): S3ObjectStorage;
 }
 /**
- * configure s3 object storage provider
+ * Configure s3 object storage provider
  * @param config s3 config
  * @param register whether to register for {@link ObjectStorage} and {@link ObjectStorageProvider}
  */

package/object-storage/s3/s3.object-storage-provider.js

@@ -15,27 +15,27 @@ import { Client } from 'minio';
 import { S3ObjectStorage } from './s3.object-storage.js';
 export class S3ObjectStorageProviderConfig {
     /**
-     * s3 endpoint
+     * S3 endpoint
      */
     endpoint;
     /**
-     * s3 bucket, use a single bucket for all modules (which will become transparent key prefixes)
+     * S3 bucket, use a single bucket for all modules (which will become transparent key prefixes)
      *
      * mutually exclusive with bucketPerModule
      */
     bucket;
     /**
-     * use an own bucket for every module
+     * Use an own bucket for every module
      *
      * mutually exclusive with bucket
      */
     bucketPerModule;
     /**
-     * s3 access key
+     * S3 access key
      */
     accessKey;
     /**
-     * s3 secret key
+     * S3 secret key
      */
     secretKey;
 }
@@ -70,7 +70,7 @@ S3ObjectStorageProvider = __decorate([
 ], S3ObjectStorageProvider);
 export { S3ObjectStorageProvider };
 /**
- * configure s3 object storage provider
+ * Configure s3 object storage provider
  * @param config s3 config
  * @param register whether to register for {@link ObjectStorage} and {@link ObjectStorageProvider}
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.0-beta9",
+  "version": "0.91.1",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -111,7 +111,7 @@
     "luxon": "^3.4",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.22"
+    "type-fest": "4.23"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -123,7 +123,7 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "7.16",
+    "@typescript-eslint/eslint-plugin": "7.17",
     "concurrently": "8.2",
     "eslint": "8.57",
     "eslint-import-resolver-typescript": "3.6",
@@ -147,11 +147,11 @@
     "koa": "^2.15",
     "minio": "^8.0",
     "mjml": "^4.15",
-    "mongodb": "^6.7",
+    "mongodb": "^6.8",
     "nodemailer": "^6.9",
     "pg": "^8.12",
     "playwright": "^1.45",
-    "preact": "^10.22",
+    "preact": "^10.23",
     "preact-render-to-string": "^6.5",
     "undici": "^6.19",
     "urlpattern-polyfill": "^10.0"

package/schema/schema.d.ts

@@ -19,10 +19,11 @@ export type SchemaTestResult<T> = {
     error: SchemaError;
 };
 type NormalizePrimitiveToConstructor<T> = Or<IsEqual<T, string>, IsEqual<T, String>> extends true ? typeof String : Or<IsEqual<T, number>, IsEqual<T, Number>> extends true ? typeof Number : Or<IsEqual<T, boolean>, IsEqual<T, Boolean>> extends true ? typeof Boolean : Or<IsEqual<T, bigint>, IsEqual<T, BigInt>> extends true ? typeof BigInt : Or<IsEqual<T, symbol>, IsEqual<T, Symbol>> extends true ? typeof Symbol : never;
-type NormalizeConstructorToPrimitve<T> = T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : T extends BigInt ? bigint : T extends Symbol ? symbol : T;
 export type SchemaTestable<T = unknown> = Schema<T> | AbstractConstructor<T> | NormalizePrimitiveToConstructor<T>;
-export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? NormalizeConstructorToPrimitve<U> : never;
+export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? U : never;
+export declare const OPTIONAL: unique symbol;
 export declare abstract class Schema<T = unknown> {
+    readonly [OPTIONAL]: boolean;
     /**
      * Test an unknown value to see whether it corresponds to the schema.
      * @param schema schema to test against

package/schema/schemas/array.js

@@ -11,16 +11,18 @@ export class ArraySchema extends Schema {
         this.itemSchema = schemaTestableToSchema(itemSchema);
     }
     _test(value, path, options) {
-        if (isArray(value)) {
-            for (let i = 0; i < value.length; i++) {
-                const result = this.itemSchema._test(value[i], path.add(i), options);
-                if (!result.valid) {
-                    return result;
-                }
+        if (!isArray(value)) {
+            return { valid: false, error: SchemaError.expectedButGot('array', typeOf(value), path) };
+        }
+        const values = [];
+        for (let i = 0; i < value.length; i++) {
+            const result = this.itemSchema._test(value[i], path.add(i), options);
+            if (!result.valid) {
+                return result;
             }
-            return { valid: true, value: value };
+            values.push(result.value);
         }
-        return { valid: false, error: SchemaError.expectedButGot('array', typeOf(value), path) };
+        return { valid: true, value: values };
     }
 }
 export function array(schema) {

package/schema/schemas/object.d.ts

@@ -3,7 +3,7 @@ import type { JsonPath } from '../../json-path/json-path.js';
 import type { AbstractConstructor, OneOrMany, PartialProperty, Record as RecordType, SimplifyObject, Type, TypedOmit } from '../../types.js';
 import { type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
 import type { SchemaPropertyDecorator } from '../decorators/types.js';
-import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import { type OPTIONAL, Schema, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type Record<K extends PropertyKey = PropertyKey, V = any> = RecordType<K, V>;
 export type ObjectSchemaFactoryFunction<T> = (data: T) => T;
 export type ObjectSchemaFactory<T> = {
@@ -22,6 +22,14 @@ export type ObjectSchemaOptions<T extends Record = Record, K extends PropertyKey
     factory?: ObjectSchemaFactory<T> | null;
 };
 export type ObjectSchemaOrType<T extends Record = any> = ObjectSchema<T> | AbstractConstructor<T>;
+export type OptionalProperties<T> = {
+    [P in keyof T]: T[P] extends {
+        [OPTIONAL]: true;
+    } ? P : never;
+}[keyof T];
+export type ObjectSchemaPropertiesType<TP extends ObjectSchemaProperties> = SimplifyObject<{
+    [P in keyof PartialProperty<TP, OptionalProperties<TP>>]: SchemaOutput<TP[P]>;
+}>;
 export declare const tryGetSchemaFromReflection: typeof _tryGetSchemaFromReflection;
 export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
     private readonly propertyKeys;
@@ -46,21 +54,21 @@ export declare function object<const V>(properties: Record<never>, options: Obje
     unknownProperties: SchemaTestable<V>;
     unknownPropertiesKey?: undefined;
 }): ObjectSchema<Record<PropertyKey, V>>;
-export declare function object<const T extends Record, const K extends PropertyKey, const V>(properties: ObjectSchemaProperties<T>, options: ObjectSchemaOptions<T & Record<K, V>> & {
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, V>> & {
     unknownProperties: SchemaTestable<V>;
     unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<SimplifyObject<T & Record<K, V>>>;
-export declare function object<const T extends Record, const K extends PropertyKey>(properties: ObjectSchemaProperties<T>, options: ObjectSchemaOptions<T & Record<K, unknown>> & {
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, V>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, unknown>> & {
     unknownPropertiesKey: SchemaTestable<K>;
-}): ObjectSchema<SimplifyObject<T & Record<K, unknown>>>;
-export declare function object<const T extends Record, const V>(properties: ObjectSchemaProperties<T>, options: ObjectSchemaOptions<T & Record<PropertyKey, V>> & {
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, unknown>>;
+export declare function object<const TP extends ObjectSchemaProperties, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<PropertyKey, V>> & {
     unknownProperties: SchemaTestable<V>;
-}): ObjectSchema<SimplifyObject<T & Record<PropertyKey, V>>>;
-export declare function object<const T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T> & {
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<PropertyKey, V>>;
+export declare function object<const TP extends ObjectSchemaProperties>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>> & {
     unknownProperties?: undefined;
     unknownPropertiesKey?: undefined;
-}): ObjectSchema<T>;
-export declare function object<const T extends Record, const K extends PropertyKey, const V>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T, K, V>): ObjectSchema<SimplifyObject<T & Record<K, V>>>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>, K, V>): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, V>>;
 export declare function explicitObject<const T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>): ObjectSchema<T>;
 export declare function record<const K extends PropertyKey, const V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Record<K, V>>;
 export declare function assign<const T1 extends Record, const T2 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>): ObjectSchema<Merge<T1, T2>>;
@@ -73,7 +81,7 @@ export declare function partial<const T extends Record, const K extends keyof T>
 export declare function pick<const T extends Record, const K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Pick<T, K>>>;
 export declare function omit<const T extends Record, const K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
 export declare function getSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T>;
-declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | null;
+declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | ObjectSchema<T> | null;
 export declare function getObjectSchema<T extends Record>(schemaOrType: SchemaTestable<T>): ObjectSchema<T>;
 export declare function Record<K extends PropertyKey, V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
 export declare const emptyObjectSchema: ObjectSchema<EmptyObject>;

package/schema/schemas/optional.d.ts

@@ -1,8 +1,9 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import { TypedOmit } from '../../types.js';
+import type { TypedOmit } from '../../types.js';
 import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
-import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import { type OPTIONAL, Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export declare class OptionalSchema<T> extends Schema<T | undefined> {
+    readonly [OPTIONAL]: true;
     readonly schema: Schema<T>;
     constructor(schema: SchemaTestable<T>);
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | undefined>;

package/utils/async-iterable-helpers/group-single.d.ts

@@ -1,3 +1,4 @@
 import type { AnyIterable } from '../any-iterable-iterator.js';
-import type { AsyncIteratorFunction } from './types.js';
+import type { AsyncGroupSelectors, AsyncIteratorFunction } from './types.js';
 export declare function groupSingleAsync<TIn, TGroup>(iterable: AnyIterable<TIn>, selector: AsyncIteratorFunction<TIn, TGroup>): AsyncIterableIterator<[TGroup, TIn]>;
+export declare function groupSingleAsync<TIn, TGroup extends [any, ...any[]]>(iterable: AnyIterable<TIn>, ...selectors: AsyncGroupSelectors<TIn, TGroup>): AsyncIterableIterator<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn]>;

package/utils/async-iterable-helpers/group-single.js

@@ -1,4 +1,4 @@
 import { groupToSingleMapAsync } from './group-to-single-map.js';
-export async function* groupSingleAsync(iterable, selector) {
-    yield* await groupToSingleMapAsync(iterable, selector);
+export async function* groupSingleAsync(iterable, ...selectors) {
+    yield* await groupToSingleMapAsync(iterable, ...selectors);
 }

package/utils/async-iterable-helpers/group-to-map.d.ts

@@ -1,3 +1,4 @@
 import type { AnyIterable } from '../any-iterable-iterator.js';
-import type { AsyncIteratorFunction } from './types.js';
+import type { AsyncGroupSelectors, AsyncIteratorFunction } from './types.js';
 export declare function groupToMapAsync<TIn, TGroup>(iterable: AnyIterable<TIn>, selector: AsyncIteratorFunction<TIn, TGroup>): Promise<Map<TGroup, TIn[]>>;
+export declare function groupToMapAsync<TIn, TGroup extends [any, ...any[]]>(iterable: AnyIterable<TIn>, ...selectors: AsyncGroupSelectors<TIn, TGroup>): Promise<Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn[]>>;

package/utils/async-iterable-helpers/group-to-map.js

@@ -1,30 +1,57 @@
+import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
 import { isAsyncIterable } from './is-async-iterable.js';
-export async function groupToMapAsync(iterable, selector) {
+export async function groupToMapAsync(iterable, ...selectors) {
     return isAsyncIterable(iterable)
-        ? async(iterable, selector)
-        : sync(iterable, selector);
+        ? async(iterable, ...selectors)
+        : sync(iterable, ...selectors);
 }
-async function async(iterable, selector) {
-    const map = new Map();
+async function async(iterable, ...selectors) {
     let index = 0;
+    if (selectors.length == 1) {
+        const selector = selectors[0];
+        const map = new Map();
+        for await (const item of iterable) {
+            const groupKey = await selector(item, index++);
+            if (!map.has(groupKey)) {
+                map.set(groupKey, []);
+            }
+            map.get(groupKey).push(item);
+        }
+        return map;
+    }
+    const map = new MultiKeyMap();
     for await (const item of iterable) {
-        const groupKey = await selector(item, index++);
-        if (!map.has(groupKey)) {
-            map.set(groupKey, []);
+        const groupKeys = await Promise.all(selectors.map(async (selector) => selector(item, index))); // eslint-disable-line @typescript-eslint/no-loop-func
+        index++;
+        if (!map.has(groupKeys)) {
+            map.set(groupKeys, []);
         }
-        map.get(groupKey).push(item);
+        map.get(groupKeys).push(item);
     }
-    return map;
+    return map.toMap();
 }
-async function sync(iterable, selector) {
-    const map = new Map();
+async function sync(iterable, ...selectors) {
     let index = 0;
+    if (selectors.length == 1) {
+        const selector = selectors[0];
+        const map = new Map();
+        for (const item of iterable) {
+            const groupKey = await selector(item, index++);
+            if (!map.has(groupKey)) {
+                map.set(groupKey, []);
+            }
+            map.get(groupKey).push(item);
+        }
+        return map;
+    }
+    const map = new MultiKeyMap();
     for (const item of iterable) {
-        const groupKey = await selector(item, index++);
-        if (!map.has(groupKey)) {
-            map.set(groupKey, []);
+        const groupKeys = await Promise.all(selectors.map(async (selector) => selector(item, index))); // eslint-disable-line @typescript-eslint/no-loop-func
+        index++;
+        if (!map.has(groupKeys)) {
+            map.set(groupKeys, []);
         }
-        map.get(groupKey).push(item);
+        map.get(groupKeys).push(item);
     }
-    return map;
+    return map.toMap();
 }

package/utils/async-iterable-helpers/group-to-single-map.d.ts

@@ -1,3 +1,4 @@
 import type { AnyIterable } from '../any-iterable-iterator.js';
-import type { AsyncIteratorFunction } from './types.js';
+import type { AsyncGroupSelectors, AsyncIteratorFunction } from './types.js';
 export declare function groupToSingleMapAsync<TIn, TGroup>(iterable: AnyIterable<TIn>, selector: AsyncIteratorFunction<TIn, TGroup>): Promise<Map<TGroup, TIn>>;
+export declare function groupToSingleMapAsync<TIn, TGroup extends [any, ...any[]]>(iterable: AnyIterable<TIn>, ...selectors: AsyncGroupSelectors<TIn, TGroup>): Promise<Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn>>;

package/utils/async-iterable-helpers/group-to-single-map.js

@@ -1,30 +1,57 @@
+import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
 import { isAsyncIterable } from './is-async-iterable.js';
-export async function groupToSingleMapAsync(iterable, selector) {
+export async function groupToSingleMapAsync(iterable, ...selectors) {
     return isAsyncIterable(iterable)
-        ? async(iterable, selector)
-        : sync(iterable, selector);
+        ? async(iterable, ...selectors)
+        : sync(iterable, ...selectors);
 }
-async function async(iterable, selector) {
-    const map = new Map();
+async function async(iterable, ...selectors) {
     let index = 0;
+    if (selectors.length == 1) {
+        const selector = selectors[0];
+        const map = new Map();
+        for await (const item of iterable) {
+            const groupKey = await selector(item, index++);
+            if (map.has(groupKey)) {
+                throw new Error(`Group ${String(groupKey)} has more than one item.`);
+            }
+            map.set(groupKey, item);
+        }
+        return map;
+    }
+    const map = new MultiKeyMap();
     for await (const item of iterable) {
-        const groupKey = await selector(item, index++);
-        if (map.has(groupKey)) {
-            throw new Error('group has more than one item');
+        const groupKeys = await Promise.all(selectors.map(async (selector) => selector(item, index))); // eslint-disable-line @typescript-eslint/no-loop-func
+        index++;
+        if (map.has(groupKeys)) {
+            throw new Error(`Group [${groupKeys.map((key) => String(key)).join(', ')}] has more than one item.`);
         }
-        map.set(groupKey, item);
+        map.set(groupKeys, item);
     }
-    return map;
+    return map.toMap();
 }
-async function sync(iterable, selector) {
-    const map = new Map();
+async function sync(iterable, ...selectors) {
     let index = 0;
+    if (selectors.length == 1) {
+        const selector = selectors[0];
+        const map = new Map();
+        for (const item of iterable) {
+            const groupKey = await selector(item, index++);
+            if (map.has(groupKey)) {
+                throw new Error(`Group ${String(groupKey)} has more than one item.`);
+            }
+            map.set(groupKey, item);
+        }
+        return map;
+    }
+    const map = new MultiKeyMap();
     for (const item of iterable) {
-        const groupKey = await selector(item, index++);
-        if (map.has(groupKey)) {
-            throw new Error('group has more than one item');
+        const groupKeys = await Promise.all(selectors.map(async (selector) => selector(item, index))); // eslint-disable-line @typescript-eslint/no-loop-func
+        index++;
+        if (map.has(groupKeys)) {
+            throw new Error(`Group [${groupKeys.map((key) => String(key)).join(', ')}] has more than one item.`);
         }
-        map.set(groupKey, item);
+        map.set(groupKeys, item);
     }
-    return map;
+    return map.toMap();
 }

package/utils/async-iterable-helpers/group.d.ts

@@ -1,3 +1,4 @@
 import type { AnyIterable } from '../any-iterable-iterator.js';
-import type { AsyncIteratorFunction } from './types.js';
+import type { AsyncGroupSelectors, AsyncIteratorFunction } from './types.js';
 export declare function groupAsync<TIn, TGroup>(iterable: AnyIterable<TIn>, selector: AsyncIteratorFunction<TIn, TGroup>): AsyncIterableIterator<[TGroup, TIn[]]>;
+export declare function groupAsync<TIn, TGroup extends [any, ...any[]]>(iterable: AnyIterable<TIn>, ...selectors: AsyncGroupSelectors<TIn, TGroup>): AsyncIterableIterator<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn[]]>;

package/utils/async-iterable-helpers/group.js

@@ -1,4 +1,4 @@
 import { groupToMapAsync } from './group-to-map.js';
-export async function* groupAsync(iterable, selector) {
-    yield* await groupToMapAsync(iterable, selector);
+export async function* groupAsync(iterable, ...selectors) {
+    yield* await groupToMapAsync(iterable, ...selectors);
 }

package/utils/async-iterable-helpers/types.d.ts

@@ -3,6 +3,9 @@ export type AsyncIteratorFunction<TIn, TOut> = (item: TIn, index: number) => TOu
 export type AsyncPredicate<T> = (item: T, index: number) => boolean | Promise<boolean>;
 export type AsyncRetryPredicate<T> = (error: Error, item: T, index: number) => boolean | Promise<boolean>;
 export type AsyncReducer<T, U> = (previous: U, current: T, index: number) => U | Promise<U>;
+export type AsyncGroupSelectors<T, TGroup extends any[]> = {
+    [P in keyof TGroup]: AsyncIteratorFunction<T, TGroup[P]>;
+};
 export type ParallelizableIteratorFunction<TIn, TOut> = (item: TIn, index: number) => Promise<TOut>;
 export type ParallelizablePredicate<T> = ParallelizableIteratorFunction<T, boolean>;
 export type ThrottleFunction = () => Promise<void>;

package/utils/iterable-helpers/group-single.d.ts

@@ -1,2 +1,3 @@
-import type { IteratorFunction } from './types.js';
+import type { GroupSelectors, IteratorFunction } from './types.js';
 export declare function groupSingle<TIn, TGroup>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, TGroup>): IterableIterator<[TGroup, TIn]>;
+export declare function groupSingle<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): IterableIterator<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn]>;

package/utils/iterable-helpers/group-single.js

@@ -1,4 +1,4 @@
 import { groupToSingleMap } from './group-to-single-map.js';
-export function groupSingle(iterable, selector) {
-    return groupToSingleMap(iterable, selector)[Symbol.iterator]();
+export function groupSingle(iterable, ...selectors) {
+    return groupToSingleMap(iterable, ...selectors)[Symbol.iterator]();
 }

package/utils/iterable-helpers/group-to-map.d.ts

@@ -1,2 +1,3 @@
-import type { IteratorFunction } from './types.js';
+import type { GroupSelectors, IteratorFunction } from './types.js';
 export declare function groupToMap<TIn, TGroup>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, TGroup>): Map<TGroup, TIn[]>;
+export declare function groupToMap<TIn, TGroup extends [any, ...any[]]>(iterable: Iterable<TIn>, ...selectors: GroupSelectors<TIn, TGroup>): Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, TIn[]>;

package/utils/iterable-helpers/group-to-map.js

@@ -1,12 +1,26 @@
-export function groupToMap(iterable, selector) {
-    const map = new Map();
+import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
+export function groupToMap(iterable, ...selectors) {
     let index = 0;
+    if (selectors.length == 1) {
+        const selector = selectors[0];
+        const map = new Map();
+        for (const item of iterable) {
+            const groupKey = selector(item, index++);
+            if (!map.has(groupKey)) {
+                map.set(groupKey, []);
+            }
+            map.get(groupKey).push(item);
+        }
+        return map;
+    }
+    const map = new MultiKeyMap();
     for (const item of iterable) {
-        const groupKey = selector(item, index++);
-        if (!map.has(groupKey)) {
-            map.set(groupKey, []);
+        const groupKeys = selectors.map((selector) => selector(item, index)); // eslint-disable-line @typescript-eslint/no-loop-func
+        index++;
+        if (!map.has(groupKeys)) {
+            map.set(groupKeys, []);
         }
-        map.get(groupKey).push(item);
+        map.get(groupKeys).push(item);
     }
-    return map;
+    return map.toMap();
 }