@bufbuild/protobuf 2.0.0-alpha.4 → 2.0.0-beta.2

package/dist/esm/reflect/reflect-types.js

@@ -12,5 +12,4 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 import {} from "../descriptors.js";
-import { FieldError } from "./error.js";
 import { unsafeLocal } from "./unsafe.js";

package/dist/esm/reflect/reflect.d.ts

@@ -1,32 +1,43 @@
 import { type DescField, type DescMessage } from "../descriptors.js";
 import type { MessageShape } from "../types.js";
-import type { MapEntryKey, ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js";
+import type { ReflectList, ReflectMap, ReflectMessage } from "./reflect-types.js";
 /**
  * Create a ReflectMessage.
  */
-export declare function reflect<Desc extends DescMessage>(messageDesc: Desc, message?: MessageShape<Desc>, opt?: {
-    /**
-     * By default, field values are validated when setting them. For example,
-     * a value for an uint32 field must be a ECMAScript Number >= 0.
-     *
-     * Note that setting a message field validates the type of the message,
-     * but does not check its fields.
-     *
-     * In some contexts, field values are trusted, and performance can be
-     * improved by disabling validation by setting disableFieldValueCheck to
-     * `false`.
-     */
-    disableFieldValueCheck?: boolean;
-}): ReflectMessage;
+export declare function reflect<Desc extends DescMessage>(messageDesc: Desc, message?: MessageShape<Desc>, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check?: boolean): ReflectMessage;
 /**
  * Create a ReflectList.
  */
 export declare function reflectList<V>(field: DescField & {
     fieldKind: "list";
-}, unsafeInput?: unknown[], check?: boolean): ReflectList<V>;
+}, unsafeInput?: unknown[], 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check?: boolean): ReflectList<V>;
 /**
  * Create a ReflectMap.
  */
-export declare function reflectMap<K extends MapEntryKey, V>(field: DescField & {
+export declare function reflectMap<K = unknown, V = unknown>(field: DescField & {
     fieldKind: "map";
-}, unsafeInput?: Record<string, unknown>, check?: boolean): ReflectMap<K, V>;
+}, unsafeInput?: Record<string, unknown>, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check?: boolean): ReflectMap<K, V>;

package/dist/esm/reflect/reflect.js

@@ -19,14 +19,20 @@ import { create } from "../create.js";
 import { isWrapper, isWrapperDesc } from "../wkt/wrappers.js";
 import { scalarZeroValue } from "./scalar.js";
 import { protoInt64 } from "../proto-int64.js";
