@sachitv/avro-typescript 0.4.2 → 0.5.0

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

@@ -0,0 +1,44 @@
+import type { Type } from "../type.js";
+import type { CompiledSyncWriter, CompiledWriter, RecordWriterContext, RecordWriterStrategy } from "./record_writer_strategy.js";
+/**
+ * Cache for compiled record writers with support for recursive types.
+ *
+ * This class manages the four cache slots (strict/unchecked × sync/async)
+ * and implements the placeholder pattern that allows recursive record types
+ * to compile without infinite recursion.
+ */
+export declare class RecordWriterCache {
+    #private;
+    /**
+     * Creates a new RecordWriterCache.
+     * @param strategy The writer strategy to use for compilation.
+     */
+    constructor(strategy?: RecordWriterStrategy);
+    /**
+     * Gets the writer strategy.
+     */
+    getStrategy(): RecordWriterStrategy;
+    /**
+     * Clears all cached writers.
+     * Call this when the record's fields change.
+     */
+    clear(): void;
+    /**
+     * Gets or creates a compiled async writer.
+     *
+     * @param validate Whether to validate values during writes.
+     * @param context The record writer context.
+     * @param getNestedWriter Callback to get writers for nested RecordTypes.
+     * @returns The compiled writer function.
+     */
+    getOrCreateWriter(validate: boolean, context: RecordWriterContext, getNestedWriter: (type: Type, validate: boolean) => CompiledWriter): CompiledWriter;
+    /**
+     * Gets or creates a compiled sync writer.
+     *
+     * @param validate Whether to validate values during writes.
+     * @param context The record writer context.
+     * @param getNestedWriter Callback to get writers for nested RecordTypes.
+     * @returns The compiled sync writer function.
+     */
+    getOrCreateSyncWriter(validate: boolean, context: RecordWriterContext, getNestedWriter: (type: Type, validate: boolean) => CompiledSyncWriter): CompiledSyncWriter;
+}

package/esm/schemas/complex/record_writer_cache.js

