@aptre/protobuf-es-lite 0.5.1 → 0.5.3

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

@@ -0,0 +1,365 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// 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.
+//
+// Wrappers for primitive (non-message) types. These types are useful
+// for embedding primitives in the `google.protobuf.Any` type and for places
+// where we need to distinguish between the absence of a primitive
+// typed field and its default value.
+//
+// These wrappers have no meaningful use within repeated fields as they lack
+// 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, 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: ScalarType.DOUBLE },
+    ],
+    packedByDefault: true,
+    fieldWrapper: {
+        wrapField(value) {
+            return DoubleValue.createComplete({ 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: ScalarType.FLOAT },
+    ],
+    packedByDefault: true,
+    fieldWrapper: {
+        wrapField(value) {
+            return FloatValue.createComplete({ 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: ScalarType.INT64 },
+    ],
+    packedByDefault: true,
+    fieldWrapper: {
+        wrapField(value) {
+            return Int64Value.createComplete({ 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: ScalarType.UINT64 },
+    ],
+    packedByDefault: true,
+    fieldWrapper: {
+        wrapField(value) {
+            return UInt64Value.createComplete({ 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: ScalarType.INT32 },
+    ],
+    packedByDefault: true,
+    fieldWrapper: {
+        wrapField(value) {
+            return Int32Value.createComplete({ 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: ScalarType.UINT32 },
+    ],
+    packedByDefault: true,
+    fieldWrapper: {
+        wrapField(value) {
+            return UInt32Value.createComplete({ 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: ScalarType.BOOL },
+    ],
+    packedByDefault: true,
+    fieldWrapper: {
+        wrapField(value) {
+            return BoolValue.createComplete({ 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: ScalarType.STRING },
+    ],
+    packedByDefault: true,
+    fieldWrapper: {
+        wrapField(value) {
+            return StringValue.createComplete({ 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: ScalarType.BYTES },
+    ],
+    packedByDefault: true,
+    fieldWrapper: {
+        wrapField(value) {
+            return BytesValue.createComplete({ value: value ?? undefined });
+        },
+        unwrapField(msg) {
+            return msg.value;
+        },
+    },
+}, BytesValue_Wkt);

package/dist/message.d.ts

@@ -76,7 +76,7 @@ export interface MessageType<T extends Message<T> = AnyMessage> {
     /**
      * Serialize the message to binary data.
      */
-    toBinary(a: Message<T>, options?: Partial<BinaryWriteOptions>): Uint8Array;
+    toBinary(a: Message<T> | undefined | null, options?: Partial<BinaryWriteOptions>): Uint8Array;
     /**
      * Serialize the message to a JSON value, a JavaScript value that can be
      * passed to JSON.stringify().

package/dist/message.js

@@ -79,6 +79,8 @@ export function createMessageType(params, exts) {
             return mt.fromJson(json, options);
         },
         toBinary(a, options) {
+            if (a == null)
+                return new Uint8Array(0);
             const opt = binaryMakeWriteOptions(options);
             const writer = opt.writerFactory();
             binaryWriteMessage(a, fields, writer, opt);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aptre/protobuf-es-lite",
   "description": "Lightweight Protobuf codegen for TypeScript and JavaScript.",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "license": "Apache-2.0",
   "repository": {
     "url": "git+ssh://git@github.com/aperturerobotics/protobuf-es-lite.git"
@@ -114,8 +114,8 @@
     "lint": "ESLINT_USE_FLAT_CONFIG=false eslint -c .eslintrc.cjs ./",
     "release:version": "npm version patch -m \"release: v%s\" --no-git-tag-version",
     "release:version:minor": "npm version minor -m \"release: v%s\" --no-git-tag-version",
-    "release:commit": "git reset && git add package.json && git commit -s -m \"release: v$npm_package_version\" && git tag v$npm_package_version",
-    "release:publish": "git push && git push --tags && npm run build && npm publish",
+    "release:commit": "git reset && git add package.json && git commit -s -m \"release: v$(node -p \"require('./package.json').version\")\" && git tag v$(node -p \"require('./package.json').version\")",
+    "release:publish": "git push && git push --tags",
     "release": "npm run release:version && npm run release:commit",
     "release:minor": "npm run release:version:minor && npm run release:commit",
     "prepare": "husky"
@@ -126,7 +126,7 @@
     "lz-string": "^1.5.0"
   },
   "devDependencies": {
-    "@types/node": "^22.7.5",
+    "@types/node": "^24.0.0",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "eslint": "^9.3.0",
@@ -137,7 +137,7 @@
     "prettier": "^3.2.5",
     "rimraf": "^6.0.0",
     "typescript": "^5.4.5",
-    "vitest": "^3.1.2"
+    "vitest": "^4.0.0"
   },
   "lint-staged": {
     "package.json": "prettier --write",

package/tsconfig.json

@@ -5,7 +5,17 @@
     "src/descriptor-set.ts",
     "src/create-descriptor-set.ts",
     "src/protoplugin/index.ts",
-    "src/protoplugin/ecmascript/index.ts"
+    "src/protoplugin/ecmascript/index.ts",
+    "src/google/index.ts",
+    "src/google/protobuf/type.pb.ts",
+    "src/google/protobuf/timestamp.pb.ts",
+    "src/google/protobuf/duration.pb.ts",
+    "src/google/protobuf/any.pb.ts",
+    "src/google/protobuf/empty.pb.ts",
+    "src/google/protobuf/wrappers.pb.ts",
+    "src/google/protobuf/struct.pb.ts",
+    "src/google/protobuf/api.pb.ts",
+    "src/google/protobuf/source_context.pb.ts"
   ],
   "extends": "./tsconfig.base.json",
   "compilerOptions": {