@aptre/protobuf-es-lite 0.3.0 → 0.4.0

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

@@ -146,6 +146,7 @@ function generateMessage(schema, f, message) {
         f.print("});");
     }
     else {
+        generateWktFieldWrapper(f, message, reWkt);
         f.print("}, ", message, "_Wkt);");
     }
     f.print();
@@ -549,3 +550,27 @@ function generateWktMethods(schema, f, message, ref) {
             break;
     }
 }
+function generateWktFieldWrapper(f, message, ref) {
+    switch (ref?.typeName) {
+        case "google.protobuf.DoubleValue":
+        case "google.protobuf.FloatValue":
+        case "google.protobuf.Int64Value":
+        case "google.protobuf.UInt64Value":
+        case "google.protobuf.Int32Value":
+        case "google.protobuf.UInt32Value":
+        case "google.protobuf.BoolValue":
+        case "google.protobuf.StringValue":
+        case "google.protobuf.BytesValue": {
+            const { typing } = getFieldTypeInfo(ref.value);
+            f.print("  fieldWrapper: {");
+            f.print("    wrapField(value: ", typing, " | null | undefined): ", message, " {");
+            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), ";");
+            f.print("    }");
+            f.print("  } as const,");
+            break;
+        }
+    }
+}

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/example/example.pb.ts

@@ -3,7 +3,13 @@
 /* eslint-disable */
 
 import type { MessageType, PartialFieldInfo } from "@aptre/protobuf-es-lite";
-import { createEnumType, createMessageType, Message, ScalarType, Timestamp } from "@aptre/protobuf-es-lite";
+import {
+  createEnumType,
+  createMessageType,
+  Message,
+  ScalarType,
+  Timestamp,
+} from "@aptre/protobuf-es-lite";
 
 export const protobufPackage = "example";
 
@@ -58,35 +64,54 @@ export type EchoMsg = Message<{
   /**
    * @generated from oneof example.EchoMsg.demo
    */
-  demo?: {
-    value?: undefined,
-    case: undefined
-  } | {
-    /**
-     * @generated from field: example.ExampleEnum example_enum = 3;
-     */
-    value: ExampleEnum;
-    case: "exampleEnum";
-  } | {
-    /**
-     * @generated from field: string example_string = 4;
-     */
-    value: string;
-    case: "exampleString";
-  };
-
+  demo?:
+    | {
+        value?: undefined;
+        case: undefined;
+      }
+    | {
+        /**
+         * @generated from field: example.ExampleEnum example_enum = 3;
+         */
+        value: ExampleEnum;
+        case: "exampleEnum";
+      }
+    | {
+        /**
+         * @generated from field: string example_string = 4;
+         */
+        value: string;
+        case: "exampleString";
+      };
 }>;
 
 // EchoMsg contains the message type declaration for EchoMsg.
 export const EchoMsg: MessageType<EchoMsg> = createMessageType({
-    typeName: "example.EchoMsg",
-    fields: [
-        { no: 1, name: "body", kind: "scalar", T: ScalarType.STRING },
-        { no: 2, name: "ts", kind: "message", T: () => Timestamp },
-        { no: 3, name: "example_enum", kind: "enum", T: ExampleEnum_Enum, oneof: "demo" },
-        { no: 4, name: "example_string", kind: "scalar", T: ScalarType.STRING, oneof: "demo" },
-        { no: 5, name: "timestamps", kind: "message", T: () => Timestamp, repeated: true },
-    ] as readonly PartialFieldInfo[],
-    packedByDefault: true,
+  typeName: "example.EchoMsg",
+  fields: [
+    { no: 1, name: "body", kind: "scalar", T: ScalarType.STRING },
+    { no: 2, name: "ts", kind: "message", T: () => Timestamp },
+    {
+      no: 3,
+      name: "example_enum",
+      kind: "enum",
+      T: ExampleEnum_Enum,
+      oneof: "demo",
+    },
+    {
+      no: 4,
+      name: "example_string",
+      kind: "scalar",
+      T: ScalarType.STRING,
+      oneof: "demo",
+    },
+    {
+      no: 5,
+      name: "timestamps",
+      kind: "message",
+      T: () => Timestamp,
+      repeated: true,
+    },
+  ] as readonly PartialFieldInfo[],
+  packedByDefault: true,
 });
-

package/package.json

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