@aptre/protobuf-es-lite 0.4.0 → 0.4.1

package/dist/binary.d.ts

@@ -50,7 +50,7 @@ declare function readMapEntry(field: FieldInfo & {
 }, reader: IBinaryReader, options: BinaryReadOptions): [string | number, ScalarValue | AnyMessage | undefined];
 declare function readScalar(reader: IBinaryReader, type: ScalarType): ScalarValue;
 declare function readScalarLTString(reader: IBinaryReader, type: ScalarType): Exclude<ScalarValue, bigint>;
-declare function readMessage<T>(message: T, fields: FieldList, reader: IBinaryReader, lengthOrEndTagFieldNo: number, options: BinaryReadOptions, delimitedMessageEncoding?: boolean): void;
+declare function readMessage<T>(message: T, fields: FieldList, reader: IBinaryReader, lengthOrEndTagFieldNo: number, options: BinaryReadOptions, delimitedMessageEncoding: boolean): void;
 /**
  * Serialize a message to binary data.
  */

package/dist/binary.js

@@ -1,6 +1,6 @@
 import { isFieldSet, resolveMessageType, } from "./field.js";
 import { handleUnknownField, unknownFieldsSymbol } from "./unknown.js";
-import { wrapField } from "./field-wrapper.js";
+import { unwrapField, wrapField } from "./field-wrapper.js";
 import { LongType, ScalarType, scalarZeroValue, } from "./scalar.js";
 import { assert } from "./assert.js";
 import { BinaryReader, BinaryWriter, WireType, } from "./binary-encoding.js";
