@aptre/protobuf-es-lite 0.2.7 → 0.2.8

package/dist/message.d.ts

@@ -1,61 +1,23 @@
-import { BinaryReadOptions, JsonReadOptions, JsonValue, MessageType as BufMessageType, BinaryWriteOptions, JsonWriteOptions, JsonWriteStringOptions } from "@bufbuild/protobuf";
 import { FieldList, FieldListSource } from "./field.js";
-/**
- * PartialMessage<T> constructs a type from a message. The resulting type
- * only contains the protobuf field members of the message, and all of them
- * are optional.
- *
- * Note that the optionality of the fields is the only difference between
- * PartialMessage and PlainMessage.
- *
- * PartialMessage is similar to the built-in type Partial<T>, but recursive,
- * and respects `oneof` groups.
- */
-export type Message<T extends Message<T>> = {
-    [k: string]: Field<any>;
-};
-/**
- * AnyMessage is an interface implemented by all messages. If you need to
- * handle messages of unknown type, this interface provides a convenient
- * index signature to access fields with message["fieldname"].
- */
-export interface AnyMessage extends Message<AnyMessage> {
-    [k: string]: Field<any>;
-}
-export type Field<F> = F extends Date | Uint8Array | bigint | boolean | string | number ? F : F extends Array<infer U> ? Array<Field<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<Field<U>> : F extends CompleteMessage<infer U> ? Message<U> : F extends OneofSelectedMessage<infer C, infer V> ? {
+import { BinaryReadOptions, BinaryWriteOptions } from "./binary.js";
+import { JsonValue, JsonReadOptions, JsonWriteOptions, JsonWriteStringOptions } from "./json.js";
+import { FieldWrapper } from "./field-wrapper.js";
+export type Field<T> = T extends Date | Uint8Array | bigint | boolean | string | number ? T : T extends Array<infer U> ? Array<Field<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<Field<U>> : T extends {
+    case: string;
+    value: any;
+} ? OneofSelectedMessage<T["case"], T["value"]> : T extends object ? Message<T> : never;
+export type OneofSelectedMessage<C extends string, V> = {
     case: C;
-    value: Message<V>;
-} : F extends {
-    case: string | undefined;
-    value?: unknown;
-} ? F : F extends {
-    [key: string | number]: CompleteMessage<infer U>;
-} ? {
-    [key: string | number]: Message<U>;
-} : F;
-/**
- * CompleteMessage<T> constructs a type from a message which requires all fields
- * be present in the object recursively (including zero values if unset).
- *
- * This type corresponds to Message in protobuf-es.
- */
-export type CompleteMessage<T extends Message<T>> = {
-    [P in keyof T as T[P] extends Function ? never : P]?: CompleteField<T[P]>;
+    value: Field<V>;
 };
-export type CompleteField<F> = F extends Date | Uint8Array | bigint | boolean | string | number ? F : F extends Array<infer U> ? Array<Field<U>> : F extends ReadonlyArray<infer U> ? ReadonlyArray<Field<U>> : F extends CompleteMessage<infer U> ? CompleteMessage<U> : F extends OneofSelectedMessage<infer C, infer V> ? {
-    case: C;
-    value: CompleteMessage<V>;
-} : F extends {
-    case: string | undefined;
-    value?: unknown;
-} ? F : F extends {
-    [key: string | number]: CompleteMessage<infer U>;
-} ? {
-    [key: string | number]: CompleteMessage<U>;
-} : F;
-type OneofSelectedMessage<K extends string, M extends Message<M>> = {
-    case: K;
-    value: M;
+export type Message<T extends object> = {
+    [K in keyof T]?: Field<T[K]>;
+};
+export type CompleteMessage<T extends object> = {
+    [K in keyof T]-?: Field<T[K]>;
+};
+export type AnyMessage = {
+    [key: string]: any | undefined;
 };
 /**
  * MessageType represents a protobuf message declaration. It provides:
@@ -63,7 +25,7 @@ type OneofSelectedMessage<K extends string, M extends Message<M>> = {
  * - metadata for reflection-based operations
  * - common functionality like serialization
  */
-export interface MessageType<T extends Message<T> = AnyMessage> extends Pick<BufMessageType, "fieldWrapper"> {
+export interface MessageType<T extends Message<T>> {
     /**
      * The fully qualified name of the message.
      */
@@ -72,10 +34,14 @@ export interface MessageType<T extends Message<T> = AnyMessage> extends Pick<Buf
      * Field metadata.
      */
     readonly fields: FieldList;
+    /**
+     * When used as a field, unwrap this message to a simple value.
+     */
+    readonly fieldWrapper?: FieldWrapper<T>;
     /**
      * Create a new instance of this message with zero values for fields.
      */
-    create(partial?: Message<T>): T;
+    create(partial?: Message<T>): CompleteMessage<T>;
     /**
      * Create a deep copy.
      */
@@ -89,15 +55,15 @@ export interface MessageType<T extends Message<T> = AnyMessage> extends Pick<Buf
      * If a message field is already present, it will be merged with the
      * new data.
      */
-    fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): T;
+    fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CompleteMessage<T>;
     /**
      * Parse a message from a JSON value.
      */
-    fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): T;
+    fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CompleteMessage<T>;
     /**
      * Parse a message from a JSON string.
      */
-    fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): T;
+    fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CompleteMessage<T>;
     /**
      * Returns true if the given arguments have equal field values, recursively.
      * Will also return true if both messages are `undefined` or `null`.
@@ -149,4 +115,7 @@ export declare function cloneMessage<T extends Message<T>>(message: T, fields: F
  * `packed` should be packed (proto3) or unpacked (proto2).
  */
 export declare function createMessageType<T extends Message<T>>(params: MessageTypeParams<T>): MessageType<T>;
-export {};
+/**
+ * createMessage recursively builds a message filled with zero values based on the given FieldList.
+ */
+export declare function createMessage<T extends Message<T>>(fields: FieldList): CompleteMessage<T>;

package/dist/message.js

@@ -13,8 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMessageType = exports.cloneMessage = exports.compareMessages = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
+exports.createMessage = exports.createMessageType = exports.cloneMessage = exports.compareMessages = void 0;
 const field_js_1 = require("./field.js");
 const partial_js_1 = require("./partial.js");
 const scalar_js_1 = require("./scalar.js");
@@ -41,20 +40,20 @@ function compareMessages(fields, a, b) {
             // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
             switch (m.kind) {
                 case "message":
-                    const messageType = typeof m.T === "function" ? m.T() : m.T;
+                    const messageType = (0, field_js_1.resolveMessageType)(m.T);
                     return va.every((a, i) => messageType.equals(a, vb[i]));
                 case "scalar":
                     return va.every((a, i) => (0, scalar_js_1.scalarEquals)(m.T, a, vb[i]));
                 case "enum":
-                    return va.every((a, i) => (0, scalar_js_1.scalarEquals)(protobuf_1.ScalarType.INT32, a, vb[i]));
+                    return va.every((a, i) => (0, scalar_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, a, vb[i]));
             }
             throw new Error(`repeated cannot contain ${m.kind}`);
         }
         switch (m.kind) {
             case "message":
-                return (typeof m.T === "function" ? m.T() : m.T).equals(va, vb);
+                return (0, field_js_1.resolveMessageType)(m.T).equals(va, vb);
             case "enum":
-                return (0, scalar_js_1.scalarEquals)(protobuf_1.ScalarType.INT32, va, vb);
+                return (0, scalar_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, va, vb);
             case "scalar":
                 return (0, scalar_js_1.scalarEquals)(m.T, va, vb);
             case "oneof":
@@ -68,10 +67,10 @@ function compareMessages(fields, a, b) {
                 // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- oneof fields are never "map"
                 switch (s.kind) {
                     case "message":
-                        const messageType = typeof s.T === "function" ? s.T() : s.T;
+                        const messageType = (0, field_js_1.resolveMessageType)(s.T);
                         return messageType.equals(va.value, vb.value);
                     case "enum":
-                        return (0, scalar_js_1.scalarEquals)(protobuf_1.ScalarType.INT32, va.value, vb.value);
+                        return (0, scalar_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, va.value, vb.value);
                     case "scalar":
                         return (0, scalar_js_1.scalarEquals)(s.T, va.value, vb.value);
                 }
@@ -80,10 +79,10 @@ function compareMessages(fields, a, b) {
                 const keys = Object.keys(va).concat(Object.keys(vb));
                 switch (m.V.kind) {
                     case "message":
-                        const messageType = typeof m.V.T === "function" ? m.V.T() : m.V.T;
+                        const messageType = (0, field_js_1.resolveMessageType)(m.V.T);
                         return keys.every((k) => messageType.equals(va[k], vb[k]));
                     case "enum":
-                        return keys.every((k) => (0, scalar_js_1.scalarEquals)(protobuf_1.ScalarType.INT32, va[k], vb[k]));
+                        return keys.every((k) => (0, scalar_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, va[k], vb[k]));
                     case "scalar":
                         const scalarType = m.V.T;
                         return keys.every((k) => (0, scalar_js_1.scalarEquals)(scalarType, va[k], vb[k]));
@@ -98,8 +97,7 @@ function cloneSingularField(value, fieldInfo) {
         return value;
     }
     if (fieldInfo.kind === "message") {
-        const messageType = typeof fieldInfo.T === "function" ? fieldInfo.T() : fieldInfo.T;
-        return cloneMessage(value, messageType.fields);
+        return cloneMessage(value, (0, field_js_1.resolveMessageType)(fieldInfo.T).fields);
     }
     if (fieldInfo.kind === "oneof") {
         if (value.case === undefined) {
@@ -138,9 +136,10 @@ function cloneMessage(message, fields) {
         }
         else if (member.kind == "oneof") {
             const f = member.findField(source.case);
-            copy = f
-                ? { case: source.case, value: cloneSingularField(source.value, member) }
-                : { case: undefined };
+            copy =
+                f ?
+                    { case: source.case, value: cloneSingularField(source.value, member) }
+                    : { case: undefined };
         }
         else {
             copy = cloneSingularField(source, member);
@@ -229,19 +228,60 @@ function createMessage(fields) {
         const fieldKind = field.kind;
         switch (fieldKind) {
             case "scalar":
-                message[field.localName] = (field.T == protobuf_1.ScalarType.BOOL ? false : 0);
+                if (field.repeated) {
+                    message[field.localName] = [];
+                }
+                else {
+                    switch (field.T) {
+                        case scalar_js_1.ScalarType.DOUBLE:
+                        case scalar_js_1.ScalarType.FLOAT:
+                            message[field.localName] = 0;
+                            break;
+                        case scalar_js_1.ScalarType.INT64:
+                        case scalar_js_1.ScalarType.UINT64:
+                        case scalar_js_1.ScalarType.INT32:
+                        case scalar_js_1.ScalarType.FIXED64:
+                        case scalar_js_1.ScalarType.FIXED32:
+                        case scalar_js_1.ScalarType.UINT32:
+                        case scalar_js_1.ScalarType.SFIXED32:
+                        case scalar_js_1.ScalarType.SFIXED64:
+                        case scalar_js_1.ScalarType.SINT32:
+                        case scalar_js_1.ScalarType.SINT64:
+                            message[field.localName] = 0;
+                            break;
+                        case scalar_js_1.ScalarType.BOOL:
+                            message[field.localName] = false;
+                            break;
+                        case scalar_js_1.ScalarType.STRING:
+                            message[field.localName] = "";
+                            break;
+                        case scalar_js_1.ScalarType.BYTES:
+                            message[field.localName] =
+                                new Uint8Array();
+                            break;
+                    }
+                }
                 break;
             case "enum":
-                message[field.localName] = 0;
+                if (field.repeated) {
+                    message[field.localName] = [];
+                }
+                else {
+                    message[field.localName] = 0;
+                }
                 break;
             case "message":
                 if (field.oneof) {
-                    // leave oneofs undefined
                     message[field.localName] = undefined;
                     continue;
                 }
-                const messageType = typeof field.T === "function" ? field.T() : field.T;
-                message[field.localName] = createMessage(messageType.fields);
+                const messageType = (0, field_js_1.resolveMessageType)(field.T);
+                if (field.repeated) {
+                    message[field.localName] = [];
+                }
+                else {
+                    message[field.localName] = createMessage(messageType.fields);
+                }
                 break;
             case "map":
                 message[field.localName] = {};
@@ -252,3 +292,4 @@ function createMessage(fields) {
     }
     return message;
 }
+exports.createMessage = createMessage;

package/dist/names.d.ts

@@ -0,0 +1,43 @@
+import type { DescEnum, DescEnumValue, DescExtension, DescField, DescMessage, DescService } from "./descriptor-set.js";
+import type { DescMethod, DescOneof } from "./descriptor-set.js";
+/**
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For
+ * messages, enumerations and services, the package name is stripped from
+ * the type name. For nested messages and enumerations, the names are joined
+ * with an underscore. For methods, the first character is made lowercase.
+ */
+export declare function localName(desc: DescEnum | DescEnumValue | DescMessage | DescExtension | DescOneof | DescField | DescService | DescMethod): string;
+/**
+ * Returns the name of a field in generated code.
+ */
+export declare function localFieldName(protoName: string, inOneof: boolean): string;
+/**
+ * Returns the name of a oneof group in generated code.
+ */
+export declare function localOneofName(protoName: string): string;
+/**
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+export declare function findEnumSharedPrefix(enumName: string, valueNames: string[]): string | undefined;
+/**
+ * Converts lowerCamelCase or UpperCamelCase into lower_snake_case.
+ * This is used to find shared prefixes in an enum.
+ */
+export declare function camelToSnakeCase(camel: string): string;
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
+export declare function protoCamelCase(snakeCase: string): string;
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+export declare const safeObjectProperty: (name: string) => string;
+/**
+ * Names that can be used for identifiers or class properties
+ */
+export declare const safeIdentifier: (name: string) => string;

package/dist/names.js

@@ -0,0 +1,276 @@
+"use strict";
+// Copyright 2021-2024 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.safeIdentifier = exports.safeObjectProperty = exports.protoCamelCase = exports.camelToSnakeCase = exports.findEnumSharedPrefix = exports.localOneofName = exports.localFieldName = exports.localName = void 0;
+/**
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For
+ * messages, enumerations and services, the package name is stripped from
+ * the type name. For nested messages and enumerations, the names are joined
+ * with an underscore. For methods, the first character is made lowercase.
+ */
+function localName(desc) {
+    switch (desc.kind) {
+        case "field":
+            return localFieldName(desc.name, desc.oneof !== undefined);
+        case "oneof":
+            return localOneofName(desc.name);
+        case "enum":
+        case "message":
+        case "service":
+        case "extension": {
+            const pkg = desc.file.proto.package;
+            const offset = pkg === undefined ? 0 : pkg.length + 1;
+            const name = desc.typeName.substring(offset).replace(/\./g, "_");
+            // For services, we only care about safe identifiers, not safe object properties,
+            // but we have shipped v1 with a bug that respected object properties, and we
+            // do not want to introduce a breaking change, so we continue to escape for
+            // safe object properties.
+            // See https://github.com/bufbuild/protobuf-es/pull/391
+            return (0, exports.safeObjectProperty)((0, exports.safeIdentifier)(name));
+        }
+        case "enum_value": {
+            let name = desc.name;
+            const sharedPrefix = desc.parent.sharedPrefix;
+            if (sharedPrefix !== undefined) {
+                name = name.substring(sharedPrefix.length);
+            }
+            return (0, exports.safeObjectProperty)(name);
+        }
+        case "rpc": {
+            let name = desc.name;
+            if (name.length == 0) {
+                return name;
+            }
+            name = name[0].toLowerCase() + name.substring(1);
+            return (0, exports.safeObjectProperty)(name);
+        }
+    }
+}
+exports.localName = localName;
+/**
+ * Returns the name of a field in generated code.
+ */
+function localFieldName(protoName, inOneof) {
+    const name = protoCamelCase(protoName);
+    if (inOneof) {
+        // oneof member names are not properties, but values of the `case` property.
+        return name;
+    }
+    return (0, exports.safeObjectProperty)(safeMessageProperty(name));
+}
+exports.localFieldName = localFieldName;
+/**
+ * Returns the name of a oneof group in generated code.
+ */
+function localOneofName(protoName) {
+    return localFieldName(protoName, false);
+}
+exports.localOneofName = localOneofName;
+/**
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+function findEnumSharedPrefix(enumName, valueNames) {
+    const prefix = camelToSnakeCase(enumName) + "_";
+    for (const name of valueNames) {
+        if (!name.toLowerCase().startsWith(prefix)) {
+            return undefined;
+        }
+        const shortName = name.substring(prefix.length);
+        if (shortName.length == 0) {
+            return undefined;
+        }
+        if (/^\d/.test(shortName)) {
+            // identifiers must not start with numbers
+            return undefined;
+        }
+    }
+    return prefix;
+}
+exports.findEnumSharedPrefix = findEnumSharedPrefix;
+/**
+ * Converts lowerCamelCase or UpperCamelCase into lower_snake_case.
+ * This is used to find shared prefixes in an enum.
+ */
+function camelToSnakeCase(camel) {
+    return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase();
+}
+exports.camelToSnakeCase = camelToSnakeCase;
+/**
+ * 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();
+                }
+                b.push(c);
+                break;
+        }
+    }
+    return b.join("");
+}
+exports.protoCamelCase = protoCamelCase;
+/**
+ * Names that cannot be used for identifiers, such as class names,
+ * but _can_ be used for object properties.
+ */
+const reservedIdentifiers = new Set([
+    // ECMAScript 2015 keywords
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+    // ECMAScript 2015 future reserved keywords
+    "enum",
+    "implements",
+    "interface",
+    "let",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "static",
+    // Class name cannot be 'Object' when targeting ES5 with module CommonJS
+    "Object",
+    // TypeScript keywords that cannot be used for types (as opposed to variables)
+    "bigint",
+    "number",
+    "boolean",
+    "string",
+    "object",
+    // Identifiers reserved for the runtime, so we can generate legible code
+    "globalThis",
+    "Uint8Array",
+    "Partial",
+]);
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+const reservedObjectProperties = new Set([
+    // names reserved by JavaScript
+    "constructor",
+    "toString",
+    "toJSON",
+    "valueOf",
+]);
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by the runtime.
+ */
+const reservedMessageProperties = new Set([
+    // names reserved by the runtime
+    "getType",
+    "clone",
+    "equals",
+    "fromBinary",
+    "fromJson",
+    "fromJsonString",
+    "toBinary",
+    "toJson",
+    "toJsonString",
+    // names reserved by the runtime for the future
+    "toObject",
+]);
+const fallback = (name) => `${name}$`;
+/**
+ * Will wrap names that are Object prototype properties or names reserved
+ * for `Message`s.
+ */
+const safeMessageProperty = (name) => {
+    if (reservedMessageProperties.has(name)) {
+        return fallback(name);
+    }
+    return name;
+};
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+const safeObjectProperty = (name) => {
+    if (reservedObjectProperties.has(name)) {
+        return fallback(name);
+    }
+    return name;
+};
+exports.safeObjectProperty = safeObjectProperty;
+/**
+ * Names that can be used for identifiers or class properties
+ */
+const safeIdentifier = (name) => {
+    if (reservedIdentifiers.has(name)) {
+        return fallback(name);
+    }
+    return name;
+};
+exports.safeIdentifier = safeIdentifier;