@bufbuild/protobuf 0.0.1-alpha.1 → 0.0.1

package/dist/esm/private/scalars.js

@@ -6,66 +6,66 @@ import { protoInt64 } from "../proto-int64.js";
  * Returns true if both scalar values are equal.
  */
 export function scalarEquals(type, a, b) {
-  if (a === b) {
-    // This correctly matches equal values except BYTES and (possibly) 64-bit integers.
-    return true;
-  }
-  // Special case BYTES - we need to compare each byte individually
-  if (type == ScalarType.BYTES) {
-    if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {
-      return false;
+    if (a === b) {
+        // This correctly matches equal values except BYTES and (possibly) 64-bit integers.
+        return true;
     }
-    if (a.length !== b.length) {
-      return false;
+    // Special case BYTES - we need to compare each byte individually
+    if (type == ScalarType.BYTES) {
+        if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {
+            return false;
+        }
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
     }
-    for (let i = 0; i < a.length; i++) {
-      if (a[i] !== b[i]) {
-        return false;
-      }
+    // Special case 64-bit integers - we support number, string and bigint representation.
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (type) {
+        case ScalarType.UINT64:
+        case ScalarType.FIXED64:
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            // Loose comparison will match between 0n, 0 and "0".
+            return a == b;
     }
-    return true;
-  }
-  // Special case 64-bit integers - we support number, string and bigint representation.
-  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-  switch (type) {
-    case ScalarType.UINT64:
-    case ScalarType.FIXED64:
-    case ScalarType.INT64:
-    case ScalarType.SFIXED64:
-    case ScalarType.SINT64:
-      // Loose comparison will match between 0n, 0 and "0".
-      return a == b;
-  }
-  // Anything that hasn't been caught by strict comparison or special cased
-  // BYTES and 64-bit integers is not equal.
-  return false;
+    // Anything that hasn't been caught by strict comparison or special cased
+    // BYTES and 64-bit integers is not equal.
+    return false;
 }
 /**
  * Returns the default value for the given scalar type, following
  * proto3 semantics.
  */
 export function scalarDefaultValue(type) {
-  switch (type) {
-    case ScalarType.BOOL:
-      return false;
-    case ScalarType.UINT64:
-    case ScalarType.FIXED64:
-    case ScalarType.INT64:
-    case ScalarType.SFIXED64:
-    case ScalarType.SINT64:
-      return protoInt64.zero;
-    case ScalarType.DOUBLE:
-    case ScalarType.FLOAT:
-      return 0.0;
-    case ScalarType.BYTES:
-      return new Uint8Array(0);
-    case ScalarType.STRING:
-      return "";
-    default:
-      // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
-      // We do not use individual cases to save a few bytes code size.
-      return 0;
-  }
+    switch (type) {
+        case ScalarType.BOOL:
+            return false;
+        case ScalarType.UINT64:
+        case ScalarType.FIXED64:
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            return protoInt64.zero;
+        case ScalarType.DOUBLE:
+        case ScalarType.FLOAT:
+            return 0.0;
+        case ScalarType.BYTES:
+            return new Uint8Array(0);
+        case ScalarType.STRING:
+            return "";
+        default:
+            // Handles INT32, UINT32, SINT32, FIXED32, SFIXED32.
+            // We do not use individual cases to save a few bytes code size.
+            return 0;
+    }
 }
 /**
  * Get information for writing a scalar value.
@@ -78,52 +78,52 @@ export function scalarDefaultValue(type) {
  * If argument `value` is omitted, [2] is always false.
  */
 export function scalarTypeInfo(type, value) {
-  const isUndefined = value === undefined;
-  let wireType = WireType.Varint;
-  let isIntrinsicDefault = value === 0;
-  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- INT32, UINT32, SINT32 are covered by the defaults
-  switch (type) {
-    case ScalarType.STRING:
-      isIntrinsicDefault = isUndefined || !value.length;
-      wireType = WireType.LengthDelimited;
-      break;
-    case ScalarType.BOOL:
-      isIntrinsicDefault = value === false;
-      break;
-    case ScalarType.DOUBLE:
-      wireType = WireType.Bit64;
-      break;
-    case ScalarType.FLOAT:
-      wireType = WireType.Bit32;
-      break;
-    case ScalarType.INT64:
-      isIntrinsicDefault = isUndefined || value == 0;
-      break;
-    case ScalarType.UINT64:
-      isIntrinsicDefault = isUndefined || value == 0;
-      break;
-    case ScalarType.FIXED64:
-      isIntrinsicDefault = isUndefined || value == 0;
-      wireType = WireType.Bit64;
-      break;
-    case ScalarType.BYTES:
-      isIntrinsicDefault = isUndefined || !value.byteLength;
-      wireType = WireType.LengthDelimited;
-      break;
-    case ScalarType.FIXED32:
-      wireType = WireType.Bit32;
-      break;
-    case ScalarType.SFIXED32:
-      wireType = WireType.Bit32;
-      break;
-    case ScalarType.SFIXED64:
-      isIntrinsicDefault = isUndefined || value == 0;
-      wireType = WireType.Bit64;
-      break;
-    case ScalarType.SINT64:
-      isIntrinsicDefault = isUndefined || value == 0;
-      break;
-  }
-  const method = ScalarType[type].toLowerCase();
-  return [wireType, method, isUndefined || isIntrinsicDefault];
+    const isUndefined = value === undefined;
+    let wireType = WireType.Varint;
+    let isIntrinsicDefault = value === 0;
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- INT32, UINT32, SINT32 are covered by the defaults
+    switch (type) {
+        case ScalarType.STRING:
+            isIntrinsicDefault = isUndefined || !value.length;
+            wireType = WireType.LengthDelimited;
+            break;
+        case ScalarType.BOOL:
+            isIntrinsicDefault = value === false;
+            break;
+        case ScalarType.DOUBLE:
+            wireType = WireType.Bit64;
+            break;
+        case ScalarType.FLOAT:
+            wireType = WireType.Bit32;
+            break;
+        case ScalarType.INT64:
+            isIntrinsicDefault = isUndefined || value == 0;
+            break;
+        case ScalarType.UINT64:
+            isIntrinsicDefault = isUndefined || value == 0;
+            break;
+        case ScalarType.FIXED64:
+            isIntrinsicDefault = isUndefined || value == 0;
+            wireType = WireType.Bit64;
+            break;
+        case ScalarType.BYTES:
+            isIntrinsicDefault = isUndefined || !value.byteLength;
+            wireType = WireType.LengthDelimited;
+            break;
+        case ScalarType.FIXED32:
+            wireType = WireType.Bit32;
+            break;
+        case ScalarType.SFIXED32:
+            wireType = WireType.Bit32;
+            break;
+        case ScalarType.SFIXED64:
+            isIntrinsicDefault = isUndefined || value == 0;
+            wireType = WireType.Bit64;
+            break;
+        case ScalarType.SINT64:
+            isIntrinsicDefault = isUndefined || value == 0;
+            break;
+    }
+    const method = ScalarType[type].toLowerCase();
+    return [wireType, method, isUndefined || isIntrinsicDefault];
 }

package/dist/esm/private/util-common.js

@@ -3,205 +3,193 @@ import { ScalarType } from "../field.js";
 import { scalarEquals } from "./scalars.js";
 /* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument,no-case-declarations */
 export function makeUtilCommon() {
-  return {
-    setEnumType,
-    initPartial(source, target) {
-      if (source === undefined) {
-        return;
-      }
-      const type = target.getType();
-      for (const member of type.fields.byMember()) {
-        const localName = member.localName,
-          t = target,
-          s = source;
-        if (s[localName] === undefined) {
-          continue;
-        }
-        switch (member.kind) {
-          case "oneof":
-            const sk = s[localName].case;
-            if (sk === undefined) {
-              continue;
+    return {
+        setEnumType,
+        initPartial(source, target) {
+            if (source === undefined) {
+                return;
             }
-            const sourceField = member.findField(sk);
-            let val = s[localName].value;
-            if (
-              sourceField &&
-              sourceField.kind == "message" &&
-              !(val instanceof sourceField.T)
-            ) {
-              val = new sourceField.T(val);
-            }
-            t[localName] = { case: sk, value: val };
-            break;
-          case "scalar":
-          case "enum":
-            t[localName] = s[localName];
-            break;
-          case "map":
-            switch (member.V.kind) {
-              case "scalar":
-              case "enum":
-                Object.assign(t[localName], s[localName]);
-                break;
-              case "message":
-                const messageType = member.V.T;
-                for (const k of Object.keys(s[localName])) {
-                  let val = s[localName][k];
-                  if (!messageType.fieldWrapper) {
-                    // We only take partial input for messages that are not a wrapper type.
-                    // For those messages, we recursively normalize the partial input.
-                    val = new messageType(val);
-                  }
-                  t[localName][k] = val;
+            const type = target.getType();
+            for (const member of type.fields.byMember()) {
+                const localName = member.localName, t = target, s = source;
+                if (s[localName] === undefined) {
+                    continue;
+                }
+                switch (member.kind) {
+                    case "oneof":
+                        const sk = s[localName].case;
+                        if (sk === undefined) {
+                            continue;
+                        }
+                        const sourceField = member.findField(sk);
+                        let val = s[localName].value;
+                        if (sourceField &&
+                            sourceField.kind == "message" &&
+                            !(val instanceof sourceField.T)) {
+                            val = new sourceField.T(val);
+                        }
+                        t[localName] = { case: sk, value: val };
+                        break;
+                    case "scalar":
+                    case "enum":
+                        t[localName] = s[localName];
+                        break;
+                    case "map":
+                        switch (member.V.kind) {
+                            case "scalar":
+                            case "enum":
+                                Object.assign(t[localName], s[localName]);
+                                break;
+                            case "message":
+                                const messageType = member.V.T;
+                                for (const k of Object.keys(s[localName])) {
+                                    let val = s[localName][k];
+                                    if (!messageType.fieldWrapper) {
+                                        // We only take partial input for messages that are not a wrapper type.
+                                        // For those messages, we recursively normalize the partial input.
+                                        val = new messageType(val);
+                                    }
+                                    t[localName][k] = val;
+                                }
+                                break;
+                        }
+                        break;
+                    case "message":
+                        const mt = member.T;
+                        if (member.repeated) {
+                            t[localName] = s[localName].map((val) => val instanceof mt ? val : new mt(val));
+                        }
+                        else if (s[localName] !== undefined) {
+                            const val = s[localName];
+                            if (mt.fieldWrapper) {
+                                t[localName] = val;
+                            }
+                            else {
+                                t[localName] = val instanceof mt ? mt : new mt(val);
+                            }
+                        }
+                        break;
                 }
-                break;
-            }
-            break;
-          case "message":
-            const mt = member.T;
-            if (member.repeated) {
-              t[localName] = s[localName].map((val) =>
-                val instanceof mt ? val : new mt(val)
-              );
-            } else if (s[localName] !== undefined) {
-              const val = s[localName];
-              if (mt.fieldWrapper) {
-                t[localName] = val;
-              } else {
-                t[localName] = val instanceof mt ? mt : new mt(val);
-              }
-            }
-            break;
-        }
-      }
-    },
-    equals(type, a, b) {
-      if (a === b) {
-        return true;
-      }
-      if (!a || !b) {
-        return false;
-      }
-      return type.fields.byMember().every((m) => {
-        const va = a[m.localName];
-        const vb = b[m.localName];
-        if (m.repeated) {
-          if (va.length !== vb.length) {
-            return false;
-          }
-          // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
-          switch (m.kind) {
-            case "message":
-              return va.every((a, i) => m.T.equals(a, vb[i]));
-            case "scalar":
-              return va.every((a, i) => scalarEquals(m.T, a, vb[i]));
-            case "enum":
-              return va.every((a, i) =>
-                scalarEquals(ScalarType.INT32, a, vb[i])
-              );
-          }
-          throw new Error(`repeated cannot contain ${m.kind}`);
-        }
-        switch (m.kind) {
-          case "message":
-            return m.T.equals(va, vb);
-          case "enum":
-            return scalarEquals(ScalarType.INT32, va, vb);
-          case "scalar":
-            return scalarEquals(m.T, va, vb);
-          case "oneof":
-            if (va.case !== vb.case) {
-              return false;
-            }
-            const k = va.case,
-              s = m.findField(k);
-            if (s === undefined) {
-              return true;
             }
-            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- oneof fields are never "map"
-            switch (s.kind) {
-              case "message":
-                return s.T.equals(va[k], vb[k]);
-              case "enum":
-                return scalarEquals(ScalarType.INT32, va, vb);
-              case "scalar":
-                return scalarEquals(s.T, va, vb);
+        },
+        equals(type, a, b) {
+            if (a === b) {
+                return true;
             }
-            throw new Error(`oneof cannot contain ${s.kind}`);
-          case "map":
-            const keys = Object.keys(va);
-            if (keys.some((k) => vb[k] === undefined)) {
-              return false;
+            if (!a || !b) {
+                return false;
             }
-            switch (m.V.kind) {
-              case "message":
-                const messageType = m.V.T;
-                return keys.every((k) => messageType.equals(va[k], vb[k]));
-              case "enum":
-                return keys.every((k) =>
-                  scalarEquals(ScalarType.INT32, va[k], vb[k])
-                );
-              case "scalar":
-                const scalarType = m.V.T;
-                return keys.every((k) =>
-                  scalarEquals(scalarType, va[k], vb[k])
-                );
+            return type.fields.byMember().every((m) => {
+                const va = a[m.localName];
+                const vb = b[m.localName];
+                if (m.repeated) {
+                    if (va.length !== vb.length) {
+                        return false;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
+                    switch (m.kind) {
+                        case "message":
+                            return va.every((a, i) => m.T.equals(a, vb[i]));
+                        case "scalar":
+                            return va.every((a, i) => scalarEquals(m.T, a, vb[i]));
+                        case "enum":
+                            return va.every((a, i) => scalarEquals(ScalarType.INT32, a, vb[i]));
+                    }
+                    throw new Error(`repeated cannot contain ${m.kind}`);
+                }
+                switch (m.kind) {
+                    case "message":
+                        return m.T.equals(va, vb);
+                    case "enum":
+                        return scalarEquals(ScalarType.INT32, va, vb);
+                    case "scalar":
+                        return scalarEquals(m.T, va, vb);
+                    case "oneof":
+                        if (va.case !== vb.case) {
+                            return false;
+                        }
+                        const k = va.case, s = m.findField(k);
+                        if (s === undefined) {
+                            return true;
+                        }
+                        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- oneof fields are never "map"
+                        switch (s.kind) {
+                            case "message":
+                                return s.T.equals(va[k], vb[k]);
+                            case "enum":
+                                return scalarEquals(ScalarType.INT32, va, vb);
+                            case "scalar":
+                                return scalarEquals(s.T, va, vb);
+                        }
+                        throw new Error(`oneof cannot contain ${s.kind}`);
+                    case "map":
+                        const keys = Object.keys(va);
+                        if (keys.some((k) => vb[k] === undefined)) {
+                            return false;
+                        }
+                        switch (m.V.kind) {
+                            case "message":
+                                const messageType = m.V.T;
+                                return keys.every((k) => messageType.equals(va[k], vb[k]));
+                            case "enum":
+                                return keys.every((k) => scalarEquals(ScalarType.INT32, va[k], vb[k]));
+                            case "scalar":
+                                const scalarType = m.V.T;
+                                return keys.every((k) => scalarEquals(scalarType, va[k], vb[k]));
+                        }
+                        break;
+                }
+            });
+        },
+        clone(message) {
+            const type = message.getType(), target = new type();
+            for (const member of type.fields.byMember()) {
+                const source = message[member.localName];
+                let copy;
+                if (member.repeated) {
+                    copy = source.map((e) => cloneSingularField(member, e));
+                }
+                else if (member.kind == "map") {
+                    copy = target[member.localName];
+                    for (const [key, v] of Object.entries(source)) {
+                        copy[key] = cloneSingularField(member.V, v);
+                    }
+                }
+                else if (member.kind == "oneof") {
+                    const f = member.findField(source.case);
+                    copy = f
+                        ? { case: source.case, value: cloneSingularField(f, source.value) }
+                        : { case: undefined };
+                }
+                else {
+                    copy = cloneSingularField(member, source);
+                }
+                target[member.localName] = copy;
             }
-            break;
-        }
-      });
-    },
-    clone(message) {
-      const type = message.getType(),
-        target = new type(),
-        any = target;
-      for (const member of type.fields.byMember()) {
-        const source = message[member.localName];
-        let copy;
-        if (member.repeated) {
-          copy = source.map((e) => cloneSingularField(member, e));
-        } else if (member.kind == "map") {
-          copy = any[member.localName];
-          for (const [key, v] of Object.entries(source)) {
-            copy[key] = cloneSingularField(member.V, v);
-          }
-        } else if (member.kind == "oneof") {
-          const f = member.findField(source.case);
-          copy = f
-            ? { case: source.case, value: cloneSingularField(f, source.value) }
-            : { case: undefined };
-        } else {
-          copy = cloneSingularField(member, source);
-        }
-        any[member.localName] = copy;
-      }
-      return target;
-    },
-  };
+            return target;
+        },
+    };
 }
 // clone a single field value - i.e. the element type of repeated fields, the value type of maps
 function cloneSingularField(field, value) {
-  if (value === undefined) {
-    return value;
-  }
-  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- unmatched "map" is unsupported
-  switch (field.kind) {
-    case "enum":
-      return value;
-    case "scalar":
-      if (field.T === ScalarType.BYTES) {
-        const c = new Uint8Array(value.byteLength);
-        c.set(value);
-        return c;
-      }
-      return value;
-    case "message":
-      if (field.T.fieldWrapper) {
-        return field.T.fieldWrapper.unwrapField(
-          field.T.fieldWrapper.wrapField(value).clone()
-        );
-      }
-      return value.clone();
-  }
+    if (value === undefined) {
+        return value;
+    }
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- unmatched "map" is unsupported
+    switch (field.kind) {
+        case "enum":
+            return value;
+        case "scalar":
+            if (field.T === ScalarType.BYTES) {
+                const c = new Uint8Array(value.byteLength);
+                c.set(value);
+                return c;
+            }
+            return value;
+        case "message":
+            if (field.T.fieldWrapper) {
+                return field.T.fieldWrapper.unwrapField(field.T.fieldWrapper.wrapField(value).clone());
+            }
+            return value.clone();
+    }
 }