webflow-api 2.3.6 → 2.4.2

package/core/fetcher/stream-wrappers/chooseStreamWrapper.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseStreamWrapper = void 0;
+const runtime_1 = require("../../runtime");
+function chooseStreamWrapper(responseBody) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (runtime_1.RUNTIME.type === "node" && runtime_1.RUNTIME.parsedVersion != null && runtime_1.RUNTIME.parsedVersion >= 18) {
+            return new (yield Promise.resolve().then(() => __importStar(require("./Node18UniversalStreamWrapper")))).Node18UniversalStreamWrapper(responseBody);
+        }
+        else if (runtime_1.RUNTIME.type !== "node" && typeof fetch === "function") {
+            return new (yield Promise.resolve().then(() => __importStar(require("./UndiciStreamWrapper")))).UndiciStreamWrapper(responseBody);
+        }
+        else {
+            return new (yield Promise.resolve().then(() => __importStar(require("./NodePre18StreamWrapper")))).NodePre18StreamWrapper(responseBody);
+        }
+    });
+}
+exports.chooseStreamWrapper = chooseStreamWrapper;

package/core/runtime/runtime.d.ts

@@ -5,4 +5,5 @@ export declare const RUNTIME: Runtime;
 export interface Runtime {
     type: "browser" | "web-worker" | "deno" | "bun" | "node" | "react-native" | "unknown" | "workerd";
     version?: string;
+    parsedVersion?: number;
 }

package/core/runtime/runtime.js

@@ -79,6 +79,7 @@ function evaluateRuntime() {
         return {
             type: "node",
             version: process.versions.node,
+            parsedVersion: Number(process.versions.node.split(".")[0]),
         };
     }
     if (isReactNative) {

package/core/schemas/Schema.d.ts

@@ -1,14 +1,14 @@
 import { SchemaUtils } from "./builders";
-import { MaybePromise } from "./utils/MaybePromise";
 export declare type Schema<Raw = unknown, Parsed = unknown> = BaseSchema<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export declare type inferRaw<S extends Schema> = S extends Schema<infer Raw, any> ? Raw : never;
 export declare type inferParsed<S extends Schema> = S extends Schema<any, infer Parsed> ? Parsed : never;
 export interface BaseSchema<Raw, Parsed> {
-    parse: (raw: unknown, opts?: SchemaOptions) => MaybePromise<MaybeValid<Parsed>>;
-    json: (parsed: unknown, opts?: SchemaOptions) => MaybePromise<MaybeValid<Raw>>;
-    getType: () => SchemaType | Promise<SchemaType>;
+    parse: (raw: unknown, opts?: SchemaOptions) => MaybeValid<Parsed>;
+    json: (parsed: unknown, opts?: SchemaOptions) => MaybeValid<Raw>;
+    getType: () => SchemaType | SchemaType;
 }
 export declare const SchemaType: {
+    readonly BIGINT: "bigint";
     readonly DATE: "date";
     readonly ENUM: "enum";
     readonly LIST: "list";
@@ -78,4 +78,8 @@ export interface SchemaOptions {
      * helpful for zurg's internal debug logging.
      */
     breadcrumbsPrefix?: string[];
+    /**
+     * whether to send 'null' for optional properties explicitly set to 'undefined'.
+     */
+    omitUndefined?: boolean;
 }

package/core/schemas/Schema.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaType = void 0;
 exports.SchemaType = {
+    BIGINT: "bigint",
     DATE: "date",
     ENUM: "enum",
     LIST: "list",

package/core/schemas/builders/bigint/bigint.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "../../Schema";
+export declare function bigint(): Schema<string, bigint>;

package/core/schemas/builders/bigint/bigint.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigint = void 0;
+const Schema_1 = require("../../Schema");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
+const schema_utils_1 = require("../schema-utils");
+function bigint() {
+    const baseSchema = {
+        parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
+            if (typeof raw !== "string") {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: breadcrumbsPrefix,
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(raw, "string"),
+                        },
+                    ],
+                };
+            }
+            return {
+                ok: true,
+                value: BigInt(raw),
+            };
+        },
+        json: (bigint, { breadcrumbsPrefix = [] } = {}) => {
+            if (typeof bigint === "bigint") {
+                return {
+                    ok: true,
+                    value: bigint.toString(),
+                };
+            }
+            else {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: breadcrumbsPrefix,
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(bigint, "bigint"),
+                        },
+                    ],
+                };
+            }
+        },
+        getType: () => Schema_1.SchemaType.BIGINT,
+    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+}
+exports.bigint = bigint;

package/core/schemas/builders/bigint/index.d.ts

