@bufbuild/protoc-gen-es 0.0.6 → 0.0.9

package/dist/cjs/src/typescript.js

@@ -0,0 +1,552 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescript = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
+const match_wkt_js_1 = require("./match-wkt.js");
+const javascript_js_1 = require("./javascript.js");
+const ecmascript_2 = require("@bufbuild/protoplugin/ecmascript");
+exports.typescript = {
+    target: "ts",
+    extension: "_pb.ts",
+    generateEnum,
+    generateMessage,
+};
+// prettier-ignore
+function generateEnum(schema, f, enumeration) {
+    const protoN = schema.runtime[enumeration.file.syntax];
+    f.print((0, ecmascript_1.makeJsDoc)(enumeration));
+    f.print("export enum ", enumeration, " {");
+    for (const value of enumeration.values) {
+        if (enumeration.values.indexOf(value) > 0) {
+            f.print();
+        }
+        f.print((0, ecmascript_1.makeJsDoc)(value, "  "));
+        f.print("  ", (0, ecmascript_1.localName)(value), " = ", value.number, ",");
+    }
+    f.print("}");
+    f.print("// Retrieve enum metadata with: ", enumeration.file.syntax, ".getEnumType(", enumeration, ")");
+    f.print(protoN, `.util.setEnumType(`, enumeration, `, "`, enumeration.typeName, `", [`);
+    for (const value of enumeration.values) {
+        f.print("  { no: ", value.number, ', name: "', value.name, '" },');
+    }
+    f.print("]);");
+    f.print();
+}
+// prettier-ignore
+function generateMessage(schema, f, message) {
+    const protoN = schema.runtime[message.file.syntax];
+    const { PartialMessage, FieldList, Message, PlainMessage, BinaryReadOptions, JsonReadOptions, JsonValue } = schema.runtime;
+    f.print((0, ecmascript_1.makeJsDoc)(message));
+    f.print("export class ", message, " extends ", Message, "<", message, "> {");
+    for (const member of message.members) {
+        switch (member.kind) {
+            case "oneof":
+                generateOneof(schema, f, member);
+                break;
+            default:
+                generateField(schema, f, member);
+                break;
+        }
+        f.print();
+    }
+    f.print("  constructor(data?: ", PartialMessage, "<", message, ">) {");
+    f.print("    super();");
+    f.print("    ", protoN, ".util.initPartial(data, this);");
+    f.print("  }");
+    f.print();
+    generateWktMethods(schema, f, message);
+    f.print("  static readonly runtime = ", protoN, ";");
+    f.print('  static readonly typeName = ', (0, ecmascript_2.literalString)(message.typeName), ';');
+    f.print("  static readonly fields: ", FieldList, " = ", protoN, ".util.newFieldList(() => [");
+    for (const field of message.fields) {
+        (0, javascript_js_1.generateFieldInfo)(schema, f, field);
+    }
+    f.print("  ]);");
+    // In case we start supporting options, we have to surface them here
+    //f.print("  static readonly options: { readonly [extensionName: string]: ", rt.JsonValue, " } = {};")
+    f.print();
+    generateWktStaticMethods(schema, f, message);
+    f.print("  static fromBinary(bytes: Uint8Array, options?: Partial<", BinaryReadOptions, ">): ", message, " {");
+    f.print("    return new ", message, "().fromBinary(bytes, options);");
+    f.print("  }");
+    f.print();
+    f.print("  static fromJson(jsonValue: ", JsonValue, ", options?: Partial<", JsonReadOptions, ">): ", message, " {");
+    f.print("    return new ", message, "().fromJson(jsonValue, options);");
+    f.print("  }");
+    f.print();
+    f.print("  static fromJsonString(jsonString: string, options?: Partial<", JsonReadOptions, ">): ", message, " {");
+    f.print("    return new ", message, "().fromJsonString(jsonString, options);");
+    f.print("  }");
+    f.print();
+    f.print("  static equals(a: ", message, " | ", PlainMessage, "<", message, "> | undefined, b: ", message, " | ", PlainMessage, "<", message, "> | undefined): boolean {");
+    f.print("    return ", protoN, ".util.equals(", message, ", a, b);");
+    f.print("  }");
+    f.print("}");
+    f.print();
+    for (const nestedEnum of message.nestedEnums) {
+        generateEnum(schema, f, nestedEnum);
+    }
+    for (const nestedMessage of message.nestedMessages) {
+        generateMessage(schema, f, nestedMessage);
+    }
+    // We do not support extensions at this time
+}
+// prettier-ignore
+function generateOneof(schema, f, oneof) {
+    f.print((0, ecmascript_1.makeJsDoc)(oneof, "  "));
+    f.print("  ", (0, ecmascript_1.localName)(oneof), ": {");
+    for (const field of oneof.fields) {
+        if (oneof.fields.indexOf(field) > 0) {
+            f.print(`  } | {`);
+        }
+        f.print((0, ecmascript_1.makeJsDoc)(field, "    "));
+        const { typing } = (0, ecmascript_1.getFieldTyping)(field, f);
+        f.print(`    value: `, typing, `;`);
+        f.print(`    case: "`, (0, ecmascript_1.localName)(field), `";`);
+    }
+    f.print(`  } | { case: undefined; value?: undefined } = { case: undefined };`);
+}
+function generateField(schema, f, field) {
+    f.print((0, ecmascript_1.makeJsDoc)(field, "  "));
+    const e = [];
+    e.push("  ", (0, ecmascript_1.localName)(field));
+    const { defaultValue, typingInferrable } = (0, ecmascript_1.getFieldIntrinsicDefaultValue)(field);
+    const { typing, optional } = (0, ecmascript_1.getFieldTyping)(field, f);
+    if (optional || defaultValue === undefined) {
+        e.push("?: ", typing);
+    }
+    else if (!typingInferrable) {
+        e.push(": ", typing);
+    }
+    if (defaultValue !== undefined) {
+        e.push(" = ", defaultValue);
+    }
+    e.push(";");
+    f.print(e);
+}
+// prettier-ignore
+function generateWktMethods(schema, f, message) {
+    var _a;
+    const ref = (0, match_wkt_js_1.matchWkt)(message);
+    if (ref === undefined) {
+        return;
+    }
+    const { Message, JsonValue, JsonReadOptions, JsonWriteOptions, JsonObject, MessageType, ScalarType: rtScalarType, protoInt64, } = schema.runtime;
+    const protoN = schema.runtime[message.file.syntax];
+    switch (ref.typeName) {
+        case "google.protobuf.Any":
+            f.print("  override toJson(options?: Partial<", JsonWriteOptions, ">): ", JsonValue, " {");
+            f.print(`    if (this.`, (0, ecmascript_1.localName)(ref.typeUrl), ` === "") {`);
+            f.print("      return {};");
+            f.print("    }");
+            f.print("    const typeName = this.typeUrlToName(this.", (0, ecmascript_1.localName)(ref.typeUrl), ");");
+            f.print("    const messageType = options?.typeRegistry?.findMessage(typeName);");
+            f.print("    if (!messageType) {");
+            f.print("      throw new Error(`cannot encode message ", message.typeName, ' to JSON: "${this.', (0, ecmascript_1.localName)(ref.typeUrl), '}" is not in the type registry`);');
+            f.print("    }");
+            f.print("    const message = messageType.fromBinary(this.", (0, ecmascript_1.localName)(ref.value), ");");
+            f.print("    let json = message.toJson(options);");
+            f.print(`    if (typeName.startsWith("google.protobuf.") || (json === null || Array.isArray(json) || typeof json !== "object")) {`);
+            f.print("      json = {value: json};");
+            f.print("    }");
+            f.print(`    json["@type"] = this.`, (0, ecmascript_1.localName)(ref.typeUrl), `;`);
+            f.print("    return json;");
+            f.print("  }");
+            f.print();
+            f.print("  override fromJson(json: ", JsonValue, ", options?: Partial<", JsonReadOptions, ">): this {");
+            f.print(`    if (json === null || Array.isArray(json) || typeof json != "object") {`);
+            f.print("      throw new Error(`cannot decode message ", message.typeName, ' from JSON: expected object but got ${json === null ? "null" : Array.isArray(json) ? "array" : typeof json}`);');
+            f.print("    }");
+            f.print(`    const typeUrl = json["@type"];`);
+            f.print(`    if (typeof typeUrl != "string" || typeUrl == "") {`);
+            f.print("      throw new Error(`cannot decode message ", message.typeName, ' from JSON: "@type" is empty`);');
+            f.print("    }");
+            f.print("    const typeName = this.typeUrlToName(typeUrl), messageType = options?.typeRegistry?.findMessage(typeName);");
+            f.print("    if (!messageType) {");
+            f.print("      throw new Error(`cannot decode message ", message.typeName, " from JSON: ${typeUrl} is not in the type registry`);");
+            f.print("    }");
+            f.print("    let message;");
+            f.print(`    if (typeName.startsWith("google.protobuf.") &&  Object.prototype.hasOwnProperty.call(json, "value")) {`);
+            f.print(`      message = messageType.fromJson(json["value"], options);`);
+            f.print("    } else {");
+            f.print("      const copy = Object.assign({}, json);");
+            f.print(`      delete copy["@type"];`);
+            f.print("      message = messageType.fromJson(copy, options);");
+            f.print("    }");
+            f.print("    this.packFrom(message);");
+            f.print("    return this;");
+            f.print("  }");
+            f.print();
+            f.print("  packFrom(message: ", Message, "): void {");
+            f.print("    this.", (0, ecmascript_1.localName)(ref.value), " = message.toBinary();");
+            f.print("    this.", (0, ecmascript_1.localName)(ref.typeUrl), " = this.typeNameToUrl(message.getType().typeName);");
+            f.print("  }");
+            f.print();
+            f.print("  unpackTo(target: ", Message, "): boolean {");
+            f.print("    if (!this.is(target.getType())) {");
+            f.print("      return false;");
+            f.print("    }");
+            f.print("    target.fromBinary(this.", (0, ecmascript_1.localName)(ref.value), ");");
+            f.print("    return true;");
+            f.print("  }");
+            f.print();
+            f.print("  is(type: ", MessageType, "): boolean {");
+            f.print("    return this.", (0, ecmascript_1.localName)(ref.typeUrl), " === this.typeNameToUrl(type.typeName);");
+            f.print("  }");
+            f.print();
+            f.print("  private typeNameToUrl(name: string): string {");
+            f.print("    return `type.googleapis.com/${name}`;");
+            f.print("  }");
+            f.print();
+            f.print("  private typeUrlToName(url: string): string {");
+            f.print("    if (!url.length) {");
+            f.print("      throw new Error(`invalid type url: ${url}`);");
+            f.print("    }");
+            f.print(`    const slash = url.lastIndexOf("/");`);
+            f.print("    const name = slash > 0 ? url.substring(slash + 1) : url;");
+            f.print("    if (!name.length) {");
+            f.print("      throw new Error(`invalid type url: ${url}`);");
+            f.print("    }");
+            f.print("    return name;");
+            f.print("  }");
+            f.print();
+            break;
+        case "google.protobuf.Timestamp":
+            f.print("  override fromJson(json: ", JsonValue, ", options?: Partial<", JsonReadOptions, ">): this {");
+            f.print(`    if (typeof json !== "string") {`);
+            f.print("      throw new Error(`cannot decode ", message.typeName, " from JSON: ${", protoN, ".json.debug(json)}`);");
+            f.print("    }");
+            f.print(`    const matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);`);
+            f.print("    if (!matches) {");
+            f.print("      throw new Error(`cannot decode ", message.typeName, " from JSON: invalid RFC 3339 string`);");
+            f.print("    }");
+            f.print(`    const ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));`);
+            f.print("    if (Number.isNaN(ms)) {");
+            f.print("      throw new Error(`cannot decode ", message.typeName, " from JSON: invalid RFC 3339 string`);");
+            f.print("    }");
+            f.print(`    if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) {`);
+            f.print("      throw new Error(`cannot decode message ", message.typeName, " from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);");
+            f.print("    }");
+            f.print("    this.", (0, ecmascript_1.localName)(ref.seconds), " = ", protoInt64, ".parse(ms / 1000);");
+            f.print("    this.", (0, ecmascript_1.localName)(ref.nanos), " = 0;");
+            f.print("    if (matches[7]) {");
+            f.print(`      this.`, (0, ecmascript_1.localName)(ref.nanos), ` = (parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000);`);
+            f.print("    }");
+            f.print("    return this;");
+            f.print("  }");
+            f.print();
+            f.print("  override toJson(options?: Partial<", JsonWriteOptions, ">): JsonValue {");
+            f.print("    const ms = Number(this.", (0, ecmascript_1.localName)(ref.seconds), ") * 1000;");
+            f.print(`    if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) {`);
+            f.print("      throw new Error(`cannot encode ", message.typeName, " to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);");
+            f.print("    }");
+            f.print("    if (this.", (0, ecmascript_1.localName)(ref.nanos), " < 0) {");
+            f.print("      throw new Error(`cannot encode ", message.typeName, " to JSON: nanos must not be negative`);");
+            f.print("    }");
+            f.print(`    let z = "Z";`);
+            f.print("    if (this.", (0, ecmascript_1.localName)(ref.nanos), " > 0) {");
+            f.print("      const nanosStr = (this.", (0, ecmascript_1.localName)(ref.nanos), " + 1000000000).toString().substring(1);");
+            f.print(`      if (nanosStr.substring(3) === "000000") {`);
+            f.print(`        z = "." + nanosStr.substring(0, 3) + "Z";`);
+            f.print(`      } else if (nanosStr.substring(6) === "000") {`);
+            f.print(`        z = "." + nanosStr.substring(0, 6) + "Z";`);
+            f.print("      } else {");
+            f.print(`        z = "." + nanosStr + "Z";`);
+            f.print("      }");
+            f.print("    }");
+            f.print(`    return new Date(ms).toISOString().replace(".000Z", z);`);
+            f.print("  }");
+            f.print();
+            f.print("  toDate(): Date {");
+            f.print("    return new Date(Number(this.", (0, ecmascript_1.localName)(ref.seconds), ") * 1000 + Math.ceil(this.", (0, ecmascript_1.localName)(ref.nanos), " / 1000000));");
+            f.print("  }");
+            f.print();
+            break;
+        case "google.protobuf.Duration":
+            f.print("  override fromJson(json: ", JsonValue, ", options?: Partial<", JsonReadOptions, ">): this {");
+            f.print(`    if (typeof json !== "string") {`);
+            f.print("      throw new Error(`cannot decode ", message.typeName, " from JSON: ${proto3.json.debug(json)}`);");
+            f.print("    }");
+            f.print(`    const match = json.match(/^(-?[0-9]+)(?:\\.([0-9]+))?s/);`);
+            f.print("    if (match === null) {");
+            f.print("      throw new Error(`cannot decode ", message.typeName, " from JSON: ${", protoN, ".json.debug(json)}`);");
+            f.print("    }");
+            f.print("    const longSeconds = Number(match[1]);");
+            f.print("    if (longSeconds > 315576000000 || longSeconds < -315576000000) {");
+            f.print("      throw new Error(`cannot decode ", message.typeName, " from JSON: ${", protoN, ".json.debug(json)}`);");
+            f.print("    }");
+            f.print("    this.", (0, ecmascript_1.localName)(ref.seconds), " = ", protoInt64, ".parse(longSeconds);");
+            f.print(`    if (typeof match[2] == "string") {`);
+            f.print(`      const nanosStr = match[2] + "0".repeat(9 - match[2].length);`);
+            f.print("      this.", (0, ecmascript_1.localName)(ref.nanos), " = parseInt(nanosStr);");
+            f.print("      if (longSeconds < ", protoInt64, ".zero) {");
+            f.print("        this.", (0, ecmascript_1.localName)(ref.nanos), " = -this.", (0, ecmascript_1.localName)(ref.nanos), ";");
+            f.print("      }");
+            f.print("    }");
+            f.print("    return this;");
+            f.print("  }");
+            f.print();
+            f.print("  override toJson(options?: Partial<", JsonWriteOptions, ">): JsonValue {");
+            f.print("    if (Number(this.", (0, ecmascript_1.localName)(ref.seconds), ") > 315576000000 || Number(this.", (0, ecmascript_1.localName)(ref.seconds), ") < -315576000000) {");
+            f.print("      throw new Error(`cannot encode ", message.typeName, " to JSON: value out of range`);");
+            f.print("    }");
+            f.print("    let text = this.", (0, ecmascript_1.localName)(ref.seconds), ".toString();");
+            f.print("    if (this.", (0, ecmascript_1.localName)(ref.nanos), " !== 0) {");
+            f.print("      let nanosStr = Math.abs(this.", (0, ecmascript_1.localName)(ref.nanos), ").toString();");
+            f.print(`      nanosStr = "0".repeat(9 - nanosStr.length) + nanosStr;`);
+            f.print(`      if (nanosStr.substring(3) === "000000") {`);
+            f.print("        nanosStr = nanosStr.substring(0, 3);");
+            f.print(`      } else if (nanosStr.substring(6) === "000") {`);
+            f.print("        nanosStr = nanosStr.substring(0, 6);");
+            f.print(`      }`);
+            f.print(`      text += "." + nanosStr;`);
+            f.print("    }");
+            f.print(`    return text + "s";`);
+            f.print("  }");
+            f.print();
+            break;
+        case "google.protobuf.Struct":
+            f.print("  override toJson(options?: Partial<", JsonWriteOptions, ">): ", JsonValue, " {");
+            f.print("    const json: ", JsonObject, " = {}");
+            f.print("    for (const [k, v] of Object.entries(this.", (0, ecmascript_1.localName)(ref.fields), ")) {");
+            f.print("      json[k] = v.toJson(options);");
+            f.print("    }");
+            f.print("    return json;");
+            f.print("  }");
+            f.print();
+            f.print("  override fromJson(json: ", JsonValue, ", options?: Partial<", JsonReadOptions, ">): this {");
+            f.print(`    if (typeof json != "object" || json == null || Array.isArray(json)) {`);
+            f.print(`      throw new Error("cannot decode `, message.typeName, ` from JSON " + `, protoN, `.json.debug(json));`);
+            f.print("    }");
+            f.print("    for (const [k, v] of Object.entries(json)) {");
+            f.print("      this.", (0, ecmascript_1.localName)(ref.fields), "[k] = ", (_a = ref.fields.mapValue.message) !== null && _a !== void 0 ? _a : "", ".fromJson(v);");
+            f.print("    }");
+            f.print("    return this;");
+            f.print("  }");
+            f.print();
+            break;
+        case "google.protobuf.Value":
+            f.print("  override toJson(options?: Partial<", JsonWriteOptions, ">): ", JsonValue, " {");
+            f.print("    switch (this.", (0, ecmascript_1.localName)(ref.kind), ".case) {");
+            f.print(`      case "`, (0, ecmascript_1.localName)(ref.nullValue), `":`);
+            f.print("        return null;");
+            f.print(`      case "`, (0, ecmascript_1.localName)(ref.boolValue), `":`);
+            f.print(`      case "`, (0, ecmascript_1.localName)(ref.numberValue), `":`);
+            f.print(`      case "`, (0, ecmascript_1.localName)(ref.stringValue), `":`);
+            f.print("        return this.", (0, ecmascript_1.localName)(ref.kind), ".value;");
+            f.print(`      case "`, (0, ecmascript_1.localName)(ref.structValue), `":`);
+            f.print(`      case "`, (0, ecmascript_1.localName)(ref.listValue), `":`);
+            f.print(`        return this.`, (0, ecmascript_1.localName)(ref.kind), `.value.toJson({...options, emitDefaultValues: true});`);
+            f.print("    }");
+            f.print(`    throw new Error("`, message.typeName, ` must have a value");`);
+            f.print("  }");
+            f.print();
+            f.print("  override fromJson(json: ", JsonValue, ", options?: Partial<", JsonReadOptions, ">): this {");
+            f.print("    switch (typeof json) {");
+            f.print(`      case "number":`);
+            f.print(`        this.kind = { case: "`, (0, ecmascript_1.localName)(ref.numberValue), `", value: json };`);
+            f.print("        break;");
+            f.print(`      case "string":`);
+            f.print(`        this.kind = { case: "`, (0, ecmascript_1.localName)(ref.stringValue), `", value: json };`);
+            f.print("        break;");
+            f.print(`      case "boolean":`);
+            f.print(`        this.kind = { case: "`, (0, ecmascript_1.localName)(ref.boolValue), `", value: json };`);
+            f.print("        break;");
+            f.print(`      case "object":`);
+            f.print("        if (json === null) {");
+            f.print(`          this.kind = { case: "`, (0, ecmascript_1.localName)(ref.nullValue), `", value: `, ref.nullValue.enum, `.`, (0, ecmascript_1.localName)(ref.nullValue.enum.values[0]), ` };`);
+            f.print("        } else if (Array.isArray(json)) {");
+            f.print(`          this.kind = { case: "`, (0, ecmascript_1.localName)(ref.listValue), `", value: `, ref.listValue.message, `.fromJson(json) };`);
+            f.print("        } else {");
+            f.print(`          this.kind = { case: "`, (0, ecmascript_1.localName)(ref.structValue), `", value: `, ref.structValue.message, `.fromJson(json) };`);
+            f.print("        }");
+            f.print("        break;");
+            f.print("      default:");
+            f.print(`        throw new Error("cannot decode `, message.typeName, ` from JSON " + `, protoN, `.json.debug(json));`);
+            f.print("    }");
+            f.print("    return this;");
+            f.print("  }");
+            f.print();
+            break;
+        case "google.protobuf.ListValue":
+            f.print(`  override toJson(options?: Partial<`, JsonWriteOptions, `>): `, JsonValue, ` {`);
+            f.print(`    return this.`, (0, ecmascript_1.localName)(ref.values), `.map(v => v.toJson());`);
+            f.print(`  }`);
+            f.print();
+            f.print(`  override fromJson(json: `, JsonValue, `, options?: Partial<`, JsonReadOptions, `>): this {`);
+            f.print(`    if (!Array.isArray(json)) {`);
+            f.print(`      throw new Error("cannot decode `, message.typeName, ` from JSON " + `, protoN, `.json.debug(json));`);
+            f.print(`    }`);
+            f.print(`    for (let e of json) {`);
+            f.print(`      this.`, (0, ecmascript_1.localName)(ref.values), `.push(`, ref.values.message, `.fromJson(e));`);
+            f.print(`    }`);
+            f.print(`    return this;`);
+            f.print(`  }`);
+            f.print();
+            break;
+        case "google.protobuf.FieldMask":
+            f.print(`  override toJson(options?: Partial<`, JsonWriteOptions, `>): `, JsonValue, ` {`);
+            f.print(`    // Converts snake_case to protoCamelCase according to the convention`);
+            f.print(`    // used by protoc to convert a field name to a JSON name.`);
+            f.print(`    function protoCamelCase(snakeCase: string): string {`);
+            f.print(`      let capNext = false;`);
+            f.print(`      const b = [];`);
+            f.print(`      for (let i = 0; i < snakeCase.length; i++) {`);
+            f.print(`        let c = snakeCase.charAt(i);`);
+            f.print(`        switch (c) {`);
+            f.print(`          case '_':`);
+            f.print(`            capNext = true;`);
+            f.print(`            break;`);
+            f.print(`          case '0':`);
+            f.print(`          case '1':`);
+            f.print(`          case '2':`);
+            f.print(`          case '3':`);
+            f.print(`          case '4':`);
+            f.print(`          case '5':`);
+            f.print(`          case '6':`);
+            f.print(`          case '7':`);
+            f.print(`          case '8':`);
+            f.print(`          case '9':`);
+            f.print(`            b.push(c);`);
+            f.print(`            capNext = false;`);
+            f.print(`            break;`);
+            f.print(`          default:`);
+            f.print(`            if (capNext) {`);
+            f.print(`              capNext = false;`);
+            f.print(`              c = c.toUpperCase();`);
+            f.print(`            }`);
+            f.print(`            b.push(c);`);
+            f.print(`            break;`);
+            f.print(`        }`);
+            f.print(`      }`);
+            f.print(`      return b.join('');`);
+            f.print(`    }`);
+            f.print(`    return this.`, (0, ecmascript_1.localName)(ref.paths), `.map(p => {`);
+            f.print(`      if (p.match(/_[0-9]?_/g) || p.match(/[A-Z]/g)) {`);
+            f.print(`        throw new Error("cannot decode `, message.typeName, ` from JSON: lowerCamelCase of path name \\"" + p + "\\" is irreversible");`);
+            f.print(`      }`);
+            f.print(`      return protoCamelCase(p);`);
+            f.print(`    }).join(",");`);
+            f.print(`  }`);
+            f.print();
+            f.print(`  override fromJson(json: `, JsonValue, `, options?: Partial<`, JsonReadOptions, `>): this {`);
+            f.print(`    if (typeof json !== "string") {`);
+            f.print(`      throw new Error("cannot decode `, message.typeName, ` from JSON: " + proto3.json.debug(json));`);
+            f.print(`    }`);
+            f.print(`    if (json === "") {`);
+            f.print(`      return this;`);
+            f.print(`    }`);
+            f.print(`    function camelToSnake (str: string) {`);
+            f.print(`      if (str.includes("_")) {`);
+            f.print(`        throw new Error("cannot decode `, message.typeName, ` from JSON: path names must be lowerCamelCase");`);
+            f.print(`      }`);
+            f.print(`      const sc = str.replace(/[A-Z]/g, letter => "_" + letter.toLowerCase());`);
+            f.print(`      return (sc[0] === "_") ? sc.substring(1) : sc;`);
+            f.print(`    }`);
+            f.print(`    this.`, (0, ecmascript_1.localName)(ref.paths), ` = json.split(",").map(camelToSnake);`);
+            f.print(`    return this;`);
+            f.print(`  }`);
+            f.print();
+            break;
+        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":
+            f.print("  override toJson(options?: Partial<", JsonWriteOptions, ">): ", JsonValue, " {");
+            f.print("    return proto3.json.writeScalar(", rtScalarType, ".", protobuf_1.ScalarType[ref.value.scalar], ", this.value, true)!;");
+            f.print("  }");
+            f.print();
+            f.print("  override fromJson(json: ", JsonValue, ", options?: Partial<", JsonReadOptions, ">): this {");
+            f.print("    try {");
+            f.print("      this.value = ", protoN, ".json.readScalar(", rtScalarType, ".", protobuf_1.ScalarType[ref.value.scalar], ", json);");
+            f.print("    } catch (e) {");
+            f.print("      let m = `cannot decode message ", message.typeName, " from JSON\"`;");
+            f.print("      if (e instanceof Error && e.message.length > 0) {");
+            f.print("        m += `: ${e.message}`");
+            f.print("      }");
+            f.print("      throw new Error(m);");
+            f.print("    }");
+            f.print("    return this;");
+            f.print("  }");
+            f.print();
+            break;
+    }
+}
+// prettier-ignore
+function generateWktStaticMethods(schema, f, message) {
+    const ref = (0, match_wkt_js_1.matchWkt)(message);
+    if (ref === undefined) {
+        return;
+    }
+    const { protoInt64, } = schema.runtime;
+    switch (ref.typeName) {
+        case "google.protobuf.Any":
+            f.print("  static pack(message: Message): ", message, " {");
+            f.print("    const any = new ", message, "();");
+            f.print("    any.packFrom(message);");
+            f.print("    return any;");
+            f.print("  }");
+            f.print();
+            break;
+        case "google.protobuf.Timestamp":
+            f.print("  static now(): ", message, " {");
+            f.print("    return ", message, ".fromDate(new Date())");
+            f.print("  }");
+            f.print();
+            f.print("  static fromDate(date: Date): ", message, " {");
+            f.print("    const ms = date.getTime();");
+            f.print("    return new ", message, "({");
+            f.print("      ", (0, ecmascript_1.localName)(ref.seconds), ": ", protoInt64, ".parse(Math.floor(ms / 1000)),");
+            f.print("      ", (0, ecmascript_1.localName)(ref.nanos), ": (ms % 1000) * 1000000,");
+            f.print("    });");
+            f.print("  }");
+            f.print();
+            break;
+        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 } = (0, ecmascript_1.getFieldTyping)(ref.value, f);
+            f.print("  static readonly fieldWrapper = {");
+            f.print("    wrapField(value: ", typing, " | ", message, "): ", message, " {");
+            f.print("      return value instanceof ", message, " ? value : new ", message, "({value});");
+            f.print("    },");
+            f.print("    unwrapField(value: ", message, "): ", typing, " {");
+            f.print("      return value.", (0, ecmascript_1.localName)(ref.value), ";");
+            f.print("    }");
+            f.print("  };");
+            f.print();
+            break;
+        }
+        case "google.protobuf.Duration":
+        case "google.protobuf.Struct":
+        case "google.protobuf.Value":
+        case "google.protobuf.ListValue":
+        case "google.protobuf.FieldMask":
+            break;
+    }
+}