@@ -26,7 +26,7 @@ reader, field, wireType, options) {
     if (field.oneof) {
         var oneofMsg = target[field.oneof.localName];
         if (!oneofMsg) {
-            oneofMsg = target[field.oneof.localName] = {};
+            oneofMsg = target[field.oneof.localName] = Object.create(null);
         }
         target = oneofMsg;
         if (target.case != localName) {
@@ -74,19 +74,16 @@ reader, field, wireType, options) {
                 if (!Array.isArray(tgtArr)) {
                     tgtArr = target[localName] = [];
                 }
-                tgtArr.push(readMessageField(reader, {}, messageType.fields, options, field));
+                tgtArr.push(unwrapField(messageType.fieldWrapper, readMessageField(reader, Object.create(null), messageType.fields, options, field)));
             }
             else {
-                target[localName] = readMessageField(reader, {}, messageType.fields, options, field);
-                if (messageType.fieldWrapper && !field.oneof && !field.repeated) {
-                    target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
-                }
+                target[localName] = unwrapField(messageType.fieldWrapper, readMessageField(reader, Object.create(null), messageType.fields, options, field));
             }
             break;
         case "map":
             let [mapKey, mapVal] = readMapEntry(field, reader, options);
             if (typeof target[localName] !== "object") {
-                target[localName] = {};
+                target[localName] = Object.create(null);
             }
             // safe to assume presence of map object, oneof cannot contain repeated values
             target[localName][mapKey] = mapVal;
@@ -113,7 +110,7 @@ function readMapEntry(field, reader, options) {
                         break;
                     case "message":
                         const messageType = resolveMessageType(field.V.T);
-                        val = readMessageField(reader, {}, messageType.fields, options, undefined);
+                        val = readMessageField(reader, Object.create(null), messageType.fields, options, undefined);
                         break;
                 }
                 break;
@@ -135,7 +132,7 @@ function readMapEntry(field, reader, options) {
                 val = field.V.T.values[0].no;
                 break;
             case "message":
-                val = {};
+                val = Object.create(null);
                 break;
         }
     }
@@ -184,13 +181,10 @@ function readScalarLTString(reader, type) {
 // Read a message, avoiding MessageType.fromBinary() to re-use the
 // BinaryReadOptions and the IBinaryReader.
 function readMessageField(reader, message, fields, options, field) {
-    const delimited = field?.delimited;
-    readMessage(message, fields, reader, delimited ? field.no : reader.uint32(), // eslint-disable-line @typescript-eslint/strict-boolean-expressions
-    options, delimited);
+    readMessage(message, fields, reader, field?.delimited ? field.no : reader.uint32(), options, field?.delimited ?? false);
     return message;
 }
 function readMessage(message, fields, reader, lengthOrEndTagFieldNo, options, delimitedMessageEncoding) {
-    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     const end = delimitedMessageEncoding ? reader.len : reader.pos + lengthOrEndTagFieldNo;
     let fieldNo, wireType;
     while (reader.pos < end) {
@@ -227,7 +221,9 @@ function writeMessage(message, fields, writer, options) {
         const value = field.oneof ?
             message[field.oneof.localName].value
             : message[field.localName];
-        writeField(field, value, writer, options);
+        if (value !== undefined) {
+            writeField(field, value, writer, options);
+        }
     }
     if (options.writeUnknownFields) {
         writeUnknownFields(message, writer);

package/dist/field-wrapper.d.ts

@@ -5,7 +5,15 @@ import { ScalarType } from "./scalar.js";
  * ergonomic for use as a message field.
  */
 export interface FieldWrapper<T = any, U = any> {
+    /**
+     * Wrap a primitive message field value in its corresponding wrapper
+     * message. This function is idempotent.
+     */
     wrapField(value: U | null | undefined): T;
+    /**
+     * If the given field uses one of the well-known wrapper types, return
+     * the primitive type it wraps.
+     */
     unwrapField(value: T): U | null | undefined;
 }
 /**
@@ -13,6 +21,11 @@ export interface FieldWrapper<T = any, U = any> {
  * message. This function is idempotent.
  */
 export declare function wrapField<T>(fieldWrapper: FieldWrapper<T> | undefined, value: any): T;
+/**
+ * Wrap a primitive message field value in its corresponding wrapper
+ * message. This function is idempotent.
+ */
+export declare function unwrapField<T, U = T>(fieldWrapper: FieldWrapper<T> | undefined, value: any): U;
 /**
  * If the given field uses one of the well-known wrapper types, return
  * the primitive type it wraps.

package/dist/field-wrapper.js

@@ -9,6 +9,13 @@ export function wrapField(fieldWrapper, value) {
     }
     return fieldWrapper.wrapField(value);
 }
+/**
+ * Wrap a primitive message field value in its corresponding wrapper
+ * message. This function is idempotent.
+ */
+export function unwrapField(fieldWrapper, value) {
+    return !!fieldWrapper ? fieldWrapper.unwrapField(value) : value;
+}
 /**
  * If the given field uses one of the well-known wrapper types, return
  * the primitive type it wraps.

package/dist/field.d.ts

@@ -113,7 +113,7 @@ export declare function newFieldList(fields: FieldListSource, packedByDefault: b
 /**
  * Returns true if the field is set.
  */
-export declare function isFieldSet(field: FieldInfo, target: Record<string, any>): boolean;
+export declare function isFieldSet(field: FieldInfo, target: Record<string, any> | null | undefined): boolean;
 /**
  * Returns the JSON name for a protobuf field, exactly like protoc does.
  */

package/dist/field.js

@@ -95,28 +95,32 @@ export function newFieldList(fields, packedByDefault) {
  */
 export function isFieldSet(field, target) {
     const localName = field.localName;
+    if (!target) {
+        return false;
+    }
     if (field.repeated) {
-        return target[localName].length > 0;
+        return !!target[localName]?.length;
     }
     if (field.oneof) {
-        return target[field.oneof.localName].case === localName; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
+        return target[field.oneof.localName]?.case === localName; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
     }
     switch (field.kind) {
         case "enum":
         case "scalar":
             if (field.opt || field.req) {
                 // explicit presence
-                return target[localName] !== undefined;
+                return target[localName] != null;
             }
             // implicit presence
             if (field.kind == "enum") {
                 return target[localName] !== field.T.values[0].no;
             }
+            // not zero value
             return !isScalarZeroValue(field.T, target[localName]);
         case "message":
-            return target[localName] !== undefined;
+            return target[localName] != null;
         case "map":
-            return Object.keys(target[localName]).length > 0; // eslint-disable-line @typescript-eslint/no-unsafe-argument
+            return (target[localName] != null && !!Object.keys(target[localName]).length); // eslint-disable-line @typescript-eslint/no-unsafe-argument
     }
 }
 /**

package/dist/google/protobuf/timestamp.pb.d.ts

@@ -118,7 +118,8 @@ export type Timestamp = Message<{
 declare const Timestamp_Wkt: {
     fromJson(json: JsonValue): Timestamp;
     toJson(msg: Timestamp): JsonValue;
-    toDate(msg: Timestamp): Date;
+    toDate(msg: Timestamp | null | undefined): Date | null;
+    fromDate(value: Date | null | undefined): Timestamp;
 };
 export declare const Timestamp: MessageType<Timestamp> & typeof Timestamp_Wkt;
 export {};

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

@@ -89,8 +89,20 @@ const Timestamp_Wkt = {
         return new Date(ms).toISOString().replace(".000Z", z);
     },
     toDate(msg) {
+        if (!msg?.seconds && !msg?.nanos) {
+            return null;
+        }
         return new Date(Number(msg.seconds ?? 0) * 1000 + Math.ceil((msg.nanos ?? 0) / 1000000));
     },
+    fromDate(value) {
+        if (value == null) {
+            return {};
+        }
+        const ms = value.getTime();
+        const seconds = Math.floor(ms / 1000);
+        const nanos = (ms % 1000) * 1000000;
+        return { seconds: protoInt64.parse(seconds), nanos: nanos };
+    },
 };
 // Timestamp contains the message type declaration for Timestamp.
 export const Timestamp = createMessageType({

package/dist/json.js

@@ -1,7 +1,8 @@
 import { isFieldSet, resolveMessageType, } from "./field.js";
 import { assert, assertFloat32, assertInt32, assertUInt32 } from "./assert.js";
-import { LongType, ScalarType, scalarZeroValue, } from "./scalar.js";
-import { wrapField } from "./field-wrapper.js";
+import { LongType, ScalarType, isScalarZeroValue, normalizeScalarValue, scalarZeroValue, } from "./scalar.js";
+import { unwrapField, wrapField } from "./field-wrapper.js";
+import { enumZeroValue, normalizeEnumValue } from "./enum.js";
 import { protoInt64 } from "./proto-int64.js";
 import { protoBase64 } from "./proto-base64.js";
 // Default options for parsing JSON.
@@ -65,7 +66,7 @@ function readMessage(fields, typeName, json, options, message) {
     return message;
 }
 function writeMessage(message, fields, options) {
-    const json = {};
+    const json = Object.create(null);
     let field;
     try {
         for (field of fields.byNumber()) {
@@ -123,7 +124,7 @@ function readField(target, jsonValue, field, options) {
             switch (field.kind) {
                 case "message":
                     const messageType = resolveMessageType(field.T);
-                    targetArray.push(messageType.fromJson(jsonItem, options));
+                    targetArray.push(unwrapField(messageType.fieldWrapper, messageType.fromJson(jsonItem, options)));
                     break;
                 case "enum":
                     const enumValue = readEnum(field.T, jsonItem, options.ignoreUnknownFields, true);
@@ -155,7 +156,7 @@ function readField(target, jsonValue, field, options) {
         }
         var targetMap = target[localName];
         if (typeof targetMap !== "object") {
-            targetMap = target[localName] = {};
+            targetMap = target[localName] = Object.create(null);
         }
         for (const [jsonMapKey, jsonMapValue] of Object.entries(jsonValue)) {
             if (jsonMapValue === null) {
@@ -210,11 +211,7 @@ function readField(target, jsonValue, field, options) {
                     messageType.typeName != "google.protobuf.Value") {
                     return;
                 }
-                let currentValue = target[localName];
-                target[localName] = currentValue = messageType.fromJson(jsonValue, options);
-                if (messageType.fieldWrapper && !field.oneof) {
-                    target[localName] = messageType.fieldWrapper.unwrapField(currentValue);
-                }
+                target[localName] = unwrapField(messageType.fieldWrapper, messageType.fromJson(jsonValue, options));
                 break;
             case "enum":
                 const enumValue = readEnum(field.T, jsonValue, options.ignoreUnknownFields, false);
@@ -418,7 +415,7 @@ export function clearField(field, target) {
     else {
         switch (field.kind) {
             case "map":
-                target[localName] = {};
+                target[localName] = Object.create(null);
                 break;
             case "enum":
                 target[localName] = implicitPresence ? field.T.values[0].no : undefined;
@@ -436,7 +433,6 @@ export function clearField(field, target) {
 // Decide whether an unset field should be emitted with JSON write option `emitDefaultValues`
 function canEmitFieldDefaultValue(field) {
     if (field.repeated || field.kind == "map") {
-        // maps are {}, repeated fields are []
         return true;
     }
     if (field.oneof) {
@@ -456,9 +452,9 @@ function canEmitFieldDefaultValue(field) {
 }
 function writeField(field, value, options) {
     if (field.kind == "map") {
-        assert(typeof value == "object" && value != null);
-        const jsonObj = {};
-        const entries = Object.entries(value);
+        const jsonObj = Object.create(null);
+        assert(!value || typeof value === "object");
+        const entries = value ? Object.entries(value) : [];
         switch (field.V.kind) {
             case "scalar":
                 for (const [entryKey, entryValue] of entries) {
@@ -485,24 +481,28 @@ function writeField(field, value, options) {
             : undefined;
     }
     if (field.repeated) {
-        assert(Array.isArray(value));
+        assert(!value || Array.isArray(value));
         const jsonArr = [];
-        switch (field.kind) {
-            case "scalar":
-                for (let i = 0; i < value.length; i++) {
-                    jsonArr.push(writeScalar(field.T, value[i]));
-                }
-                break;
-            case "enum":
-                for (let i = 0; i < value.length; i++) {
-                    jsonArr.push(writeEnum(field.T, value[i], options.enumAsInteger));
-                }
-                break;
-            case "message":
-                for (let i = 0; i < value.length; i++) {
-                    jsonArr.push(value[i].toJson(options));
-                }
-                break;
+        const valueArr = value;
+        if (valueArr && valueArr.length) {
+            switch (field.kind) {
+                case "scalar":
+                    for (let i = 0; i < valueArr.length; i++) {
+                        jsonArr.push(writeScalar(field.T, valueArr[i]));
+                    }
+                    break;
+                case "enum":
+                    for (let i = 0; i < valueArr.length; i++) {
+                        jsonArr.push(writeEnum(field.T, valueArr[i], options.enumAsInteger));
+                    }
+                    break;
+                case "message":
+                    const messageType = resolveMessageType(field.T);
+                    for (let i = 0; i < valueArr.length; i++) {
+                        jsonArr.push(messageType.toJson(wrapField(messageType.fieldWrapper, valueArr[i])));
+                    }
+                    break;
+            }
         }
         return options.emitDefaultValues || jsonArr.length > 0 ?
             jsonArr
@@ -510,10 +510,22 @@ function writeField(field, value, options) {
     }
     switch (field.kind) {
         case "scalar":
+            const scalarValue = normalizeScalarValue(field.T, value, false);
+            if (!options.emitDefaultValues
+                && isScalarZeroValue(field.T, scalarValue)) {
+                return undefined;
+            }
             return writeScalar(field.T, value);
         case "enum":
+            const enumValue = normalizeEnumValue(field.T, value);
+            if (!options.emitDefaultValues && enumZeroValue(field.T) === enumValue) {
+                return undefined;
+            }
             return writeEnum(field.T, value, options.enumAsInteger);
         case "message":
+            if (!options.emitDefaultValues && value == null) {
+                return undefined;
+            }
             const messageType = resolveMessageType(field.T);
             return messageType.toJson(wrapField(messageType.fieldWrapper, value));
     }

package/dist/message.d.ts

@@ -111,7 +111,7 @@ export type MessageTypeParams<T extends Message<T>> = Pick<MessageType<T>, "fiel
  */
 export declare function createMessageType<T extends Message<T>, E extends Record<string, Function> = {}>(params: MessageTypeParams<T>, exts?: E): MessageType<T> & E;
 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;
+export declare function cloneMessage<T extends Message<T>>(message: T | null | undefined, fields: FieldList): T | null;
 /**
  * createCompleteMessage recursively builds a message filled with zero values based on the given FieldList.
  */

package/dist/message.js

@@ -13,9 +13,11 @@
 // limitations under the License.
 import { newFieldList, resolveMessageType, } from "./field.js";
 import { applyPartialMessage } from "./partial.js";
-import { ScalarType, scalarEquals } from "./scalar.js";
+import { LongType, ScalarType, scalarEquals, scalarZeroValue, } from "./scalar.js";
 import { binaryReadMessage, binaryWriteMessage, binaryMakeReadOptions, binaryMakeWriteOptions, } from "./binary.js";
 import { jsonReadMessage, jsonWriteMessage, jsonMakeReadOptions, jsonMakeWriteOptions, } from "./json.js";
+import { throwSanitizeKey } from "./names.js";
+import { enumZeroValue } from "./enum.js";
 /**
  * createMessageType creates a new message type.
  *
@@ -52,7 +54,7 @@ export function createMessageType(params, exts) {
             const message = {};
             if (bytes && bytes.length) {
                 const opt = binaryMakeReadOptions(options);
-                binaryReadMessage(message, fields, opt.readerFactory(bytes), bytes.byteLength, opt, delimitedMessageEncoding);
+                binaryReadMessage(message, fields, opt.readerFactory(bytes), bytes.byteLength, opt, delimitedMessageEncoding ?? false);
             }
             return message;
         },
@@ -109,9 +111,12 @@ export function compareMessages(fields, a, b) {
         const va = a[m.localName];
         const vb = b[m.localName];
         if (m.repeated) {
-            if (va.length !== vb.length) {
+            if ((va?.length ?? 0) !== (vb?.length ?? 0)) {
                 return false;
             }
+            if (!va?.length) {
+                return true;
+            }
             // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
             switch (m.kind) {
                 case "message":
@@ -132,9 +137,12 @@ export function compareMessages(fields, a, b) {
             case "scalar":
                 return scalarEquals(m.T, va, vb);
             case "oneof":
-                if (va.case !== vb.case) {
+                if (va?.case !== vb?.case) {
                     return false;
                 }
+                if (va == null) {
+                    return true;
+                }
                 const s = m.findField(va.case);
                 if (s === undefined) {
                     return true;
@@ -165,61 +173,12 @@ export function compareMessages(fields, a, b) {
         }
     });
 }
-// clone a single field value - i.e. the element type of repeated fields, the value type of maps
-function cloneSingularField(value, fieldInfo) {
-    if (value === undefined) {
-        return value;
-    }
-    if (fieldInfo.kind === "message") {
-        return cloneMessage(value, resolveMessageType(fieldInfo.T).fields);
-    }
-    if (fieldInfo.kind === "oneof") {
-        if (value.case === undefined) {
-            return undefined;
-        }
-        const selectedField = fieldInfo.findField(value.case);
-        if (!selectedField) {
-            throw new Error(`Invalid oneof case "${value.case}" for ${fieldInfo.name}`);
-        }
-        return {
-            case: value.case,
-            value: cloneSingularField(value.value, selectedField),
-        };
-    }
-    if (value instanceof Uint8Array) {
-        const c = new Uint8Array(value.byteLength);
-        c.set(value);
-        return c;
-    }
-    return value;
-}
-// TODO use isFieldSet() here to support future field presence
 export function cloneMessage(message, fields) {
-    const clone = {};
-    for (const member of fields.byMember()) {
-        const source = message[member.localName];
-        let copy;
-        if (member.repeated) {
-            copy = source.map((v) => cloneSingularField(v, member));
-        }
-        else if (member.kind == "map") {
-            copy = {};
-            for (const [key, v] of Object.entries(source)) {
-                copy[key] = cloneSingularField(v, member);
-            }
-        }
-        else if (member.kind == "oneof") {
-            const f = member.findField(source.case);
-            copy =
-                f ?
-                    { case: source.case, value: cloneSingularField(source.value, member) }
-                    : { case: undefined };
-        }
-        else {
-            copy = cloneSingularField(source, member);
-        }
-        clone[member.localName] = copy;
+    if (message == null) {
+        return null;
     }
+    const clone = Object.create(null);
+    applyPartialMessage(message, clone, fields, true);
     return clone;
 }
 /**
@@ -227,67 +186,42 @@ export function cloneMessage(message, fields) {
  */
 export function createCompleteMessage(fields) {
     const message = {};
-    for (const field of fields.list()) {
-        const fieldKind = field.kind;
+    for (const field of fields.byMember()) {
+        const { localName, kind: fieldKind } = field;
+        throwSanitizeKey(localName);
         switch (fieldKind) {
+            case "oneof":
+                message[localName] = Object.create(null);
+                message[localName].case = undefined;
+                break;
             case "scalar":
                 if (field.repeated) {
-                    message[field.localName] = [];
+                    message[localName] = [];
                 }
                 else {
-                    switch (field.T) {
-                        case ScalarType.DOUBLE:
-                        case ScalarType.FLOAT:
-                            message[field.localName] = 0;
-                            break;
-                        case ScalarType.INT64:
-                        case ScalarType.UINT64:
-                        case ScalarType.INT32:
-                        case ScalarType.FIXED64:
-                        case ScalarType.FIXED32:
-                        case ScalarType.UINT32:
-                        case ScalarType.SFIXED32:
-                        case ScalarType.SFIXED64:
-                        case ScalarType.SINT32:
-                        case ScalarType.SINT64:
-                            message[field.localName] = 0;
-                            break;
-                        case ScalarType.BOOL:
-                            message[field.localName] = false;
-                            break;
-                        case ScalarType.STRING:
-                            message[field.localName] = "";
-                            break;
-                        case ScalarType.BYTES:
-                            message[field.localName] =
-                                new Uint8Array();
-                            break;
-                    }
+                    message[localName] = scalarZeroValue(field.T, LongType.BIGINT);
                 }
                 break;
             case "enum":
-                if (field.repeated) {
-                    message[field.localName] = [];
-                }
-                else {
-                    message[field.localName] = 0;
-                }
+                message[localName] = field.repeated ? [] : enumZeroValue(field.T);
                 break;
             case "message":
+                // oneofs are handled above
                 if (field.oneof) {
-                    message[field.localName] = undefined;
-                    continue;
+                    break;
                 }
-                const messageType = resolveMessageType(field.T);
                 if (field.repeated) {
-                    message[field.localName] = [];
-                }
-                else {
-                    message[field.localName] = createCompleteMessage(messageType.fields);
+                    message[localName] = [];
+                    break;
                 }
+                const messageType = resolveMessageType(field.T);
+                message[localName] =
+                    !!messageType.fieldWrapper ?
+                        messageType.fieldWrapper.unwrapField(null)
+                        : createCompleteMessage(messageType.fields);
                 break;
             case "map":
-                message[field.localName] = {};
+                message[localName] = Object.create(null);
                 break;
             default:
                 field;

package/dist/partial.d.ts

@@ -1,4 +1,4 @@
 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;
+export declare function applyPartialMessage<T extends Message<T>>(source: Message<T> | undefined, target: Message<T>, fields: FieldList, clone?: boolean): void;
+export declare function applyPartialMap(sourceMap: Record<string, any> | undefined, targetMap: Record<string, any>, value: MapValueInfo, clone: boolean): void;

package/dist/partial.js

@@ -4,7 +4,9 @@ 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 clone is set: values are deep-copied including Uint8Arrays.
+export function applyPartialMessage(source, target, fields, clone = false) {
     if (source == null || target == null) {
         return;
     }
@@ -62,7 +64,7 @@ export function applyPartialMessage(source, target, fields) {
                     }
                 }
                 else if (sourceField.kind === "scalar") {
-                    dv.value = normalizeScalarValue(sourceField.T, sv);
+                    dv.value = normalizeScalarValue(sourceField.T, sv, clone);
                 }
                 else {
                     dv.value = sv;
@@ -77,10 +79,10 @@ export function applyPartialMessage(source, target, fields) {
                     if (dst == null || !Array.isArray(dst)) {
                         dst = t[localName] = [];
                     }
-                    dst.push(...sourceValue.map((v) => normalizeScalarValue(member.T, v)));
+                    dst.push(...sourceValue.map((v) => normalizeScalarValue(member.T, v, clone)));
                     break;
                 }
-                t[localName] = normalizeScalarValue(member.T, sourceValue);
+                t[localName] = normalizeScalarValue(member.T, sourceValue, clone);
                 break;
             case "enum":
                 t[localName] = normalizeEnumValue(member.T, sourceValue);
@@ -93,7 +95,7 @@ export function applyPartialMessage(source, target, fields) {
                 if (typeof tMap !== "object") {
                     tMap = t[localName] = Object.create(null);
                 }
-                applyPartialMap(sourceValue, tMap, member.V);
+                applyPartialMap(sourceValue, tMap, member.V, clone);
                 break;
             case "message":
                 const mt = resolveMessageType(member.T);
@@ -137,7 +139,7 @@ export function applyPartialMessage(source, target, fields) {
     }
 }
 // applyPartialMap applies a partial source map to a target map.
-export function applyPartialMap(sourceMap, targetMap, value) {
+export function applyPartialMap(sourceMap, targetMap, value, clone) {
     if (sourceMap == null) {
         return;
     }
@@ -149,7 +151,7 @@ export function applyPartialMap(sourceMap, targetMap, value) {
             for (const [k, v] of Object.entries(sourceMap)) {
                 throwSanitizeKey(k);
                 if (v !== undefined) {
-                    targetMap[k] = normalizeScalarValue(value.T, v);
+                    targetMap[k] = normalizeScalarValue(value.T, v, clone);
                 }
                 else {
                     delete targetMap[k];

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

@@ -384,9 +384,17 @@ function generateWktMethods(schema, f, message, ref) {
             f.print("    }");
             f.print(`    return new Date(ms).toISOString().replace(".000Z", z);`);
             f.print("  },");
-            f.print("  toDate(msg: ", message, "): Date {");
+            f.print("  toDate(msg: ", message, " | null | undefined): Date | null {");
+            f.print("    if (!msg?.", localName(ref.seconds), " && !msg?.", localName(ref.nanos), ") { return null; }");
             f.print("    return new Date(Number(msg.", localName(ref.seconds), " ?? 0) * 1000 + Math.ceil((msg.", localName(ref.nanos), " ?? 0) / 1000000));");
             f.print("  },");
+            f.print("  fromDate(value: Date | null | undefined): ", message, " {");
+            f.print("    if (value == null) { return {}; }");
+            f.print("    const ms = value.getTime();");
+            f.print("    const seconds = Math.floor(ms / 1000);");
+            f.print("    const nanos = (ms % 1000) * 1000000;");
+            f.print("    return { ", localName(ref.seconds), ": ", protoInt64, ".parse(seconds), ", localName(ref.nanos), ": nanos };");
+            f.print("  },");
             break;
         case "google.protobuf.Duration":
             f.print("  fromJson(json: ", JsonValue, " | null | undefined, _options?: Partial<", JsonReadOptions, ">): ", message, " {");
@@ -552,6 +560,30 @@ function generateWktMethods(schema, f, message, ref) {
 }
 function generateWktFieldWrapper(f, message, ref) {
     switch (ref?.typeName) {
+        /* TODO Wrap Timestamp => Date
+        case "google.protobuf.Timestamp": {
+          f.print("  fieldWrapper: {");
+          f.print(
+            "    wrapField(value: ",
+            message,
+            " | Date | null | undefined): ",
+            message,
+            " {",
+          );
+          f.print(
+            "      if (value == null || value instanceof Date) { return ",
+            message,
+            "_Wkt.fromDate(value); }",
+          );
+          f.print("      return ", message, ".createComplete(value);");
+          f.print("    },");
+          f.print("    unwrapField(msg: ", message, "): Date | null {");
+          f.print("      return ", message, "_Wkt.toDate(msg);");
+          f.print("    }");
+          f.print("  } as const,");
+          break;
+        }
+        */
         case "google.protobuf.DoubleValue":
         case "google.protobuf.FloatValue":
         case "google.protobuf.Int64Value":

package/dist/scalar.d.ts

@@ -72,6 +72,7 @@ export declare function isScalarZeroValue(type: ScalarType, value: unknown): boo
  * Zero or null is cast to the zero value.
  * Bytes is cast to a Uint8Array.
  * The BigInt long type is used.
+ * If clone is set, Uint8Array will always be copied to a new value.
  */
-export declare function normalizeScalarValue<T>(type: ScalarType, value: T | null | undefined, longType?: LongType): T;
-export declare function toU8Arr(input: ArrayLike<number>): Uint8Array;
+export declare function normalizeScalarValue<T>(type: ScalarType, value: T | null | undefined, clone: boolean, longType?: LongType): T;
+export declare function toU8Arr(input: ArrayLike<number>, clone: boolean): Uint8Array;

package/dist/scalar.js

@@ -166,21 +166,22 @@ export function isScalarZeroValue(type, value) {
  * Zero or null is cast to the zero value.
  * Bytes is cast to a Uint8Array.
  * The BigInt long type is used.
+ * If clone is set, Uint8Array will always be copied to a new value.
  */
-export function normalizeScalarValue(type, value, longType = LongType.BIGINT) {
+export function normalizeScalarValue(type, value, clone, longType = LongType.BIGINT) {
     if (value == null) {
         return scalarZeroValue(type, longType);
     }
     if (type === ScalarType.BYTES) {
-        return toU8Arr(value);
+        return toU8Arr(value, clone);
     }
     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);
+// if clone is set, force clones the array to a copy.
+export function toU8Arr(input, clone) {
+    return !clone && input instanceof Uint8Array ? input : new Uint8Array(input);
 }

package/example/tsconfig.json

@@ -4,10 +4,8 @@
   "compilerOptions": {
     "paths": {
       "@aptre/protobuf-es-lite": [
-        "../",
-        "../dist"
+        "../src",
       ],
-      "@aptre/protobuf-es-lite/google": ["../src/google", "../dist/google"],
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aptre/protobuf-es-lite",
   "description": "Lightweight Protobuf codegen for TypeScript and JavaScript.",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "license": "Apache-2.0",
   "repository": {
     "url": "git+ssh://git@github.com/aperturerobotics/protobuf-es-lite.git"
@@ -49,18 +49,19 @@
   "scripts": {
     "clean": "rimraf ./dist",
     "build": "npm run clean && tsc --project tsconfig.json --outDir ./dist",
-    "release:version": "npm version patch -m \"release: v%s\" --no-git-tag-version",
-    "release:version:minor": "npm version minor -m \"release: v%s\" --no-git-tag-version",
-    "release:commit": "git reset && git add package.json && git commit -s -m \"release: v$npm_package_version\" && git tag v$npm_package_version",
-    "release:publish": "git push && git push --tags && npm run build && npm publish",
-    "release": "npm run release:version && npm run release:commit",
-    "release:minor": "npm run release:version:minor && npm run release:commit",
     "typecheck": "tsc --noEmit --project tsconfig.json --outDir ./dist",
     "gen": "npm run build && npm run gen:wkt && npm run gen:example",
     "gen:wkt": "cd ./src && bash gen.bash",
     "gen:example": "bash gen.bash ./example/example.proto",
     "format": "prettier --write './src/**/(*.ts|*.tsx|*.html|*.css|*.scss)'",
-    "precommit": "lint-staged"
+    "precommit": "lint-staged",
+    "test": "vitest run",
+    "release:version": "npm version patch -m \"release: v%s\" --no-git-tag-version",
+    "release:version:minor": "npm version minor -m \"release: v%s\" --no-git-tag-version",
+    "release:commit": "git reset && git add package.json && git commit -s -m \"release: v$npm_package_version\" && git tag v$npm_package_version",
+    "release:publish": "git push && git push --tags && npm run build && npm publish",
+    "release": "npm run release:version && npm run release:commit",
+    "release:minor": "npm run release:version:minor && npm run release:commit"
   },
   "preferUnplugged": true,
   "pre-commit": [
@@ -76,7 +77,8 @@
     "pre-commit": "^1.2.2",
     "prettier": "^3.2.5",
     "rimraf": "^5.0.5",
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "vitest": "^1.5.3"
   },
   "lint-staged": {
     "package.json": "prettier --write",