@@ -0,0 +1 @@
+export { bigint } from "./bigint";

package/core/schemas/builders/bigint/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigint = void 0;
+var bigint_1 = require("./bigint");
+Object.defineProperty(exports, "bigint", { enumerable: true, get: function () { return bigint_1.bigint; } });

package/core/schemas/builders/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./bigint";
 export * from "./date";
 export * from "./enum";
 export * from "./lazy";

package/core/schemas/builders/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bigint"), exports);
 __exportStar(require("./date"), exports);
 __exportStar(require("./enum"), exports);
 __exportStar(require("./lazy"), exports);

package/core/schemas/builders/lazy/lazy.d.ts

@@ -1,5 +1,5 @@
 import { BaseSchema, Schema } from "../../Schema";
-export declare type SchemaGetter<SchemaType extends Schema<any, any>> = () => SchemaType | Promise<SchemaType>;
+export declare type SchemaGetter<SchemaType extends Schema<any, any>> = () => SchemaType;
 export declare function lazy<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): Schema<Raw, Parsed>;
 export declare function constructLazyBaseSchema<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): BaseSchema<Raw, Parsed>;
-export declare function getMemoizedSchema<SchemaType extends Schema<any, any>>(getter: SchemaGetter<SchemaType>): Promise<SchemaType>;
+export declare function getMemoizedSchema<SchemaType extends Schema<any, any>>(getter: SchemaGetter<SchemaType>): SchemaType;

package/core/schemas/builders/lazy/lazy.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMemoizedSchema = exports.constructLazyBaseSchema = exports.lazy = void 0;
 const schema_utils_1 = require("../schema-utils");
@@ -18,19 +9,17 @@ function lazy(getter) {
 exports.lazy = lazy;
 function constructLazyBaseSchema(getter) {
     return {
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).parse(raw, opts); }),
-        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).json(parsed, opts); }),
-        getType: () => __awaiter(this, void 0, void 0, function* () { return (yield getMemoizedSchema(getter)).getType(); }),
+        parse: (raw, opts) => getMemoizedSchema(getter).parse(raw, opts),
+        json: (parsed, opts) => getMemoizedSchema(getter).json(parsed, opts),
+        getType: () => getMemoizedSchema(getter).getType(),
     };
 }
 exports.constructLazyBaseSchema = constructLazyBaseSchema;
 function getMemoizedSchema(getter) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const castedGetter = getter;
-        if (castedGetter.__zurg_memoized == null) {
-            castedGetter.__zurg_memoized = yield getter();
-        }
-        return castedGetter.__zurg_memoized;
-    });
+    const castedGetter = getter;
+    if (castedGetter.__zurg_memoized == null) {
+        castedGetter.__zurg_memoized = getter();
+    }
+    return castedGetter.__zurg_memoized;
 }
 exports.getMemoizedSchema = getMemoizedSchema;

package/core/schemas/builders/lazy/lazyObject.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lazyObject = void 0;
 const object_1 = require("../object");
@@ -15,7 +6,7 @@ const object_like_1 = require("../object-like");
 const schema_utils_1 = require("../schema-utils");
 const lazy_1 = require("./lazy");
 function lazyObject(getter) {
-    const baseSchema = Object.assign(Object.assign({}, (0, lazy_1.constructLazyBaseSchema)(getter)), { _getRawProperties: () => __awaiter(this, void 0, void 0, function* () { return (yield (0, lazy_1.getMemoizedSchema)(getter))._getRawProperties(); }), _getParsedProperties: () => __awaiter(this, void 0, void 0, function* () { return (yield (0, lazy_1.getMemoizedSchema)(getter))._getParsedProperties(); }) });
+    const baseSchema = Object.assign(Object.assign({}, (0, lazy_1.constructLazyBaseSchema)(getter)), { _getRawProperties: () => (0, lazy_1.getMemoizedSchema)(getter)._getRawProperties(), _getParsedProperties: () => (0, lazy_1.getMemoizedSchema)(getter)._getParsedProperties() });
     return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), (0, object_1.getObjectUtils)(baseSchema));
 }
 exports.lazyObject = lazyObject;

package/core/schemas/builders/list/list.js

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.list = void 0;
 const Schema_1 = require("../../Schema");