@@ -0,0 +1,141 @@
+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 _RecordWriterCache_compiledSyncWriterStrict, _RecordWriterCache_compiledSyncWriterUnchecked, _RecordWriterCache_compiledWriterStrict, _RecordWriterCache_compiledWriterUnchecked, _RecordWriterCache_strategy;
+import { defaultWriterStrategy } from "./record_writer_strategy.js";
+/**
+ * Cache for compiled record writers with support for recursive types.
+ *
+ * This class manages the four cache slots (strict/unchecked × sync/async)
+ * and implements the placeholder pattern that allows recursive record types
+ * to compile without infinite recursion.
+ */
+export class RecordWriterCache {
+    /**
+     * Creates a new RecordWriterCache.
+     * @param strategy The writer strategy to use for compilation.
+     */
+    constructor(strategy = defaultWriterStrategy) {
+        _RecordWriterCache_compiledSyncWriterStrict.set(this, void 0);
+        _RecordWriterCache_compiledSyncWriterUnchecked.set(this, void 0);
+        _RecordWriterCache_compiledWriterStrict.set(this, void 0);
+        _RecordWriterCache_compiledWriterUnchecked.set(this, void 0);
+        _RecordWriterCache_strategy.set(this, void 0);
+        __classPrivateFieldSet(this, _RecordWriterCache_strategy, strategy, "f");
+    }
+    /**
+     * Gets the writer strategy.
+     */
+    getStrategy() {
+        return __classPrivateFieldGet(this, _RecordWriterCache_strategy, "f");
+    }
+    /**
+     * Clears all cached writers.
+     * Call this when the record's fields change.
+     */
+    clear() {
+        __classPrivateFieldSet(this, _RecordWriterCache_compiledSyncWriterStrict, undefined, "f");
+        __classPrivateFieldSet(this, _RecordWriterCache_compiledSyncWriterUnchecked, undefined, "f");
+        __classPrivateFieldSet(this, _RecordWriterCache_compiledWriterStrict, undefined, "f");
+        __classPrivateFieldSet(this, _RecordWriterCache_compiledWriterUnchecked, undefined, "f");
+    }
+    /**
+     * Gets or creates a compiled async writer.
+     *
+     * @param validate Whether to validate values during writes.
+     * @param context The record writer context.
+     * @param getNestedWriter Callback to get writers for nested RecordTypes.
+     * @returns The compiled writer function.
+     */
+    getOrCreateWriter(validate, context, getNestedWriter) {
+        const cached = validate
+            ? __classPrivateFieldGet(this, _RecordWriterCache_compiledWriterStrict, "f")
+            : __classPrivateFieldGet(this, _RecordWriterCache_compiledWriterUnchecked, "f");
+        if (cached) {
+            return cached;
+        }
+        // Support recursive record types by installing a placeholder before walking
+        // field types; recursive references will see this function and avoid
+        // infinite recursion during compilation. The impl array allows the
+        // placeholder to delegate to the actual writer once it's created.
+        const impl = [null];
+        const placeholder = (tap, value) => impl[0](tap, value);
+        if (validate) {
+            __classPrivateFieldSet(this, _RecordWriterCache_compiledWriterStrict, placeholder, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _RecordWriterCache_compiledWriterUnchecked, placeholder, "f");
+        }
+        // Compile field writers using the strategy
+        const fieldCount = context.fieldTypes.length;
+        const fieldWriters = new Array(fieldCount);
+        for (let i = 0; i < fieldCount; i++) {
+            const fieldType = context.fieldTypes[i];
+            fieldWriters[i] = __classPrivateFieldGet(this, _RecordWriterCache_strategy, "f").compileFieldWriter(fieldType, validate, getNestedWriter);
+        }
+        // Assemble the complete record writer
+        const actualWriter = __classPrivateFieldGet(this, _RecordWriterCache_strategy, "f").assembleRecordWriter(context, fieldWriters);
+        if (validate) {
+            __classPrivateFieldSet(this, _RecordWriterCache_compiledWriterStrict, actualWriter, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _RecordWriterCache_compiledWriterUnchecked, actualWriter, "f");
+        }
+        impl[0] = actualWriter;
+        return placeholder;
+    }
+    /**
+     * Gets or creates a compiled sync writer.
+     *
+     * @param validate Whether to validate values during writes.
+     * @param context The record writer context.
+     * @param getNestedWriter Callback to get writers for nested RecordTypes.
+     * @returns The compiled sync writer function.
+     */
+    getOrCreateSyncWriter(validate, context, getNestedWriter) {
+        const cached = validate
+            ? __classPrivateFieldGet(this, _RecordWriterCache_compiledSyncWriterStrict, "f")
+            : __classPrivateFieldGet(this, _RecordWriterCache_compiledSyncWriterUnchecked, "f");
+        if (cached) {
+            return cached;
+        }
+        // Support recursive record types by installing a placeholder before walking
+        // field types; recursive references will see this function and avoid
+        // infinite recursion during compilation. The impl array allows the
+        // placeholder to delegate to the actual writer once it's created.
+        const impl = [null];
+        const placeholder = (tap, value) => impl[0](tap, value);
+        if (validate) {
+            __classPrivateFieldSet(this, _RecordWriterCache_compiledSyncWriterStrict, placeholder, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _RecordWriterCache_compiledSyncWriterUnchecked, placeholder, "f");
+        }
+        // Compile field writers using the strategy
+        const fieldCount = context.fieldTypes.length;
+        const fieldWriters = new Array(fieldCount);
+        for (let i = 0; i < fieldCount; i++) {
+            const fieldType = context.fieldTypes[i];
+            fieldWriters[i] = __classPrivateFieldGet(this, _RecordWriterCache_strategy, "f").compileSyncFieldWriter(fieldType, validate, getNestedWriter);
+        }
+        // Assemble the complete record writer
+        const actualWriter = __classPrivateFieldGet(this, _RecordWriterCache_strategy, "f").assembleSyncRecordWriter(context, fieldWriters);
+        impl[0] = actualWriter;
+        if (validate) {
+            __classPrivateFieldSet(this, _RecordWriterCache_compiledSyncWriterStrict, actualWriter, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _RecordWriterCache_compiledSyncWriterUnchecked, actualWriter, "f");
+        }
+        return placeholder;
+    }
+}
+_RecordWriterCache_compiledSyncWriterStrict = new WeakMap(), _RecordWriterCache_compiledSyncWriterUnchecked = new WeakMap(), _RecordWriterCache_compiledWriterStrict = new WeakMap(), _RecordWriterCache_compiledWriterUnchecked = new WeakMap(), _RecordWriterCache_strategy = new WeakMap();

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

