mavenagi 0.0.0-alpha.2 → 0.0.0-alpha.20

package/dist/core/schemas/builders/object/object.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { SchemaType } from "../../Schema";
 import { entries } from "../../utils/entries";
 import { filterObject } from "../../utils/filterObject";
@@ -20,9 +11,9 @@ import { getSchemaUtils } from "../schema-utils";
 import { isProperty } from "./property";
 export function object(schemas) {
     const baseSchema = {
-        _getRawProperties: () => Promise.resolve(Object.entries(schemas).map(([parsedKey, propertySchema]) => isProperty(propertySchema) ? propertySchema.rawKey : parsedKey)),
-        _getParsedProperties: () => Promise.resolve(keys(schemas)),
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+        _getRawProperties: () => Object.entries(schemas).map(([parsedKey, propertySchema]) => isProperty(propertySchema) ? propertySchema.rawKey : parsedKey),
+        _getParsedProperties: () => keys(schemas),
+        parse: (raw, opts) => {
             const rawKeyToProperty = {};
             const requiredKeys = [];
             for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
@@ -59,9 +50,10 @@ export function object(schemas) {
                 unrecognizedObjectKeys: opts === null || opts === void 0 ? void 0 : opts.unrecognizedObjectKeys,
                 skipValidation: opts === null || opts === void 0 ? void 0 : opts.skipValidation,
                 breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
+                omitUndefined: opts === null || opts === void 0 ? void 0 : opts.omitUndefined,
             });
-        }),
-        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+        },
+        json: (parsed, opts) => {
             const requiredKeys = [];
             for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
                 const valueSchema = isProperty(schemaOrObjectProperty)
@@ -102,109 +94,98 @@ export function object(schemas) {
                 unrecognizedObjectKeys: opts === null || opts === void 0 ? void 0 : opts.unrecognizedObjectKeys,
                 skipValidation: opts === null || opts === void 0 ? void 0 : opts.skipValidation,
                 breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
+                omitUndefined: opts === null || opts === void 0 ? void 0 : opts.omitUndefined,
             });
