@aptre/protobuf-es-lite 0.2.14 → 0.3.0

package/dist/google/protobuf/struct.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";
 /**
@@ -33,7 +33,11 @@ export type ListValue = Message<{
      */
     values?: Value[];
 }>;
-export declare const ListValue: MessageType<ListValue>;
+declare const ListValue_Wkt: {
+    toJson(msg: ListValue, options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, options?: Partial<JsonReadOptions>): ListValue;
+};
+export declare const ListValue: MessageType<ListValue> & typeof ListValue_Wkt;
 /**
  * `Value` represents a dynamically typed value which can be either
  * null, a number, a string, a boolean, a recursive struct value, or a
@@ -103,7 +107,11 @@ export type Value = Message<{
         case: "listValue";
     };
 }>;
-export declare const Value: MessageType<Value>;
+declare const Value_Wkt: {
+    toJson(msg: Value, options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): Value;
+};
+export declare const Value: MessageType<Value> & typeof Value_Wkt;
 /**
  * `Struct` represents a structured data value, consisting of fields
  * which map to dynamically typed values. In some languages, `Struct`
@@ -126,4 +134,9 @@ export type Struct = Message<{
         [key: string]: Value;
     };
 }>;
-export declare const Struct: MessageType<Struct>;
+declare const Struct_Wkt: {
+    toJson(msg: Struct, options?: Partial<JsonWriteOptions>): JsonValue;
+    fromJson(json: JsonValue | null | undefined, _options?: Partial<JsonReadOptions>): Struct;
+};
+export declare const Struct: MessageType<Struct> & typeof Struct_Wkt;
+export {};

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

@@ -27,7 +27,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-import { createEnumType, createMessageType } from "../../index.js";
+import { createEnumType, createMessageType, jsonDebugValue, ScalarType } from "../../index.js";
 export const protobufPackage = "google.protobuf";
 /**
  * `NullValue` is a singleton enumeration to represent the null value for the
@@ -50,29 +50,125 @@ export var NullValue;
 export const NullValue_Enum = createEnumType("google.protobuf.NullValue", [
     { no: 0, name: "NULL_VALUE" },
 ]);
+// ListValue_Wkt contains the well-known-type overrides for ListValue.
+const ListValue_Wkt = {
+    toJson(msg, options) {
+        return msg.values?.map(v => Value.toJson(v, options)) ?? [];
+    },
+    fromJson(json, options) {
+        if (json == null) {
+            return {};
+        }
+        if (!Array.isArray(json)) {
+            throw new Error(`cannot decode google.protobuf.ListValue from JSON ${jsonDebugValue(json)}`);
+        }
+        const values = json.map(v => Value.fromJson(v, options));
+        return { values: values };
+    },
+};
+// ListValue contains the message type declaration for ListValue.
 export const ListValue = createMessageType({
     typeName: "google.protobuf.ListValue",
     fields: [
         { no: 1, name: "values", kind: "message", T: () => Value, repeated: true },
     ],
     packedByDefault: true,
-});
+}, ListValue_Wkt);
+// Value_Wkt contains the well-known-type overrides for Value.
+const Value_Wkt = {
+    toJson(msg, options) {
+        switch (msg.kind?.case) {
+            case "nullValue":
+                return null;
+            case "numberValue":
+                if (!Number.isFinite(msg.kind.value)) {
+                    throw new Error("google.protobuf.Value cannot be NaN or Infinity");
+                }
+                return msg.kind.value;
+            case "boolValue":
+                return msg.kind.value;
+            case "stringValue":
+                return msg.kind.value;
+            case "structValue":
+                return Struct.toJson(msg.kind.value, { ...options, emitDefaultValues: true });
+            case "listValue":
+                return ListValue.toJson(msg.kind.value, { ...options, emitDefaultValues: true });
+            case null:
+            case undefined:
+            default:
+                return null;
+        }
+    },
+    fromJson(json, _options) {
+        const msg = {};
+        switch (typeof json) {
+            case "number":
+                msg.kind = { case: "numberValue", value: json };
+                break;
+            case "string":
+                msg.kind = { case: "stringValue", value: json };
+                break;
+            case "boolean":
+                msg.kind = { case: "boolValue", value: json };
+                break;
+            case "object":
+                if (json == null) {
+                    msg.kind = { case: "nullValue", value: NullValue.NULL_VALUE };
+                }
+                else if (Array.isArray(json)) {
+                    msg.kind = { case: "listValue", value: ListValue.fromJson(json) };
+                }
+                else {
+                    msg.kind = { case: "structValue", value: Struct.fromJson(json) };
+                }
+                break;
+            default:
+                throw new Error(`cannot decode google.protobuf.Value from JSON ${jsonDebugValue(json)}`);
+        }
+        return msg;
+    },
+};
+// Value contains the message type declaration for Value.
 export const Value = createMessageType({
     typeName: "google.protobuf.Value",
     fields: [
         { no: 1, name: "null_value", kind: "enum", T: NullValue_Enum, oneof: "kind" },
-        { no: 2, name: "number_value", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, oneof: "kind" },
-        { no: 3, name: "string_value", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "kind" },
-        { no: 4, name: "bool_value", kind: "scalar", T: 8 /* ScalarType.BOOL */, oneof: "kind" },
+        { no: 2, name: "number_value", kind: "scalar", T: ScalarType.DOUBLE, oneof: "kind" },
+        { no: 3, name: "string_value", kind: "scalar", T: ScalarType.STRING, oneof: "kind" },
+        { no: 4, name: "bool_value", kind: "scalar", T: ScalarType.BOOL, oneof: "kind" },
         { no: 5, name: "struct_value", kind: "message", T: () => Struct, oneof: "kind" },
         { no: 6, name: "list_value", kind: "message", T: () => ListValue, oneof: "kind" },
     ],
     packedByDefault: true,
