@aptre/protobuf-es-lite 0.3.1 → 0.4.0

package/dist/enum.d.ts

@@ -1,3 +1,4 @@
+import { DescEnum } from "./index.js";
 /**
  * Reflection information for a protobuf enumeration.
  */
@@ -33,8 +34,17 @@ export interface EnumValueInfo {
      */
     readonly localName: string;
 }
-export declare function normalizeEnumValue(value: EnumValueInfo | Omit<EnumValueInfo, "localName">): EnumValueInfo;
 /**
  * Create a new EnumType with the given values.
  */
 export declare function createEnumType(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], _opt?: {}): EnumType;
+export declare function enumInfoZeroValue(values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[]): number;
+export declare function enumDescZeroValue(info: DescEnum): number;
+export declare function enumZeroValue<T extends EnumType>(info: T): number;
+/**
+ * Returns the normalized version of the enum value.
+ * Null is cast to the default value.
+ * String names are cast to the number enum.
+ * If string and the value is unknown, throws an error.
+ */
+export declare function normalizeEnumValue(info: EnumType, value: string | number | null | undefined): number;

package/dist/enum.js

@@ -1,9 +1,3 @@
-export function normalizeEnumValue(value) {
-    if ("localName" in value) {
-        return value;
-    }
-    return { ...value, localName: value.name };
-}
 /**
  * Create a new EnumType with the given values.
  */
@@ -16,7 +10,7 @@ _opt) {
     for (const value of values) {
         // We do not surface options at this time
         // const value: EnumValueInfo = {...v, options: v.options ?? emptyReadonlyObject};
-        const n = normalizeEnumValue(value);
+        const n = "localName" in value ? value : { ...value, localName: value.name };
         normalValues.push(n);
         names[value.name] = n;
         numbers[value.no] = n;
@@ -34,3 +28,58 @@ _opt) {
         },
     };
 }
+// enumInfoZeroValue returns the zero value for an enum info.
+export function enumInfoZeroValue(values) {
+    if (!values?.length) {
+        return 0;
+    }
+    // In proto3, the first enum value must be zero.
+    // In proto2, protobuf-go returns the first value as the default.
+    const zeroValue = values[0];
+    return zeroValue.no;
+}
+// enumDescZeroValue returns the zero value for an enum description.
+export function enumDescZeroValue(info) {
+    // In proto3, the first enum value must be zero.
+    // In proto2, protobuf-go returns the first value as the default.
+    if (info.values.length < 1) {
+        throw new Error("invalid enum: missing at least one value");
+    }
+    const zeroValue = info.values[0];
+    return zeroValue.number;
+}
+// enumZeroValue returns the zero value for an enum type.
+export function enumZeroValue(info) {
+    // In proto3, the first enum value must be zero.
+    // In proto2, protobuf-go returns the first value as the default.
+    if (info.values.length < 1) {
+        throw new Error("invalid enum: missing at least one value");
+    }
+    const zeroValue = info.values[0];
+    return zeroValue.no;
+}
+/**
+ * Returns the normalized version of the enum value.
+ * Null is cast to the default value.
+ * String names are cast to the number enum.
+ * If string and the value is unknown, throws an error.
+ */
+export function normalizeEnumValue(info, value) {
+    const zeroValue = enumZeroValue(info);
+    if (value == null) {
+        return zeroValue;
+    }
+    if (value === "" || value === zeroValue) {
+        return zeroValue;
+    }
+    if (typeof value === "string") {
+        // TODO: strip the type name prefix as well? MyEnum_VALUE
+        const val = info.findName(value);
+        if (!val) {
+            throw new Error(`enum ${info.typeName}: invalid value: "${value}"`);
+        }
+        return val.no;
+    }
+    // return the number value
+    return value;
+}

package/dist/field.d.ts

@@ -28,7 +28,42 @@ import { protoCamelCase } from "./names.js";
  * - "default": Only proto2: An explicit default value.
  * - "delimited": Only proto2: Use the tag-delimited group encoding.
  */