-        }),
+        },
         getType: () => SchemaType.OBJECT,
     };
     return Object.assign(Object.assign(Object.assign(Object.assign({}, maybeSkipValidation(baseSchema)), getSchemaUtils(baseSchema)), getObjectLikeUtils(baseSchema)), getObjectUtils(baseSchema));
 }
 function validateAndTransformObject({ value, requiredKeys, getProperty, unrecognizedObjectKeys = "fail", skipValidation = false, breadcrumbsPrefix = [], }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!isPlainObject(value)) {
-            return {
-                ok: false,
-                errors: [
-                    {
-                        path: breadcrumbsPrefix,
-                        message: getErrorMessageForIncorrectType(value, "object"),
-                    },
-                ],
-            };
-        }
-        const missingRequiredKeys = new Set(requiredKeys);
-        const errors = [];
-        const transformed = {};
-        for (const [preTransformedKey, preTransformedItemValue] of Object.entries(value)) {
-            const property = getProperty(preTransformedKey);
-            if (property != null) {
-                missingRequiredKeys.delete(preTransformedKey);
-                const value = yield property.transform(preTransformedItemValue);
-                if (value.ok) {
-                    transformed[property.transformedKey] = value.value;
-                }
-                else {
-                    transformed[preTransformedKey] = preTransformedItemValue;
-                    errors.push(...value.errors);
-                }
+    if (!isPlainObject(value)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: getErrorMessageForIncorrectType(value, "object"),
+                },
+            ],
+        };
+    }
+    const missingRequiredKeys = new Set(requiredKeys);
+    const errors = [];
+    const transformed = {};
+    for (const [preTransformedKey, preTransformedItemValue] of Object.entries(value)) {
+        const property = getProperty(preTransformedKey);
+        if (property != null) {
+            missingRequiredKeys.delete(preTransformedKey);
+            const value = property.transform(preTransformedItemValue);
+            if (value.ok) {
+                transformed[property.transformedKey] = value.value;
             }
             else {
-                switch (unrecognizedObjectKeys) {
-                    case "fail":
-                        errors.push({
-                            path: [...breadcrumbsPrefix, preTransformedKey],
-                            message: `Unexpected key "${preTransformedKey}"`,
-                        });
-                        break;
-                    case "strip":
-                        break;
-                    case "passthrough":
-                        transformed[preTransformedKey] = preTransformedItemValue;
-                        break;
-                }
+                transformed[preTransformedKey] = preTransformedItemValue;
+                errors.push(...value.errors);
             }
         }
-        errors.push(...requiredKeys
-            .filter((key) => missingRequiredKeys.has(key))
-            .map((key) => ({
-            path: breadcrumbsPrefix,
-            message: `Missing required key "${key}"`,
-        })));
-        if (errors.length === 0 || skipValidation) {
-            return {
-                ok: true,
-                value: transformed,
-            };
-        }
         else {
-            return {
-                ok: false,
-                errors,
-            };
+            switch (unrecognizedObjectKeys) {
+                case "fail":
+                    errors.push({
+                        path: [...breadcrumbsPrefix, preTransformedKey],
+                        message: `Unexpected key "${preTransformedKey}"`,
+                    });
+                    break;
+                case "strip":
+                    break;
+                case "passthrough":
+                    transformed[preTransformedKey] = preTransformedItemValue;
+                    break;
+            }
         }
-    });
+    }
+    errors.push(...requiredKeys
+        .filter((key) => missingRequiredKeys.has(key))
+        .map((key) => ({
+        path: breadcrumbsPrefix,
+        message: `Missing required key "${key}"`,
+    })));
+    if (errors.length === 0 || skipValidation) {
+        return {
+            ok: true,
+            value: transformed,
+        };
+    }
+    else {
+        return {
+            ok: false,
+            errors,
+        };
+    }
 }
 export function getObjectUtils(schema) {
     return {
         extend: (extension) => {
             const baseSchema = {
-                _getParsedProperties: () => __awaiter(this, void 0, void 0, function* () {
-                    return [
-                        ...(yield schema._getParsedProperties()),
-                        ...(yield extension._getParsedProperties()),
-                    ];
-                }),
-                _getRawProperties: () => __awaiter(this, void 0, void 0, function* () {
-                    return [
-                        ...(yield schema._getRawProperties()),
-                        ...(yield extension._getRawProperties()),
-                    ];
-                }),
-                parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+                _getParsedProperties: () => [...schema._getParsedProperties(), ...extension._getParsedProperties()],
+                _getRawProperties: () => [...schema._getRawProperties(), ...extension._getRawProperties()],
+                parse: (raw, opts) => {
                     return validateAndTransformExtendedObject({
-                        extensionKeys: yield extension._getRawProperties(),
+                        extensionKeys: extension._getRawProperties(),
                         value: raw,
                         transformBase: (rawBase) => schema.parse(rawBase, opts),
                         transformExtension: (rawExtension) => extension.parse(rawExtension, opts),
                     });
-                }),
-                json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+                },
+                json: (parsed, opts) => {
                     return validateAndTransformExtendedObject({
-                        extensionKeys: yield extension._getParsedProperties(),
+                        extensionKeys: extension._getParsedProperties(),
                         value: parsed,
                         transformBase: (parsedBase) => schema.json(parsedBase, opts),
                         transformExtension: (parsedExtension) => extension.json(parsedExtension, opts),
                     });
-                }),
+                },
                 getType: () => SchemaType.OBJECT,
             };
             return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema)), getObjectLikeUtils(baseSchema)), getObjectUtils(baseSchema));
