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

package/dist/esm/private/json-format-proto2.js

@@ -1,90 +1,98 @@
+// 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 { wrapField } from "./field-wrapper.js";
 import { assert } from "./assert.js";
 import { makeJsonFormatCommon } from "./json-format-common.js";
 /* eslint-disable no-case-declarations, @typescript-eslint/restrict-plus-operands,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
 export function makeJsonFormatProto2() {
-  return makeJsonFormatCommon((writeEnum, writeScalar) => {
-    return function writeField(field, value, options) {
-      if (field.kind == "map") {
-        const jsonObj = {};
-        switch (field.V.kind) {
-          case "scalar":
-            for (const [entryKey, entryValue] of Object.entries(value)) {
-              const val = writeScalar(field.V.T, entryValue, true);
-              assert(val !== undefined);
-              jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+    return makeJsonFormatCommon((writeEnum, writeScalar) => {
+        return function writeField(field, value, options) {
+            if (field.kind == "map") {
+                const jsonObj = {};
+                switch (field.V.kind) {
+                    case "scalar":
+                        for (const [entryKey, entryValue] of Object.entries(value)) {
+                            const val = writeScalar(field.V.T, entryValue, true);
+                            assert(val !== undefined);
+                            jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+                        }
+                        break;
+                    case "message":
+                        for (const [entryKey, entryValue] of Object.entries(value)) {
+                            // JSON standard allows only (double quoted) string as property key
+                            jsonObj[entryKey.toString()] = entryValue.toJson(options);
+                        }
+                        break;
+                    case "enum":
+                        const enumType = field.V.T;
+                        for (const [entryKey, entryValue] of Object.entries(value)) {
+                            assert(entryValue === undefined || typeof entryValue == "number");
+                            const val = writeEnum(enumType, entryValue, true, options.enumAsInteger);
+                            assert(val !== undefined);
+                            jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+                        }
+                        break;
+                }
+                return options.emitDefaultValues || Object.keys(jsonObj).length > 0
+                    ? jsonObj
+                    : undefined;
             }
-            break;
-          case "message":
-            for (const [entryKey, entryValue] of Object.entries(value)) {
-              // JSON standard allows only (double quoted) string as property key
-              jsonObj[entryKey.toString()] = entryValue.toJson(options);
+            else if (field.repeated) {
+                const jsonArr = [];
+                switch (field.kind) {
+                    case "scalar":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push(writeScalar(field.T, value[i], true));
+                        }
+                        break;
+                    case "enum":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push(writeEnum(field.T, value[i], true, options.enumAsInteger));
+                        }
+                        break;
+                    case "message":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push(value[i].toJson(options));
+                        }
+                        break;
+                }
+                return options.emitDefaultValues || jsonArr.length > 0
+                    ? jsonArr
+                    : undefined;
             }
-            break;
-          case "enum":
-            const enumType = field.V.T;
-            for (const [entryKey, entryValue] of Object.entries(value)) {
-              assert(entryValue === undefined || typeof entryValue == "number");
-              const val = writeEnum(
-                enumType,
-                entryValue,
-                true,
-                options.enumAsInteger
-              );
-              assert(val !== undefined);
-              jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+            else {
+                // In contrast to proto3, we raise an error if a non-optional (proto2 required)
+                // field is missing a value.
+                if (value === undefined) {
+                    if (!field.oneof && !field.opt) {
+                        throw `required field not set`;
+                    }
+                    return undefined;
+                }
+                switch (field.kind) {
+                    case "scalar":
+                        // In contrast to proto3, we do not skip intrinsic default values.
+                        // Explicit default values are not special cased either.
+                        return writeScalar(field.T, value, true);
+                    case "enum":
+                        // In contrast to proto3, we do not skip intrinsic default values.
+                        // Explicit default values are not special cased either.
+                        return writeEnum(field.T, value, true, options.enumAsInteger);
+                    case "message":
+                        return wrapField(field.T, value).toJson(options);
+                }
             }
-            break;
-        }
-        return options.emitDefaultValues || Object.keys(jsonObj).length > 0
-          ? jsonObj
-          : undefined;
-      } else if (field.repeated) {
-        const jsonArr = [];
-        switch (field.kind) {
-          case "scalar":
-            for (let i = 0; i < value.length; i++) {
-              jsonArr.push(writeScalar(field.T, value[i], true));
-            }
-            break;
-          case "enum":
-            for (let i = 0; i < value.length; i++) {
-              jsonArr.push(
-                writeEnum(field.T, value[i], true, options.enumAsInteger)
-              );
-            }
-            break;
-          case "message":
-            for (let i = 0; i < value.length; i++) {
-              jsonArr.push(value[i].toJson(options));
-            }
-            break;
-        }
-        return options.emitDefaultValues || jsonArr.length > 0
-          ? jsonArr
-          : undefined;
-      } else {
-        // In contrast to proto3, we raise an error if a non-optional (proto2 required)
-        // field is missing a value.
-        if (value === undefined) {
-          if (!field.oneof && !field.opt) {
-            throw `required field not set`;
-          }
-          return undefined;
-        }
-        switch (field.kind) {
-          case "scalar":
-            // In contrast to proto3, we do not skip intrinsic default values.
-            // Explicit default values are not special cased either.
-            return writeScalar(field.T, value, true);
-          case "enum":
-            // In contrast to proto3, we do not skip intrinsic default values.
-            // Explicit default values are not special cased either.
-            return writeEnum(field.T, value, true, options.enumAsInteger);
-          case "message":
-            return wrapField(field.T, value).toJson(options);
-        }
-      }
-    };
-  });
+        };
+    });
 }

package/dist/esm/private/json-format-proto3.js

@@ -1,89 +1,88 @@
+// 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 { wrapField } from "./field-wrapper.js";
 import { assert } from "./assert.js";
 import { makeJsonFormatCommon } from "./json-format-common.js";
 /* eslint-disable no-case-declarations, @typescript-eslint/restrict-plus-operands,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
 export function makeJsonFormatProto3() {
-  return makeJsonFormatCommon((writeEnum, writeScalar) => {
-    return function writeField(field, value, options) {
-      if (field.kind == "map") {
-        const jsonObj = {};
-        switch (field.V.kind) {
-          case "scalar":
-            for (const [entryKey, entryValue] of Object.entries(value)) {
-              const val = writeScalar(field.V.T, entryValue, true);
-              assert(val !== undefined);
-              jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+    return makeJsonFormatCommon((writeEnum, writeScalar) => {
+        return function writeField(field, value, options) {
+            if (field.kind == "map") {
+                const jsonObj = {};
+                switch (field.V.kind) {
+                    case "scalar":
+                        for (const [entryKey, entryValue] of Object.entries(value)) {
+                            const val = writeScalar(field.V.T, entryValue, true);
+                            assert(val !== undefined);
+                            jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+                        }
+                        break;
+                    case "message":
+                        for (const [entryKey, entryValue] of Object.entries(value)) {
+                            // JSON standard allows only (double quoted) string as property key
+                            jsonObj[entryKey.toString()] = entryValue.toJson(options);
+                        }
+                        break;
+                    case "enum":
+                        const enumType = field.V.T;
+                        for (const [entryKey, entryValue] of Object.entries(value)) {
+                            assert(entryValue === undefined || typeof entryValue == "number");
+                            const val = writeEnum(enumType, entryValue, true, options.enumAsInteger);
+                            assert(val !== undefined);
+                            jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+                        }
+                        break;
+                }
+                return options.emitDefaultValues || Object.keys(jsonObj).length > 0
+                    ? jsonObj
+                    : undefined;
             }
-            break;
-          case "message":
-            for (const [entryKey, entryValue] of Object.entries(value)) {
-              // JSON standard allows only (double quoted) string as property key
-              jsonObj[entryKey.toString()] = entryValue.toJson(options);
+            else if (field.repeated) {
+                const jsonArr = [];
+                switch (field.kind) {
+                    case "scalar":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push(writeScalar(field.T, value[i], true));
+                        }
+                        break;
+                    case "enum":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push(writeEnum(field.T, value[i], true, options.enumAsInteger));
+                        }
+                        break;
+                    case "message":
+                        for (let i = 0; i < value.length; i++) {
+                            jsonArr.push(wrapField(field.T, value[i]).toJson(options));
+                        }
+                        break;
+                }
+                return options.emitDefaultValues || jsonArr.length > 0
+                    ? jsonArr
+                    : undefined;
             }
-            break;
-          case "enum":
-            const enumType = field.V.T;
-            for (const [entryKey, entryValue] of Object.entries(value)) {
-              assert(entryValue === undefined || typeof entryValue == "number");
-              const val = writeEnum(
-                enumType,
-                entryValue,
-                true,
-                options.enumAsInteger
-              );
-              assert(val !== undefined);
-              jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+            else {
+                switch (field.kind) {
+                    case "scalar":
+                        return writeScalar(field.T, value, !!field.oneof || field.opt || options.emitDefaultValues);
+                    case "enum":
+                        return writeEnum(field.T, value, !!field.oneof || field.opt || options.emitDefaultValues, options.enumAsInteger);
+                    case "message":
+                        return value !== undefined
+                            ? wrapField(field.T, value).toJson(options)
+                            : undefined;
+                }
             }
-            break;
-        }
-        return options.emitDefaultValues || Object.keys(jsonObj).length > 0
-          ? jsonObj
-          : undefined;
-      } else if (field.repeated) {
-        const jsonArr = [];
-        switch (field.kind) {
-          case "scalar":
-            for (let i = 0; i < value.length; i++) {
-              jsonArr.push(writeScalar(field.T, value[i], true));
-            }
-            break;
-          case "enum":
-            for (let i = 0; i < value.length; i++) {
-              jsonArr.push(
-                writeEnum(field.T, value[i], true, options.enumAsInteger)
-              );
-            }
-            break;
-          case "message":
-            for (let i = 0; i < value.length; i++) {
-              jsonArr.push(wrapField(field.T, value[i]).toJson(options));
-            }
-            break;
-        }
-        return options.emitDefaultValues || jsonArr.length > 0
-          ? jsonArr
-          : undefined;
-      } else {
-        switch (field.kind) {
-          case "scalar":
-            return writeScalar(
-              field.T,
-              value,
-              !!field.oneof || field.opt || options.emitDefaultValues
-            );
-          case "enum":
-            return writeEnum(
-              field.T,
-              value,
-              !!field.oneof || field.opt || options.emitDefaultValues,
-              options.enumAsInteger
-            );
-          case "message":
-            return value !== undefined
-              ? wrapField(field.T, value).toJson(options)
-              : undefined;
-        }
-      }
-    };
-  });
+        };
+    });
 }

package/dist/esm/private/message-type.js

@@ -1,33 +1,45 @@
-import { Message } from "../message.js";
+// 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 { Message, } from "../message.js";
 /**
  * Create a new message type using the given runtime.
  */
 export function makeMessageType(runtime, typeName, fields, opt) {
-  const localName =
-    opt?.localName ?? typeName.substring(typeName.lastIndexOf(".") + 1);
-  const type = {
-    [localName]: function (data) {
-      runtime.util.initFields(this);
-      runtime.util.initPartial(data, this);
-    },
-  }[localName];
-  Object.setPrototypeOf(type.prototype, new Message());
-  Object.assign(type, {
-    runtime,
-    typeName,
-    fields: runtime.util.newFieldList(fields),
-    fromBinary(bytes, options) {
-      return new type().fromBinary(bytes, options);
-    },
-    fromJson(jsonValue, options) {
-      return new type().fromJson(jsonValue, options);
-    },
-    fromJsonString(jsonString, options) {
-      return new type().fromJsonString(jsonString, options);
-    },
-    equals(a, b) {
-      return runtime.util.equals(type, a, b);
-    },
-  });
-  return type;
+    const localName = opt?.localName ?? typeName.substring(typeName.lastIndexOf(".") + 1);
+    const type = {
+        [localName]: function (data) {
+            runtime.util.initFields(this);
+            runtime.util.initPartial(data, this);
+        },
+    }[localName];
+    Object.setPrototypeOf(type.prototype, new Message());
+    Object.assign(type, {
+        runtime,
+        typeName,
+        fields: runtime.util.newFieldList(fields),
+        fromBinary(bytes, options) {
+            return new type().fromBinary(bytes, options);
+        },
+        fromJson(jsonValue, options) {
+            return new type().fromJson(jsonValue, options);
+        },
+        fromJsonString(jsonString, options) {
+            return new type().fromJsonString(jsonString, options);
+        },
+        equals(a, b) {
+            return runtime.util.equals(type, a, b);
+        },
+    });
+    return type;
 }