@@ -0,0 +1,123 @@
+import type { WritableTapLike } from "../../serialization/tap.js";
+import type { SyncWritableTapLike } from "../../serialization/tap_sync.js";
+import type { Type } from "../type.js";
+/**
+ * Compiled async writer function signature.
+ */
+export type CompiledWriter = (tap: WritableTapLike, value: unknown) => Promise<void>;
+/**
+ * Compiled sync writer function signature.
+ */
+export type CompiledSyncWriter = (tap: SyncWritableTapLike, value: unknown) => void;
+/**
+ * Context passed to strategy methods for assembling record writers.
+ */
+export interface RecordWriterContext {
+    /** Field names in order. */
+    fieldNames: string[];
+    /** Field types in order. */
+    fieldTypes: Type[];
+    /** Default value getters for each field (undefined if no default). */
+    fieldDefaultGetters: Array<(() => unknown) | undefined>;
+    /** Whether each field has a default value. */
+    fieldHasDefault: boolean[];
+    /** Whether to validate values during writes. */
+    validate: boolean;
+    /** Reference to the parent RecordType for error reporting. */
+    recordType: Type;
+    /** Callback to check if a value is a valid record object. */
+    isRecord: (value: unknown) => value is Record<string, unknown>;
+}
+/**
+ * Strategy interface for compiling record field writers.
+ *
+ * Implementations can choose different approaches:
+ * - CompiledWriterStrategy: Inlines primitive tap methods for performance
+ * - InterpretedWriterStrategy: Delegates to type.write() for simplicity
+ */
+export interface RecordWriterStrategy {
+    /**
+     * Compiles an async writer for a single field type.
+     * @param fieldType The type of the field.
+     * @param validate Whether to validate values.
+     * @param getRecordWriter Callback to get a writer for nested RecordTypes (handles recursion).
+     */
+    compileFieldWriter(fieldType: Type, validate: boolean, getRecordWriter: (type: Type, validate: boolean) => CompiledWriter): CompiledWriter;
+    /**
+     * Compiles a sync writer for a single field type.
+     * @param fieldType The type of the field.
+     * @param validate Whether to validate values.
+     * @param getRecordWriter Callback to get a writer for nested RecordTypes (handles recursion).
+     */
+    compileSyncFieldWriter(fieldType: Type, validate: boolean, getRecordWriter: (type: Type, validate: boolean) => CompiledSyncWriter): CompiledSyncWriter;
+    /**
+     * Assembles field writers into a complete async record writer.
+     * @param context The record writer context.
+     * @param fieldWriters Pre-compiled writers for each field.
+     */
+    assembleRecordWriter(context: RecordWriterContext, fieldWriters: CompiledWriter[]): CompiledWriter;
+    /**
+     * Assembles field writers into a complete sync record writer.
+     * @param context The record writer context.
+     * @param fieldWriters Pre-compiled writers for each field.
+     */
+    assembleSyncRecordWriter(context: RecordWriterContext, fieldWriters: CompiledSyncWriter[]): CompiledSyncWriter;
+}
+/**
+ * Compiled writer strategy that inlines primitive tap methods for performance.
+ *
+ * This is the default strategy that provides optimized serialization by:
+ * - Inlining primitive type writes directly to tap methods
+ * - Using unchecked writes when validation is disabled
+ * - Supporting recursive record types via the getRecordWriter callback
+ */
+export declare class CompiledWriterStrategy implements RecordWriterStrategy {
+    #private;
+    /**
+     * Compiles an async writer for a single field type with primitive inlining.
+     */
+    compileFieldWriter(fieldType: Type, validate: boolean, getRecordWriter: (type: Type, validate: boolean) => CompiledWriter): CompiledWriter;
+    /**
+     * Compiles a sync writer for a single field type with primitive inlining.
+     */
+    compileSyncFieldWriter(fieldType: Type, validate: boolean, getRecordWriter: (type: Type, validate: boolean) => CompiledSyncWriter): CompiledSyncWriter;
+    /**
+     * Assembles an async record writer from field writers.
+     */
+    assembleRecordWriter(context: RecordWriterContext, fieldWriters: CompiledWriter[]): CompiledWriter;
+    /**
+     * Assembles a sync record writer from field writers.
+     */
+    assembleSyncRecordWriter(context: RecordWriterContext, fieldWriters: CompiledSyncWriter[]): CompiledSyncWriter;
+}
+/**
+ * Interpreted writer strategy that delegates to type.write() methods.
+ *
+ * This strategy provides simpler, more straightforward serialization by
+ * delegating all writes to the type's own write methods. It's useful for:
+ * - Debugging and testing
+ * - Scenarios where compilation overhead isn't worth the performance gain
+ * - Future extensibility without recompilation
+ */
+export declare class InterpretedWriterStrategy implements RecordWriterStrategy {
+    /**
+     * Compiles an async writer that delegates to the type's write method.
+     */
+    compileFieldWriter(fieldType: Type, validate: boolean, _getRecordWriter: (type: Type, validate: boolean) => CompiledWriter): CompiledWriter;
+    /**
+     * Compiles a sync writer that delegates to the type's writeSync method.
+     */
+    compileSyncFieldWriter(fieldType: Type, validate: boolean, _getRecordWriter: (type: Type, validate: boolean) => CompiledSyncWriter): CompiledSyncWriter;
+    /**
+     * Assembles an async record writer from field writers.
+     */
+    assembleRecordWriter(context: RecordWriterContext, fieldWriters: CompiledWriter[]): CompiledWriter;
+    /**
+     * Assembles a sync record writer from field writers.
+     */
+    assembleSyncRecordWriter(context: RecordWriterContext, fieldWriters: CompiledSyncWriter[]): CompiledSyncWriter;
+}
+/**
+ * Default strategy instance used when no strategy is specified.
+ */
+export declare const defaultWriterStrategy: RecordWriterStrategy;

