@aptre/protobuf-es-lite 0.2.14 → 0.3.0

package/dist/google/protobuf/wrappers.pb.js

@@ -37,68 +37,239 @@
 // the ability to detect presence on individual elements.
 // These wrappers have no meaningful use within a map or a oneof since
 // individual entries of a map or fields of a oneof can already detect presence.
-import { createMessageType } from "../../index.js";
+import { createMessageType, jsonReadScalar, jsonWriteScalar, LongType, ScalarType } from "../../index.js";
 export const protobufPackage = "google.protobuf";
+// DoubleValue_Wkt contains the well-known-type overrides for DoubleValue.
+const DoubleValue_Wkt = {
+    toJson(msg, _options) {
+        return jsonWriteScalar(ScalarType.DOUBLE, msg.value);
+    },
+    fromJson(json, _options) {
+        try {
+            return { value: jsonReadScalar(ScalarType.DOUBLE, json, LongType.BIGINT) };
+        }
+        catch (e) {
+            let m = `cannot decode message google.protobuf.DoubleValue from JSON"`;
+            if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+            }
+            throw new Error(m);
+        }
+    },
+};
+// DoubleValue contains the message type declaration for DoubleValue.
 export const DoubleValue = createMessageType({
     typeName: "google.protobuf.DoubleValue",
     fields: [
-        { no: 1, name: "value", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
+        { no: 1, name: "value", kind: "scalar", T: ScalarType.DOUBLE },
     ],
     packedByDefault: true,
-});
+}, DoubleValue_Wkt);
+// FloatValue_Wkt contains the well-known-type overrides for FloatValue.
+const FloatValue_Wkt = {
+    toJson(msg, _options) {
+        return jsonWriteScalar(ScalarType.FLOAT, msg.value);
+    },
+    fromJson(json, _options) {
+        try {
+            return { value: jsonReadScalar(ScalarType.FLOAT, json, LongType.BIGINT) };
+        }
+        catch (e) {
+            let m = `cannot decode message google.protobuf.FloatValue from JSON"`;
+            if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+            }
+            throw new Error(m);
+        }
+    },
+};
+// FloatValue contains the message type declaration for FloatValue.
 export const FloatValue = createMessageType({
     typeName: "google.protobuf.FloatValue",
     fields: [
-        { no: 1, name: "value", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
+        { no: 1, name: "value", kind: "scalar", T: ScalarType.FLOAT },
     ],
     packedByDefault: true,
-});
+}, FloatValue_Wkt);
+// Int64Value_Wkt contains the well-known-type overrides for Int64Value.
+const Int64Value_Wkt = {
+    toJson(msg, _options) {
+        return jsonWriteScalar(ScalarType.INT64, msg.value);
+    },
+    fromJson(json, _options) {
+        try {
+            return { value: jsonReadScalar(ScalarType.INT64, json, LongType.BIGINT) };
+        }
+        catch (e) {
+            let m = `cannot decode message google.protobuf.Int64Value from JSON"`;
+            if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+            }
+            throw new Error(m);
+        }
+    },
+};
+// Int64Value contains the message type declaration for Int64Value.
 export const Int64Value = createMessageType({
     typeName: "google.protobuf.Int64Value",
     fields: [
-        { no: 1, name: "value", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
+        { no: 1, name: "value", kind: "scalar", T: ScalarType.INT64 },
     ],
     packedByDefault: true,
-});
+}, Int64Value_Wkt);
+// UInt64Value_Wkt contains the well-known-type overrides for UInt64Value.
+const UInt64Value_Wkt = {
+    toJson(msg, _options) {
+        return jsonWriteScalar(ScalarType.UINT64, msg.value);
+    },
+    fromJson(json, _options) {
+        try {
+            return { value: jsonReadScalar(ScalarType.UINT64, json, LongType.BIGINT) };
+        }
+        catch (e) {
+            let m = `cannot decode message google.protobuf.UInt64Value from JSON"`;
+            if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+            }
+            throw new Error(m);
+        }
+    },
+};
+// UInt64Value contains the message type declaration for UInt64Value.
 export const UInt64Value = createMessageType({
     typeName: "google.protobuf.UInt64Value",
     fields: [
-        { no: 1, name: "value", kind: "scalar", T: 4 /* ScalarType.UINT64 */ },
+        { no: 1, name: "value", kind: "scalar", T: ScalarType.UINT64 },
     ],
     packedByDefault: true,
-});
+}, UInt64Value_Wkt);
+// Int32Value_Wkt contains the well-known-type overrides for Int32Value.
+const Int32Value_Wkt = {
+    toJson(msg, _options) {
+        return jsonWriteScalar(ScalarType.INT32, msg.value);
+    },
+    fromJson(json, _options) {
+        try {
+            return { value: jsonReadScalar(ScalarType.INT32, json, LongType.BIGINT) };
+        }
+        catch (e) {
+            let m = `cannot decode message google.protobuf.Int32Value from JSON"`;
+            if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+            }
+            throw new Error(m);
+        }
+    },
+};
+// Int32Value contains the message type declaration for Int32Value.
 export const Int32Value = createMessageType({
     typeName: "google.protobuf.Int32Value",
     fields: [
-        { no: 1, name: "value", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 1, name: "value", kind: "scalar", T: ScalarType.INT32 },
     ],
     packedByDefault: true,
-});
+}, Int32Value_Wkt);
+// UInt32Value_Wkt contains the well-known-type overrides for UInt32Value.
+const UInt32Value_Wkt = {
+    toJson(msg, _options) {
+        return jsonWriteScalar(ScalarType.UINT32, msg.value);
+    },
+    fromJson(json, _options) {
+        try {
+            return { value: jsonReadScalar(ScalarType.UINT32, json, LongType.BIGINT) };
+        }
+        catch (e) {
+            let m = `cannot decode message google.protobuf.UInt32Value from JSON"`;
+            if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+            }
+            throw new Error(m);
+        }
+    },
+};
+// UInt32Value contains the message type declaration for UInt32Value.
 export const UInt32Value = createMessageType({
     typeName: "google.protobuf.UInt32Value",
     fields: [
-        { no: 1, name: "value", kind: "scalar", T: 13 /* ScalarType.UINT32 */ },
+        { no: 1, name: "value", kind: "scalar", T: ScalarType.UINT32 },
     ],
     packedByDefault: true,
-});
+}, UInt32Value_Wkt);
+// BoolValue_Wkt contains the well-known-type overrides for BoolValue.
+const BoolValue_Wkt = {
+    toJson(msg, _options) {
+        return jsonWriteScalar(ScalarType.BOOL, msg.value);
+    },
+    fromJson(json, _options) {
+        try {
+            return { value: jsonReadScalar(ScalarType.BOOL, json, LongType.BIGINT) };
+        }
+        catch (e) {
+            let m = `cannot decode message google.protobuf.BoolValue from JSON"`;
+            if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+            }
+            throw new Error(m);
+        }
+    },
+};
+// BoolValue contains the message type declaration for BoolValue.
 export const BoolValue = createMessageType({
     typeName: "google.protobuf.BoolValue",
     fields: [
-        { no: 1, name: "value", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+        { no: 1, name: "value", kind: "scalar", T: ScalarType.BOOL },
     ],
     packedByDefault: true,
-});
+}, BoolValue_Wkt);
+// StringValue_Wkt contains the well-known-type overrides for StringValue.
+const StringValue_Wkt = {
+    toJson(msg, _options) {
+        return jsonWriteScalar(ScalarType.STRING, msg.value);
+    },
+    fromJson(json, _options) {
+        try {
+            return { value: jsonReadScalar(ScalarType.STRING, json, LongType.BIGINT) };
+        }
+        catch (e) {
+            let m = `cannot decode message google.protobuf.StringValue from JSON"`;
+            if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+            }
+            throw new Error(m);
+        }
+    },
+};
+// StringValue contains the message type declaration for StringValue.
 export const StringValue = createMessageType({
     typeName: "google.protobuf.StringValue",
     fields: [
-        { no: 1, name: "value", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 1, name: "value", kind: "scalar", T: ScalarType.STRING },
     ],
     packedByDefault: true,
-});
+}, StringValue_Wkt);
+// BytesValue_Wkt contains the well-known-type overrides for BytesValue.
+const BytesValue_Wkt = {
+    toJson(msg, _options) {
+        return jsonWriteScalar(ScalarType.BYTES, msg.value);
+    },
+    fromJson(json, _options) {
+        try {
+            return { value: jsonReadScalar(ScalarType.BYTES, json, LongType.BIGINT) };
+        }
+        catch (e) {
+            let m = `cannot decode message google.protobuf.BytesValue from JSON"`;
+            if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+            }
+            throw new Error(m);
+        }
+    },
+};
+// BytesValue contains the message type declaration for BytesValue.
 export const BytesValue = createMessageType({
     typeName: "google.protobuf.BytesValue",
     fields: [
-        { no: 1, name: "value", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
+        { no: 1, name: "value", kind: "scalar", T: ScalarType.BYTES },
     ],
     packedByDefault: true,
-});
+}, BytesValue_Wkt);