-});
+}, Value_Wkt);
+// Struct_Wkt contains the well-known-type overrides for Struct.
+const Struct_Wkt = {
+    toJson(msg, options) {
+        const json = {};
+        if (!msg.fields) {
+            return json;
+        }
+        for (const [k, v] of Object.entries(msg.fields)) {
+            json[k] = v != null ? Value.toJson(v, options) : null;
+        }
+        return json;
+    },
+    fromJson(json, _options) {
+        if (typeof json != "object" || json == null || Array.isArray(json)) {
+            throw new Error(`cannot decode google.protobuf.Struct from JSON ${jsonDebugValue(json)}`);
+        }
+        const fields = {};
+        for (const [k, v] of Object.entries(json)) {
+            fields[k] = Value.fromJson(v);
+        }
+        return { fields: fields };
+    },
+};
+// Struct contains the message type declaration for Struct.
 export const Struct = createMessageType({
     typeName: "google.protobuf.Struct",
     fields: [
-        { no: 1, name: "fields", kind: "map", K: 9 /* ScalarType.STRING */, V: { kind: "message", T: () => Value } },
+        { no: 1, name: "fields", kind: "map", K: ScalarType.STRING, V: { kind: "message", T: () => Value } },
     ],
     packedByDefault: true,
-});
+}, Struct_Wkt);

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

@@ -1,4 +1,4 @@
-import type { MessageType } from "../../index.js";
+import type { JsonValue, MessageType } from "../../index.js";
 import { Message } from "../../index.js";
 export declare const protobufPackage = "google.protobuf";
 /**
@@ -115,4 +115,10 @@ export type Timestamp = Message<{
      */
     nanos?: number;
 }>;
-export declare const Timestamp: MessageType<Timestamp>;
+declare const Timestamp_Wkt: {
+    fromJson(json: JsonValue): Timestamp;
+    toJson(msg: Timestamp): JsonValue;
+    toDate(msg: Timestamp): Date;
+};
+export declare const Timestamp: MessageType<Timestamp> & typeof Timestamp_Wkt;
+export {};

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

@@ -27,13 +27,63 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-import { createMessageType } from "../../index.js";
+import { createMessageType, protoInt64, ScalarType } from "../../index.js";
 export const protobufPackage = "google.protobuf";