package/esm/schemas/complex/record_writer_strategy.js

@@ -0,0 +1,309 @@
+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 _a, _CompiledWriterStrategy_compileUncheckedWriter, _CompiledWriterStrategy_compileUncheckedSyncWriter;
+import { throwInvalidError } from "../error.js";
+import { BooleanType } from "../primitive/boolean_type.js";
+import { BytesType } from "../primitive/bytes_type.js";
+import { DoubleType } from "../primitive/double_type.js";
+import { FloatType } from "../primitive/float_type.js";
+import { IntType } from "../primitive/int_type.js";
+import { LongType } from "../primitive/long_type.js";
+import { NullType } from "../primitive/null_type.js";
+import { StringType } from "../primitive/string_type.js";
+/**
+ * Checks if a type is a RecordType without importing it (avoids circular dependency).
+ */
+function isRecordType(type) {
+    return type.constructor.name === "RecordType";
+}
+/**
+ * Compiled writer strategy that inlines primitive tap methods for performance.
+ *
+ * This is the default strategy that provides optimized serialization by:
+ * - Inlining primitive type writes directly to tap methods
+ * - Using unchecked writes when validation is disabled
+ * - Supporting recursive record types via the getRecordWriter callback
+ */
+export class CompiledWriterStrategy {
+    /**
+     * Compiles an async writer for a single field type with primitive inlining.
+     */
+    compileFieldWriter(fieldType, validate, getRecordWriter) {
+        if (isRecordType(fieldType)) {
+            return getRecordWriter(fieldType, validate);
+        }
+        if (!validate) {
+            return __classPrivateFieldGet(_a, _a, "m", _CompiledWriterStrategy_compileUncheckedWriter).call(_a, fieldType);
+        }
+        return (tap, value) => fieldType.write(tap, value);
+    }
+    /**
+     * Compiles a sync writer for a single field type with primitive inlining.
+     */
+    compileSyncFieldWriter(fieldType, validate, getRecordWriter) {
+        if (isRecordType(fieldType)) {
+            return getRecordWriter(fieldType, validate);
+        }
+        if (!validate) {
+            return __classPrivateFieldGet(_a, _a, "m", _CompiledWriterStrategy_compileUncheckedSyncWriter).call(_a, fieldType);
+        }
+        return (tap, value) => fieldType.writeSync(tap, value);
+    }
+    /**
+     * Assembles an async record writer from field writers.
+     */
+    assembleRecordWriter(context, fieldWriters) {
+        const { fieldNames, fieldDefaultGetters, fieldHasDefault, validate, recordType, isRecord, } = context;
+        const fieldCount = fieldNames.length;
+        const hasAnyDefaults = fieldHasDefault.some((hasDefault) => hasDefault);
+        return async (tap, value) => {
+            if (validate && !isRecord(value)) {
+                throwInvalidError([], value, recordType);
+            }
+            const record = value;
+            if (!validate && !hasAnyDefaults) {
+                for (let i = 0; i < fieldCount; i++) {
+                    const name = fieldNames[i];
+                    await fieldWriters[i](tap, record[name]);
+                }
+                return;
+            }
+            for (let i = 0; i < fieldCount; i++) {
+                const name = fieldNames[i];
+                const hasValue = Object.hasOwn(record, name);
+                let toWrite;
+                if (hasValue) {
+                    toWrite = record[name];
+                }
+                else {
+                    const getter = fieldDefaultGetters[i];
+                    if (getter) {
+                        toWrite = getter();
+                    }
+                    else {
+                        if (validate) {
+                            throwInvalidError([name], undefined, recordType);
+                        }
+                        toWrite = undefined;
+                    }
+                }
+                await fieldWriters[i](tap, toWrite);
+            }
+        };
+    }
+    /**
+     * Assembles a sync record writer from field writers.
+     */
+    assembleSyncRecordWriter(context, fieldWriters) {
+        const { fieldNames, fieldDefaultGetters, fieldHasDefault, validate, recordType, isRecord, } = context;
+        const fieldCount = fieldNames.length;
+        const hasAnyDefaults = fieldHasDefault.some((hasDefault) => hasDefault);
+        return (tap, value) => {
+            if (validate && !isRecord(value)) {
+                throwInvalidError([], value, recordType);
+            }
+            const record = value;
+            if (!validate && !hasAnyDefaults) {
+                for (let i = 0; i < fieldCount; i++) {
+                    const name = fieldNames[i];
+                    fieldWriters[i](tap, record[name]);
+                }
+                return;
+            }
+            for (let i = 0; i < fieldCount; i++) {
+                const name = fieldNames[i];
+                const hasValue = Object.hasOwn(record, name);
+                let toWrite;
+                if (hasValue) {
+                    toWrite = record[name];
+                }
+                else {
+                    const getter = fieldDefaultGetters[i];
+                    if (getter) {
+                        toWrite = getter();
+                    }
+                    else {
+                        if (validate) {
+                            throwInvalidError([name], undefined, recordType);
+                        }
+                        toWrite = undefined;
+                    }
+                }
+                fieldWriters[i](tap, toWrite);
+            }
+        };
+    }
+}
+_a = CompiledWriterStrategy, _CompiledWriterStrategy_compileUncheckedWriter = function _CompiledWriterStrategy_compileUncheckedWriter(type) {
+    if (type instanceof NullType) {
+        return async () => { };
+    }
+    if (type instanceof BooleanType) {
+        return (tap, value) => tap.writeBoolean(value);
+    }
+    if (type instanceof IntType) {
+        return (tap, value) => tap.writeInt(value);
+    }
+    if (type instanceof LongType) {
+        return (tap, value) => tap.writeLong(value);
+    }
+    if (type instanceof FloatType) {
+        return (tap, value) => tap.writeFloat(value);
+    }
+    if (type instanceof DoubleType) {
+        return (tap, value) => tap.writeDouble(value);
+    }
+    if (type instanceof BytesType) {
+        return (tap, value) => tap.writeBytes(value);
+    }
+    if (type instanceof StringType) {
+        return (tap, value) => tap.writeString(value);
+    }
+    return (tap, value) => type.writeUnchecked(tap, value);
+}, _CompiledWriterStrategy_compileUncheckedSyncWriter = function _CompiledWriterStrategy_compileUncheckedSyncWriter(type) {
+    if (type instanceof NullType) {
+        return () => { };
+    }
+    if (type instanceof BooleanType) {
+        return (tap, value) => tap.writeBoolean(value);
+    }
+    if (type instanceof IntType) {
+        return (tap, value) => tap.writeInt(value);
+    }
+    if (type instanceof LongType) {
+        return (tap, value) => tap.writeLong(value);
+    }
+    if (type instanceof FloatType) {
+        return (tap, value) => tap.writeFloat(value);
+    }
+    if (type instanceof DoubleType) {
+        return (tap, value) => tap.writeDouble(value);
+    }
+    if (type instanceof BytesType) {
+        return (tap, value) => tap.writeBytes(value);
+    }
+    if (type instanceof StringType) {
+        return (tap, value) => tap.writeString(value);
+    }
+    return (tap, value) => type.writeSyncUnchecked(tap, value);
+};
+/**
+ * Interpreted writer strategy that delegates to type.write() methods.
+ *
+ * This strategy provides simpler, more straightforward serialization by
+ * delegating all writes to the type's own write methods. It's useful for:
+ * - Debugging and testing
+ * - Scenarios where compilation overhead isn't worth the performance gain
+ * - Future extensibility without recompilation
+ */
+export class InterpretedWriterStrategy {
+    /**
+     * Compiles an async writer that delegates to the type's write method.
+     */
+    compileFieldWriter(fieldType, validate, _getRecordWriter) {
+        if (validate) {
+            return (tap, value) => fieldType.write(tap, value);
+        }
+        return (tap, value) => fieldType.writeUnchecked(tap, value);
+    }
+    /**
+     * Compiles a sync writer that delegates to the type's writeSync method.
+     */
+    compileSyncFieldWriter(fieldType, validate, _getRecordWriter) {
+        if (validate) {
+            return (tap, value) => fieldType.writeSync(tap, value);
+        }
+        return (tap, value) => fieldType.writeSyncUnchecked(tap, value);
+    }
+    /**
+     * Assembles an async record writer from field writers.
+     */
+    assembleRecordWriter(context, fieldWriters) {
+        const { fieldNames, fieldDefaultGetters, fieldHasDefault, validate, recordType, isRecord, } = context;
+        const fieldCount = fieldNames.length;
+        const hasAnyDefaults = fieldHasDefault.some((hasDefault) => hasDefault);
+        return async (tap, value) => {
+            if (validate && !isRecord(value)) {
+                throwInvalidError([], value, recordType);
+            }
+            const record = value;
+            if (!validate && !hasAnyDefaults) {
+                for (let i = 0; i < fieldCount; i++) {
+                    const name = fieldNames[i];
+                    await fieldWriters[i](tap, record[name]);
+                }
+                return;
+            }
+            for (let i = 0; i < fieldCount; i++) {
+                const name = fieldNames[i];
+                const hasValue = Object.hasOwn(record, name);
+                let toWrite;
+                if (hasValue) {
+                    toWrite = record[name];
+                }
+                else {
+                    const getter = fieldDefaultGetters[i];
+                    if (getter) {
+                        toWrite = getter();
+                    }
+                    else {
+                        if (validate) {
+                            throwInvalidError([name], undefined, recordType);
+                        }
+                        toWrite = undefined;
+                    }
+                }
+                await fieldWriters[i](tap, toWrite);
+            }
+        };
+    }
+    /**
+     * Assembles a sync record writer from field writers.
+     */
+    assembleSyncRecordWriter(context, fieldWriters) {
+        const { fieldNames, fieldDefaultGetters, fieldHasDefault, validate, recordType, isRecord, } = context;
+        const fieldCount = fieldNames.length;
+        const hasAnyDefaults = fieldHasDefault.some((hasDefault) => hasDefault);
+        return (tap, value) => {
+            if (validate && !isRecord(value)) {
+                throwInvalidError([], value, recordType);
+            }
+            const record = value;
+            if (!validate && !hasAnyDefaults) {
+                for (let i = 0; i < fieldCount; i++) {
+                    const name = fieldNames[i];
+                    fieldWriters[i](tap, record[name]);
+                }
+                return;
+            }
+            for (let i = 0; i < fieldCount; i++) {
+                const name = fieldNames[i];
+                const hasValue = Object.hasOwn(record, name);
+                let toWrite;
+                if (hasValue) {
+                    toWrite = record[name];
+                }
+                else {
+                    const getter = fieldDefaultGetters[i];
+                    if (getter) {
+                        toWrite = getter();
+                    }
+                    else {
+                        if (validate) {
+                            throwInvalidError([name], undefined, recordType);
+                        }
+                        toWrite = undefined;
+                    }
+                }
+                fieldWriters[i](tap, toWrite);
+            }
+        };
+    }
+}
+/**
+ * Default strategy instance used when no strategy is specified.
+ */
+export const defaultWriterStrategy = new CompiledWriterStrategy();