@@ -212,27 +193,25 @@ export function getObjectUtils(schema) {
     };
 }
 function validateAndTransformExtendedObject({ extensionKeys, value, transformBase, transformExtension, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const extensionPropertiesSet = new Set(extensionKeys);
-        const [extensionProperties, baseProperties] = partition(keys(value), (key) => extensionPropertiesSet.has(key));
-        const transformedBase = yield transformBase(filterObject(value, baseProperties));
-        const transformedExtension = yield transformExtension(filterObject(value, extensionProperties));
-        if (transformedBase.ok && transformedExtension.ok) {
-            return {
-                ok: true,
-                value: Object.assign(Object.assign({}, transformedBase.value), transformedExtension.value),
-            };
-        }
-        else {
-            return {
-                ok: false,
-                errors: [
-                    ...(transformedBase.ok ? [] : transformedBase.errors),
-                    ...(transformedExtension.ok ? [] : transformedExtension.errors),
-                ],
-            };
-        }
-    });
+    const extensionPropertiesSet = new Set(extensionKeys);
+    const [extensionProperties, baseProperties] = partition(keys(value), (key) => extensionPropertiesSet.has(key));
+    const transformedBase = transformBase(filterObject(value, baseProperties));
+    const transformedExtension = transformExtension(filterObject(value, extensionProperties));
+    if (transformedBase.ok && transformedExtension.ok) {
+        return {
+            ok: true,
+            value: Object.assign(Object.assign({}, transformedBase.value), transformedExtension.value),
+        };
+    }
+    else {
+        return {
+            ok: false,
+            errors: [
+                ...(transformedBase.ok ? [] : transformedBase.errors),
+                ...(transformedExtension.ok ? [] : transformedExtension.errors),
+            ],
+        };
+    }
 }
 function isSchemaRequired(schema) {
     return !isSchemaOptional(schema);

package/dist/core/schemas/builders/object/types.d.ts

@@ -5,8 +5,8 @@ import { SchemaUtils } from "../schema-utils";
 import { Property } from "./property";
 export declare type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export interface BaseObjectSchema<Raw, Parsed> extends BaseSchema<Raw, Parsed> {
-    _getRawProperties: () => Promise<(keyof Raw)[]>;
-    _getParsedProperties: () => Promise<(keyof Parsed)[]>;
+    _getRawProperties: () => (keyof Raw)[];
+    _getParsedProperties: () => (keyof Parsed)[];
 }
 export interface ObjectUtils<Raw, Parsed> {
     extend: <RawExtension, ParsedExtension>(schemas: ObjectSchema<RawExtension, ParsedExtension>) => ObjectSchema<Raw & RawExtension, Parsed & ParsedExtension>;

package/dist/core/schemas/builders/object-like/getObjectLikeUtils.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { filterObject } from "../../utils/filterObject";
 import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
 import { isPlainObject } from "../../utils/isPlainObject";
@@ -21,8 +12,8 @@ export function getObjectLikeUtils(schema) {
  */
 export function withParsedProperties(objectLike, properties) {
     const objectSchema = {
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
-            const parsedObject = yield objectLike.parse(raw, opts);
+        parse: (raw, opts) => {
+            const parsedObject = objectLike.parse(raw, opts);
             if (!parsedObject.ok) {
                 return parsedObject;
             }
@@ -33,7 +24,7 @@ export function withParsedProperties(objectLike, properties) {
                 ok: true,
                 value: Object.assign(Object.assign({}, parsedObject.value), additionalProperties),
             };
-        }),
+        },
         json: (parsed, opts) => {
             var _a;
             if (!isPlainObject(parsed)) {

package/dist/core/schemas/builders/record/record.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { SchemaType } from "../../Schema";
 import { entries } from "../../utils/entries";
 import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
@@ -15,10 +6,10 @@ import { maybeSkipValidation } from "../../utils/maybeSkipValidation";
 import { getSchemaUtils } from "../schema-utils";
 export function record(keySchema, valueSchema) {
     const baseSchema = {
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+        parse: (raw, opts) => {
             return validateAndTransformRecord({
                 value: raw,
-                isKeyNumeric: (yield keySchema.getType()) === SchemaType.NUMBER,
+                isKeyNumeric: keySchema.getType() === SchemaType.NUMBER,
                 transformKey: (key) => {
                     var _a;
                     return keySchema.parse(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key} (key)`] }));
@@ -29,11 +20,11 @@ export function record(keySchema, valueSchema) {
                 },
                 breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
             });
-        }),
-        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+        },
+        json: (parsed, opts) => {
             return validateAndTransformRecord({
                 value: parsed,
-                isKeyNumeric: (yield keySchema.getType()) === SchemaType.NUMBER,
+                isKeyNumeric: keySchema.getType() === SchemaType.NUMBER,
                 transformKey: (key) => {
                     var _a;
                     return keySchema.json(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key} (key)`] }));
@@ -44,59 +35,57 @@ export function record(keySchema, valueSchema) {
                 },
                 breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
             });
-        }),
+        },
         getType: () => SchemaType.RECORD,
     };
     return Object.assign(Object.assign({}, maybeSkipValidation(baseSchema)), getSchemaUtils(baseSchema));
 }
 function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, breadcrumbsPrefix = [], }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!isPlainObject(value)) {
-            return {
-                ok: false,
-                errors: [
-                    {
-                        path: breadcrumbsPrefix,
-                        message: getErrorMessageForIncorrectType(value, "object"),
-                    },
-                ],
-            };
+    if (!isPlainObject(value)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: getErrorMessageForIncorrectType(value, "object"),
+                },
+            ],
+        };
+    }
+    return entries(value).reduce((accPromise, [stringKey, value]) => {
+        // skip nullish keys
+        if (value == null) {
+            return accPromise;
         }
-        return entries(value).reduce((accPromise, [stringKey, value]) => __awaiter(this, void 0, void 0, function* () {
-            // skip nullish keys
-            if (value == null) {
-                return accPromise;
-            }
-            const acc = yield accPromise;
-            let key = stringKey;
-            if (isKeyNumeric) {
-                const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
-                if (!isNaN(numberKey)) {
-                    key = numberKey;
-                }
-            }
-            const transformedKey = yield transformKey(key);
-            const transformedValue = yield transformValue(value, key);
-            if (acc.ok && transformedKey.ok && transformedValue.ok) {
-                return {
-                    ok: true,
-                    value: Object.assign(Object.assign({}, acc.value), { [transformedKey.value]: transformedValue.value }),
-                };
-            }
-            const errors = [];
-            if (!acc.ok) {
-                errors.push(...acc.errors);
-            }
-            if (!transformedKey.ok) {
-                errors.push(...transformedKey.errors);
-            }
-            if (!transformedValue.ok) {
-                errors.push(...transformedValue.errors);
+        const acc = accPromise;
+        let key = stringKey;
+        if (isKeyNumeric) {
+            const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
+            if (!isNaN(numberKey)) {
+                key = numberKey;
             }
+        }
+        const transformedKey = transformKey(key);
+        const transformedValue = transformValue(value, key);
+        if (acc.ok && transformedKey.ok && transformedValue.ok) {
             return {
-                ok: false,
-                errors,
+                ok: true,
+                value: Object.assign(Object.assign({}, acc.value), { [transformedKey.value]: transformedValue.value }),
             };
-        }), Promise.resolve({ ok: true, value: {} }));
-    });
+        }
+        const errors = [];
+        if (!acc.ok) {
+            errors.push(...acc.errors);
+        }
+        if (!transformedKey.ok) {
+            errors.push(...transformedKey.errors);
+        }
+        if (!transformedValue.ok) {
+            errors.push(...transformedValue.errors);
+        }
+        return {
+            ok: false,
+            errors,
+        };
+    }, { ok: true, value: {} });
 }

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.d.ts

