@aptre/protobuf-es-lite 0.2.15 → 0.3.1

package/dist/google/protobuf/wrappers.pb.d.ts

@@ -1,4 +1,4 @@
-import type { MessageType } from "../../index.js";
+import type { JsonReadOptions, JsonValue, JsonWriteOptions, MessageType } from "../../index.js";
 import { Message } from "../../index.js";
 export declare const protobufPackage = "google.protobuf";
 /**
@@ -18,7 +18,11 @@ export type DoubleValue = Message<{
      */
     value?: number;
 }>;
-export declare const DoubleValue: MessageType<DoubleValue>;
+declare const DoubleValue_Wkt: {
+    toJson(msg: DoubleValue, _options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): DoubleValue;
+};
+export declare const DoubleValue: MessageType<DoubleValue> & typeof DoubleValue_Wkt;
 /**
  * Wrapper message for `float`.
  *
@@ -36,7 +40,11 @@ export type FloatValue = Message<{
      */
     value?: number;
 }>;
-export declare const FloatValue: MessageType<FloatValue>;
+declare const FloatValue_Wkt: {
+    toJson(msg: FloatValue, _options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): FloatValue;
+};
+export declare const FloatValue: MessageType<FloatValue> & typeof FloatValue_Wkt;
 /**
  * Wrapper message for `int64`.
  *
@@ -54,7 +62,11 @@ export type Int64Value = Message<{
      */
     value?: bigint;
 }>;
-export declare const Int64Value: MessageType<Int64Value>;
+declare const Int64Value_Wkt: {
+    toJson(msg: Int64Value, _options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): Int64Value;
+};
+export declare const Int64Value: MessageType<Int64Value> & typeof Int64Value_Wkt;
 /**
  * Wrapper message for `uint64`.
  *
@@ -72,7 +84,11 @@ export type UInt64Value = Message<{
      */
     value?: bigint;
 }>;
-export declare const UInt64Value: MessageType<UInt64Value>;
+declare const UInt64Value_Wkt: {
+    toJson(msg: UInt64Value, _options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): UInt64Value;
+};
+export declare const UInt64Value: MessageType<UInt64Value> & typeof UInt64Value_Wkt;
 /**
  * Wrapper message for `int32`.
  *
@@ -90,7 +106,11 @@ export type Int32Value = Message<{
      */
     value?: number;
 }>;
-export declare const Int32Value: MessageType<Int32Value>;
+declare const Int32Value_Wkt: {
+    toJson(msg: Int32Value, _options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): Int32Value;
+};
+export declare const Int32Value: MessageType<Int32Value> & typeof Int32Value_Wkt;
 /**
  * Wrapper message for `uint32`.
  *
@@ -108,7 +128,11 @@ export type UInt32Value = Message<{
      */
     value?: number;
 }>;
-export declare const UInt32Value: MessageType<UInt32Value>;
+declare const UInt32Value_Wkt: {
+    toJson(msg: UInt32Value, _options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): UInt32Value;
+};
+export declare const UInt32Value: MessageType<UInt32Value> & typeof UInt32Value_Wkt;
 /**
  * Wrapper message for `bool`.
  *
@@ -126,7 +150,11 @@ export type BoolValue = Message<{
      */
     value?: boolean;
 }>;
-export declare const BoolValue: MessageType<BoolValue>;
+declare const BoolValue_Wkt: {
+    toJson(msg: BoolValue, _options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): BoolValue;
+};
+export declare const BoolValue: MessageType<BoolValue> & typeof BoolValue_Wkt;
 /**
  * Wrapper message for `string`.
  *
@@ -144,7 +172,11 @@ export type StringValue = Message<{
      */
     value?: string;
 }>;
-export declare const StringValue: MessageType<StringValue>;
+declare const StringValue_Wkt: {
+    toJson(msg: StringValue, _options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): StringValue;
+};
+export declare const StringValue: MessageType<StringValue> & typeof StringValue_Wkt;
 /**
  * Wrapper message for `bytes`.
  *
@@ -162,4 +194,9 @@ export type BytesValue = Message<{
      */
     value?: Uint8Array;
 }>;
-export declare const BytesValue: MessageType<BytesValue>;
+declare const BytesValue_Wkt: {
+    toJson(msg: BytesValue, _options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): BytesValue;
+};
+export declare const BytesValue: MessageType<BytesValue> & typeof BytesValue_Wkt;
+export {};

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

@@ -37,68 +37,329 @@
 // 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,
-});
+    fieldWrapper: {
+        wrapField(value) {
+            return DoubleValue.create({ value: value ?? undefined });
+        },
+        unwrapField(msg) {
+            return msg.value;
+        },
+    },
+}, 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,
-});
+    fieldWrapper: {
+        wrapField(value) {
+            return FloatValue.create({ value: value ?? undefined });
+        },
+        unwrapField(msg) {
+            return msg.value;
+        },
+    },
+}, 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,
-});
+    fieldWrapper: {
+        wrapField(value) {
+            return Int64Value.create({ value: value ?? undefined });
+        },
+        unwrapField(msg) {
+            return msg.value;
+        },
+    },
+}, 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,
-});
+    fieldWrapper: {
+        wrapField(value) {
+            return UInt64Value.create({ value: value ?? undefined });
+        },
+        unwrapField(msg) {
+            return msg.value;
+        },
+    },
+}, 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,
-});
+    fieldWrapper: {
+        wrapField(value) {
+            return Int32Value.create({ value: value ?? undefined });
+        },
+        unwrapField(msg) {
+            return msg.value;
+        },
+    },
+}, 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,
-});
+    fieldWrapper: {
+        wrapField(value) {
+            return UInt32Value.create({ value: value ?? undefined });
+        },
+        unwrapField(msg) {
+            return msg.value;
+        },
+    },
+}, 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,
-});
+    fieldWrapper: {
+        wrapField(value) {
+            return BoolValue.create({ value: value ?? undefined });
+        },
+        unwrapField(msg) {
+            return msg.value;
+        },
+    },
+}, 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,
-});
+    fieldWrapper: {
+        wrapField(value) {
+            return StringValue.create({ value: value ?? undefined });
+        },
+        unwrapField(msg) {
+            return msg.value;
+        },
+    },
+}, 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,
-});
+    fieldWrapper: {
+        wrapField(value) {
+            return BytesValue.create({ value: value ?? undefined });
+        },
+        unwrapField(msg) {
+            return msg.value;
+        },
+    },
+}, 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, };