@sachitv/avro-typescript 0.4.1 → 0.5.0

package/esm/schemas/complex/map_type.d.ts

@@ -1,14 +1,17 @@
-import { type ReadableTapLike, type WritableTapLike } from "../../serialization/tap.js";
+import type { ReadableTapLike, WritableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike, SyncWritableTapLike } from "../../serialization/tap_sync.js";
 import { BaseType } from "../base_type.js";
 import { Resolver } from "../resolver.js";
 import type { JSONType, Type } from "../type.js";
-import { type ErrorHook } from "../error.js";
+import type { ErrorHook } from "../error.js";
 /**
  * Parameters for creating a MapType.
  */
 export interface MapTypeParams<T> {
     /** The type of values in the map. */
     values: Type<T>;
+    /** Whether to validate during writes. Defaults to true. */
+    validate?: boolean;
 }
 /**
  * Helper function to read a map from a tap.
@@ -17,6 +20,13 @@ export interface MapTypeParams<T> {
  * @param collect Function to collect each key-value pair.
  */
 export declare function readMapInto<T>(tap: ReadableTapLike, readValue: (tap: ReadableTapLike) => Promise<T>, collect: (key: string, value: T) => void): Promise<void>;
+/**
+ * Synchronous helper function to read a map from a tap.
+ * @param tap The tap to read from.
+ * @param readValue Function to read a single value.
+ * @param collect Function to collect each key-value pair.
+ */
+export declare function readMapIntoSync<T>(tap: SyncReadableTapLike, readValue: (tap: SyncReadableTapLike) => T, collect: (key: string, value: T) => void): void;
 /**
  * Avro `map` type for string-keyed collections of values matching a schema.
  */