-import { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";
+import { isObject, isReflectList, isReflectMap, isReflectMessage, } from "./guard.js";
 /**
  * Create a ReflectMessage.
  */
 export function reflect(messageDesc, message, 
-// TODO either remove this option, or support it in reflect-list and reflect-map as well
-opt) {
-    return new ReflectMessageImpl(messageDesc, message, (opt === null || opt === void 0 ? void 0 : opt.disableFieldValueCheck) !== true);
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
+    return new ReflectMessageImpl(messageDesc, message, check);
 }
 class ReflectMessageImpl {
     get sortedFields() {
@@ -35,9 +41,7 @@ class ReflectMessageImpl {
             .concat()
             .sort((a, b) => a.number - b.number)));
     }
-    constructor(messageDesc, message, 
-    // TODO either remove this option, or support it in reflect-list and reflect-map as well
-    check = true) {
+    constructor(messageDesc, message, check = true) {
         this.lists = new Map();
         this.maps = new Map();
         this.check = check;
@@ -67,7 +71,7 @@ class ReflectMessageImpl {
     }
     get(field) {
         assertOwn(this.message, field);
-        let value = unsafeGet(this.message, field);
+        const value = unsafeGet(this.message, field);
         switch (field.fieldKind) {
             case "list":
                 // eslint-disable-next-line no-case-declarations
@@ -84,15 +88,7 @@ class ReflectMessageImpl {
                 }
                 return map;
             case "message":
-                if (value !== undefined &&
-                    !field.oneof &&
-                    isWrapperDesc(field.message)) {
-                    value = {
-                        $typeName: field.message.typeName,
-                        value: longToReflect(field.message.fields[0], value),
-                    };
-                }
-                return new ReflectMessageImpl(field.message, value, this.check);
+                return messageToReflect(field, value, this.check);
             case "scalar":
                 return (value === undefined
                     ? scalarZeroValue(field.scalar, false)
@@ -106,22 +102,20 @@ class ReflectMessageImpl {
         if (this.check) {
             const err = checkField(field, value);
             if (err) {
-                return err;
+                throw err;
             }
         }
         let local;
-        if (isReflectMap(value) || isReflectList(value)) {
-            local = value[unsafeLocal];
+        if (field.fieldKind == "message") {
+            local = messageToLocal(field, value);
         }
-        else if (isReflectMessage(value)) {
-            const msg = value.message;
-            local = !field.oneof && isWrapper(msg) ? msg.value : msg;
+        else if (isReflectMap(value) || isReflectList(value)) {
+            local = value[unsafeLocal];
         }
         else {
             local = longToLocal(field, value);
         }
         unsafeSet(this.message, field, local);
-        return undefined;
     }
     getUnknown() {
         return this.message.$unknown;
@@ -138,7 +132,15 @@ function assertOwn(owner, member) {
 /**
  * Create a ReflectList.
  */
-export function reflectList(field, unsafeInput, check = true) {
+export function reflectList(field, unsafeInput, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
     return new ReflectListImpl(field, unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : [], check);
 }
 class ReflectListImpl {
@@ -161,29 +163,24 @@ class ReflectListImpl {
     }
     set(index, item) {
         if (index < 0 || index >= this._arr.length) {
-            return new FieldError(this._field, `list item #${index + 1}: out of range`);
+            throw new FieldError(this._field, `list item #${index + 1}: out of range`);
         }
         if (this.check) {
             const err = checkListItem(this._field, index, item);
             if (err) {
-                return err;
+                throw err;
             }
         }
         this._arr[index] = listItemToLocal(this._field, item);
-        return undefined;
     }
-    add(...items) {
+    add(item) {
         if (this.check) {
-            for (let i = 0; i < items.length; i++) {
-                const err = checkListItem(this._field, this._arr.length + i, items[i]);
-                if (err) {
-                    return err;
-                }
+            const err = checkListItem(this._field, this._arr.length, item);
+            if (err) {
+                throw err;
             }
         }
-        for (const item of items) {
-            this._arr.push(listItemToLocal(this._field, item));
-        }
+        this._arr.push(listItemToLocal(this._field, item));
         return undefined;
     }
     clear() {
@@ -209,7 +206,15 @@ class ReflectListImpl {
 /**
  * Create a ReflectMap.
  */
-export function reflectMap(field, unsafeInput, check = true) {
+export function reflectMap(field, unsafeInput, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
     return new ReflectMapImpl(field, unsafeInput, check);
 }
 class ReflectMapImpl {
@@ -225,11 +230,11 @@ class ReflectMapImpl {
         if (this.check) {
             const err = checkMapEntry(this._field, key, value);
             if (err) {
-                return err;
+                throw err;
             }
         }
         this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value);
-        return undefined;
+        return this;
     }
     delete(key) {
         const k = mapKeyToLocal(key);
@@ -284,27 +289,68 @@ class ReflectMapImpl {
         }
     }
 }
+function messageToLocal(field, value) {
+    if (!isReflectMessage(value)) {
+        return value;
+    }
+    if (isWrapper(value.message) &&
+        !field.oneof &&
+        field.fieldKind == "message") {
+        // Types from google/protobuf/wrappers.proto are unwrapped when used in
+        // a singular field that is not part of a oneof group.
+        return value.message.value;
+    }
+    if (value.desc.typeName == "google.protobuf.Struct" &&
+        field.parent.typeName != "google.protobuf.Value") {
+        // google.protobuf.Struct is represented with JsonObject when used in a
+        // field, except when used in google.protobuf.Value.
+        return wktStructToLocal(value.message);
+    }
+    return value.message;
+}
+function messageToReflect(field, value, check) {
+    if (value !== undefined) {
+        if (isWrapperDesc(field.message) &&
+            !field.oneof &&
+            field.fieldKind == "message") {
+            // Types from google/protobuf/wrappers.proto are unwrapped when used in
+            // a singular field that is not part of a oneof group.
+            value = {
+                $typeName: field.message.typeName,
+                value: longToReflect(field.message.fields[0], value),
+            };
+        }
+        else if (field.message.typeName == "google.protobuf.Struct" &&
+            field.parent.typeName != "google.protobuf.Value" &&
+            isObject(value)) {
+            // google.protobuf.Struct is represented with JsonObject when used in a
+            // field, except when used in google.protobuf.Value.
+            value = wktStructToReflect(value);
+        }
+    }
+    return new ReflectMessageImpl(field.message, value, check);
+}
 function listItemToLocal(field, value) {
-    if (isReflectMessage(value)) {
-        return value.message;
+    if (field.listKind == "message") {
+        return messageToLocal(field, value);
     }
     return longToLocal(field, value);
 }
 function listItemToReflect(field, value, check) {
     if (field.listKind == "message") {
-        return new ReflectMessageImpl(field.message, value, check);
+        return messageToReflect(field, value, check);
     }
     return longToReflect(field, value);
 }
 function mapValueToLocal(field, value) {
-    if (isReflectMessage(value)) {
-        return value.message;
+    if (field.mapKind == "message") {
+        return messageToLocal(field, value);
     }
     return longToLocal(field, value);
 }
 function mapValueToReflect(field, value, check) {
     if (field.mapKind == "message") {
-        return new ReflectMessageImpl(field.message, value, check);
+        return messageToReflect(field, value, check);
     }
     return value;
 }
@@ -408,3 +454,81 @@ function longToLocal(field, value) {
     }
     return value;
 }
+function wktStructToReflect(json) {
+    const struct = {
+        $typeName: "google.protobuf.Struct",
+        fields: {},
+    };
+    if (isObject(json)) {
+        for (const [k, v] of Object.entries(json)) {
+            struct.fields[k] = wktValueToReflect(v);
+        }
+    }
+    return struct;
+}
+function wktStructToLocal(val) {
+    const json = {};
+    for (const [k, v] of Object.entries(val.fields)) {
+        json[k] = wktValueToLocal(v);
+    }
+    return json;
+}
+function wktValueToLocal(val) {
+    switch (val.kind.case) {
+        case "structValue":
+            return wktStructToLocal(val.kind.value);
+        case "listValue":
+            return val.kind.value.values.map(wktValueToLocal);
+        case "nullValue":
+        case undefined:
+            return null;
+        default:
+            return val.kind.value;
+    }
+}
+function wktValueToReflect(json) {
+    const value = {
+        $typeName: "google.protobuf.Value",
+        kind: { case: undefined },
+    };
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- invalid input is unselected kind
+    switch (typeof json) {
+        case "number":
+            value.kind = { case: "numberValue", value: json };
+            break;
+        case "string":
+            value.kind = { case: "stringValue", value: json };
+            break;
+        case "boolean":
+            value.kind = { case: "boolValue", value: json };
+            break;
+        case "object":
+            if (json === null) {
+                const nullValue = 0;
+                value.kind = { case: "nullValue", value: nullValue };
+            }
+            else if (Array.isArray(json)) {
+                const listValue = {
+                    $typeName: "google.protobuf.ListValue",
+                    values: [],
+                };
+                if (Array.isArray(json)) {
+                    for (const e of json) {
+                        listValue.values.push(wktValueToReflect(e));
+                    }
+                }
+                value.kind = {
+                    case: "listValue",
+                    value: listValue,
+                };
+            }
+            else {
+                value.kind = {
+                    case: "structValue",
+                    value: wktStructToReflect(json),
+                };
+            }
+            break;
+    }
+    return value;
+}

package/dist/esm/reflect/scalar.d.ts

@@ -6,7 +6,7 @@ export type ScalarValue<T = ScalarType, LongAsString extends boolean = false> =
 /**
  * Returns true if both scalar values are equal.
  */
-export declare function scalarEquals(type: ScalarType, a: string | boolean | number | bigint | Uint8Array | undefined, b: string | boolean | number | bigint | Uint8Array | undefined): boolean;
+export declare function scalarEquals(type: ScalarType, a: ScalarValue | undefined, b: ScalarValue | undefined): boolean;
 /**
  * Returns the zero value for the given scalar type.
  */

package/dist/esm/registry.d.ts

@@ -39,8 +39,20 @@ export interface Registry {
     getService(typeName: string): DescService | undefined;
 }
 /**
- * A set of descriptors for messages, enumerations, extensions,
- * and services - and files.
+ * A registry that allows adding and removing descriptors.
+ */
+export interface MutableRegistry extends Registry {
+    /**
+     * Adds the given descriptor - but not types nested within - to the registry.
+     */
+    add(desc: DescMessage | DescEnum | DescExtension | DescService): void;
+    /**
+     * Remove the given descriptor - but not types nested within - from the registry.
+     */
+    remove(desc: DescMessage | DescEnum | DescExtension | DescService): void;
+}
+/**
+ * A registry that includes files.
  */
 export interface FileRegistry extends Registry {
     /**
@@ -64,6 +76,10 @@ export interface FileRegistry extends Registry {
  * For duplicate descriptors (same type name), the one given last wins.
  */
 export declare function createRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): Registry;
+/**
+ * Create a registry that allows adding and removing descriptors.
+ */
+export declare function createMutableRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): MutableRegistry;
 /**
  * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorSet
  * message.

package/dist/esm/registry.js

@@ -28,28 +28,23 @@ import { protoCamelCase, safeObjectProperty } from "./reflect/names.js";
  * For duplicate descriptors (same type name), the one given last wins.
  */
 export function createRegistry(...input) {
-    const reg = createMutableRegistry();
-    for (const i of input) {
-        switch (i.kind) {
-            case "registry":
-                for (const n of i) {
-                    reg.add(n);
-                }
-                break;
-            case "file":
-                for (const n of nestedTypes(i)) {
-                    reg.add(n);
-                }
-                break;
-            default:
-                reg.add(i);
-                break;
-        }
-    }
-    return reg;
+    return initBaseRegistry(input);
+}
+/**
+ * Create a registry that allows adding and removing descriptors.
+ */
+export function createMutableRegistry(...input) {
+    const reg = initBaseRegistry(input);
+    return Object.assign(Object.assign({}, reg), { remove(desc) {
+            var _a;
+            if (desc.kind == "extension") {
+                (_a = reg.extendees.get(desc.extendee.typeName)) === null || _a === void 0 ? void 0 : _a.delete(desc.number);
+            }
+            reg.types.delete(desc.typeName);
+        } });
 }
 export function createFileRegistry(...args) {
-    const registry = createMutableRegistry();
+    const registry = createBaseRegistry();
     if ("$typeName" in args[0] &&
         args[0].$typeName == "google.protobuf.FileDescriptorSet") {
         for (const file of args[0].file) {
@@ -76,14 +71,14 @@ export function createFileRegistry(...args) {
                     throw new Error(`Unable to resolve ${protoFileName}, imported by ${file.name}`);
                 }
                 if ("kind" in dep) {
-                    addDescFile(dep, registry);
+                    registry.addFile(dep, false, true);
                 }
                 else {
                     seen.add(dep.name);
                     deps.push(dep);
                 }
             }
-            return [...deps, ...deps.flatMap((dep) => recurseDeps(dep))];
+            return deps.concat(...deps.map(recurseDeps));
         }
         for (const file of [input, ...recurseDeps(input)].reverse()) {
             addFile(file, registry);
@@ -92,57 +87,53 @@ export function createFileRegistry(...args) {
     else {
         for (const fileReg of args) {
             for (const file of fileReg.files) {
-                registry.add(file);
-                for (const type of nestedTypes(file)) {
-                    registry.add(type);
-                }
+                registry.addFile(file);
             }
         }
     }
     return registry;
 }
 /**
- * Create a mutable file registry.
  * @private
  */
-function createMutableRegistry() {
+function createBaseRegistry() {
     const types = new Map();
     const extendees = new Map();
     const files = new Map();
     return {
         kind: "registry",
+        types,
+        extendees,
         [Symbol.iterator]() {
             return types.values();
         },
         get files() {
             return files.values();
         },
-        add(desc) {
-            switch (desc.kind) {
-                case "file":
-                    files.set(desc.proto.name, desc);
-                    break;
-                // @ts-expect-error TS7029
-                case "extension":
-                    // eslint-disable-next-line no-case-declarations
-                    let numberToExt = extendees.get(desc.extendee.typeName);
-                    if (!numberToExt) {
-                        extendees.set(desc.extendee.typeName, (numberToExt = new Map()));
-                    }
-                    numberToExt.set(desc.number, desc);
-                // eslint-disable-next-line no-fallthrough
-                default:
-                    types.set(desc.typeName, desc);
+        addFile(file, skipTypes, withDeps) {
+            files.set(file.proto.name, file);
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (!skipTypes) {
+                for (const type of nestedTypes(file)) {
+                    this.add(type);
+                }
+            }
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (withDeps) {
+                for (const f of file.dependencies) {
+                    this.addFile(f, skipTypes, withDeps);
+                }
             }
         },
-        remove(desc) {
-            switch (desc.kind) {
-                case "file":
-                    files.delete(desc.proto.name);
-                    break;
-                default:
-                    types.delete(desc.typeName);
+        add(desc) {
+            if (desc.kind == "extension") {
+                let numberToExt = extendees.get(desc.extendee.typeName);
+                if (!numberToExt) {
+                    extendees.set(desc.extendee.typeName, (numberToExt = new Map()));
+                }
+                numberToExt.set(desc.number, desc);
             }
+            types.set(desc.typeName, desc);
         },
         get(typeName) {
             return types.get(typeName);
@@ -173,16 +164,26 @@ function createMutableRegistry() {
     };
 }
 /**
- * Add the file descriptor and the types it contains to the registry.
+ * @private
  */
-function addDescFile(file, reg) {
-    reg.add(file);
-    for (const type of nestedTypes(file)) {
-        reg.add(type);
-    }
-    for (const dep of file.dependencies) {
-        addDescFile(dep, reg);
+function initBaseRegistry(inputs) {
+    const registry = createBaseRegistry();
+    for (const input of inputs) {
+        switch (input.kind) {
+            case "registry":
+                for (const n of input) {
+                    registry.add(n);
+                }
+                break;
+            case "file":
+                registry.addFile(input);
+                break;
+            default:
+                registry.add(input);
+                break;
+        }
     }
+    return registry;
 }
 // bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number;
 const EDITION_PROTO2 = 998;
@@ -301,7 +302,7 @@ function addFile(proto, reg) {
         addFields(message, reg, mapEntries);
         addExtensions(message, reg);
     }
-    reg.add(file);
+    reg.addFile(file, true);
 }
 /**
  * Create descriptors for extensions, and add them to the message / file,

package/dist/esm/to-binary.d.ts

@@ -17,7 +17,7 @@ export interface BinaryWriteOptions {
      */
     writeUnknownFields: boolean;
 }
-export declare function toBinary<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, options?: Partial<BinaryWriteOptions>): Uint8Array;
+export declare function toBinary<Desc extends DescMessage>(schema: Desc, message: MessageShape<Desc>, options?: Partial<BinaryWriteOptions>): Uint8Array;
 /**
  * @private
  */

package/dist/esm/to-binary.js

@@ -23,8 +23,8 @@ const writeDefaults = {
 function makeWriteOptions(options) {
     return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults;
 }
-export function toBinary(messageDesc, message, options) {
-    return writeFields(new BinaryWriter(), makeWriteOptions(options), reflect(messageDesc, message)).finish();
+export function toBinary(schema, message, options) {
+    return writeFields(new BinaryWriter(), makeWriteOptions(options), reflect(schema, message)).finish();
 }
 function writeFields(writer, opts, msg) {
     var _a;