-export type FieldInfo = fiRules<fiScalar> | fiRules<fiEnum> | fiRules<fiMessage> | fiRules<fiMap>;
+export type FieldInfo = ScalarFieldInfo | EnumFieldInfo | MessageFieldInfo | MapFieldInfo;
+/**
+ * ScalarFieldInfo represents a scalar field.
+ * It includes rules for field presence, repetition, and packing.
+ */
+export type ScalarFieldInfo = fiRules<fiScalar>;
+/**
+ * EnumFieldInfo represents an enum field.
+ * It includes rules for field presence, repetition, and packing.
+ */
+export type EnumFieldInfo = fiRules<fiEnum>;
+/**
+ * MessageFieldInfo represents a message field.
+ * It includes rules for field presence, repetition, and packing.
+ */
+export type MessageFieldInfo = fiRules<fiMessage>;
+/**
+ * MapFieldInfo represents a map field with a scalar key type and
+ * a scalar, enum, or message value type.
+ * It includes rules for field presence, repetition, and packing.
+ */
+export type MapFieldInfo = fiRules<fiMap>;
+/**
+ * MapValueInfo represents the value type of a map field.
+ * The value can be a scalar, enum, or message type.
+ */
+export type MapValueInfo = {
+    readonly kind: "scalar";
+    readonly T: ScalarType;
+} | {
+    readonly kind: "enum";
+    readonly T: EnumType;
+} | {
+    readonly kind: "message";
+    readonly T: MessageType<any> | (() => MessageType<any>);
+};
 /**
  * Provides convenient access to field information of a message type.
  */
