@bufbuild/protobuf 0.0.1-alpha.1 → 0.0.2-alpha.2

package/dist/esm/proto-int64.js

@@ -1,118 +1,130 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 import { int64fromString, int64toString } from "./google/varint.js";
 function makeInt64Support() {
-  const dv = new DataView(new ArrayBuffer(8));
-  // note that Safari 14 implements BigInt, but not the DataView methods
-  const ok =
-    globalThis.BigInt !== undefined && // eslint-disable-line @typescript-eslint/no-unnecessary-condition -- conditional for BigInt is very much necessary
-    typeof dv.getBigInt64 === "function" &&
-    typeof dv.getBigUint64 === "function" &&
-    typeof dv.setBigInt64 === "function" &&
-    typeof dv.setBigUint64 === "function";
-  if (ok) {
-    const MIN = BigInt("-9223372036854775808"),
-      MAX = BigInt("9223372036854775807"),
-      UMIN = BigInt("0"),
-      UMAX = BigInt("18446744073709551615");
-    return {
-      zero: BigInt(0),
-      supported: true,
-      parse(value) {
-        const bi = typeof value == "bigint" ? value : BigInt(value);
-        if (bi > MAX || bi < MIN) {
-          throw new Error(`int64 invalid: ${value}`);
-        }
-        return bi;
-      },
-      uParse(value) {
-        const bi = typeof value == "bigint" ? value : BigInt(value);
-        if (bi > UMAX || bi < UMIN) {
-          throw new Error(`uint64 invalid: ${value}`);
-        }
-        return bi;
-      },
-      enc(value) {
-        dv.setBigInt64(0, this.parse(value), true);
-        return {
-          lo: dv.getInt32(0, true),
-          hi: dv.getInt32(4, true),
-        };
-      },
-      uEnc(value) {
-        dv.setBigInt64(0, this.uParse(value), true);
+    const dv = new DataView(new ArrayBuffer(8));
+    // note that Safari 14 implements BigInt, but not the DataView methods
+    const ok = globalThis.BigInt !== undefined && // eslint-disable-line @typescript-eslint/no-unnecessary-condition -- conditional for BigInt is very much necessary
+        typeof dv.getBigInt64 === "function" &&
+        typeof dv.getBigUint64 === "function" &&
+        typeof dv.setBigInt64 === "function" &&
+        typeof dv.setBigUint64 === "function";
+    if (ok) {
+        const MIN = BigInt("-9223372036854775808"), MAX = BigInt("9223372036854775807"), UMIN = BigInt("0"), UMAX = BigInt("18446744073709551615");
         return {
-          lo: dv.getInt32(0, true),
-          hi: dv.getInt32(4, true),
+            zero: BigInt(0),
+            supported: true,
+            parse(value) {
+                const bi = typeof value == "bigint" ? value : BigInt(value);
+                if (bi > MAX || bi < MIN) {
+                    throw new Error(`int64 invalid: ${value}`);
+                }
+                return bi;
+            },
+            uParse(value) {
+                const bi = typeof value == "bigint" ? value : BigInt(value);
+                if (bi > UMAX || bi < UMIN) {
+                    throw new Error(`uint64 invalid: ${value}`);
+                }
+                return bi;
+            },
+            enc(value) {
+                dv.setBigInt64(0, this.parse(value), true);
+                return {
+                    lo: dv.getInt32(0, true),
+                    hi: dv.getInt32(4, true),
+                };
+            },
+            uEnc(value) {
+                dv.setBigInt64(0, this.uParse(value), true);
+                return {
+                    lo: dv.getInt32(0, true),
+                    hi: dv.getInt32(4, true),
+                };
+            },
+            dec(lo, hi) {
+                dv.setInt32(0, lo, true);
+                dv.setInt32(4, hi, true);
+                return dv.getBigInt64(0, true);
+            },
+            uDec(lo, hi) {
+                dv.setInt32(0, lo, true);
+                dv.setInt32(4, hi, true);
+                return dv.getBigUint64(0, true);
+            },
         };
-      },
-      dec(lo, hi) {
-        dv.setInt32(0, lo, true);
-        dv.setInt32(4, hi, true);
-        return dv.getBigInt64(0, true);
-      },
-      uDec(lo, hi) {
-        dv.setInt32(0, lo, true);
-        dv.setInt32(4, hi, true);
-        return dv.getBigUint64(0, true);
-      },
+    }
+    return {
+        zero: "0",
+        supported: false,
+        parse(value) {
+            if (!/^-?[0-9]+$/.test(value)) {
+                throw new Error(`int64 invalid: ${value}`);
+            }
+            return value;
+        },
+        uParse(value) {
+            if (!/^-?[0-9]+$/.test(value)) {
+                throw new Error(`uint64 invalid: ${value}`);
+            }
+            return value;
+        },
+        enc(value) {
+            if (typeof value == "string") {
+                if (!/^-?[0-9]+$/.test(value)) {
+                    throw new Error(`int64 invalid: ${value}`);
+                }
+            }
+            else {
+                value = value.toString(10);
+            }
+            const [, lo, hi] = int64fromString(value);
+            return { lo, hi };
+        },
+        uEnc(value) {
+            if (typeof value == "string") {
+                if (!/^-?[0-9]+$/.test(value)) {
+                    throw new Error(`uint64 invalid: ${value}`);
+                }
+            }
+            else {
+                value = value.toString(10);
+            }
+            const [minus, lo, hi] = int64fromString(value);
+            if (minus) {
+                throw new Error(`uint64 invalid: ${value}`);
+            }
+            return { lo, hi };
+        },
+        dec(lo, hi) {
+            const minus = (hi & 0x80000000) !== 0;
+            if (minus) {
+                // negate
+                hi = ~hi;
+                if (lo) {
+                    lo = ~lo + 1;
+                }
+                else {
+                    hi += 1;
+                }
+                return ("-" + int64toString(lo, hi));
+            }
+            return int64toString(lo, hi);
+        },
+        uDec(lo, hi) {
+            return int64toString(lo, hi);
+        },
     };
-  }
-  return {
-    zero: "0",
-    supported: false,
-    parse(value) {
-      if (!/^-?[0-9]+$/.test(value)) {
-        throw new Error(`int64 invalid: ${value}`);
-      }
-      return value;
-    },
-    uParse(value) {
-      if (!/^-?[0-9]+$/.test(value)) {
-        throw new Error(`uint64 invalid: ${value}`);
-      }
-      return value;
-    },
-    enc(value) {
-      if (typeof value == "string") {
-        if (!/^-?[0-9]+$/.test(value)) {
-          throw new Error(`int64 invalid: ${value}`);
-        }
-      } else {
-        value = value.toString(10);
-      }
-      const [, lo, hi] = int64fromString(value);
-      return { lo, hi };
-    },
-    uEnc(value) {
-      if (typeof value == "string") {
-        if (!/^-?[0-9]+$/.test(value)) {
-          throw new Error(`uint64 invalid: ${value}`);
-        }
-      } else {
-        value = value.toString(10);
-      }
-      const [minus, lo, hi] = int64fromString(value);
-      if (minus) {
-        throw new Error(`uint64 invalid: ${value}`);
-      }
-      return { lo, hi };
-    },
-    dec(lo, hi) {
-      const minus = (hi & 0x80000000) !== 0;
-      if (minus) {
-        // negate
-        hi = ~hi;
-        if (lo) {
-          lo = ~lo + 1;
-        } else {
-          hi += 1;
-        }
-        return "-" + int64toString(lo, hi);
-      }
-      return int64toString(lo, hi);
-    },
-    uDec(lo, hi) {
-      return int64toString(lo, hi);
-    },
-  };
 }
 export const protoInt64 = makeInt64Support();

package/dist/esm/proto2.js

@@ -1,3 +1,16 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 import { makeProtoRuntime } from "./private/proto-runtime.js";
 import { makeBinaryFormatProto2 } from "./private/binary-format-proto2.js";
 import { makeUtilCommon } from "./private/util-common.js";
@@ -8,70 +21,63 @@ import { makeJsonFormatProto2 } from "./private/json-format-proto2.js";
 /**
  * Provides functionality for messages defined with the proto2 syntax.
  */
-export const proto2 = makeProtoRuntime(
-  "proto2",
-  makeJsonFormatProto2(),
-  makeBinaryFormatProto2(),
-  {
+export const proto2 = makeProtoRuntime("proto2", makeJsonFormatProto2(), makeBinaryFormatProto2(), {
     ...makeUtilCommon(),
     newFieldList(fields) {
-      return new InternalFieldList(fields, normalizeFieldInfosProto2);
+        return new InternalFieldList(fields, normalizeFieldInfosProto2);
     },
     initFields(target) {
-      for (const member of target.getType().fields.byMember()) {
-        const name = member.localName,
-          t = target;
-        if (member.repeated) {
-          t[name] = [];
-          continue;
+        for (const member of target.getType().fields.byMember()) {
+            const name = member.localName, t = target;
+            if (member.repeated) {
+                t[name] = [];
+                continue;
+            }
+            switch (member.kind) {
+                case "oneof":
+                    t[name] = { case: undefined };
+                    break;
+                case "map":
+                    t[name] = {};
+                    break;
+                case "scalar":
+                case "enum":
+                case "message":
+                    // In contrast to proto3, enum and scalar fields have no intrinsic default value,
+                    // only an optional explicit default value.
+                    // Unlike proto3 intrinsic default values, proto2 explicit default values are not
+                    // set on construction, because they are not omitted on the wire. If we did set
+                    // default values on construction, a deserialize-serialize round-trip would add
+                    // fields to a message.
+                    break;
+            }
         }
-        switch (member.kind) {
-          case "oneof":
-            t[name] = { case: undefined };
-            break;
-          case "map":
-            t[name] = {};
-            break;
-          case "scalar":
-          case "enum":
-          case "message":
-            // In contrast to proto3, enum and scalar fields have no intrinsic default value,
-            // only an optional explicit default value.
-            // Unlike proto3 intrinsic default values, proto2 explicit default values are not
-            // set on construction, because they are not omitted on the wire. If we did set
-            // default values on construction, a deserialize-serialize round-trip would add
-            // fields to a message.
-            break;
-        }
-      }
     },
-  }
-);
+});
 /* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
 function normalizeFieldInfosProto2(fieldInfos) {
-  const r = [];
-  let o;
-  for (const field of typeof fieldInfos == "function"
-    ? fieldInfos()
-    : fieldInfos) {
-    const f = field;
-    f.localName = makeFieldName(field.name, field.oneof !== undefined);
-    f.jsonName = field.jsonName ?? makeJsonName(field.name);
-    f.repeated = field.repeated ?? false;
-    // In contrast to proto3, repeated fields are unpacked except when explicitly specified.
-    f.packed = field.packed ?? false;
-    // We do not surface options at this time
-    // f.options = field.options ?? emptyReadonlyObject;
-    if (field.oneof !== undefined) {
-      const ooname =
-        typeof field.oneof == "string" ? field.oneof : field.oneof.name;
-      if (!o || o.name != ooname) {
-        o = new InternalOneofInfo(ooname);
-      }
-      f.oneof = o;
-      o.addField(f);
+    const r = [];
+    let o;
+    for (const field of typeof fieldInfos == "function"
+        ? fieldInfos()
+        : fieldInfos) {
+        const f = field;
+        f.localName = makeFieldName(field.name, field.oneof !== undefined);
+        f.jsonName = field.jsonName ?? makeJsonName(field.name);
+        f.repeated = field.repeated ?? false;
+        // In contrast to proto3, repeated fields are unpacked except when explicitly specified.
+        f.packed = field.packed ?? false;
+        // We do not surface options at this time
+        // f.options = field.options ?? emptyReadonlyObject;
+        if (field.oneof !== undefined) {
+            const ooname = typeof field.oneof == "string" ? field.oneof : field.oneof.name;
+            if (!o || o.name != ooname) {
+                o = new InternalOneofInfo(ooname);
+            }
+            f.oneof = o;
+            o.addField(f);
+        }
+        r.push(f);
     }
-    r.push(f);
-  }
-  return r;
+    return r;
 }

package/dist/esm/proto3.js

@@ -1,3 +1,16 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 import { makeProtoRuntime } from "./private/proto-runtime.js";
 import { makeBinaryFormatProto3 } from "./private/binary-format-proto3.js";
 import { makeJsonFormatProto3 } from "./private/json-format-proto3.js";
@@ -10,81 +23,74 @@ import { makeFieldName, makeJsonName } from "./private/names.js";
 /**
  * Provides functionality for messages defined with the proto3 syntax.
  */
-export const proto3 = makeProtoRuntime(
-  "proto3",
-  makeJsonFormatProto3(),
-  makeBinaryFormatProto3(),
-  {
+export const proto3 = makeProtoRuntime("proto3", makeJsonFormatProto3(), makeBinaryFormatProto3(), {
     ...makeUtilCommon(),
     newFieldList(fields) {
-      return new InternalFieldList(fields, normalizeFieldInfosProto3);
+        return new InternalFieldList(fields, normalizeFieldInfosProto3);
     },
     initFields(target) {
-      for (const member of target.getType().fields.byMember()) {
-        if (member.opt) {
-          continue;
+        for (const member of target.getType().fields.byMember()) {
+            if (member.opt) {
+                continue;
+            }
+            const name = member.localName, t = target;
+            if (member.repeated) {
+                t[name] = [];
+                continue;
+            }
+            switch (member.kind) {
+                case "oneof":
+                    t[name] = { case: undefined };
+                    break;
+                case "enum":
+                    t[name] = 0;
+                    break;
+                case "map":
+                    t[name] = {};
+                    break;
+                case "scalar":
+                    t[name] = scalarDefaultValue(member.T); // eslint-disable-line @typescript-eslint/no-unsafe-assignment
+                    break;
+                case "message":
+                    // message fields are always optional in proto3
+                    break;
+            }
         }
-        const name = member.localName,
-          t = target;
-        if (member.repeated) {
-          t[name] = [];
-          continue;
-        }
-        switch (member.kind) {
-          case "oneof":
-            t[name] = { case: undefined };
-            break;
-          case "enum":
-            t[name] = 0;
-            break;
-          case "map":
-            t[name] = {};
-            break;
-          case "scalar":
-            t[name] = scalarDefaultValue(member.T); // eslint-disable-line @typescript-eslint/no-unsafe-assignment
-            break;
-          case "message":
-            // message fields are always optional in proto3
-            break;
-        }
-      }
     },
-  }
-);
+});
 /* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
 function normalizeFieldInfosProto3(fieldInfos) {
-  const r = [];
-  let o;
-  for (const field of typeof fieldInfos == "function"
-    ? fieldInfos()
-    : fieldInfos) {
-    const f = field;
-    f.localName = makeFieldName(field.name, field.oneof !== undefined);
-    f.jsonName = field.jsonName ?? makeJsonName(field.name);
-    f.repeated = field.repeated ?? false;
-    // From the proto3 language guide:
-    // > In proto3, repeated fields of scalar numeric types are packed by default.
-    // This information is incomplete - according to the conformance tests, BOOL
-    // and ENUM are packed by default as well. This means only STRING and BYTES
-    // are not packed by default, which makes sense because they are length-delimited.
-    f.packed =
-      field.packed ??
-      (field.kind == "enum" ||
-        (field.kind == "scalar" &&
-          field.T != ScalarType.BYTES &&
-          field.T != ScalarType.STRING));
-    // We do not surface options at this time
-    // f.options = field.options ?? emptyReadonlyObject;
-    if (field.oneof !== undefined) {
-      const ooname =
-        typeof field.oneof == "string" ? field.oneof : field.oneof.name;
-      if (!o || o.name != ooname) {
-        o = new InternalOneofInfo(ooname);
-      }
-      f.oneof = o;
-      o.addField(f);
+    const r = [];
+    let o;
+    for (const field of typeof fieldInfos == "function"
+        ? fieldInfos()
+        : fieldInfos) {
+        const f = field;
+        f.localName = makeFieldName(field.name, field.oneof !== undefined);
+        f.jsonName = field.jsonName ?? makeJsonName(field.name);
+        f.repeated = field.repeated ?? false;
+        // From the proto3 language guide:
+        // > In proto3, repeated fields of scalar numeric types are packed by default.
+        // This information is incomplete - according to the conformance tests, BOOL
+        // and ENUM are packed by default as well. This means only STRING and BYTES
+        // are not packed by default, which makes sense because they are length-delimited.
+        f.packed =
+            field.packed ??
+                (field.kind == "enum" ||
+                    (field.kind == "scalar" &&
+                        field.T != ScalarType.BYTES &&
+                        field.T != ScalarType.STRING));
+        // We do not surface options at this time
+        // f.options = field.options ?? emptyReadonlyObject;
+        if (field.oneof !== undefined) {
+            const ooname = typeof field.oneof == "string" ? field.oneof : field.oneof.name;
+            if (!o || o.name != ooname) {
+                o = new InternalOneofInfo(ooname);
+            }
+            f.oneof = o;
+            o.addField(f);
+        }
+        r.push(f);
     }
-    r.push(f);
-  }
-  return r;
+    return r;
 }

package/dist/esm/service-type.js

@@ -1,3 +1,16 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 /**
  * MethodKind represents the four method types that can be declared in
  * protobuf with the `stream` keyword:
@@ -9,10 +22,10 @@
  */
 export var MethodKind;
 (function (MethodKind) {
-  MethodKind[(MethodKind["Unary"] = 0)] = "Unary";
-  MethodKind[(MethodKind["ServerStreaming"] = 1)] = "ServerStreaming";
-  MethodKind[(MethodKind["ClientStreaming"] = 2)] = "ClientStreaming";
-  MethodKind[(MethodKind["BiDiStreaming"] = 3)] = "BiDiStreaming";
+    MethodKind[MethodKind["Unary"] = 0] = "Unary";
+    MethodKind[MethodKind["ServerStreaming"] = 1] = "ServerStreaming";
+    MethodKind[MethodKind["ClientStreaming"] = 2] = "ClientStreaming";
+    MethodKind[MethodKind["BiDiStreaming"] = 3] = "BiDiStreaming";
 })(MethodKind || (MethodKind = {}));
 /**
  * Is this method side-effect-free (or safe in HTTP parlance), or just
@@ -26,12 +39,12 @@ export var MethodKind;
  */
 export var MethodIdempotency;
 (function (MethodIdempotency) {
-  /**
-   * Idempotent, no side effects.
-   */
-  MethodIdempotency[(MethodIdempotency["NoSideEffects"] = 1)] = "NoSideEffects";
-  /**
-   * Idempotent, but may have side effects.
-   */
-  MethodIdempotency[(MethodIdempotency["Idempotent"] = 2)] = "Idempotent";
+    /**
+     * Idempotent, no side effects.
+     */
+    MethodIdempotency[MethodIdempotency["NoSideEffects"] = 1] = "NoSideEffects";
+    /**
+     * Idempotent, but may have side effects.
+     */
+    MethodIdempotency[MethodIdempotency["Idempotent"] = 2] = "Idempotent";
 })(MethodIdempotency || (MethodIdempotency = {}));

package/dist/esm/type-registry.js

@@ -1,38 +1,53 @@
+// Copyright 2021-2022 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 /**
  * TypeRegistry is a basic type registry
  */
 export class TypeRegistry {
-  constructor() {
-    this.messages = {};
-    this.enums = {};
-    this.services = {};
-  }
-  findMessage(typeName) {
-    return this.messages[typeName];
-  }
-  findEnum(typeName) {
-    return this.enums[typeName];
-  }
-  findService(typeName) {
-    return this.services[typeName];
-  }
-  add(type) {
-    if ("fields" in type) {
-      this.messages[type.typeName] = type;
-    } else if ("methods" in type) {
-      this.services[type.typeName] = type;
-    } else {
-      this.enums[type.typeName] = type;
+    constructor() {
+        this.messages = {};
+        this.enums = {};
+        this.services = {};
     }
-  }
-  static fromIterable(types) {
-    const r = new TypeRegistry();
-    for (const t of types) {
-      r.add(t);
+    findMessage(typeName) {
+        return this.messages[typeName];
+    }
+    findEnum(typeName) {
+        return this.enums[typeName];
+    }
+    findService(typeName) {
+        return this.services[typeName];
+    }
+    add(type) {
+        if ("fields" in type) {
+            this.messages[type.typeName] = type;
+        }
+        else if ("methods" in type) {
+            this.services[type.typeName] = type;
+        }
+        else {
+            this.enums[type.typeName] = type;
+        }
+    }
+    static fromIterable(types) {
+        const r = new TypeRegistry();
+        for (const t of types) {
+            r.add(t);
+        }
+        return r;
+    }
+    static fromTypes(...types) {
+        return TypeRegistry.fromIterable(types);
     }
-    return r;
-  }
-  static fromTypes(...types) {
-    return TypeRegistry.fromIterable(types);
-  }
 }