package/dist/index.d.ts

@@ -2,7 +2,8 @@ export { Message, CompleteMessage, AnyMessage, MessageType, Field, compareMessag
 export { ServiceType, MethodInfo, MethodInfoUnary, MethodInfoServerStreaming, MethodInfoClientStreaming, MethodInfoBiDiStreaming, MethodKind, MethodIdempotency, } from "./service-type.js";
 export { isCompleteMessage, isCompleteField } from "./is-message.js";
 export { newFieldList, FieldList, PartialFieldInfo, FieldInfo, OneofInfo, fieldJsonName, } from "./field.js";
-export { scalarEquals, scalarZeroValue, isScalarZeroValue } from "./scalar.js";
+export { applyPartialMessage } from "./partial.js";
+export { scalarEquals, scalarZeroValue, isScalarZeroValue, ScalarType, ScalarValue, LongType, } from "./scalar.js";
 export { createEnumType, normalizeEnumValue } from "./enum.js";
 export { localName, localFieldName, localOneofName, findEnumSharedPrefix, camelToSnakeCase, protoCamelCase, safeObjectProperty, safeIdentifier, } from "./names.js";
 export { int64FromString, int64ToString, uInt64ToString } from "./varint.js";
@@ -11,3 +12,6 @@ export { protoBase64 } from "./proto-base64.js";
 export { protoDouble } from "./proto-double.js";
 export { Timestamp, Duration, Any, Empty, DoubleValue, FloatValue, Int64Value, UInt64Value, Int32Value, UInt32Value, BoolValue, StringValue, BytesValue, Value, NullValue, ListValue, Struct, } from "./google/index.js";
 export { DescComments, AnyDesc, DescEnum, DescEnumValue, DescExtension, DescField, DescFile, DescMessage, DescMethod, DescOneof, DescService, DescriptorSet, } from "./descriptor-set.js";
+export { jsonReadEnum, jsonReadField, jsonReadMapKey, jsonReadScalar, jsonReadMessage, jsonWriteEnum, jsonWriteField, jsonWriteScalar, jsonWriteMessage, jsonDebugValue, JsonValue, JsonObject, JsonReadOptions, jsonMakeReadOptions, JsonWriteOptions, JsonWriteStringOptions, jsonMakeWriteOptions, } from "./json.js";
+export { binaryReadField, binaryReadMapEntry, binaryReadScalar, binaryReadScalarLTString, binaryReadMessage, binaryWriteField, binaryWriteScalar, binaryWritePacked, binaryWriteMapEntry, binaryWriteMessage, binaryMakeReadOptions, binaryMakeWriteOptions, BinaryReadOptions, BinaryWriteOptions, } from "./binary.js";
+export type { IMessageTypeRegistry, IServiceTypeRegistry, IEnumTypeRegistry, } from "./type-registry.js";

package/dist/index.js

@@ -2,7 +2,8 @@ export { compareMessages, createMessageType, } from "./message.js";
 export { MethodKind, MethodIdempotency, } from "./service-type.js";
 export { isCompleteMessage, isCompleteField } from "./is-message.js";
 export { newFieldList, FieldList, fieldJsonName, } from "./field.js";
-export { scalarEquals, scalarZeroValue, isScalarZeroValue } from "./scalar.js";
+export { applyPartialMessage } from "./partial.js";
+export { scalarEquals, scalarZeroValue, isScalarZeroValue, ScalarType, LongType, } from "./scalar.js";
 export { createEnumType, normalizeEnumValue } from "./enum.js";
 export { localName, localFieldName, localOneofName, findEnumSharedPrefix, camelToSnakeCase, protoCamelCase, safeObjectProperty, safeIdentifier, } from "./names.js";
 export { int64FromString, int64ToString, uInt64ToString } from "./varint.js";
@@ -10,3 +11,5 @@ export { protoInt64 } from "./proto-int64.js";
 export { protoBase64 } from "./proto-base64.js";
 export { protoDouble } from "./proto-double.js";
 export { Timestamp, Duration, Any, Empty, DoubleValue, FloatValue, Int64Value, UInt64Value, Int32Value, UInt32Value, BoolValue, StringValue, BytesValue, Value, NullValue, ListValue, Struct, } from "./google/index.js";
+export { jsonReadEnum, jsonReadField, jsonReadMapKey, jsonReadScalar, jsonReadMessage, jsonWriteEnum, jsonWriteField, jsonWriteScalar, jsonWriteMessage, jsonDebugValue, jsonMakeReadOptions, jsonMakeWriteOptions, } from "./json.js";
+export { binaryReadField, binaryReadMapEntry, binaryReadScalar, binaryReadScalarLTString, binaryReadMessage, binaryWriteField, binaryWriteScalar, binaryWritePacked, binaryWriteMapEntry, binaryWriteMessage, binaryMakeReadOptions, binaryMakeWriteOptions, } from "./binary.js";

package/dist/json.d.ts

@@ -1,4 +1,7 @@
 import { FieldInfo, FieldList } from "./field.js";
+import { LongType, ScalarType, ScalarValue } from "./scalar.js";
+import { EnumType } from "./enum.js";
+import { IMessageTypeRegistry } from "./type-registry.js";
 /**
  * Options for parsing JSON data.
  */
@@ -9,6 +12,10 @@ export interface JsonReadOptions {
      * unrecognized enum string representations.
      */
     ignoreUnknownFields: boolean;
+    /**
+     * This option is required to read `google.protobuf.Any` from JSON format.
+     */
+    typeRegistry?: IMessageTypeRegistry;
 }
 /**
  * Options for serializing to JSON.
@@ -35,6 +42,10 @@ export interface JsonWriteOptions {
      * field name.
      */
     useProtoFieldName: boolean;
+    /**
+     * This option is required to write `google.protobuf.Any` to JSON format.
+     */
+    typeRegistry?: IMessageTypeRegistry;
 }
 /**
  * Options for serializing to JSON.
@@ -58,11 +69,26 @@ export type JsonValue = number | string | boolean | null | JsonObject | JsonValu
 export type JsonObject = {
     [k: string]: JsonValue;
 };
-export declare function makeReadOptions(options?: Partial<JsonReadOptions>): Readonly<JsonReadOptions>;
-export declare function makeWriteOptions(options?: Partial<JsonWriteStringOptions>): Readonly<JsonWriteStringOptions>;
-export declare function readMessage<T>(fields: FieldList, typeName: string, json: JsonValue, options: JsonReadOptions, message: T): T;
-export declare function writeMessage<T>(message: T, fields: FieldList, options: JsonWriteOptions): JsonValue;
+declare function makeReadOptions(options?: Partial<JsonReadOptions>): Readonly<JsonReadOptions>;
+declare function makeWriteOptions(options?: Partial<JsonWriteStringOptions>): Readonly<JsonWriteStringOptions>;
+declare function jsonDebugValue(json: unknown): string;
+declare function readMessage<T>(fields: FieldList, typeName: string, json: JsonValue, options: JsonReadOptions, message: T): T;
+declare function writeMessage<T>(message: T, fields: FieldList, options: JsonWriteOptions): JsonValue;
+declare function readField(target: Record<string, unknown>, jsonValue: JsonValue, field: FieldInfo, options: JsonReadOptions): void;
+declare const tokenNull: unique symbol;
+declare const tokenIgnoredUnknownEnum: unique symbol;
+declare function readEnum(type: EnumType, json: JsonValue, ignoreUnknownFields: boolean, nullAsZeroValue: false): number | typeof tokenIgnoredUnknownEnum | typeof tokenNull;
+declare function readEnum(type: EnumType, json: JsonValue, ignoreUnknownFields: boolean, nullAsZeroValue: true): number | typeof tokenIgnoredUnknownEnum;
+declare function readScalar(type: ScalarType, json: JsonValue | null | undefined): ScalarValue;
+declare function readScalar(type: ScalarType, json: JsonValue | null | undefined, longType: LongType): ScalarValue;
+declare function readScalar(type: ScalarType, json: JsonValue | null | undefined, longType: LongType, nullAsZeroValue: true): ScalarValue;
+declare function readScalar(type: ScalarType, json: JsonValue | null | undefined, longType: LongType, nullAsZeroValue: false): ScalarValue | typeof tokenNull;
+declare function readMapKey(type: ScalarType, json: JsonValue): string;
 /**
  * Resets the field, so that isFieldSet() will return false.
  */
 export declare function clearField(field: FieldInfo, target: Record<string, any>): void;