@@ -16,11 +7,9 @@ const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
 function list(schema) {
     const baseSchema = {
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
-            return validateAndTransformArray(raw, (item, index) => {
-                var _a;
-                return schema.parse(item, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `[${index}]`] }));
-            });
+        parse: (raw, opts) => validateAndTransformArray(raw, (item, index) => {
+            var _a;
+            return schema.parse(item, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `[${index}]`] }));
         }),
         json: (parsed, opts) => validateAndTransformArray(parsed, (item, index) => {
             var _a;
@@ -32,37 +21,35 @@ function list(schema) {
 }
 exports.list = list;
 function validateAndTransformArray(value, transformItem) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!Array.isArray(value)) {
+    if (!Array.isArray(value)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "list"),
+                    path: [],
+                },
+            ],
+        };
+    }
+    const maybeValidItems = value.map((item, index) => transformItem(item, index));
+    return maybeValidItems.reduce((acc, item) => {
+        if (acc.ok && item.ok) {
             return {
-                ok: false,
-                errors: [
-                    {
-                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "list"),
-                        path: [],
-                    },
-                ],
+                ok: true,
+                value: [...acc.value, item.value],
             };
         }
-        const maybeValidItems = yield Promise.all(value.map((item, index) => transformItem(item, index)));
-        return maybeValidItems.reduce((acc, item) => {
-            if (acc.ok && item.ok) {
-                return {
-                    ok: true,
-                    value: [...acc.value, item.value],
-                };
-            }
-            const errors = [];
-            if (!acc.ok) {
-                errors.push(...acc.errors);
-            }
-            if (!item.ok) {
-                errors.push(...item.errors);
-            }
-            return {
-                ok: false,
-                errors,
-            };
-        }, { ok: true, value: [] });
-    });
+        const errors = [];
+        if (!acc.ok) {
+            errors.push(...acc.errors);
+        }
+        if (!item.ok) {
+            errors.push(...item.errors);
+        }
+        return {
+            ok: false,
+            errors,
+        };
+    }, { ok: true, value: [] });
 }

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

@@ -1,13 +1,4 @@
 "use strict";
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getObjectUtils = exports.object = void 0;
 const Schema_1 = require("../../Schema");
@@ -23,9 +14,9 @@ const schema_utils_1 = require("../schema-utils");
 const property_1 = require("./property");
 function object(schemas) {
     const baseSchema = {
-        _getRawProperties: () => Promise.resolve(Object.entries(schemas).map(([parsedKey, propertySchema]) => (0, property_1.isProperty)(propertySchema) ? propertySchema.rawKey : parsedKey)),
-        _getParsedProperties: () => Promise.resolve((0, keys_1.keys)(schemas)),
-        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+        _getRawProperties: () => Object.entries(schemas).map(([parsedKey, propertySchema]) => (0, property_1.isProperty)(propertySchema) ? propertySchema.rawKey : parsedKey),
+        _getParsedProperties: () => (0, keys_1.keys)(schemas),
+        parse: (raw, opts) => {
             const rawKeyToProperty = {};
             const requiredKeys = [];
             for (const [parsedKey, schemaOrObjectProperty] of (0, entries_1.entries)(schemas)) {
@@ -62,9 +53,10 @@ 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 (0, entries_1.entries)(schemas)) {
                 const valueSchema = (0, property_1.isProperty)(schemaOrObjectProperty)
@@ -105,110 +97,99 @@ 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: () => Schema_1.SchemaType.OBJECT,
     };
     return Object.assign(Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
 }
 exports.object = object;
 function validateAndTransformObject({ value, requiredKeys, getProperty, unrecognizedObjectKeys = "fail", skipValidation = false, breadcrumbsPrefix = [], }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!(0, isPlainObject_1.isPlainObject)(value)) {
-            return {
-                ok: false,
-                errors: [
-                    {
-                        path: breadcrumbsPrefix,
-                        message: (0, getErrorMessageForIncorrectType_1.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 (!(0, isPlainObject_1.isPlainObject)(value)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_1.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,
+        };
+    }
 }
 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: () => Schema_1.SchemaType.OBJECT,
             };
             return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
@@ -217,27 +198,25 @@ function getObjectUtils(schema) {
 }
 exports.getObjectUtils = getObjectUtils;
 function validateAndTransformExtendedObject({ extensionKeys, value, transformBase, transformExtension, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const extensionPropertiesSet = new Set(extensionKeys);
-        const [extensionProperties, baseProperties] = (0, partition_1.partition)((0, keys_1.keys)(value), (key) => extensionPropertiesSet.has(key));
-        const transformedBase = yield transformBase((0, filterObject_1.filterObject)(value, baseProperties));
-        const transformedExtension = yield transformExtension((0, filterObject_1.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] = (0, partition_1.partition)((0, keys_1.keys)(value), (key) => extensionPropertiesSet.has(key));
+    const transformedBase = transformBase((0, filterObject_1.filterObject)(value, baseProperties));
+    const transformedExtension = transformExtension((0, filterObject_1.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/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>;