@@ -36,26 +46,33 @@ export declare class MapType<T = unknown> extends BaseType<Map<string, T>> {
      */
     check(value: unknown, errorHook?: ErrorHook, path?: string[]): boolean;
     /**
-     * Writes the map value to the tap.
-     * @param tap The writable tap to write to.
-     * @param value The map value to write.
+     * Writes map without validation.
+     */
+    writeUnchecked(tap: WritableTapLike, value: Map<string, T>): Promise<void>;
+    /**
+     * Writes map without validation synchronously.
      */
-    write(tap: WritableTapLike, value: Map<string, T>): Promise<void>;
+    writeSyncUnchecked(tap: SyncWritableTapLike, value: Map<string, T>): void;
     /**
      * Reads a map value from the provided tap.
      */
     read(tap: ReadableTapLike): Promise<Map<string, T>>;
+    /**
+     * Reads the map from a sync tap without asynchronous operations.
+     */
+    /**
+     * Resolves nested map entries synchronously using the value resolver.
+     */
+    readSync(tap: SyncReadableTapLike): Map<string, T>;
     /**
      * Skips over a map value in the tap without reading it.
      * @param tap The readable tap to skip from.
      */
     skip(tap: ReadableTapLike): Promise<void>;
     /**
-     * Serializes the map value to an ArrayBuffer.
-     * @param value The map value to serialize.
-     * @returns The serialized ArrayBuffer.
+     * Skips the encoded map blocks on the sync tap efficiently.
      */
-    toBuffer(value: Map<string, T>): Promise<ArrayBuffer>;
+    skipSync(tap: SyncReadableTapLike): void;
     /**
      * Creates a deep clone of the map from the given value.
      * @param value The value to clone, which can be a Map or a plain object.
@@ -88,6 +105,10 @@ export declare class MapType<T = unknown> extends BaseType<Map<string, T>> {
      * @throws Always throws an error.
      */
     match(_tap1: ReadableTapLike, _tap2: ReadableTapLike): Promise<number>;
+    /**
+     * Raises for maps because they cannot be compared even in sync mode.
+     */
+    matchSync(_tap1: SyncReadableTapLike, _tap2: SyncReadableTapLike): number;
     /**
      * Creates a resolver for schema evolution from a writer type to this reader type.
      * @param writerType The writer schema type.

package/esm/schemas/complex/map_type.js

@@ -10,13 +10,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _MapType_valuesType, _MapResolver_valueResolver;
-import { WritableTap, } from "../../serialization/tap.js";
-import { encode } from "../../serialization/text_encoding.js";
 import { bigIntToSafeNumber } from "../../serialization/conversion.js";
 import { BaseType } from "../base_type.js";
 import { Resolver } from "../resolver.js";
-import { throwInvalidError } from "../error.js";
-import { calculateVarintSize } from "../../internal/varint.js";
 /**
  * Helper function to read a map from a tap.
  * @param tap The tap to read from.
@@ -41,6 +37,33 @@ export async function readMapInto(tap, readValue, collect) {
         }
     }
 }
+/**
+ * Synchronous helper function to read a map from a tap.
+ * @param tap The tap to read from.
+ * @param readValue Function to read a single value.
+ * @param collect Function to collect each key-value pair.
+ */
+export function readMapIntoSync(tap, readValue, collect) {
+    /**
+     * Synchronously reads map blocks from the tap and populates the provided map.
+     */
+    while (true) {
+        let rawCount = tap.readLong();
+        if (rawCount === 0n) {
+            break;
+        }
+        if (rawCount < 0n) {
+            rawCount = -rawCount;
+            tap.skipLong();
+        }
+        const count = bigIntToSafeNumber(rawCount, "Map block length");
+        for (let i = 0; i < count; i++) {
+            const key = tap.readString();
+            const value = readValue(tap);
+            collect(key, value);
+        }
+    }
+}
 /**
  * Avro `map` type for string-keyed collections of values matching a schema.
  */
@@ -50,7 +73,7 @@ export class MapType extends BaseType {
      * @param params The map type parameters.
      */
     constructor(params) {
-        super();
+        super(params.validate ?? true);
         _MapType_valuesType.set(this, void 0);
         if (!params.values) {
             throw new Error("MapType requires a values type.");
@@ -95,26 +118,31 @@ export class MapType extends BaseType {
         return isValid;
     }
     /**
-     * Writes the map value to the tap.
-     * @param tap The writable tap to write to.
-     * @param value The map value to write.
+     * Writes map without validation.
      */
-    async write(tap, value) {
-        if (!(value instanceof Map)) {
-            throwInvalidError([], value, this);
-        }
+    async writeUnchecked(tap, value) {
         if (value.size > 0) {
             await tap.writeLong(BigInt(value.size));
             for (const [key, entry] of value) {
-                if (typeof key !== "string") {
-                    throwInvalidError([], value, this);
-                }
                 await tap.writeString(key);
-                await __classPrivateFieldGet(this, _MapType_valuesType, "f").write(tap, entry);
+                await __classPrivateFieldGet(this, _MapType_valuesType, "f").writeUnchecked(tap, entry);
             }
         }
         await tap.writeLong(0n);
     }
+    /**
+     * Writes map without validation synchronously.
+     */
+    writeSyncUnchecked(tap, value) {
+        if (value.size > 0) {
+            tap.writeLong(BigInt(value.size));
+            for (const [key, entry] of value) {
+                tap.writeString(key);
+                __classPrivateFieldGet(this, _MapType_valuesType, "f").writeSyncUnchecked(tap, entry);
+            }
+        }
+        tap.writeLong(0n);
+    }
     /**
      * Reads a map value from the provided tap.
      */
@@ -125,6 +153,19 @@ export class MapType extends BaseType {
         });
         return result;
     }
+    /**
+     * Reads the map from a sync tap without asynchronous operations.
+     */
+    /**
+     * Resolves nested map entries synchronously using the value resolver.
+     */
+    readSync(tap) {
+        const result = new Map();
+        readMapIntoSync(tap, (innerTap) => __classPrivateFieldGet(this, _MapType_valuesType, "f").readSync(innerTap), (key, value) => {
+            result.set(key, value);
+        });
+        return result;
+    }
     /**
      * Skips over a map value in the tap without reading it.
      * @param tap The readable tap to skip from.
@@ -151,41 +192,28 @@ export class MapType extends BaseType {
         }
     }
     /**
-     * Serializes the map value to an ArrayBuffer.
-     * @param value The map value to serialize.
-     * @returns The serialized ArrayBuffer.
+     * Skips the encoded map blocks on the sync tap efficiently.
      */
-    async toBuffer(value) {
-        if (!(value instanceof Map)) {
-            throwInvalidError([], value, this);
-        }
-        const serializedEntries = [];
-        let totalSize = 1; // final zero block terminator
-        for (const [key, entry] of value.entries()) {
-            if (typeof key !== "string") {
-                throwInvalidError([], value, this);
+    skipSync(tap) {
+        while (true) {
+            const rawCount = tap.readLong();
+            if (rawCount === 0n) {
+                break;
             }
-            const keyBytes = encode(key);
-            const valueBytes = new Uint8Array(await __classPrivateFieldGet(this, _MapType_valuesType, "f").toBuffer(entry));
-            totalSize += calculateVarintSize(keyBytes.length) + keyBytes.length;
-            totalSize += valueBytes.length;
-            serializedEntries.push({ keyBytes, valueBytes });
-        }
-        if (serializedEntries.length > 0) {
-            totalSize += calculateVarintSize(serializedEntries.length);
-        }
-        const buffer = new ArrayBuffer(totalSize);
-        const tap = new WritableTap(buffer);
-        if (serializedEntries.length > 0) {
-            await tap.writeLong(BigInt(serializedEntries.length));
-            for (const { keyBytes, valueBytes } of serializedEntries) {
-                await tap.writeLong(BigInt(keyBytes.length));
-                await tap.writeFixed(keyBytes);
-                await tap.writeFixed(valueBytes);
+            if (rawCount < 0n) {
+                const blockSize = tap.readLong();
+                const size = bigIntToSafeNumber(blockSize, "Map block size");
+                if (size > 0) {
+                    tap.skipFixed(size);
+                }
+                continue;
+            }
+            const count = bigIntToSafeNumber(rawCount, "Map block length");
+            for (let i = 0; i < count; i++) {
+                tap.skipString();
+                __classPrivateFieldGet(this, _MapType_valuesType, "f").skipSync(tap);
             }
         }
-        await tap.writeLong(0n);
-        return buffer;
     }
     /**
      * Creates a deep clone of the map from the given value.
@@ -256,6 +284,12 @@ export class MapType extends BaseType {
     async match(_tap1, _tap2) {
         throw new Error("maps cannot be compared");
     }
+    /**
+     * Raises for maps because they cannot be compared even in sync mode.
+     */
+    matchSync(_tap1, _tap2) {
+        throw new Error("maps cannot be compared");
+    }
     /**
      * Creates a resolver for schema evolution from a writer type to this reader type.
      * @param writerType The writer schema type.
@@ -286,5 +320,12 @@ class MapResolver extends Resolver {
         });
         return result;
     }
+    readSync(tap) {
+        const result = new Map();
+        readMapIntoSync(tap, (innerTap) => __classPrivateFieldGet(this, _MapResolver_valueResolver, "f").readSync(innerTap), (key, value) => {
+            result.set(key, value);
+        });
+        return result;
+    }
 }
 _MapResolver_valueResolver = new WeakMap();

package/esm/schemas/complex/named_type.d.ts

@@ -10,7 +10,7 @@ export declare abstract class NamedType<T = unknown> extends BaseType<T> {
      * Creates a new NamedType.
      * @param resolvedNames The resolved names (full name, namespace, aliases).
      */
-    protected constructor(resolvedNames: ResolvedNames);
+    protected constructor(resolvedNames: ResolvedNames, validate?: boolean);
     /**
      * Fully qualified schema name.
      */

package/esm/schemas/complex/named_type.js

@@ -20,8 +20,8 @@ export class NamedType extends BaseType {
      * Creates a new NamedType.
      * @param resolvedNames The resolved names (full name, namespace, aliases).
      */
-    constructor(resolvedNames) {
-        super();
+    constructor(resolvedNames, validate = true) {
+        super(validate);
         _NamedType_fullName.set(this, void 0);
         _NamedType_namespace.set(this, void 0);
         _NamedType_aliases.set(this, void 0);

package/esm/schemas/complex/record_field.d.ts

@@ -0,0 +1,62 @@
+import { Type } from "../type.js";
+/**
+ * Specifies the sort order for record fields.
+ */
+export type RecordFieldOrder = "ascending" | "descending" | "ignore";
+/**
+ * Parameters for defining a record field.
+ */
+export interface RecordFieldParams {
+    /** The name of the field. */
+    name: string;
+    /** The type of the field. */
+    type: Type;
+    /** Optional aliases for the field. */
+    aliases?: string[];
+    /** Optional ordering for the field. */
+    order?: RecordFieldOrder;
+    /** Optional default value for the field. */
+    default?: unknown;
+}
+/**
+ * Represents a field in an Avro record type.
+ */
+export declare class RecordField {
+    #private;
+    /**
+     * Constructs a new RecordField instance.
+     */
+    constructor(params: RecordFieldParams);
+    /**
+     * Gets the name of the field.
+     */
+    getName(): string;
+    /**
+     * Gets the type of the field.
+     */
+    getType(): Type;
+    /**
+     * Gets the aliases of the field.
+     */
+    getAliases(): string[];
+    /**
+     * Gets the order of the field.
+     */
+    getOrder(): RecordFieldOrder;
+    /**
+     * Returns true if the field has a default value.
+     */
+    hasDefault(): boolean;
+    /**
+     * Gets the default value for the field.
+     * @returns The default value.
+     * @throws Error if the field has no default.
+     */
+    getDefault(): unknown;
+    /**
+     * Checks if the given name matches the field name or any of its aliases.
+     * @param name The name to check.
+     * @returns True if the name matches, false otherwise.
+     */
+    nameMatches(name: string): boolean;
+}

package/esm/schemas/complex/record_field.js

@@ -0,0 +1,112 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _a, _RecordField_name, _RecordField_type, _RecordField_aliases, _RecordField_order, _RecordField_hasDefault, _RecordField_defaultValue, _RecordField_isValidOrder;
+import { isValidName } from "./resolve_names.js";
+import { Type } from "../type.js";
+/**
+ * Represents a field in an Avro record type.
+ */
+export class RecordField {
+    /**
+     * Constructs a new RecordField instance.
+     */
+    constructor(params) {
+        _RecordField_name.set(this, void 0);
+        _RecordField_type.set(this, void 0);
+        _RecordField_aliases.set(this, void 0);
+        _RecordField_order.set(this, void 0);
+        _RecordField_hasDefault.set(this, void 0);
+        _RecordField_defaultValue.set(this, void 0);
+        const { name, type, aliases = [], order = "ascending" } = params;
+        if (typeof name !== "string" || !isValidName(name)) {
+            throw new Error(`Invalid record field name: ${name}`);
+        }
+        if (!(type instanceof Type)) {
+            throw new Error(`Invalid field type for ${name}`);
+        }
+        if (!__classPrivateFieldGet(_a, _a, "m", _RecordField_isValidOrder).call(_a, order)) {
+            throw new Error(`Invalid record field order: ${order}`);
+        }
+        __classPrivateFieldSet(this, _RecordField_name, name, "f");
+        __classPrivateFieldSet(this, _RecordField_type, type, "f");
+        __classPrivateFieldSet(this, _RecordField_order, order, "f");
+        const aliasSet = new Set();
+        const resolvedAliases = [];
+        for (const alias of aliases) {
+            if (typeof alias !== "string" || !isValidName(alias)) {
+                throw new Error(`Invalid record field alias: ${alias}`);
+            }
+            if (!aliasSet.has(alias)) {
+                aliasSet.add(alias);
+                resolvedAliases.push(alias);
+            }
+        }
+        __classPrivateFieldSet(this, _RecordField_aliases, resolvedAliases, "f");
+        __classPrivateFieldSet(this, _RecordField_hasDefault, Object.prototype.hasOwnProperty.call(params, "default"), "f");
+        if (__classPrivateFieldGet(this, _RecordField_hasDefault, "f")) {
+            __classPrivateFieldSet(this, _RecordField_defaultValue, __classPrivateFieldGet(this, _RecordField_type, "f").cloneFromValue(params.default), "f");
+        }
+    }
+    /**
+     * Gets the name of the field.
+     */
+    getName() {
+        return __classPrivateFieldGet(this, _RecordField_name, "f");
+    }
+    /**
+     * Gets the type of the field.
+     */
+    getType() {
+        return __classPrivateFieldGet(this, _RecordField_type, "f");
+    }
+    /**
+     * Gets the aliases of the field.
+     */
+    getAliases() {
+        return __classPrivateFieldGet(this, _RecordField_aliases, "f").slice();
+    }
+    /**
+     * Gets the order of the field.
+     */
+    getOrder() {
+        return __classPrivateFieldGet(this, _RecordField_order, "f");
+    }
+    /**
+     * Returns true if the field has a default value.
+     */
+    hasDefault() {
+        return __classPrivateFieldGet(this, _RecordField_hasDefault, "f");
+    }
+    /**
+     * Gets the default value for the field.
+     * @returns The default value.
+     * @throws Error if the field has no default.
+     */
+    getDefault() {
+        if (!__classPrivateFieldGet(this, _RecordField_hasDefault, "f")) {
+            throw new Error(`Field '${__classPrivateFieldGet(this, _RecordField_name, "f")}' has no default.`);
+        }
+        return __classPrivateFieldGet(this, _RecordField_type, "f").cloneFromValue(__classPrivateFieldGet(this, _RecordField_defaultValue, "f"));
+    }
+    /**
+     * Checks if the given name matches the field name or any of its aliases.
+     * @param name The name to check.
+     * @returns True if the name matches, false otherwise.
+     */
+    nameMatches(name) {
+        return name === __classPrivateFieldGet(this, _RecordField_name, "f") || __classPrivateFieldGet(this, _RecordField_aliases, "f").includes(name);
+    }
+}
+_a = RecordField, _RecordField_name = new WeakMap(), _RecordField_type = new WeakMap(), _RecordField_aliases = new WeakMap(), _RecordField_order = new WeakMap(), _RecordField_hasDefault = new WeakMap(), _RecordField_defaultValue = new WeakMap(), _RecordField_isValidOrder = function _RecordField_isValidOrder(order) {
+    return order === "ascending" || order === "descending" ||
+        order === "ignore";
+};

package/esm/schemas/complex/record_resolver.d.ts

@@ -0,0 +1,45 @@
+import type { ReadableTapLike } from "../../serialization/tap.js";
+import type { SyncReadableTapLike } from "../../serialization/tap_sync.js";
+import { Resolver } from "../resolver.js";
+import type { RecordField } from "./record_field.js";
+import type { RecordType } from "./record_type.js";
+/**
+ * Mapping between writer and reader fields during schema evolution.
+ */
+export interface FieldMapping {
+    /** Index in the reader's field array, or -1 if the field should be skipped. */
+    readerIndex: number;
+    /** The writer field being mapped. */
+    writerField: RecordField;
+    /** Optional resolver for type promotion between writer and reader field types. */
+    resolver?: Resolver;
+}
+/**
+ * Resolver for record schema evolution.
+ *
+ * Handles reading data written with a writer schema into a reader schema,
+ * mapping fields by name/alias, skipping removed fields, and applying
+ * default values for new fields.
+ */
+export declare class RecordResolver extends Resolver<Record<string, unknown>> {
+    #private;
+    /**
+     * Creates a new RecordResolver.
+     * @param reader The reader record type.
+     * @param mappings Field mappings from writer to reader.
+     * @param readerFields The reader's field definitions.
+     */
+    constructor(reader: RecordType, mappings: FieldMapping[], readerFields: RecordField[]);
+    /**
+     * Reads a record from the tap using the resolution mappings.
+     * @param tap The tap to read from.
+     * @returns The resolved record value.
+     */
+    read(tap: ReadableTapLike): Promise<Record<string, unknown>>;
+    /**
+     * Resolves incoming data synchronously, applying missing defaults as needed.
+     * @param tap The tap to read from.
+     * @returns The resolved record value.
+     */
+    readSync(tap: SyncReadableTapLike): Record<string, unknown>;
+}

package/esm/schemas/complex/record_resolver.js

@@ -0,0 +1,92 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RecordResolver_mappings, _RecordResolver_readerFields;
+import { Resolver } from "../resolver.js";
+/**
+ * Resolver for record schema evolution.
+ *
+ * Handles reading data written with a writer schema into a reader schema,
+ * mapping fields by name/alias, skipping removed fields, and applying
+ * default values for new fields.
+ */
+export class RecordResolver extends Resolver {
+    /**
+     * Creates a new RecordResolver.
+     * @param reader The reader record type.
+     * @param mappings Field mappings from writer to reader.
+     * @param readerFields The reader's field definitions.
+     */
+    constructor(reader, mappings, readerFields) {
+        super(reader);
+        _RecordResolver_mappings.set(this, void 0);
+        _RecordResolver_readerFields.set(this, void 0);
+        __classPrivateFieldSet(this, _RecordResolver_mappings, mappings, "f");
+        __classPrivateFieldSet(this, _RecordResolver_readerFields, readerFields, "f");
+    }
+    /**
+     * Reads a record from the tap using the resolution mappings.
+     * @param tap The tap to read from.
+     * @returns The resolved record value.
+     */
+    async read(tap) {
+        const result = {};
+        const seen = new Array(__classPrivateFieldGet(this, _RecordResolver_readerFields, "f").length).fill(false);
+        for (const mapping of __classPrivateFieldGet(this, _RecordResolver_mappings, "f")) {
+            if (mapping.readerIndex === -1) {
+                await mapping.writerField.getType().skip(tap);
+                continue;
+            }
+            const value = mapping.resolver
+                ? await mapping.resolver.read(tap)
+                : await mapping.writerField.getType().read(tap);
+            const readerField = __classPrivateFieldGet(this, _RecordResolver_readerFields, "f")[mapping.readerIndex];
+            result[readerField.getName()] = value;
+            seen[mapping.readerIndex] = true;
+        }
+        for (let i = 0; i < __classPrivateFieldGet(this, _RecordResolver_readerFields, "f").length; i++) {
+            if (!seen[i]) {
+                const field = __classPrivateFieldGet(this, _RecordResolver_readerFields, "f")[i];
+                result[field.getName()] = field.getDefault();
+            }
+        }
+        return result;
+    }
+    /**
+     * Resolves incoming data synchronously, applying missing defaults as needed.
+     * @param tap The tap to read from.
+     * @returns The resolved record value.
+     */
+    readSync(tap) {
+        const result = {};
+        const seen = new Array(__classPrivateFieldGet(this, _RecordResolver_readerFields, "f").length).fill(false);
+        for (const mapping of __classPrivateFieldGet(this, _RecordResolver_mappings, "f")) {
+            if (mapping.readerIndex === -1) {
+                mapping.writerField.getType().skipSync(tap);
+                continue;
+            }
+            const value = mapping.resolver
+                ? mapping.resolver.readSync(tap)
+                : mapping.writerField.getType().readSync(tap);
+            const readerField = __classPrivateFieldGet(this, _RecordResolver_readerFields, "f")[mapping.readerIndex];
+            result[readerField.getName()] = value;
+            seen[mapping.readerIndex] = true;
+        }
+        for (let i = 0; i < __classPrivateFieldGet(this, _RecordResolver_readerFields, "f").length; i++) {
+            if (!seen[i]) {
+                const field = __classPrivateFieldGet(this, _RecordResolver_readerFields, "f")[i];
+                result[field.getName()] = field.getDefault();
+            }
+        }
+        return result;
+    }
+}
+_RecordResolver_mappings = new WeakMap(), _RecordResolver_readerFields = new WeakMap();