+declare function writeField(field: FieldInfo, value: unknown, options: JsonWriteOptions): JsonValue | undefined;
+declare function writeScalar(type: ScalarType, value: unknown): string | number | boolean;
+declare function writeEnum(type: EnumType, value: unknown, enumAsInteger: boolean): string | number | null;
+export { readEnum as jsonReadEnum, readField as jsonReadField, readMapKey as jsonReadMapKey, readScalar as jsonReadScalar, readMessage as jsonReadMessage, writeEnum as jsonWriteEnum, writeField as jsonWriteField, writeScalar as jsonWriteScalar, writeMessage as jsonWriteMessage, makeReadOptions as jsonMakeReadOptions, makeWriteOptions as jsonMakeWriteOptions, jsonDebugValue, };

package/dist/json.js

@@ -15,13 +15,13 @@ const jsonWriteDefaults = {
     useProtoFieldName: false,
     prettySpaces: 0,
 };
-export function makeReadOptions(options) {
+function makeReadOptions(options) {
     return options ? { ...jsonReadDefaults, ...options } : jsonReadDefaults;
 }
-export function makeWriteOptions(options) {
+function makeWriteOptions(options) {
     return options ? { ...jsonWriteDefaults, ...options } : jsonWriteDefaults;
 }
-function debugJsonValue(json) {
+function jsonDebugValue(json) {
     if (json === null) {
         return "null";
     }
@@ -34,9 +34,9 @@ function debugJsonValue(json) {
             return String(json);
     }
 }
-export function readMessage(fields, typeName, json, options, message) {
+function readMessage(fields, typeName, json, options, message) {
     if (json == null || Array.isArray(json) || typeof json != "object") {
-        throw new Error(`cannot decode message ${typeName} from JSON: ${debugJsonValue(json)}`);
+        throw new Error(`cannot decode message ${typeName} from JSON: ${jsonDebugValue(json)}`);
     }
     const oneofSeen = new Map();
     for (const [jsonKey, jsonValue] of Object.entries(json)) {
@@ -64,7 +64,7 @@ export function readMessage(fields, typeName, json, options, message) {
     }
     return message;
 }
-export function writeMessage(message, fields, options) {
+function writeMessage(message, fields, options) {
     const json = {};
     let field;
     try {
@@ -110,7 +110,7 @@ function readField(target, jsonValue, field, options) {
             return;
         }
         if (!Array.isArray(jsonValue)) {
-            throw new Error(`cannot decode field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`);
+            throw new Error(`cannot decode field ${field.name} from JSON: ${jsonDebugValue(jsonValue)}`);
         }
         var targetArray = target[localName];
         if (!Array.isArray(targetArray)) {
@@ -118,7 +118,7 @@ function readField(target, jsonValue, field, options) {
         }
         for (const jsonItem of jsonValue) {
             if (jsonItem === null) {
-                throw new Error(`cannot decode field ${field.name} from JSON: ${debugJsonValue(jsonItem)}`);
+                throw new Error(`cannot decode field ${field.name} from JSON: ${jsonDebugValue(jsonItem)}`);
             }
             switch (field.kind) {
                 case "message":
@@ -136,7 +136,7 @@ function readField(target, jsonValue, field, options) {
                         targetArray.push(readScalar(field.T, jsonItem, field.L, true));
                     }
                     catch (e) {
-                        let m = `cannot decode field ${field.name} from JSON: ${debugJsonValue(jsonItem)}`;
+                        let m = `cannot decode field ${field.name} from JSON: ${jsonDebugValue(jsonItem)}`;
                         if (e instanceof Error && e.message.length > 0) {
                             m += `: ${e.message}`;
                         }
@@ -151,7 +151,7 @@ function readField(target, jsonValue, field, options) {
             return;
         }
         if (typeof jsonValue != "object" || Array.isArray(jsonValue)) {
-            throw new Error(`cannot decode field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`);
+            throw new Error(`cannot decode field ${field.name} from JSON: ${jsonDebugValue(jsonValue)}`);
         }
         var targetMap = target[localName];
         if (typeof targetMap !== "object") {
@@ -166,7 +166,7 @@ function readField(target, jsonValue, field, options) {
                 key = readMapKey(field.K, jsonMapKey);
             }
             catch (e) {
-                let m = `cannot decode map key for field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
+                let m = `cannot decode map key for field ${field.name} from JSON: ${jsonDebugValue(jsonValue)}`;
                 if (e instanceof Error && e.message.length > 0) {
                     m += `: ${e.message}`;
                 }
@@ -188,7 +188,7 @@ function readField(target, jsonValue, field, options) {
                         targetMap[key] = readScalar(field.V.T, jsonMapValue, LongType.BIGINT, true);
                     }
                     catch (e) {
-                        let m = `cannot decode map value for field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
+                        let m = `cannot decode map value for field ${field.name} from JSON: ${jsonDebugValue(jsonValue)}`;
                         if (e instanceof Error && e.message.length > 0) {
                             m += `: ${e.message}`;
                         }
@@ -242,7 +242,7 @@ function readField(target, jsonValue, field, options) {
                     }
                 }
                 catch (e) {
-                    let m = `cannot decode field ${field.name} from JSON: ${debugJsonValue(jsonValue)}`;
+                    let m = `cannot decode field ${field.name} from JSON: ${jsonDebugValue(jsonValue)}`;
                     if (e instanceof Error && e.message.length > 0) {
                         m += `: ${e.message}`;
                     }
@@ -278,10 +278,10 @@ function readEnum(type, json, ignoreUnknownFields, nullAsZeroValue) {
             }
             break;
     }
-    throw new Error(`cannot decode enum ${type.typeName} from JSON: ${debugJsonValue(json)}`);
+    throw new Error(`cannot decode enum ${type.typeName} from JSON: ${jsonDebugValue(json)}`);
 }
-function readScalar(type, json, longType, nullAsZeroValue) {
-    if (json === null) {
+function readScalar(type, json, longType = LongType.BIGINT, nullAsZeroValue = true) {
+    if (json == null) {
         if (nullAsZeroValue) {
             return scalarZeroValue(type, longType);
         }
@@ -577,3 +577,4 @@ function writeEnum(type, value, enumAsInteger) {
     const val = type.findNumber(value);
     return val?.name ?? value; // if we don't know the enum value, just return the number
 }
+export { readEnum as jsonReadEnum, readField as jsonReadField, readMapKey as jsonReadMapKey, readScalar as jsonReadScalar, readMessage as jsonReadMessage, writeEnum as jsonWriteEnum, writeField as jsonWriteField, writeScalar as jsonWriteScalar, writeMessage as jsonWriteMessage, makeReadOptions as jsonMakeReadOptions, makeWriteOptions as jsonMakeWriteOptions, jsonDebugValue, };

package/dist/message.d.ts

@@ -55,15 +55,15 @@ export interface MessageType<T extends Message<T> = AnyMessage> {
      * 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 | null | undefined, options?: Partial<BinaryReadOptions>): T;
     /**
      * Parse a message from a JSON value.
      */
-    fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): T;
+    fromJson(jsonValue: JsonValue | null | undefined, options?: Partial<JsonReadOptions>): T;
     /**
      * Parse a message from a JSON string.
      */
-    fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): T;
+    fromJsonString(jsonString: string | null | undefined, options?: Partial<JsonReadOptions>): T;
     /**
      * Returns true if the given arguments have equal field values, recursively.
      * Will also return true if both messages are `undefined` or `null`.
@@ -83,7 +83,7 @@ export interface MessageType<T extends Message<T> = AnyMessage> {
      */
     toJsonString(a: Message<T>, options?: Partial<JsonWriteStringOptions>): string;
 }
-export interface MessageTypeParams<T extends Message<T>> extends Pick<MessageType<T>, "typeName" | "fieldWrapper"> {
+export type MessageTypeParams<T extends Message<T>> = Pick<MessageType<T>, "fieldWrapper" | "typeName"> & {
     /**
      * Fields contains the list of message fields.
      */
@@ -98,23 +98,16 @@ export interface MessageTypeParams<T extends Message<T>> extends Pick<MessageTyp
      * delimited fields (proto3) or with (proto2 legacy).
      */
     delimitedMessageEncoding?: boolean;
-    /**
-     * Serialize the message to a JSON value, a JavaScript value that can be
-     * passed to JSON.stringify().
-     *
-     * When passed as MessageTypeParams this will override the default serializer behavior.
-     */
-    toJson?: MessageType<T>["toJson"];
-}
-export declare function compareMessages<T extends Message<T>>(fields: FieldList, a: T | undefined | null, b: T | undefined | null): boolean;
-export declare function cloneMessage<T extends Message<T>>(message: T, fields: FieldList): T;
+};
 /**
  * createMessageType creates a new message type.
  *
  * The argument `packedByDefault` specifies whether fields that do not specify
  * `packed` should be packed (proto3) or unpacked (proto2).
  */
-export declare function createMessageType<T extends Message<T>>(params: MessageTypeParams<T>): MessageType<T>;
+export declare function createMessageType<T extends Message<T>, E extends Record<string, Function> = {}>(params: MessageTypeParams<T>, exts?: E): MessageType<T> & E;
+export declare function compareMessages<T extends Message<T>>(fields: FieldList, a: T | undefined | null, b: T | undefined | null): boolean;
+export declare function cloneMessage<T extends Message<T>>(message: T, fields: FieldList): T;
 /**
  * createMessage recursively builds a message filled with zero values based on the given FieldList.
  */