package/dist/esm/private/names.js

@@ -1,68 +1,81 @@
+// 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.
 /**
  * Returns the JSON name for a protobuf field, exactly like protoc does.
  */
 export function makeJsonName(protoName) {
-  return protoCamelCase(protoName);
+    return protoCamelCase(protoName);
 }
 /**
  * Returns the local name of a field, exactly like protoc-gen-es does.
  */
 export function makeFieldName(protoName, inOneof) {
-  const n = protoCamelCase(protoName);
-  if (inOneof) {
-    return n;
-  }
-  return rProp[n] ? n + escapeChar : n;
+    const n = protoCamelCase(protoName);
+    if (inOneof) {
+        return n;
+    }
+    return rProp[n] ? n + escapeChar : n;
 }
 /**
  * Returns the local name of a oneof group, exactly like protoc-gen-es does.
  */
 export function makeOneofName(protoName) {
-  return makeFieldName(protoName, false);
+    return makeFieldName(protoName, false);
 }
 /**
  * Returns the local name of a rpc, exactly like protoc-gen-es does.
  */
 export function makeMethodName(protoName) {
-  if (protoName.length == 0) {
-    return protoName;
-  }
-  return protoName[0].toLowerCase() + protoName.substring(1);
+    if (protoName.length == 0) {
+        return protoName;
+    }
+    return protoName[0].toLowerCase() + protoName.substring(1);
 }
 // Converts snake_case to protoCamelCase according to the convention
 // used by protoc to convert a field name to a JSON name.
 function protoCamelCase(snakeCase) {
-  let capNext = false;
-  const b = [];
-  for (let i = 0; i < snakeCase.length; i++) {
-    let c = snakeCase.charAt(i);
-    switch (c) {
-      case "_":
-        capNext = true;
-        break;
-      case "0":
-      case "1":
-      case "2":
-      case "3":
-      case "4":
-      case "5":
-      case "6":
-      case "7":
-      case "8":
-      case "9":
-        b.push(c);
-        capNext = false;
-        break;
-      default:
-        if (capNext) {
-          capNext = false;
-          c = c.toUpperCase();
+    let capNext = false;
+    const b = [];
+    for (let i = 0; i < snakeCase.length; i++) {
+        let c = snakeCase.charAt(i);
+        switch (c) {
+            case "_":
+                capNext = true;
+                break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9":
+                b.push(c);
+                capNext = false;
+                break;
+            default:
+                if (capNext) {
+                    capNext = false;
+                    c = c.toUpperCase();
+                }
+                b.push(c);
+                break;
         }
-        b.push(c);
-        break;
     }
-  }
-  return b.join("");
+    return b.join("");
 }
 // escapeChar must be appended to a reserved name.
 // We choose '$' because it is invalid in proto identifiers.
@@ -70,21 +83,21 @@ const escapeChar = "$";
 // Names that cannot be used for object properties.
 // See buf_es/protoc-gen-es/internal/protoplugin/names.go
 const rProp = {
-  // names reserved by JavaScript
-  constructor: true,
-  toString: true,
-  toJSON: true,
-  valueOf: true,
-  // names reserved by the runtime
-  getType: true,
-  clone: true,
-  equals: true,
-  fromBinary: true,
-  fromJson: true,
-  fromJsonString: true,
-  toBinary: true,
-  toJson: true,
-  toJsonString: true,
-  // names reserved by the runtime for the future
-  toObject: true,
+    // names reserved by JavaScript
+    constructor: true,
+    toString: true,
+    toJSON: true,
+    valueOf: true,
+    // names reserved by the runtime
+    getType: true,
+    clone: true,
+    equals: true,
+    fromBinary: true,
+    fromJson: true,
+    fromJsonString: true,
+    toBinary: true,
+    toJson: true,
+    toJsonString: true,
+    // names reserved by the runtime for the future
+    toObject: true,
 };

package/dist/esm/private/options-map.js

@@ -1 +1,14 @@
+// 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.
 export {};

package/dist/esm/private/proto-runtime.js

@@ -1,15 +1,29 @@
-import { getEnumType, makeEnumType } from "./enum.js";
+// 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 { getEnumType, makeEnum, makeEnumType } from "./enum.js";
 import { makeMessageType } from "./message-type.js";
 export function makeProtoRuntime(syntax, json, bin, util) {
-  return {
-    syntax,
-    json,
-    bin,
-    util,
-    makeMessageType(typeName, fields, opt) {
-      return makeMessageType(this, typeName, fields, opt);
-    },
-    makeEnumType,
-    getEnumType,
-  };
+    return {
+        syntax,
+        json,
+        bin,
+        util,
+        makeMessageType(typeName, fields, opt) {
+            return makeMessageType(this, typeName, fields, opt);
+        },
+        makeEnum,
+        makeEnumType,
+        getEnumType,
+    };
 }