@aptre/protobuf-es-lite 0.2.10 → 0.2.12

package/bin/protoc-gen-es-lite

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const {runNodeJs} = require("../dist/protoplugin");
-const {protocGenEsLite} = require("../dist/protoc-gen-es-lite/protoc-gen-es-lite-plugin.js");
+import {runNodeJs} from "../dist/protoplugin/index.js";
+import {protocGenEsLite} from "../dist/protoc-gen-es-lite/protoc-gen-es-lite-plugin.js";
 
 runNodeJs(protocGenEsLite);

package/dist/assert.js

@@ -1,4 +1,3 @@
-"use strict";
 // Copyright 2021-2024 Buf Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,43 +11,38 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertFloat32 = exports.assertUInt32 = exports.assertInt32 = exports.assert = void 0;
 /**
  * Assert that condition is truthy or throw error (with message)
  */
-function assert(condition, msg) {
+export function assert(condition, msg) {
     // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we want the implicit conversion to boolean
     if (!condition) {
         throw new Error(msg);
     }
 }
-exports.assert = assert;
 const FLOAT32_MAX = 3.4028234663852886e38, FLOAT32_MIN = -3.4028234663852886e38, UINT32_MAX = 0xffffffff, INT32_MAX = 0x7fffffff, INT32_MIN = -0x80000000;
 /**
  * Assert a valid signed protobuf 32-bit integer.
  */
-function assertInt32(arg) {
+export function assertInt32(arg) {
     if (typeof arg !== "number")
         throw new Error("invalid int 32: " + typeof arg);
     if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN)
         throw new Error("invalid int 32: " + arg); // eslint-disable-line @typescript-eslint/restrict-plus-operands -- we want the implicit conversion to string
 }
-exports.assertInt32 = assertInt32;
 /**
  * Assert a valid unsigned protobuf 32-bit integer.
  */
-function assertUInt32(arg) {
+export function assertUInt32(arg) {
     if (typeof arg !== "number")
         throw new Error("invalid uint 32: " + typeof arg);
     if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0)
         throw new Error("invalid uint 32: " + arg); // eslint-disable-line @typescript-eslint/restrict-plus-operands -- we want the implicit conversion to string
 }
-exports.assertUInt32 = assertUInt32;
 /**
  * Assert a valid protobuf float value.
  */
-function assertFloat32(arg) {
+export function assertFloat32(arg) {
     if (typeof arg !== "number")
         throw new Error("invalid float 32: " + typeof arg);
     if (!Number.isFinite(arg))
@@ -56,4 +50,3 @@ function assertFloat32(arg) {
     if (arg > FLOAT32_MAX || arg < FLOAT32_MIN)
         throw new Error("invalid float 32: " + arg); // eslint-disable-line @typescript-eslint/restrict-plus-operands -- we want the implicit conversion to string
 }
-exports.assertFloat32 = assertFloat32;

package/dist/binary-encoding.js

@@ -1,4 +1,3 @@
-"use strict";
 // Copyright 2021-2024 Buf Technologies, Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,11 +11,9 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinaryReader = exports.BinaryWriter = exports.WireType = void 0;
-const varint_js_1 = require("./varint.js");
-const assert_js_1 = require("./assert.js");
-const proto_int64_js_1 = require("./proto-int64.js");
+import { varint32read, varint32write, varint64read, varint64write, } from "./varint.js";
+import { assertFloat32, assertInt32, assertUInt32 } from "./assert.js";
+import { protoInt64 } from "./proto-int64.js";
 /* eslint-disable prefer-const,no-case-declarations,@typescript-eslint/restrict-plus-operands */
 /**
  * Protobuf binary format wire types.
@@ -26,7 +23,7 @@ const proto_int64_js_1 = require("./proto-int64.js");
  *
  * See https://developers.google.com/protocol-buffers/docs/encoding#structure
  */
-var WireType;
+export var WireType;
 (function (WireType) {
     /**
      * Used for int32, int64, uint32, uint64, sint32, sint64, bool, enum
@@ -59,13 +56,34 @@ var WireType;
      * Always 4 bytes with little-endian byte order.
      */
     WireType[WireType["Bit32"] = 5] = "Bit32";
-})(WireType || (exports.WireType = WireType = {}));
-class BinaryWriter {
+})(WireType || (WireType = {}));
+export class BinaryWriter {
+    /**
+     * We cannot allocate a buffer for the entire output
+     * because we don't know it's size.
+     *
+     * So we collect smaller chunks of known size and
+     * concat them later.
+     *
+     * Use `raw()` to push data to this array. It will flush
+     * `buf` first.
+     */
+    chunks;
+    /**
+     * A growing buffer for byte values. If you don't know
+     * the size of the data you are writing, push to this
+     * array.
+     */
+    buf;
+    /**
+     * Previous fork states.
+     */
+    stack = [];
+    /**
+     * Text encoder instance to convert UTF-8 to bytes.
+     */
+    textEncoder;
     constructor(textEncoder) {
-        /**
-         * Previous fork states.
-         */
-        this.stack = [];
         this.textEncoder = textEncoder ?? new TextEncoder();
         this.chunks = [];
         this.buf = [];
@@ -141,7 +159,7 @@ class BinaryWriter {
      * Write a `uint32` value, an unsigned 32 bit varint.
      */
     uint32(value) {
-        (0, assert_js_1.assertUInt32)(value);
+        assertUInt32(value);
         // write value as varint 32, inlined for speed
         while (value > 0x7f) {
             this.buf.push((value & 0x7f) | 0x80);
@@ -154,8 +172,8 @@ class BinaryWriter {
      * Write a `int32` value, a signed 32 bit varint.
      */
     int32(value) {
-        (0, assert_js_1.assertInt32)(value);
-        (0, varint_js_1.varint32write)(value, this.buf);
+        assertInt32(value);
+        varint32write(value, this.buf);
         return this;
     }
     /**
@@ -184,7 +202,7 @@ class BinaryWriter {
      * Write a `float` value, 32-bit floating point number.
      */
     float(value) {
-        (0, assert_js_1.assertFloat32)(value);
+        assertFloat32(value);
         let chunk = new Uint8Array(4);
         new DataView(chunk.buffer).setFloat32(0, value, true);
         return this.raw(chunk);
@@ -201,7 +219,7 @@ class BinaryWriter {
      * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
      */
     fixed32(value) {
-        (0, assert_js_1.assertUInt32)(value);
+        assertUInt32(value);
         let chunk = new Uint8Array(4);
         new DataView(chunk.buffer).setUint32(0, value, true);
         return this.raw(chunk);
@@ -210,7 +228,7 @@ class BinaryWriter {
      * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
      */
     sfixed32(value) {
-        (0, assert_js_1.assertInt32)(value);
+        assertInt32(value);
         let chunk = new Uint8Array(4);
         new DataView(chunk.buffer).setInt32(0, value, true);
         return this.raw(chunk);
@@ -219,17 +237,17 @@ class BinaryWriter {
      * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
      */
     sint32(value) {
-        (0, assert_js_1.assertInt32)(value);
+        assertInt32(value);
         // zigzag encode
         value = ((value << 1) ^ (value >> 31)) >>> 0;
-        (0, varint_js_1.varint32write)(value, this.buf);
+        varint32write(value, this.buf);
         return this;
     }
     /**
      * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
      */
     sfixed64(value) {
-        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = proto_int64_js_1.protoInt64.enc(value);
+        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.enc(value);
         view.setInt32(0, tc.lo, true);
         view.setInt32(4, tc.hi, true);
         return this.raw(chunk);
@@ -238,7 +256,7 @@ class BinaryWriter {
      * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
      */
     fixed64(value) {
-        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = proto_int64_js_1.protoInt64.uEnc(value);
+        let chunk = new Uint8Array(8), view = new DataView(chunk.buffer), tc = protoInt64.uEnc(value);
         view.setInt32(0, tc.lo, true);
         view.setInt32(4, tc.hi, true);
         return this.raw(chunk);
@@ -247,37 +265,42 @@ class BinaryWriter {
      * Write a `int64` value, a signed 64-bit varint.
      */
     int64(value) {
-        let tc = proto_int64_js_1.protoInt64.enc(value);
-        (0, varint_js_1.varint64write)(tc.lo, tc.hi, this.buf);
+        let tc = protoInt64.enc(value);
+        varint64write(tc.lo, tc.hi, this.buf);
         return this;
     }
     /**
      * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
      */
     sint64(value) {
-        let tc = proto_int64_js_1.protoInt64.enc(value), 
+        let tc = protoInt64.enc(value), 
         // zigzag encode
         sign = tc.hi >> 31, lo = (tc.lo << 1) ^ sign, hi = ((tc.hi << 1) | (tc.lo >>> 31)) ^ sign;
-        (0, varint_js_1.varint64write)(lo, hi, this.buf);
+        varint64write(lo, hi, this.buf);
         return this;
     }
     /**
      * Write a `uint64` value, an unsigned 64-bit varint.
      */
     uint64(value) {
-        let tc = proto_int64_js_1.protoInt64.uEnc(value);
-        (0, varint_js_1.varint64write)(tc.lo, tc.hi, this.buf);
+        let tc = protoInt64.uEnc(value);
+        varint64write(tc.lo, tc.hi, this.buf);
         return this;
     }
 }
-exports.BinaryWriter = BinaryWriter;
-class BinaryReader {
+export class BinaryReader {
+    /**
+     * Current position.
+     */
+    pos;
+    /**
+     * Number of bytes available in this reader.
+     */
+    len;
+    buf;
+    view;
+    textDecoder;
     constructor(buf, textDecoder) {
-        this.varint64 = varint_js_1.varint64read; // dirty cast for `this`
-        /**
-         * Read a `uint32` field, an unsigned 32 bit varint.
-         */
-        this.uint32 = varint_js_1.varint32read; // dirty cast for `this` and access to protected `buf`
         this.buf = buf;
         this.len = buf.length;
         this.pos = 0;
@@ -331,6 +354,7 @@ class BinaryReader {
         this.assertBounds();
         return this.buf.subarray(start, this.pos);
     }
+    varint64 = varint64read; // dirty cast for `this`
     /**
      * Throws error if position in byte array is out of range.
      */
@@ -338,6 +362,10 @@ class BinaryReader {
         if (this.pos > this.len)
             throw new RangeError("premature EOF");
     }
+    /**
+     * Read a `uint32` field, an unsigned 32 bit varint.
+     */
+    uint32 = varint32read; // dirty cast for `this` and access to protected `buf`
     /**
      * Read a `int32` field, a signed 32 bit varint.
      */
@@ -356,13 +384,13 @@ class BinaryReader {
      * Read a `int64` field, a signed 64-bit varint.
      */
     int64() {
-        return proto_int64_js_1.protoInt64.dec(...this.varint64());
+        return protoInt64.dec(...this.varint64());
     }
     /**
      * Read a `uint64` field, an unsigned 64-bit varint.
      */
     uint64() {
-        return proto_int64_js_1.protoInt64.uDec(...this.varint64());
+        return protoInt64.uDec(...this.varint64());
     }
     /**
      * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
@@ -373,7 +401,7 @@ class BinaryReader {
         let s = -(lo & 1);
         lo = ((lo >>> 1) | ((hi & 1) << 31)) ^ s;
         hi = (hi >>> 1) ^ s;
-        return proto_int64_js_1.protoInt64.dec(lo, hi);
+        return protoInt64.dec(lo, hi);
     }
     /**
      * Read a `bool` field, a variant.
@@ -398,13 +426,13 @@ class BinaryReader {
      * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
      */
     fixed64() {
-        return proto_int64_js_1.protoInt64.uDec(this.sfixed32(), this.sfixed32());
+        return protoInt64.uDec(this.sfixed32(), this.sfixed32());
     }
     /**
      * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
      */
     sfixed64() {
-        return proto_int64_js_1.protoInt64.dec(this.sfixed32(), this.sfixed32());
+        return protoInt64.dec(this.sfixed32(), this.sfixed32());
     }
     /**
      * Read a `float` field, 32-bit floating point number.
@@ -434,4 +462,3 @@ class BinaryReader {
         return this.textDecoder.decode(this.bytes());
     }
 }
-exports.BinaryReader = BinaryReader;