@@ -2,8 +2,8 @@ import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
 export interface SchemaUtils<Raw, Parsed> {
     optional: () => Schema<Raw | null | undefined, Parsed | undefined>;
     transform: <Transformed>(transformer: SchemaTransformer<Parsed, Transformed>) => Schema<Raw, Transformed>;
-    parseOrThrow: (raw: unknown, opts?: SchemaOptions) => Promise<Parsed>;
-    jsonOrThrow: (raw: unknown, opts?: SchemaOptions) => Promise<Raw>;
+    parseOrThrow: (raw: unknown, opts?: SchemaOptions) => Parsed;
+    jsonOrThrow: (raw: unknown, opts?: SchemaOptions) => Raw;
 }
 export interface SchemaTransformer<Parsed, Transformed> {
     transform: (parsed: Parsed) => Transformed;

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { SchemaType } from "../../Schema";
 import { JsonError } from "./JsonError";
 import { ParseError } from "./ParseError";
@@ -14,20 +5,20 @@ export function getSchemaUtils(schema) {
     return {
         optional: () => optional(schema),
         transform: (transformer) => transform(schema, transformer),
-        parseOrThrow: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
-            const parsed = yield schema.parse(raw, opts);
+        parseOrThrow: (raw, opts) => {
+            const parsed = schema.parse(raw, opts);
             if (parsed.ok) {
                 return parsed.value;
             }
             throw new ParseError(parsed.errors);
-        }),
-        jsonOrThrow: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
-            const raw = yield schema.json(parsed, opts);
+        },
+        jsonOrThrow: (parsed, opts) => {
+            const raw = schema.json(parsed, opts);
             if (raw.ok) {
                 return raw.value;
             }
             throw new JsonError(raw.errors);
-        }),
+        },
     };
 }
 /**
@@ -45,6 +36,12 @@ export function optional(schema) {
             return schema.parse(raw, opts);
         },
         json: (parsed, opts) => {
+            if ((opts === null || opts === void 0 ? void 0 : opts.omitUndefined) && parsed === undefined) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
             if (parsed == null) {
                 return {
                     ok: true,
@@ -59,8 +56,8 @@ export function optional(schema) {
 }
 export function transform(schema, transformer) {
     const baseSchema = {
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
-            const parsed = yield schema.parse(raw, opts);
+        parse: (raw, opts) => {
+            const parsed = schema.parse(raw, opts);
             if (!parsed.ok) {
                 return parsed;
             }
@@ -68,11 +65,11 @@ export function transform(schema, transformer) {
                 ok: true,
                 value: transformer.transform(parsed.value),
             };
-        }),
-        json: (transformed, opts) => __awaiter(this, void 0, void 0, function* () {
-            const parsed = yield transformer.untransform(transformed);
+        },
+        json: (transformed, opts) => {
+            const parsed = transformer.untransform(transformed);
             return schema.json(parsed, opts);
-        }),
+        },
         getType: () => schema.getType(),
     };
     return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));

package/dist/core/schemas/builders/set/set.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { SchemaType } from "../../Schema";
 import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
 import { maybeSkipValidation } from "../../utils/maybeSkipValidation";
@@ -15,8 +6,8 @@ import { getSchemaUtils } from "../schema-utils";
 export function set(schema) {
     const listSchema = list(schema);
     const baseSchema = {
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
-            const parsedList = yield listSchema.parse(raw, opts);
+        parse: (raw, opts) => {
+            const parsedList = listSchema.parse(raw, opts);
             if (parsedList.ok) {
                 return {
                     ok: true,
@@ -26,8 +17,8 @@ export function set(schema) {
             else {
                 return parsedList;
             }
-        }),
-        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+        },
+        json: (parsed, opts) => {
             var _a;
             if (!(parsed instanceof Set)) {
                 return {
@@ -40,9 +31,9 @@ export function set(schema) {
                     ],
                 };
             }
-            const jsonList = yield listSchema.json([...parsed], opts);
+            const jsonList = listSchema.json([...parsed], opts);
             return jsonList;
-        }),
+        },
         getType: () => SchemaType.SET,
     };
     return Object.assign(Object.assign({}, maybeSkipValidation(baseSchema)), getSchemaUtils(baseSchema));

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.js

@@ -1,47 +1,36 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { SchemaType } from "../../Schema";
 import { maybeSkipValidation } from "../../utils/maybeSkipValidation";
 import { getSchemaUtils } from "../schema-utils";
 export function undiscriminatedUnion(schemas) {
     const baseSchema = {
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+        parse: (raw, opts) => {
             return validateAndTransformUndiscriminatedUnion((schema, opts) => schema.parse(raw, opts), schemas, opts);
-        }),
-        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+        },
+        json: (parsed, opts) => {
             return validateAndTransformUndiscriminatedUnion((schema, opts) => schema.json(parsed, opts), schemas, opts);
-        }),
+        },
         getType: () => SchemaType.UNDISCRIMINATED_UNION,
     };
     return Object.assign(Object.assign({}, maybeSkipValidation(baseSchema)), getSchemaUtils(baseSchema));
 }
 function validateAndTransformUndiscriminatedUnion(transform, schemas, opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const errors = [];
-        for (const [index, schema] of schemas.entries()) {
-            const transformed = yield transform(schema, Object.assign(Object.assign({}, opts), { skipValidation: false }));
-            if (transformed.ok) {
-                return transformed;
-            }
-            else {
-                for (const error of transformed.errors) {
-                    errors.push({
-                        path: error.path,
-                        message: `[Variant ${index}] ${error.message}`,
-                    });
-                }
+    const errors = [];
+    for (const [index, schema] of schemas.entries()) {
+        const transformed = transform(schema, Object.assign(Object.assign({}, opts), { skipValidation: false }));
+        if (transformed.ok) {
+            return transformed;
+        }
+        else {
+            for (const error of transformed.errors) {
+                errors.push({
+                    path: error.path,
+                    message: `[Variant ${index}] ${error.message}`,
+                });
             }
         }
-        return {
-            ok: false,
-            errors,
-        };
-    });
+    }
+    return {
+        ok: false,
+        errors,
+    };
 }