@aptre/protobuf-es-lite 0.2.10 → 0.2.12

package/dist/binary.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeMapEntry = exports.writeMessage = exports.readMessage = exports.makeWriteOptions = exports.makeReadOptions = exports.readScalarLTString = exports.readScalar = exports.readMapEntry = exports.readField = void 0;
-const field_js_1 = require("./field.js");
-const is_message_js_1 = require("./is-message.js");
-const unknown_js_1 = require("./unknown.js");
-const field_wrapper_js_1 = require("./field-wrapper.js");
-const scalar_js_1 = require("./scalar.js");
-const assert_js_1 = require("./assert.js");
-const binary_encoding_js_1 = require("./binary-encoding.js");
-function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+import { isFieldSet, resolveMessageType, } from "./field.js";
+import { handleUnknownField, unknownFieldsSymbol } from "./unknown.js";
+import { wrapField } from "./field-wrapper.js";
+import { LongType, ScalarType, scalarZeroValue, } from "./scalar.js";
+import { assert } from "./assert.js";
+import { BinaryReader, BinaryWriter, WireType, } from "./binary-encoding.js";
+export function readField(target, // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
 reader, field, wireType, options) {
     let { repeated, localName } = field;
     if (field.oneof) {
@@ -26,7 +22,7 @@ reader, field, wireType, options) {
     switch (field.kind) {
         case "scalar":
         case "enum":
-            const scalarType = field.kind == "enum" ? scalar_js_1.ScalarType.INT32 : field.T;
+            const scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
             let read = readScalar;
             // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- acceptable since it's covered by tests
             if (field.kind == "scalar" && field.L > 0) {
@@ -37,9 +33,9 @@ reader, field, wireType, options) {
                 if (!Array.isArray(tgtArr)) {
                     tgtArr = target[localName] = [];
                 }
-                const isPacked = wireType == binary_encoding_js_1.WireType.LengthDelimited &&
-                    scalarType != scalar_js_1.ScalarType.STRING &&
-                    scalarType != scalar_js_1.ScalarType.BYTES;
+                const isPacked = wireType == WireType.LengthDelimited &&
+                    scalarType != ScalarType.STRING &&
+                    scalarType != ScalarType.BYTES;
                 if (isPacked) {
                     let e = reader.uint32() + reader.pos;
                     while (reader.pos < e) {
@@ -62,17 +58,12 @@ reader, field, wireType, options) {
                 if (!Array.isArray(tgtArr)) {
                     tgtArr = target[localName] = [];
                 }
-                tgtArr.push(readMessageField(reader, messageType.create(), messageType.fields, options, field));
+                tgtArr.push(readMessageField(reader, {}, messageType.fields, options, field));
             }
             else {
-                if ((0, is_message_js_1.isCompleteMessage)(target[localName], messageType.fields.list())) {
-                    readMessageField(reader, target[localName], messageType.fields, options, field);
-                }
-                else {
-                    target[localName] = readMessageField(reader, messageType.create(), messageType.fields, options, field);
-                    if (messageType.fieldWrapper && !field.oneof && !field.repeated) {
-                        target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
-                    }
+                target[localName] = readMessageField(reader, {}, messageType.fields, options, field);
+                if (messageType.fieldWrapper && !field.oneof && !field.repeated) {
+                    target[localName] = messageType.fieldWrapper.unwrapField(target[localName]);
                 }
             }
             break;
@@ -86,9 +77,8 @@ reader, field, wireType, options) {
             break;
     }
 }
-exports.readField = readField;
 // Read a map field, expecting key field = 1, value field = 2
-function readMapEntry(field, reader, options) {
+export function readMapEntry(field, reader, options) {
     const length = reader.uint32(), end = reader.pos + length;
     let key, val;
     while (reader.pos < end) {
@@ -106,15 +96,15 @@ function readMapEntry(field, reader, options) {
                         val = reader.int32();
                         break;
                     case "message":
-                        const messageType = (0, field_js_1.resolveMessageType)(field.V.T);
-                        val = readMessageField(reader, messageType.create(), messageType.fields, options, undefined);
+                        const messageType = resolveMessageType(field.V.T);
+                        val = readMessageField(reader, {}, messageType.fields, options, undefined);
                         break;
                 }
                 break;
         }
     }
     if (key === undefined) {
-        key = (0, scalar_js_1.scalarZeroValue)(field.K, scalar_js_1.LongType.BIGINT);
+        key = scalarZeroValue(field.K, LongType.BIGINT);
     }
     if (typeof key != "string" && typeof key != "number") {
         key = key.toString();
@@ -123,61 +113,58 @@ function readMapEntry(field, reader, options) {
         const fieldKind = field.V.kind;
         switch (fieldKind) {
             case "scalar":
-                val = (0, scalar_js_1.scalarZeroValue)(field.V.T, scalar_js_1.LongType.BIGINT);
+                val = scalarZeroValue(field.V.T, LongType.BIGINT);
                 break;
             case "enum":
                 val = field.V.T.values[0].no;
                 break;
             case "message":
-                val = (0, field_js_1.resolveMessageType)(field.V.T).create();
+                val = {};
                 break;
         }
     }
     return [key, val];
 }
-exports.readMapEntry = readMapEntry;
-function readScalar(reader, type) {
+export function readScalar(reader, type) {
     switch (type) {
-        case scalar_js_1.ScalarType.STRING:
+        case ScalarType.STRING:
             return reader.string();
-        case scalar_js_1.ScalarType.BOOL:
+        case ScalarType.BOOL:
             return reader.bool();
-        case scalar_js_1.ScalarType.DOUBLE:
+        case ScalarType.DOUBLE:
             return reader.double();
-        case scalar_js_1.ScalarType.FLOAT:
+        case ScalarType.FLOAT:
             return reader.float();
-        case scalar_js_1.ScalarType.INT32:
+        case ScalarType.INT32:
             return reader.int32();
-        case scalar_js_1.ScalarType.INT64:
+        case ScalarType.INT64:
             return reader.int64();
-        case scalar_js_1.ScalarType.UINT64:
+        case ScalarType.UINT64:
             return reader.uint64();
-        case scalar_js_1.ScalarType.FIXED64:
+        case ScalarType.FIXED64:
             return reader.fixed64();
-        case scalar_js_1.ScalarType.BYTES:
+        case ScalarType.BYTES:
             return reader.bytes();
-        case scalar_js_1.ScalarType.FIXED32:
+        case ScalarType.FIXED32:
             return reader.fixed32();
-        case scalar_js_1.ScalarType.SFIXED32:
+        case ScalarType.SFIXED32:
             return reader.sfixed32();
-        case scalar_js_1.ScalarType.SFIXED64:
+        case ScalarType.SFIXED64:
             return reader.sfixed64();
-        case scalar_js_1.ScalarType.SINT64:
+        case ScalarType.SINT64:
             return reader.sint64();
-        case scalar_js_1.ScalarType.UINT32:
+        case ScalarType.UINT32:
             return reader.uint32();
-        case scalar_js_1.ScalarType.SINT32:
+        case ScalarType.SINT32:
             return reader.sint32();
     }
 }
-exports.readScalar = readScalar;
 // Read a scalar value, but return 64 bit integral types (int64, uint64,
 // sint64, fixed64, sfixed64) as string instead of bigint.
-function readScalarLTString(reader, type) {
+export function readScalarLTString(reader, type) {
     const v = readScalar(reader, type);
     return typeof v == "bigint" ? v.toString() : v;
 }
-exports.readScalarLTString = readScalarLTString;
 // Read a message, avoiding MessageType.fromBinary() to re-use the
 // BinaryReadOptions and the IBinaryReader.
 function readMessageField(reader, message, fields, options, field) {
@@ -189,52 +176,49 @@ function readMessageField(reader, message, fields, options, field) {
 // Default options for parsing binary data.
 const readDefaults = {
     readUnknownFields: true,
-    readerFactory: (bytes) => new binary_encoding_js_1.BinaryReader(bytes),
+    readerFactory: (bytes) => new BinaryReader(bytes),
 };
 // Default options for serializing binary data.
 const writeDefaults = {
     writeUnknownFields: true,
-    writerFactory: () => new binary_encoding_js_1.BinaryWriter(),
+    writerFactory: () => new BinaryWriter(),
 };
-function makeReadOptions(options) {
+export function makeReadOptions(options) {
     return options ? { ...readDefaults, ...options } : readDefaults;
 }
-exports.makeReadOptions = makeReadOptions;
-function makeWriteOptions(options) {
+export function makeWriteOptions(options) {
     return options ? { ...writeDefaults, ...options } : writeDefaults;
 }
-exports.makeWriteOptions = makeWriteOptions;
-function readMessage(message, fields, reader, lengthOrEndTagFieldNo, options, delimitedMessageEncoding) {
+export function readMessage(message, fields, reader, lengthOrEndTagFieldNo, options, delimitedMessageEncoding) {
     // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     const end = delimitedMessageEncoding ? reader.len : reader.pos + lengthOrEndTagFieldNo;
     let fieldNo, wireType;
     while (reader.pos < end) {
         [fieldNo, wireType] = reader.tag();
-        if (wireType == binary_encoding_js_1.WireType.EndGroup) {
+        if (wireType == WireType.EndGroup) {
             break;
         }
         const field = fields.find(fieldNo);
         if (!field) {
             const data = reader.skip(wireType);
             if (options.readUnknownFields) {
-                (0, unknown_js_1.handleUnknownField)(message, fieldNo, wireType, data);
+                handleUnknownField(message, fieldNo, wireType, data);
             }
             continue;
         }
         readField(message, reader, field, wireType, options);
     }
     if (delimitedMessageEncoding && // eslint-disable-line @typescript-eslint/strict-boolean-expressions
-        (wireType != binary_encoding_js_1.WireType.EndGroup || fieldNo !== lengthOrEndTagFieldNo)) {
+        (wireType != WireType.EndGroup || fieldNo !== lengthOrEndTagFieldNo)) {
         throw new Error(`invalid end group tag`);
     }
 }
-exports.readMessage = readMessage;
 /**
  * Serialize a message to binary data.
  */
-function writeMessage(message, fields, writer, options) {
+export function writeMessage(message, fields, writer, options) {
     for (const field of fields.byNumber()) {
-        if (!(0, field_js_1.isFieldSet)(field, message)) {
+        if (!isFieldSet(field, message)) {
             if (field.req) {
                 throw new Error(`cannot encode field ${field.name} to binary: required field not set`);
             }
@@ -249,16 +233,15 @@ function writeMessage(message, fields, writer, options) {
         writeUnknownFields(message, writer);
     }
 }
-exports.writeMessage = writeMessage;
 function writeField(field, value, writer, options) {
-    (0, assert_js_1.assert)(value !== undefined);
+    assert(value !== undefined);
     const repeated = field.repeated;
     switch (field.kind) {
         case "scalar":
         case "enum":
-            let scalarType = field.kind == "enum" ? scalar_js_1.ScalarType.INT32 : field.T;
+            let scalarType = field.kind == "enum" ? ScalarType.INT32 : field.T;
             if (repeated) {
-                (0, assert_js_1.assert)(Array.isArray(value));
+                assert(Array.isArray(value));
                 if (field.packed) {
                     writePacked(writer, scalarType, field.no, value);
                 }
@@ -274,7 +257,7 @@ function writeField(field, value, writer, options) {
             break;
         case "message":
             if (repeated) {
-                (0, assert_js_1.assert)(Array.isArray(value));
+                assert(Array.isArray(value));
                 for (const item of value) {
                     writeMessageField(writer, options, field, item);
                 }
@@ -284,7 +267,7 @@ function writeField(field, value, writer, options) {
             }
             break;
         case "map":
-            (0, assert_js_1.assert)(typeof value == "object" && value != null);
+            assert(typeof value == "object" && value != null);
             for (const [key, val] of Object.entries(value)) {
                 writeMapEntry(writer, options, field, key, val);
             }
@@ -293,7 +276,7 @@ function writeField(field, value, writer, options) {
 }
 function writeUnknownFields(message, writer) {
     const m = message;
-    const c = m[unknown_js_1.unknownFieldsSymbol];
+    const c = m[unknownFieldsSymbol];
     if (c) {
         for (const f of c) {
             writer.tag(f.no, f.wireType).raw(f.data);
@@ -302,21 +285,21 @@ function writeUnknownFields(message, writer) {
 }
 // Value must not be undefined
 function writeMessageField(writer, options, field, value) {
-    const messageType = (0, field_js_1.resolveMessageType)(field.T);
-    const message = (0, field_wrapper_js_1.wrapField)(messageType.fieldWrapper, value);
+    const messageType = resolveMessageType(field.T);
+    const message = wrapField(messageType.fieldWrapper, value);
     // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (field.delimited)
         writer
-            .tag(field.no, binary_encoding_js_1.WireType.StartGroup)
+            .tag(field.no, WireType.StartGroup)
             .raw(messageType.toBinary(message, options))
-            .tag(field.no, binary_encoding_js_1.WireType.EndGroup);
+            .tag(field.no, WireType.EndGroup);
     else
         writer
-            .tag(field.no, binary_encoding_js_1.WireType.LengthDelimited)
+            .tag(field.no, WireType.LengthDelimited)
             .bytes(messageType.toBinary(message, options));
 }
 function writeScalar(writer, type, fieldNo, value) {
-    (0, assert_js_1.assert)(value !== undefined);
+    assert(value !== undefined);
     let [wireType, method] = scalarTypeInfo(type);
     writer.tag(fieldNo, wireType)[method](value);
 }
@@ -324,7 +307,7 @@ function writePacked(writer, type, fieldNo, value) {
     if (!value.length) {
         return;
     }
-    writer.tag(fieldNo, binary_encoding_js_1.WireType.LengthDelimited).fork();
+    writer.tag(fieldNo, WireType.LengthDelimited).fork();
     let [, method] = scalarTypeInfo(type);
     for (let i = 0; i < value.length; i++) {
         writer[method](value[i]);
@@ -343,44 +326,44 @@ function writePacked(writer, type, fieldNo, value) {
  */
 // TODO replace call-sites writeScalar() and writePacked(), then remove
 function scalarTypeInfo(type) {
-    let wireType = binary_encoding_js_1.WireType.Varint;
+    let wireType = WireType.Varint;
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- INT32, UINT32, SINT32 are covered by the defaults
     switch (type) {
-        case scalar_js_1.ScalarType.BYTES:
-        case scalar_js_1.ScalarType.STRING:
-            wireType = binary_encoding_js_1.WireType.LengthDelimited;
+        case ScalarType.BYTES:
+        case ScalarType.STRING:
+            wireType = WireType.LengthDelimited;
             break;
-        case scalar_js_1.ScalarType.DOUBLE:
-        case scalar_js_1.ScalarType.FIXED64:
-        case scalar_js_1.ScalarType.SFIXED64:
-            wireType = binary_encoding_js_1.WireType.Bit64;
+        case ScalarType.DOUBLE:
+        case ScalarType.FIXED64:
+        case ScalarType.SFIXED64:
+            wireType = WireType.Bit64;
             break;
-        case scalar_js_1.ScalarType.FIXED32:
-        case scalar_js_1.ScalarType.SFIXED32:
-        case scalar_js_1.ScalarType.FLOAT:
-            wireType = binary_encoding_js_1.WireType.Bit32;
+        case ScalarType.FIXED32:
+        case ScalarType.SFIXED32:
+        case ScalarType.FLOAT:
+            wireType = WireType.Bit32;
             break;
     }
-    const method = scalar_js_1.ScalarType[type].toLowerCase();
+    const method = ScalarType[type].toLowerCase();
     return [wireType, method];
 }
-function writeMapEntry(writer, options, field, key, value) {
-    writer.tag(field.no, binary_encoding_js_1.WireType.LengthDelimited);
+export function writeMapEntry(writer, options, field, key, value) {
+    writer.tag(field.no, WireType.LengthDelimited);
     writer.fork();
     // javascript only allows number or string for object properties
     // we convert from our representation to the protobuf type
     let keyValue = key;
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- we deliberately handle just the special cases for map keys
     switch (field.K) {
-        case scalar_js_1.ScalarType.INT32:
-        case scalar_js_1.ScalarType.FIXED32:
-        case scalar_js_1.ScalarType.UINT32:
-        case scalar_js_1.ScalarType.SFIXED32:
-        case scalar_js_1.ScalarType.SINT32:
+        case ScalarType.INT32:
+        case ScalarType.FIXED32:
+        case ScalarType.UINT32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32:
             keyValue = Number.parseInt(key);
             break;
-        case scalar_js_1.ScalarType.BOOL:
-            (0, assert_js_1.assert)(key == "true" || key == "false");
+        case ScalarType.BOOL:
+            assert(key == "true" || key == "false");
             keyValue = key == "true";
             break;
     }
@@ -392,16 +375,15 @@ function writeMapEntry(writer, options, field, key, value) {
             writeScalar(writer, field.V.T, 2, value);
             break;
         case "enum":
-            writeScalar(writer, scalar_js_1.ScalarType.INT32, 2, value);
+            writeScalar(writer, ScalarType.INT32, 2, value);
             break;
         case "message":
-            (0, assert_js_1.assert)(value !== undefined);
-            const messageType = (0, field_js_1.resolveMessageType)(field.V.T);
+            assert(value !== undefined);
+            const messageType = resolveMessageType(field.V.T);
             writer
-                .tag(2, binary_encoding_js_1.WireType.LengthDelimited)
+                .tag(2, WireType.LengthDelimited)
                 .bytes(messageType.toBinary(value, options));
             break;
     }
     writer.join();
 }
-exports.writeMapEntry = writeMapEntry;

package/dist/codegen-info.d.ts

@@ -32,7 +32,6 @@ export declare const codegenInfo: {
         readonly LongType: RuntimeSymbolInfo;
         readonly MethodKind: RuntimeSymbolInfo;
         readonly MethodIdempotency: RuntimeSymbolInfo;
-        readonly IMessageTypeRegistry: RuntimeSymbolInfo;
         readonly createEnumType: RuntimeSymbolInfo;
         readonly createMessageType: RuntimeSymbolInfo;
     };

package/dist/codegen-info.js

@@ -1,4 +1,3 @@
-"use strict";
 // Copyright 2024 Aperture Robotics, LLC.
 // Copyright 2021-2024 Buf Technologies, Inc.
 //
@@ -13,16 +12,14 @@
 // 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.codegenInfo = exports.packageName = void 0;
-const names_js_1 = require("./names.js");
-const field_wrapper_js_1 = require("./field-wrapper.js");
-const scalar_js_1 = require("./scalar.js");
-exports.packageName = "@aptre/protobuf-es-lite";
+import { localName, safeIdentifier, safeObjectProperty } from "./names.js";
+import { getUnwrappedFieldType } from "./field-wrapper.js";
+import { scalarZeroValue } from "./scalar.js";
+export const packageName = "@aptre/protobuf-es-lite";
 const symbolInfo = (typeOnly, privateImportPath) => ({
     typeOnly,
     privateImportPath,
-    publicImportPath: exports.packageName,
+    publicImportPath: packageName,
 });
 const symbols = {
     Message: symbolInfo(false, "./message.js"),
@@ -42,18 +39,17 @@ const symbols = {
     LongType: symbolInfo(false, "./scalar.js"),
     MethodKind: symbolInfo(false, "./service-type.js"),
     MethodIdempotency: symbolInfo(false, "./service-type.js"),
-    IMessageTypeRegistry: symbolInfo(true, "./type-registry.js"),
     createEnumType: symbolInfo(false, "./enum.js"),
     createMessageType: symbolInfo(false, "./message.js"),
 };
 // prettier-ignore
-exports.codegenInfo = {
-    packageName: exports.packageName,
-    localName: names_js_1.localName,
-    getUnwrappedFieldType: field_wrapper_js_1.getUnwrappedFieldType,
-    scalarZeroValue: scalar_js_1.scalarZeroValue,
-    safeIdentifier: names_js_1.safeIdentifier,
-    safeObjectProperty: names_js_1.safeObjectProperty,
+export const codegenInfo = {
+    packageName,
+    localName,
+    getUnwrappedFieldType,
+    scalarZeroValue,
+    safeIdentifier,
+    safeObjectProperty,
     symbols,
     wktSourceFiles: [
         "google/protobuf/compiler/plugin.proto",