package/package.json

@@ -1,37 +1,33 @@
 {
   "name": "@bufbuild/protoc-gen-es",
-  "version": "0.0.6",
-  "description": "protoc-gen-es",
+  "version": "0.0.9",
+  "description": "Protocol Buffers code generator for ECMAScript",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/bufbuild/protobuf-es.git"
+    "url": "https://github.com/bufbuild/protobuf-es.git",
+    "directory": "packages/protoc-gen-es"
   },
   "bin": {
     "protoc-gen-es": "bin/protoc-gen-es"
   },
+  "engines": {
+    "node": ">=14"
+  },
+  "scripts": {
+    "clean": "rm -rf ./dist/cjs/*",
+    "build": "npx tsc --project tsconfig.json --module commonjs --outDir ./dist/cjs"
+  },
   "preferUnplugged": true,
+  "dependencies": {
+    "@bufbuild/protoplugin": "^0.0.9"
+  },
   "peerDependencies": {
-    "@bufbuild/protobuf": "^0.0.6"
+    "@bufbuild/protobuf": "^0.0.9"
   },
   "peerDependenciesMeta": {
     "@bufbuild/protobuf": {
       "optional": true
     }
-  },
-  "optionalDependencies": {
-    "@bufbuild/protoc-gen-es-darwin-64": "0.0.6",
-    "@bufbuild/protoc-gen-es-darwin-arm64": "0.0.6",
-    "@bufbuild/protoc-gen-es-windows-64": "0.0.6",
-    "@bufbuild/protoc-gen-es-windows-arm64": "0.0.6",
-    "@bufbuild/protoc-gen-es-windows-32": "0.0.6",
-    "@bufbuild/protoc-gen-es-linux-64": "0.0.6",
-    "@bufbuild/protoc-gen-es-linux-32": "0.0.6",
-    "@bufbuild/protoc-gen-es-linux-arm": "0.0.6",
-    "@bufbuild/protoc-gen-es-linux-arm64": "0.0.6",
-    "@bufbuild/protoc-gen-es-freebsd-64": "0.0.6",
-    "@bufbuild/protoc-gen-es-freebsd-arm64": "0.0.6",
-    "@bufbuild/protoc-gen-es-netbsd-64": "0.0.6",
-    "@bufbuild/protoc-gen-es-openbsd-64": "0.0.6"
   }
 }