@tstdl/base 0.91.0-beta8 → 0.91.0

package/authentication/authentication.api.d.ts

@@ -1,5 +1,5 @@
 import { type ApiDefinition } from '../api/types.js';
-import { type ObjectSchema, type ObjectSchemaOrType } from '../schema/index.js';
+import { ObjectSchema, type ObjectSchemaOrType } from '../schema/index.js';
 import type { SchemaTestable } from '../schema/schema.js';
 import type { Record } from '../types.js';
 import type { TokenPayload } from './index.js';

package/examples/api/basic-overview.js

@@ -18,7 +18,7 @@ import { configureHttpClient } from '../../http/client/module.js';
 import { configureNodeHttpServer } from '../../http/server/node/module.js';
 import { inject } from '../../injector/inject.js';
 import { WebServerModule } from '../../module/modules/web-server.module.js';
-import { Number, Property, array, boolean, number, object } from '../../schema/index.js';
+import { NumberProperty, Property, array, boolean, number, object } from '../../schema/index.js';
 import { timeout } from '../../utils/timing.js';
 import { Agent } from 'undici';
 class User {
@@ -26,7 +26,7 @@ class User {
     name;
 }
 __decorate([
-    Number({ coerce: true }),
+    NumberProperty({ coerce: true }),
     __metadata("design:type", Number)
 ], User.prototype, "id", void 0);
 __decorate([

package/image-service/image-service.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Enumeration, Number, Optional } from '../schema/index.js';
+import { Enumeration, NumberProperty, Optional } from '../schema/index.js';
 export var ImageResizeMode;
 (function (ImageResizeMode) {
     ImageResizeMode["Fit"] = "fit";
@@ -49,11 +49,11 @@ __decorate([
     __metadata("design:type", String)
 ], ImageOptions.prototype, "resizeMode", void 0);
 __decorate([
-    Number({ optional: true, coerce: true }),
+    NumberProperty({ optional: true, coerce: true }),
     __metadata("design:type", Number)
 ], ImageOptions.prototype, "width", void 0);
 __decorate([
-    Number({ optional: true, coerce: true }),
+    NumberProperty({ optional: true, coerce: true }),
     __metadata("design:type", Number)
 ], ImageOptions.prototype, "height", void 0);
 __decorate([
@@ -62,7 +62,7 @@ __decorate([
     __metadata("design:type", String)
 ], ImageOptions.prototype, "origin", void 0);
 __decorate([
-    Number({ optional: true, coerce: true }),
+    NumberProperty({ optional: true, coerce: true }),
     __metadata("design:type", Number)
 ], ImageOptions.prototype, "quality", void 0);
 __decorate([

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/mail/mail.client.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Property } from '../schema/decorators/property.js';
-import { Boolean } from '../schema/index.js';
+import { BooleanProperty } from '../schema/index.js';
 import { Optional } from '../schema/schemas/optional.js';
 export class MailClientAuthConfig {
     user;
@@ -38,7 +38,7 @@ __decorate([
     __metadata("design:type", Number)
 ], MailClientConfig.prototype, "port", void 0);
 __decorate([
-    Boolean({ optional: true }),
+    BooleanProperty({ optional: true }),
     __metadata("design:type", Boolean)
 ], MailClientConfig.prototype, "secure", void 0);
 __decorate([

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/orm/entity.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Number, Property, any, record } from '../schema/index.js';
+import { NumberProperty, Property, any, record } from '../schema/index.js';
 export class EntityMetadata {
     revision;
     revisionTimestamp;
@@ -28,7 +28,7 @@ __decorate([
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "createTimestamp", void 0);
 __decorate([
-    Number({ nullable: true }),
+    NumberProperty({ nullable: true }),
     __metadata("design:type", Object)
 ], EntityMetadata.prototype, "deleteTimestamp", void 0);
 __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.0-beta8",
+  "version": "0.91.0",
   "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/bigint.d.ts

@@ -6,4 +6,4 @@ export declare class BigIntSchema extends Schema<bigint> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<bigint>;
 }
 export declare function bigint(): BigIntSchema;
-export declare function BigInt(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function BigIntProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/bigint.js

@@ -14,6 +14,6 @@ export class BigIntSchema extends Schema {
 export function bigint() {
     return new BigIntSchema();
 }
-export function BigInt(options) {
+export function BigIntProperty(options) {
     return Property(bigint(), options);
 }

package/schema/schemas/boolean.d.ts

@@ -8,8 +8,4 @@ export declare class BooleanSchema extends SimpleSchema<boolean> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<boolean>;
 }
 export declare function boolean(options?: BooleanSchemaOptions): BooleanSchema;
-export declare function Boolean(options?: BooleanSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
-/**
- * @deprecated use {@link Boolean()} instead
- */
 export declare function BooleanProperty(options?: BooleanSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/boolean.js

@@ -39,12 +39,6 @@ export class BooleanSchema extends SimpleSchema {
 export function boolean(options) {
     return new BooleanSchema(options);
 }
-export function Boolean(options) {
-    return Property(boolean(options), options);
-}
-/**
- * @deprecated use {@link Boolean()} instead
- */
 export function BooleanProperty(options) {
-    return Boolean(options);
+    return Property(boolean(options), options);
 }

package/schema/schemas/date.d.ts

@@ -7,4 +7,4 @@ export declare class DateSchema extends SimpleSchema<globalThis.Date> {
     constructor(options?: DateSchemaOptions);
 }
 export declare function date(options?: DateSchemaOptions): DateSchema;
-export declare function Date(options?: SchemaPropertyDecoratorOptions & DateSchemaOptions): SchemaPropertyDecorator;
+export declare function DateProperty(options?: SchemaPropertyDecoratorOptions & DateSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/date.js

@@ -23,6 +23,6 @@ export class DateSchema extends SimpleSchema {
 export function date(options) {
     return new DateSchema(options);
 }
-export function Date(options) {
+export function DateProperty(options) {
     return Property(date(options), options);
 }

package/schema/schemas/function.d.ts

@@ -5,4 +5,4 @@ export declare class FunctionSchema extends SimpleSchema<Function> {
     constructor(options?: FunctionSchemaOptions);
 }
 export declare function func(): FunctionSchema;
-export declare function Function(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function FunctionProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/function.js

@@ -9,6 +9,6 @@ export class FunctionSchema extends SimpleSchema {
 export function func() {
     return new FunctionSchema();
 }
-export function Function(options) {
+export function FunctionProperty(options) {
     return Property(func(), options);
 }

package/schema/schemas/number.d.ts

@@ -7,9 +7,5 @@ export declare class NumberSchema extends SimpleSchema<number> {
     constructor(options?: NumberSchemaOptions);
 }
 export declare function number(options?: NumberSchemaOptions): NumberSchema;
-export declare function Number(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
-export declare function Integer(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
-/**
- * @deprecated use {@link Number()} instead
- */
 export declare function NumberProperty(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
+export declare function Integer(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/number.js

@@ -24,15 +24,9 @@ export class NumberSchema extends SimpleSchema {
 export function number(options) {
     return new NumberSchema(options);
 }
-export function Number(options) {
+export function NumberProperty(options) {
     return Property(number(options), options);
 }
 export function Integer(options) {
     return Property(number({ ...options, integer: true }), options);
 }
-/**
- * @deprecated use {@link Number()} instead
- */
-export function NumberProperty(options) {
-    return Number(options);
-}

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/object.js

@@ -155,7 +155,7 @@ function getObjectSchemaPropertiesFromReflection(metadata, type) {
     for (const [key, propertyMetadata] of metadata.properties) {
         const reflectionData = propertyMetadata.data.tryGet('schema');
         if (isUndefined(reflectionData?.schema) && (propertyMetadata.type == Object)) {
-            throw new Error(`Schema of property "${String(key)}" on type ${type.name} is inferred as Object. This is most likely unwanted and happens when the property is defined as partial or the type is an union. Use an explicit @Property(Object) if wanted.`);
+            throw new Error(`Schema of property "${String(key)}" on type ${type.name} is inferred as Object. This is most likely unwanted and happens when the property is defined as partial or the type is an union. Use an explicit @Property(Object) if this is wanted.`);
         }
         let propertySchema = reflectionData?.schema ?? propertyMetadata.type;
         if (reflectionData?.array == true) {

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/schema/schemas/readable-stream.d.ts

@@ -5,4 +5,4 @@ export declare class ReadableStreamSchema extends SimpleSchema<ReadableStream> {
     constructor(options?: ReadableStreamSchemaOptions);
 }
 export declare function readableStream(options?: ReadableStreamSchemaOptions): ReadableStreamSchema;
-export declare function ReadableStream(options?: SchemaPropertyDecoratorOptions & ReadableStreamSchemaOptions): SchemaPropertyDecorator;
+export declare function ReadableStreamProperty(options?: SchemaPropertyDecoratorOptions & ReadableStreamSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/readable-stream.js

@@ -9,6 +9,6 @@ export class ReadableStreamSchema extends SimpleSchema {
 export function readableStream(options) {
     return new ReadableStreamSchema(options);
 }
-export function ReadableStream(options) {
+export function ReadableStreamProperty(options) {
     return Property(readableStream(options), options);
 }

package/schema/schemas/regexp.d.ts

@@ -5,4 +5,4 @@ export declare class RegExpSchema extends SimpleSchema<RegExp> {
     constructor(options?: RegExpSchemaOptions);
 }
 export declare function regExp(options?: RegExpSchemaOptions): RegExpSchema;
-export declare function RegExp(options?: SchemaPropertyDecoratorOptions & RegExpSchemaOptions): SchemaPropertyDecorator;
+export declare function RegExpProperty(options?: SchemaPropertyDecoratorOptions & RegExpSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/regexp.js

@@ -22,6 +22,6 @@ export class RegExpSchema extends SimpleSchema {
 export function regExp(options) {
     return new RegExpSchema(options);
 }
-export function RegExp(options) {
+export function RegExpProperty(options) {
     return Property(regExp(options), options);
 }

package/schema/schemas/string.d.ts

@@ -7,8 +7,4 @@ export declare class StringSchema extends SimpleSchema<string> {
     constructor(options?: StringSchemaOptions);
 }
 export declare function string(options?: StringSchemaOptions): StringSchema;
-export declare function String(options?: SchemaPropertyDecoratorOptions & StringSchemaOptions): SchemaPropertyDecorator;
-/**
- * @deprecated use {@link String()} instead
- */
 export declare function StringProperty(options?: SchemaPropertyDecoratorOptions & StringSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/string.js

@@ -19,12 +19,6 @@ export class StringSchema extends SimpleSchema {
 export function string(options) {
     return new StringSchema(options);
 }
-export function String(options) {
-    return Property(string(options), options);
-}
-/**
- * @deprecated use {@link String()} instead
- */
 export function StringProperty(options) {
-    return String(options);
+    return Property(string(options), options);
 }

package/schema/schemas/symbol.d.ts

@@ -5,8 +5,4 @@ export declare class SymbolSchema extends Schema<symbol> {
     _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<symbol>;
 }
 export declare function symbol(): SymbolSchema;
-export declare function Symbol(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
-/**
- * @deprecated use {@link Symbol()} instead
- */
 export declare function SymbolProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/symbol.js

@@ -14,12 +14,6 @@ export class SymbolSchema extends Schema {
 export function symbol() {
     return new SymbolSchema();
 }
-export function Symbol(options) {
-    return Property(symbol(), options);
-}
-/**
- * @deprecated use {@link Symbol()} instead
- */
 export function SymbolProperty(options) {
-    return Symbol(options);
+    return Property(symbol(), options);
 }

package/schema/schemas/uint8-array.d.ts

@@ -11,4 +11,4 @@ export declare class Uint8ArraySchema extends SimpleSchema<Uint8Array> {
     constructor(options?: Uint8ArraySchemaOptions);
 }
 export declare function uint8Array(options?: Uint8ArraySchemaOptions): Uint8ArraySchema;
-export declare function Uint8Array(schemaOptions?: Uint8ArraySchemaOptions, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare function Uint8ArrayProperty(schemaOptions?: Uint8ArraySchemaOptions, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/uint8-array.js

@@ -6,8 +6,8 @@ export class Uint8ArraySchema extends SimpleSchema {
     constructor(options) {
         super('Uint8Array', isUint8Array, options, {
             constraints: [
-                isDefined(options?.minimumLength) ? (value) => (value.byteLength >= options.minimumLength) ? ({ success: true }) : ({ success: false, error: `size must be at least ${options.minimumLength} bytes.` }) : null,
-                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= options.maximumLength) ? ({ success: true }) : ({ success: false, error: `size must be at most ${options.maximumLength} bytes.` }) : null
+                isDefined(options?.minimumLength) ? (value) => (value.byteLength >= options.minimumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at least ${options.minimumLength} bytes.` }) : null,
+                isDefined(options?.maximumLength) ? (value) => (value.byteLength <= options.maximumLength) ? ({ success: true }) : ({ success: false, error: `Size must be at most ${options.maximumLength} bytes.` }) : null
             ]
         });
     }
@@ -15,6 +15,6 @@ export class Uint8ArraySchema extends SimpleSchema {
 export function uint8Array(options) {
     return new Uint8ArraySchema(options);
 }
-export function Uint8Array(schemaOptions, options) {
+export function Uint8ArrayProperty(schemaOptions, options) {
     return Property(uint8Array(schemaOptions), options);
 }

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();
 }

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

@@ -1,2 +1,3 @@
-import type { IteratorFunction } from './types.js';
+import type { GroupSelectors, IteratorFunction } from './types.js';
 export declare function groupToSingleMap<TIn, TGroup>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, TGroup>): Map<TGroup, TIn>;
+export declare function groupToSingleMap<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-single-map.js

@@ -1,12 +1,26 @@
-export function groupToSingleMap(iterable, selector) {
-    const map = new Map();
+import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
+export function groupToSingleMap(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)) {
+                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 = selector(item, index++);
-        if (map.has(groupKey)) {
-            throw new Error('group has more than one item');
+        const groupKeys = selectors.map((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/iterable-helpers/group.d.ts

@@ -1,2 +1,3 @@
-import type { IteratorFunction } from './types.js';
+import type { GroupSelectors, IteratorFunction } from './types.js';
 export declare function group<TIn, TGroup>(iterable: Iterable<TIn>, selector: IteratorFunction<TIn, TGroup>): IterableIterator<[TGroup, TIn[]]>;
+export declare function group<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.js

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

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

@@ -12,3 +12,6 @@ export type IterableItemMetadata<T> = {
     isLast: boolean;
     value: T;
 };
+export type GroupSelectors<T, TGroup extends any[]> = {
+    [P in keyof TGroup]: IteratorFunction<T, TGroup[P]>;
+};