@@ -283,16 +318,7 @@ interface fiMap extends fiShared {
     /**
      * Map value type. Can be scalar, enum, or message.
      */
-    readonly V: {
-        readonly kind: "scalar";
-        readonly T: ScalarType;
-    } | {
-        readonly kind: "enum";
-        readonly T: EnumType;
-    } | {
-        readonly kind: "message";
-        readonly T: MessageType<any> | (() => MessageType<any>);
-    };
+    readonly V: MapValueInfo;
     /**
      * Is the field repeated? Never true for maps.
      */

package/dist/google/protobuf/wrappers.pb.js

@@ -68,7 +68,7 @@ export const DoubleValue = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return DoubleValue.create({ value: value ?? undefined });
+            return DoubleValue.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -104,7 +104,7 @@ export const FloatValue = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return FloatValue.create({ value: value ?? undefined });
+            return FloatValue.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -140,7 +140,7 @@ export const Int64Value = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return Int64Value.create({ value: value ?? undefined });
+            return Int64Value.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -176,7 +176,7 @@ export const UInt64Value = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return UInt64Value.create({ value: value ?? undefined });
+            return UInt64Value.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -212,7 +212,7 @@ export const Int32Value = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return Int32Value.create({ value: value ?? undefined });
+            return Int32Value.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -248,7 +248,7 @@ export const UInt32Value = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return UInt32Value.create({ value: value ?? undefined });
+            return UInt32Value.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -284,7 +284,7 @@ export const BoolValue = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return BoolValue.create({ value: value ?? undefined });
+            return BoolValue.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -320,7 +320,7 @@ export const StringValue = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return StringValue.create({ value: value ?? undefined });
+            return StringValue.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;
@@ -356,7 +356,7 @@ export const BytesValue = createMessageType({
     packedByDefault: true,
     fieldWrapper: {
         wrapField(value) {
-            return BytesValue.create({ value: value ?? undefined });
+            return BytesValue.createComplete({ value: value ?? undefined });
         },
         unwrapField(msg) {
             return msg.value;

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export { Message, CompleteMessage, AnyMessage, MessageType, Field, compareMessages, createMessageType, } from "./message.js";
 export { ServiceType, MethodInfo, MethodInfoUnary, MethodInfoServerStreaming, MethodInfoClientStreaming, MethodInfoBiDiStreaming, MethodKind, MethodIdempotency, } from "./service-type.js";
 export { isCompleteMessage, isCompleteField } from "./is-message.js";
-export { newFieldList, FieldList, PartialFieldInfo, FieldInfo, OneofInfo, fieldJsonName, } from "./field.js";
+export { FieldList, PartialFieldInfo, FieldInfo, ScalarFieldInfo, EnumFieldInfo, MessageFieldInfo, MapFieldInfo, OneofInfo, newFieldList, fieldJsonName, } from "./field.js";
 export { applyPartialMessage } from "./partial.js";
 export { scalarEquals, scalarZeroValue, isScalarZeroValue, ScalarType, ScalarValue, LongType, } from "./scalar.js";
-export { createEnumType, normalizeEnumValue } from "./enum.js";
+export { EnumType, EnumValueInfo, createEnumType, enumInfoZeroValue, enumZeroValue, enumDescZeroValue, normalizeEnumValue, } from "./enum.js";
 export { localName, localFieldName, localOneofName, findEnumSharedPrefix, camelToSnakeCase, protoCamelCase, safeObjectProperty, safeIdentifier, } from "./names.js";
 export { int64FromString, int64ToString, uInt64ToString } from "./varint.js";
 export { protoInt64 } from "./proto-int64.js";
@@ -15,3 +15,4 @@ export { DescComments, AnyDesc, DescEnum, DescEnumValue, DescExtension, DescFiel
 export { jsonReadEnum, jsonReadField, jsonReadMapKey, jsonReadScalar, jsonReadMessage, jsonWriteEnum, jsonWriteField, jsonWriteScalar, jsonWriteMessage, jsonDebugValue, JsonValue, JsonObject, JsonReadOptions, jsonMakeReadOptions, JsonWriteOptions, JsonWriteStringOptions, jsonMakeWriteOptions, } from "./json.js";
 export { binaryReadField, binaryReadMapEntry, binaryReadScalar, binaryReadScalarLTString, binaryReadMessage, binaryWriteField, binaryWriteScalar, binaryWritePacked, binaryWriteMapEntry, binaryWriteMessage, binaryMakeReadOptions, binaryMakeWriteOptions, BinaryReadOptions, BinaryWriteOptions, } from "./binary.js";
 export type { IMessageTypeRegistry, IServiceTypeRegistry, IEnumTypeRegistry, } from "./type-registry.js";
+export { compareFieldZeroValue, isMessageZeroValue, getFieldZeroValue, } from "./zero-value.js";

package/dist/index.js

@@ -1,10 +1,10 @@
 export { compareMessages, createMessageType, } from "./message.js";
 export { MethodKind, MethodIdempotency, } from "./service-type.js";
 export { isCompleteMessage, isCompleteField } from "./is-message.js";
-export { newFieldList, FieldList, fieldJsonName, } from "./field.js";
+export { FieldList, newFieldList, fieldJsonName, } from "./field.js";
 export { applyPartialMessage } from "./partial.js";
 export { scalarEquals, scalarZeroValue, isScalarZeroValue, ScalarType, LongType, } from "./scalar.js";
-export { createEnumType, normalizeEnumValue } from "./enum.js";
+export { createEnumType, enumInfoZeroValue, enumZeroValue, enumDescZeroValue, normalizeEnumValue, } from "./enum.js";
 export { localName, localFieldName, localOneofName, findEnumSharedPrefix, camelToSnakeCase, protoCamelCase, safeObjectProperty, safeIdentifier, } from "./names.js";
 export { int64FromString, int64ToString, uInt64ToString } from "./varint.js";
 export { protoInt64 } from "./proto-int64.js";
@@ -13,3 +13,4 @@ export { protoDouble } from "./proto-double.js";
 export { Timestamp, Duration, Any, Empty, DoubleValue, FloatValue, Int64Value, UInt64Value, Int32Value, UInt32Value, BoolValue, StringValue, BytesValue, Value, NullValue, ListValue, Struct, } from "./google/index.js";
 export { jsonReadEnum, jsonReadField, jsonReadMapKey, jsonReadScalar, jsonReadMessage, jsonWriteEnum, jsonWriteField, jsonWriteScalar, jsonWriteMessage, jsonDebugValue, jsonMakeReadOptions, jsonMakeWriteOptions, } from "./json.js";
 export { binaryReadField, binaryReadMapEntry, binaryReadScalar, binaryReadScalarLTString, binaryReadMessage, binaryWriteField, binaryWriteScalar, binaryWritePacked, binaryWriteMapEntry, binaryWriteMessage, binaryMakeReadOptions, binaryMakeWriteOptions, } from "./binary.js";
+export { compareFieldZeroValue, isMessageZeroValue, getFieldZeroValue, } from "./zero-value.js";

package/dist/message.d.ts

@@ -38,10 +38,14 @@ export interface MessageType<T extends Message<T> = AnyMessage> {
      * When used as a field, unwrap this message to a simple value.
      */
     readonly fieldWrapper?: FieldWrapper<T>;
+    /**
+     * Create a new empty instance of this message applying the partial message.
+     */
+    create(partial?: Message<T>): Message<T>;
     /**
      * Create a new instance of this message with zero values for fields.
      */
-    create(partial?: Message<T>): CompleteMessage<T>;
+    createComplete(partial?: Message<T>): CompleteMessage<T>;
     /**
      * Create a deep copy.
      */
@@ -109,6 +113,6 @@ export declare function createMessageType<T extends Message<T>, E extends Record
 export declare function compareMessages<T extends Message<T>>(fields: FieldList, a: T | undefined | null, b: T | undefined | null): boolean;
 export declare function cloneMessage<T extends Message<T>>(message: T, fields: FieldList): T;
 /**
- * createMessage recursively builds a message filled with zero values based on the given FieldList.
+ * createCompleteMessage recursively builds a message filled with zero values based on the given FieldList.
  */
-export declare function createMessage<T extends Message<T>>(fields: FieldList): CompleteMessage<T>;
+export declare function createCompleteMessage<T extends Message<T>>(fields: FieldList): CompleteMessage<T>;

package/dist/message.js

@@ -30,7 +30,12 @@ export function createMessageType(params, exts) {
         fields,
         fieldWrapper,
         create(partial) {
-            const message = createMessage(fields);
+            const message = Object.create(null);
+            applyPartialMessage(partial, message, fields);
+            return message;
+        },
+        createComplete(partial) {
+            const message = createCompleteMessage(fields);
             applyPartialMessage(partial, message, fields);
             return message;
         },
@@ -218,9 +223,9 @@ export function cloneMessage(message, fields) {
     return clone;
 }
 /**
- * createMessage recursively builds a message filled with zero values based on the given FieldList.
+ * createCompleteMessage recursively builds a message filled with zero values based on the given FieldList.
  */
-export function createMessage(fields) {
+export function createCompleteMessage(fields) {
     const message = {};
     for (const field of fields.list()) {
         const fieldKind = field.kind;
@@ -278,7 +283,7 @@ export function createMessage(fields) {
                     message[field.localName] = [];
                 }
                 else {
-                    message[field.localName] = createMessage(messageType.fields);
+                    message[field.localName] = createCompleteMessage(messageType.fields);
                 }
                 break;
             case "map":

package/dist/names.d.ts

@@ -41,3 +41,5 @@ export declare const safeObjectProperty: (name: string) => string;
  * Names that can be used for identifiers or class properties
  */
 export declare const safeIdentifier: (name: string) => string;
+export declare function checkSanitizeKey(key: string): boolean;
+export declare function throwSanitizeKey(key: string): void;

package/dist/names.js

@@ -32,12 +32,7 @@ export function localName(desc) {
             const pkg = desc.file.proto.package;
             const offset = pkg === undefined ? 0 : pkg.length + 1;
             const name = desc.typeName.substring(offset).replace(/\./g, "_");
-            // For services, we only care about safe identifiers, not safe object properties,
-            // but we have shipped v1 with a bug that respected object properties, and we
-            // do not want to introduce a breaking change, so we continue to escape for
-            // safe object properties.
-            // See https://github.com/bufbuild/protobuf-es/pull/391
-            return safeObjectProperty(safeIdentifier(name));
+            return safeIdentifier(name);
         }
         case "enum_value": {
             let name = desc.name;
@@ -219,20 +214,7 @@ const reservedObjectProperties = new Set([
  * Names that cannot be used for object properties because they are reserved
  * by the runtime.
  */
-const reservedMessageProperties = new Set([
-    // names reserved by the runtime
-    "getType",
-    "clone",
-    "equals",
-    "fromBinary",
-    "fromJson",
-    "fromJsonString",
-    "toBinary",
-    "toJson",
-    "toJsonString",
-    // names reserved by the runtime for the future
-    "toObject",
-]);
+const reservedMessageProperties = new Set(["__proto__"]);
 const fallback = (name) => `${name}$`;
 /**
  * Will wrap names that are Object prototype properties or names reserved
@@ -263,3 +245,14 @@ export const safeIdentifier = (name) => {
     }
     return name;
 };
+export function checkSanitizeKey(key) {
+    return typeof key === "string" && key !== "__proto__";
+}
+export function throwSanitizeKey(key) {
+    if (typeof key !== "string") {
+        throw new Error("illegal non-string object key: " + typeof key);
+    }
+    if (!checkSanitizeKey(key)) {
+        throw new Error("illegal object key: " + key);
+    }
+}

package/dist/partial.d.ts

@@ -1,3 +1,4 @@
-import { FieldList } from "./field.js";
+import { FieldList, MapValueInfo } from "./field.js";
 import { Message } from "./message.js";
 export declare function applyPartialMessage<T extends Message<T>>(source: Message<T> | undefined, target: Message<T>, fields: FieldList): void;
+export declare function applyPartialMap(sourceMap: Record<string, any> | undefined, targetMap: Record<string, any>, value: MapValueInfo): void;

package/dist/partial.js

@@ -1,99 +1,194 @@
+import { normalizeEnumValue } from "./enum.js";
 import { resolveMessageType } from "./field.js";
-import { ScalarType } from "./scalar.js";
-// applyPartialMessage applies a partial message to a message.
+import { createCompleteMessage } from "./message.js";
+import { throwSanitizeKey } from "./names.js";
+import { normalizeScalarValue } from "./scalar.js";
+// applyPartialMessage applies a partial source message to a target message.
 export function applyPartialMessage(source, target, fields) {
-    if (source === undefined) {
+    if (source == null || target == null) {
         return;
     }
+    const t = target, s = source;
     for (const member of fields.byMember()) {
-        const localName = member.localName, t = target, s = source;
-        if (s[localName] === undefined) {
+        const localName = member.localName;
+        throwSanitizeKey(localName);
+        if (!(localName in s) || s[localName] === undefined) {
+            continue;
+        }
+        const sourceValue = s[localName];
+        if (sourceValue === null) {
+            delete t[localName];
             continue;
         }
         switch (member.kind) {
             case "oneof":
-                const sk = s[localName].case;
-                if (sk === undefined) {
-                    continue;
+                if (typeof sourceValue !== "object") {
+                    throw new Error(`field ${localName}: invalid oneof: must be an object with case and value`);
+                }
+                // sk, sk are the source case and value
+                const { case: sk, value: sv } = sourceValue;
+                // sourceField is the field set by the source case, if any.
+                const sourceField = sk != null ? member.findField(sk) : null;
+                // dv is the destination oneof object
+                let dv = localName in t ? t[localName] : undefined;
+                if (typeof dv !== "object") {
+                    dv = Object.create(null);
+                }
+                // check the case is valid and throw if not
+                if (sk != null && sourceField == null) {
+                    throw new Error(`field ${localName}: invalid oneof case: ${sk}`);
+                }
+                // update the case
+                dv.case = sk;
+                // if the case was different or null, clear the value.
+                if (dv.case !== sk || sk == null) {
+                    delete dv.value;
                 }
-                const sourceField = member.findField(sk);
-                let val = s[localName].value;
-                if (sourceField?.kind == "message") {
-                    if (val === undefined) {
-                        val = {};
+                t[localName] = dv;
+                // stop here if there was no valid case selected
+                if (!sourceField) {
+                    break;
+                }
+                if (sourceField.kind === "message") {
+                    // apply the partial to the value
+                    let dest = dv.value;
+                    if (typeof dest !== "object") {
+                        dest = dv.value = Object.create(null);
+                    }
+                    // skip zero or null value
+                    if (sv != null) {
+                        const sourceFieldMt = resolveMessageType(sourceField.T);
+                        applyPartialMessage(sv, dest, sourceFieldMt.fields);
                     }
                 }
-                else if (sourceField &&
-                    sourceField.kind === "scalar" &&
-                    sourceField.T === ScalarType.BYTES) {
-                    val = toU8Arr(val);
+                else if (sourceField.kind === "scalar") {
+                    dv.value = normalizeScalarValue(sourceField.T, sv);
+                }
+                else {
+                    dv.value = sv;
                 }
-                t[localName] = { case: sk, value: val };
                 break;
             case "scalar":
+                if (member.repeated) {
+                    if (!Array.isArray(sourceValue)) {
+                        throw new Error(`field ${localName}: invalid value: must be array`);
+                    }
+                    let dst = localName in t ? t[localName] : null;
+                    if (dst == null || !Array.isArray(dst)) {
+                        dst = t[localName] = [];
+                    }
+                    dst.push(...sourceValue.map((v) => normalizeScalarValue(member.T, v)));
+                    break;
+                }
+                t[localName] = normalizeScalarValue(member.T, sourceValue);
+                break;
             case "enum":
-                let copy = s[localName];
-                if (member.T === ScalarType.BYTES) {
-                    copy =
-                        member.repeated ?
-                            copy.map(toU8Arr)
-                            : toU8Arr(copy);
-                }
-                t[localName] = copy;
+                t[localName] = normalizeEnumValue(member.T, sourceValue);
                 break;
             case "map":
-                switch (member.V.kind) {
-                    case "scalar":
-                    case "enum":
-                        if (member.V.T === ScalarType.BYTES) {
-                            for (const [k, v] of Object.entries(s[localName])) {
-                                t[localName][k] = toU8Arr(v);
-                            }
-                        }
-                        else {
-                            Object.assign(t[localName], s[localName]);
-                        }
-                        break;
-                    case "message":
-                        const messageType = resolveMessageType(member.V.T);
-                        for (const k of Object.keys(s[localName])) {
-                            let val = s[localName][k];
-                            if (!messageType.fieldWrapper) {
-                                if (val === undefined) {
-                                    val = {};
-                                }
-                            }
-                            t[localName][k] = val;
-                        }
-                        break;
+                if (typeof sourceValue !== "object") {
+                    throw new Error(`field ${member.localName}: invalid value: must be object`);
+                }
+                let tMap = t[localName];
+                if (typeof tMap !== "object") {
+                    tMap = t[localName] = Object.create(null);
                 }
+                applyPartialMap(sourceValue, tMap, member.V);
                 break;
             case "message":
                 const mt = resolveMessageType(member.T);
                 if (member.repeated) {
-                    t[localName] = s[localName].map((val) => val ?? {});
+                    // skip null or undefined values
+                    if (!Array.isArray(sourceValue)) {
+                        throw new Error(`field ${localName}: invalid value: must be array`);
+                    }
+                    let tArr = t[localName];
+                    if (!Array.isArray(tArr)) {
+                        tArr = t[localName] = [];
+                    }
+                    for (const v of sourceValue) {
+                        // skip null or undefined values
+                        if (v != null) {
+                            if (mt.fieldWrapper) {
+                                tArr.push(mt.fieldWrapper.unwrapField(mt.fieldWrapper.wrapField(v)));
+                            }
+                            else {
+                                tArr.push(mt.create(v));
+                            }
+                        }
+                    }
+                    break;
+                }
+                if (mt.fieldWrapper) {
+                    t[localName] = mt.fieldWrapper.unwrapField(mt.fieldWrapper.wrapField(sourceValue));
                 }
                 else {
-                    const val = s[localName];
-                    if (mt.fieldWrapper) {
-                        if (
-                        // We can't use BytesValue.typeName as that will create a circular import
-                        mt.typeName === "google.protobuf.BytesValue") {
-                            t[localName] = toU8Arr(val);
-                        }
-                        else {
-                            t[localName] = val;
-                        }
+                    if (typeof sourceValue !== "object") {
+                        throw new Error(`field ${member.localName}: invalid value: must be object`);
                     }
-                    else {
-                        t[localName] = val ?? {};
+                    let destMsg = t[localName];
+                    if (typeof destMsg !== "object") {
+                        destMsg = t[localName] = Object.create(null);
                     }
+                    applyPartialMessage(sourceValue, destMsg, mt.fields);
                 }
                 break;
         }
     }
 }
-// converts any ArrayLike<number> to Uint8Array if necessary.
-function toU8Arr(input) {
-    return input instanceof Uint8Array ? input : new Uint8Array(input);
+// applyPartialMap applies a partial source map to a target map.
+export function applyPartialMap(sourceMap, targetMap, value) {
+    if (sourceMap == null) {
+        return;
+    }
+    if (typeof sourceMap !== "object") {
+        throw new Error(`invalid map: must be object`);
+    }
+    switch (value.kind) {
+        case "scalar":
+            for (const [k, v] of Object.entries(sourceMap)) {
+                throwSanitizeKey(k);
+                if (v !== undefined) {
+                    targetMap[k] = normalizeScalarValue(value.T, v);
+                }
+                else {
+                    delete targetMap[k];
+                }
+            }
+            break;
+        case "enum":
+            for (const [k, v] of Object.entries(sourceMap)) {
+                throwSanitizeKey(k);
+                if (v !== undefined) {
+                    targetMap[k] = normalizeEnumValue(value.T, v);
+                }
+                else {
+                    delete targetMap[k];
+                }
+            }
+            break;
+        case "message":
+            const messageType = resolveMessageType(value.T);
+            for (const [k, v] of Object.entries(sourceMap)) {
+                throwSanitizeKey(k);
+                if (v === undefined) {
+                    delete targetMap[k];
+                    continue;
+                }
+                if (typeof v !== "object") {
+                    throw new Error(`invalid value: must be object`);
+                }
+                let val = targetMap[k];
+                if (!!messageType.fieldWrapper) {
+                    // For wrapper type messages, call createCompleteMessage.
+                    val = targetMap[k] = createCompleteMessage(messageType.fields);
+                }
+                else if (typeof val !== "object") {
+                    // Otherwise apply the partial to the existing value, if any.
+                    val = targetMap[k] = Object.create(null);
+                }
+                applyPartialMessage(v, val, messageType.fields);
+            }
+            break;
+    }
 }

package/dist/protoc-gen-es-lite/typescript.js

@@ -564,7 +564,7 @@ function generateWktFieldWrapper(f, message, ref) {
             const { typing } = getFieldTypeInfo(ref.value);
             f.print("  fieldWrapper: {");
             f.print("    wrapField(value: ", typing, " | null | undefined): ", message, " {");
-            f.print("      return ", message, ".create({ value: value ?? undefined });");
+            f.print("      return ", message, ".createComplete({ value: value ?? undefined });");
             f.print("    },");
             f.print("    unwrapField(msg: ", message, "): ", typing, " | null | undefined {");
             f.print("      return msg.", localName(ref.value), ";");

package/dist/scalar.d.ts

@@ -67,3 +67,11 @@ export declare function scalarZeroValue<T extends ScalarType, L extends LongType
  * optional or repeated.
  */
 export declare function isScalarZeroValue(type: ScalarType, value: unknown): boolean;
+/**
+ * Returns the normalized version of the scalar value.
+ * Zero or null is cast to the zero value.
+ * Bytes is cast to a Uint8Array.
+ * The BigInt long type is used.
+ */
+export declare function normalizeScalarValue<T>(type: ScalarType, value: T | null | undefined, longType?: LongType): T;
+export declare function toU8Arr(input: ArrayLike<number>): Uint8Array;

package/dist/scalar.js

@@ -161,3 +161,26 @@ export function isScalarZeroValue(type, value) {
             return value == 0; // Loose comparison matches 0n, 0 and "0"
     }
 }
+/**
+ * Returns the normalized version of the scalar value.
+ * Zero or null is cast to the zero value.
+ * Bytes is cast to a Uint8Array.
+ * The BigInt long type is used.
+ */
+export function normalizeScalarValue(type, value, longType = LongType.BIGINT) {
+    if (value == null) {
+        return scalarZeroValue(type, longType);
+    }
+    if (type === ScalarType.BYTES) {
+        return toU8Arr(value);
+    }
+    if (isScalarZeroValue(type, value)) {
+        return scalarZeroValue(type, longType);
+    }
+    // TODO: enforce correct type for other values as well.
+    return value;
+}
+// converts any ArrayLike<number> to Uint8Array if necessary.
+export function toU8Arr(input) {
+    return input instanceof Uint8Array ? input : new Uint8Array(input);
+}

package/dist/util.d.ts

@@ -15,7 +15,7 @@ export declare function getFieldDefaultValueExpression(field: DescField | DescEx
  *
  * Returns either:
  * - empty array literal for repeated fields
- * - empty object literal for maps
+ * - Object.create(null) for maps
  * - undefined for message fields
  * - an enums first value
  * - scalar zero value

package/dist/util.js

@@ -134,7 +134,7 @@ export function getFieldDefaultValueExpression(field, enumAs = "enum_value_as_is
  *
  * Returns either:
  * - empty array literal for repeated fields
- * - empty object literal for maps
+ * - Object.create(null) for maps
  * - undefined for message fields
  * - an enums first value
  * - scalar zero value
@@ -147,7 +147,7 @@ export function getFieldZeroValueExpression(field, enumAs = "enum_value_as_is")
         case "message":
             return undefined;
         case "map":
-            return "{}";
+            return "Object.create(null)";
         case "enum": {
             // In proto3, the first enum value must be zero.
             // In proto2, protobuf-go returns the first value as the default.

package/dist/zero-value.d.ts

@@ -0,0 +1,23 @@
+import { DescExtension, DescField } from "./descriptor-set.js";
+/**
+ * Returns the zero value for a field.
+ *
+ * Returns either:
+ * - empty array literal for repeated fields
+ * - Object.create(null) for maps
+ * - undefined for message fields
+ * - an enums first value
+ * - scalar zero value
+ */
+export declare function getFieldZeroValue(field: DescField | DescExtension): any;
+/**
+ * Returns true for a zero-value (all fields are zero).
+ *
+ * In proto3, zero-values are not written to the wire, unless the field is
+ * optional or repeated.
+ */
+export declare function isMessageZeroValue<T extends Record<string, any>>(value: T | null | undefined, fields: (DescField | DescExtension)[]): boolean;
+/**
+ * Compares if the value is considered a zero value for the field.
+ */
+export declare function compareFieldZeroValue<T>(field: DescField | DescExtension, value: T | null | undefined): boolean;

package/dist/zero-value.js

@@ -0,0 +1,88 @@
+import { enumDescZeroValue } from "./enum.js";
+import { localName } from "./names.js";
+import { scalarZeroValue } from "./scalar.js";
+/**
+ * Returns the zero value for a field.
+ *
+ * Returns either:
+ * - empty array literal for repeated fields
+ * - Object.create(null) for maps
+ * - undefined for message fields
+ * - an enums first value
+ * - scalar zero value
+ */
+export function getFieldZeroValue(field) {
+    if (field.repeated) {
+        return [];
+    }
+    switch (field.fieldKind) {
+        case "message":
+            return undefined;
+        case "map":
+            return Object.create(null);
+        case "enum": {
+            return enumDescZeroValue(field.enum);
+        }
+        case "scalar": {
+            return scalarZeroValue(field.scalar, field.longType);
+        }
+    }
+}
+/**
+ * Returns true for a zero-value (all fields are zero).
+ *
+ * In proto3, zero-values are not written to the wire, unless the field is
+ * optional or repeated.
+ */
+export function isMessageZeroValue(value, fields) {
+    if (value == null) {
+        return true;
+    }
+    if (typeof value !== "object") {
+        return false;
+    }
+    for (const field of fields) {
+        const fieldLocalName = localName(field);
+        if (fieldLocalName in value &&
+            !compareFieldZeroValue(field, value[fieldLocalName])) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Compares if the value is considered a zero value for the field.
+ */
+export function compareFieldZeroValue(field, value) {
+    if (value == null || value == 0) {
+        return true;
+    }
+    if (field.repeated) {
+        if (!Array.isArray(value) || typeof value.length !== "number") {
+            throw new Error("invalid repeated field: must be an array");
+        }
+        return value.length === 0;
+    }
+    switch (field.fieldKind) {
+        case "message":
+            if (typeof value !== "object") {
+                throw new Error("invalid message: must be an object");
+            }
+            // We need to check if all the fields are empty.
+            return isMessageZeroValue(value, field.message.fields);
+        case "map":
+            return Object.create(null);
+        case "enum": {
+            // In proto3, the first enum value must be zero.
+            // In proto2, protobuf-go returns the first value as the default.
+            if (field.enum.values.length < 1) {
+                throw new Error("invalid enum: missing at least one value");
+            }
+            const zeroValue = field.enum.values[0];
+            return zeroValue.number === value;
+        }
+        case "scalar": {
+            return scalarZeroValue(field.scalar, field.longType) === value;
+        }
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aptre/protobuf-es-lite",
   "description": "Lightweight Protobuf codegen for TypeScript and JavaScript.",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "license": "Apache-2.0",
   "repository": {
     "url": "git+ssh://git@github.com/aperturerobotics/protobuf-es-lite.git"