+// Timestamp_Wkt contains the well-known-type overrides for Timestamp.
+const Timestamp_Wkt = {
+    fromJson(json) {
+        if (typeof json !== "string") {
+            throw new Error(`cannot decode google.protobuf.Timestamp(json)}`);
+        }
+        const matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
+        if (!matches) {
+            throw new Error(`cannot decode google.protobuf.Timestamp from JSON: invalid RFC 3339 string`);
+        }
+        const ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
+        if (Number.isNaN(ms)) {
+            throw new Error(`cannot decode google.protobuf.Timestamp from JSON: invalid RFC 3339 string`);
+        }
+        if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) {
+            throw new Error(`cannot decode message google.protobuf.Timestamp from JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
+        }
+        return {
+            seconds: protoInt64.parse(ms / 1000),
+            nanos: !matches[7] ? 0 : (parseInt("1" + matches[7] + "0".repeat(9 - matches[7].length)) - 1000000000),
+        };
+    },
+    toJson(msg) {
+        const ms = Number(msg.seconds) * 1000;
+        if (ms < Date.parse("0001-01-01T00:00:00Z") || ms > Date.parse("9999-12-31T23:59:59Z")) {
+            throw new Error(`cannot encode google.protobuf.Timestamp to JSON: must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive`);
+        }
+        if (msg.nanos != null && msg.nanos < 0) {
+            throw new Error(`cannot encode google.protobuf.Timestamp to JSON: nanos must not be negative`);
+        }
+        let z = "Z";
+        if (msg.nanos != null && msg.nanos > 0) {
+            const nanosStr = (msg.nanos + 1000000000).toString().substring(1);
+            if (nanosStr.substring(3) === "000000") {
+                z = "." + nanosStr.substring(0, 3) + "Z";
+            }
+            else if (nanosStr.substring(6) === "000") {
+                z = "." + nanosStr.substring(0, 6) + "Z";
+            }
+            else {
+                z = "." + nanosStr + "Z";
+            }
+        }
+        return new Date(ms).toISOString().replace(".000Z", z);
+    },
+    toDate(msg) {
+        return new Date(Number(msg.seconds ?? 0) * 1000 + Math.ceil((msg.nanos ?? 0) / 1000000));
+    },
+};
+// Timestamp contains the message type declaration for Timestamp.
 export const Timestamp = createMessageType({
     typeName: "google.protobuf.Timestamp",
     fields: [
-        { no: 1, name: "seconds", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
-        { no: 2, name: "nanos", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 1, name: "seconds", kind: "scalar", T: ScalarType.INT64 },
+        { no: 2, name: "nanos", kind: "scalar", T: ScalarType.INT32 },
     ],
     packedByDefault: true,
-});
+}, Timestamp_Wkt);

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

@@ -27,7 +27,7 @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-import { createEnumType, createMessageType } from "../../index.js";
+import { createEnumType, createMessageType, ScalarType } from "../../index.js";
 import { Any } from "./any.pb.js";
 import { SourceContext } from "./source_context.pb.js";
 export const protobufPackage = "google.protobuf";
@@ -246,61 +246,66 @@ export const Field_Cardinality_Enum = createEnumType("google.protobuf.Field.Card
     { no: 2, name: "CARDINALITY_REQUIRED" },
     { no: 3, name: "CARDINALITY_REPEATED" },
 ]);
+// Option contains the message type declaration for Option.
 export const Option = createMessageType({
     typeName: "google.protobuf.Option",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
         { no: 2, name: "value", kind: "message", T: () => Any },
     ],
     packedByDefault: true,
 });
+// Field contains the message type declaration for Field.
 export const Field = createMessageType({
     typeName: "google.protobuf.Field",
     fields: [
         { no: 1, name: "kind", kind: "enum", T: Field_Kind_Enum },
         { no: 2, name: "cardinality", kind: "enum", T: Field_Cardinality_Enum },
-        { no: 3, name: "number", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
-        { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 6, name: "type_url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 7, name: "oneof_index", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
-        { no: 8, name: "packed", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
+        { no: 3, name: "number", kind: "scalar", T: ScalarType.INT32 },
+        { no: 4, name: "name", kind: "scalar", T: ScalarType.STRING },
+        { no: 6, name: "type_url", kind: "scalar", T: ScalarType.STRING },
+        { no: 7, name: "oneof_index", kind: "scalar", T: ScalarType.INT32 },
+        { no: 8, name: "packed", kind: "scalar", T: ScalarType.BOOL },
         { no: 9, name: "options", kind: "message", T: () => Option, repeated: true },
-        { no: 10, name: "json_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 11, name: "default_value", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 10, name: "json_name", kind: "scalar", T: ScalarType.STRING },
+        { no: 11, name: "default_value", kind: "scalar", T: ScalarType.STRING },
     ],
     packedByDefault: true,
 });
+// Type contains the message type declaration for Type.
 export const Type = createMessageType({
     typeName: "google.protobuf.Type",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
         { no: 2, name: "fields", kind: "message", T: () => Field, repeated: true },
-        { no: 3, name: "oneofs", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
+        { no: 3, name: "oneofs", kind: "scalar", T: ScalarType.STRING, repeated: true },
         { no: 4, name: "options", kind: "message", T: () => Option, repeated: true },
         { no: 5, name: "source_context", kind: "message", T: () => SourceContext },
         { no: 6, name: "syntax", kind: "enum", T: Syntax_Enum },
-        { no: 7, name: "edition", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 7, name: "edition", kind: "scalar", T: ScalarType.STRING },
     ],
     packedByDefault: true,
 });
+// EnumValue contains the message type declaration for EnumValue.
 export const EnumValue = createMessageType({
     typeName: "google.protobuf.EnumValue",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
-        { no: 2, name: "number", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
+        { no: 2, name: "number", kind: "scalar", T: ScalarType.INT32 },
         { no: 3, name: "options", kind: "message", T: () => Option, repeated: true },
     ],
     packedByDefault: true,
 });
+// Enum contains the message type declaration for Enum.
 export const Enum = createMessageType({
     typeName: "google.protobuf.Enum",
     fields: [
-        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 1, name: "name", kind: "scalar", T: ScalarType.STRING },
         { no: 2, name: "enumvalue", kind: "message", T: () => EnumValue, repeated: true },
         { no: 3, name: "options", kind: "message", T: () => Option, repeated: true },
         { no: 4, name: "source_context", kind: "message", T: () => SourceContext },
         { no: 5, name: "syntax", kind: "enum", T: Syntax_Enum },
-        { no: 6, name: "edition", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 6, name: "edition", kind: "scalar", T: ScalarType.STRING },
     ],
     packedByDefault: true,
 });

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 {};