@aptre/protobuf-es-lite 0.1.0

package/dist/binary.js

@@ -0,0 +1,389 @@
+"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 protobuf_1 = require("@bufbuild/protobuf");
+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");
+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) {
+        target = target[field.oneof.localName];
+        if (target.case != localName) {
+            delete target.value;
+        }
+        target.case = localName;
+        localName = "value";
+    }
+    switch (field.kind) {
+        case "scalar":
+        case "enum":
+            const scalarType = field.kind == "enum" ? protobuf_1.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) {
+                read = readScalarLTString;
+            }
+            if (repeated) {
+                let arr = target[localName]; // safe to assume presence of array, oneof cannot contain repeated values
+                const isPacked = wireType == protobuf_1.WireType.LengthDelimited &&
+                    scalarType != protobuf_1.ScalarType.STRING &&
+                    scalarType != protobuf_1.ScalarType.BYTES;
+                if (isPacked) {
+                    let e = reader.uint32() + reader.pos;
+                    while (reader.pos < e) {
+                        arr.push(read(reader, scalarType));
+                    }
+                }
+                else {
+                    arr.push(read(reader, scalarType));
+                }
+            }
+            else {
+                target[localName] = read(reader, scalarType);
+            }
+            break;
+        case "message":
+            const messageType = field.T;
+            if (repeated) {
+                // safe to assume presence of array, oneof cannot contain repeated values
+                target[localName].push(readMessageField(reader, messageType.create(), 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]);
+                    }
+                }
+            }
+            break;
+        case "map":
+            let [mapKey, mapVal] = readMapEntry(field, reader, options);
+            // safe to assume presence of map object, oneof cannot contain repeated values
+            target[localName][mapKey] = mapVal;
+            break;
+    }
+}
+exports.readField = readField;
+// Read a map field, expecting key field = 1, value field = 2
+function readMapEntry(field, reader, options) {
+    const length = reader.uint32(), end = reader.pos + length;
+    let key, val;
+    while (reader.pos < end) {
+        const [fieldNo] = reader.tag();
+        switch (fieldNo) {
+            case 1:
+                key = readScalar(reader, field.K);
+                break;
+            case 2:
+                switch (field.V.kind) {
+                    case "scalar":
+                        val = readScalar(reader, field.V.T);
+                        break;
+                    case "enum":
+                        val = reader.int32();
+                        break;
+                    case "message":
+                        val = readMessageField(reader, field.V.T.create(), field.V.T.fields, options, undefined);
+                        break;
+                }
+                break;
+        }
+    }
+    if (key === undefined) {
+        key = (0, scalar_js_1.scalarZeroValue)(field.K, protobuf_1.LongType.BIGINT);
+    }
+    if (typeof key != "string" && typeof key != "number") {
+        key = key.toString();
+    }
+    if (val === undefined) {
+        switch (field.V.kind) {
+            case "scalar":
+                val = (0, scalar_js_1.scalarZeroValue)(field.V.T, protobuf_1.LongType.BIGINT);
+                break;
+            case "enum":
+                val = field.V.T.values[0].no;
+                break;
+            case "message":
+                val = field.V.T.create();
+                break;
+        }
+    }
+    return [key, val];
+}
+exports.readMapEntry = readMapEntry;
+function readScalar(reader, type) {
+    switch (type) {
+        case protobuf_1.ScalarType.STRING:
+            return reader.string();
+        case protobuf_1.ScalarType.BOOL:
+            return reader.bool();
+        case protobuf_1.ScalarType.DOUBLE:
+            return reader.double();
+        case protobuf_1.ScalarType.FLOAT:
+            return reader.float();
+        case protobuf_1.ScalarType.INT32:
+            return reader.int32();
+        case protobuf_1.ScalarType.INT64:
+            return reader.int64();
+        case protobuf_1.ScalarType.UINT64:
+            return reader.uint64();
+        case protobuf_1.ScalarType.FIXED64:
+            return reader.fixed64();
+        case protobuf_1.ScalarType.BYTES:
+            return reader.bytes();
+        case protobuf_1.ScalarType.FIXED32:
+            return reader.fixed32();
+        case protobuf_1.ScalarType.SFIXED32:
+            return reader.sfixed32();
+        case protobuf_1.ScalarType.SFIXED64:
+            return reader.sfixed64();
+        case protobuf_1.ScalarType.SINT64:
+            return reader.sint64();
+        case protobuf_1.ScalarType.UINT32:
+            return reader.uint32();
+        case protobuf_1.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) {
+    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) {
+    const delimited = field?.delimited;
+    readMessage(message, fields, reader, delimited ? field.no : reader.uint32(), // eslint-disable-line @typescript-eslint/strict-boolean-expressions
+    options, delimited);
+    return message;
+}
+// Default options for parsing binary data.
+const readDefaults = {
+    readUnknownFields: true,
+    readerFactory: (bytes) => new protobuf_1.BinaryReader(bytes),
+};
+// Default options for serializing binary data.
+const writeDefaults = {
+    writeUnknownFields: true,
+    writerFactory: () => new protobuf_1.BinaryWriter(),
+};
+function makeReadOptions(options) {
+    return options ? { ...readDefaults, ...options } : readDefaults;
+}
+exports.makeReadOptions = makeReadOptions;
+function makeWriteOptions(options) {
+    return options ? { ...writeDefaults, ...options } : writeDefaults;
+}
+exports.makeWriteOptions = makeWriteOptions;
+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 == protobuf_1.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);
+            }
+            continue;
+        }
+        readField(message, reader, field, wireType, options);
+    }
+    if (delimitedMessageEncoding && // eslint-disable-line @typescript-eslint/strict-boolean-expressions
+        (wireType != protobuf_1.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) {
+    for (const field of fields.byNumber()) {
+        if (!(0, field_js_1.isFieldSet)(field, message)) {
+            if (field.req) {
+                throw new Error(`cannot encode field ${field.name} to binary: required field not set`);
+            }
+            continue;
+        }
+        const value = field.oneof
+            ? message[field.oneof.localName].value
+            : message[field.localName];
+        writeField(field, value, writer, options);
+    }
+    if (options.writeUnknownFields) {
+        writeUnknownFields(message, writer);
+    }
+}
+exports.writeMessage = writeMessage;
+function writeField(field, value, writer, options) {
+    (0, assert_js_1.assert)(value !== undefined);
+    const repeated = field.repeated;
+    switch (field.kind) {
+        case "scalar":
+        case "enum":
+            let scalarType = field.kind == "enum" ? protobuf_1.ScalarType.INT32 : field.T;
+            if (repeated) {
+                (0, assert_js_1.assert)(Array.isArray(value));
+                if (field.packed) {
+                    writePacked(writer, scalarType, field.no, value);
+                }
+                else {
+                    for (const item of value) {
+                        writeScalar(writer, scalarType, field.no, item);
+                    }
+                }
+            }
+            else {
+                writeScalar(writer, scalarType, field.no, value);
+            }
+            break;
+        case "message":
+            if (repeated) {
+                (0, assert_js_1.assert)(Array.isArray(value));
+                for (const item of value) {
+                    writeMessageField(writer, options, field, item);
+                }
+            }
+            else {
+                writeMessageField(writer, options, field, value);
+            }
+            break;
+        case "map":
+            (0, assert_js_1.assert)(typeof value == "object" && value != null);
+            for (const [key, val] of Object.entries(value)) {
+                writeMapEntry(writer, options, field, key, val);
+            }
+            break;
+    }
+}
+function writeUnknownFields(message, writer) {
+    const m = message;
+    const c = m[unknown_js_1.unknownFieldsSymbol];
+    if (c) {
+        for (const f of c) {
+            writer.tag(f.no, f.wireType).raw(f.data);
+        }
+    }
+}
+// Value must not be undefined
+function writeMessageField(writer, options, field, value) {
+    const message = (0, field_wrapper_js_1.wrapField)(field.T.fieldWrapper, value);
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (field.delimited)
+        writer
+            .tag(field.no, protobuf_1.WireType.StartGroup)
+            .raw(message.toBinary(options))
+            .tag(field.no, protobuf_1.WireType.EndGroup);
+    else
+        writer
+            .tag(field.no, protobuf_1.WireType.LengthDelimited)
+            .bytes(message.toBinary(options));
+}
+function writeScalar(writer, type, fieldNo, value) {
+    (0, assert_js_1.assert)(value !== undefined);
+    let [wireType, method] = scalarTypeInfo(type);
+    writer.tag(fieldNo, wireType)[method](value);
+}
+function writePacked(writer, type, fieldNo, value) {
+    if (!value.length) {
+        return;
+    }
+    writer.tag(fieldNo, protobuf_1.WireType.LengthDelimited).fork();
+    let [, method] = scalarTypeInfo(type);
+    for (let i = 0; i < value.length; i++) {
+        writer[method](value[i]);
+    }
+    writer.join();
+}
+/**
+ * Get information for writing a scalar value.
+ *
+ * Returns tuple:
+ * [0]: appropriate WireType
+ * [1]: name of the appropriate method of IBinaryWriter
+ * [2]: whether the given value is a default value for proto3 semantics
+ *
+ * If argument `value` is omitted, [2] is always false.
+ */
+// TODO replace call-sites writeScalar() and writePacked(), then remove
+function scalarTypeInfo(type) {
+    let wireType = protobuf_1.WireType.Varint;
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- INT32, UINT32, SINT32 are covered by the defaults
+    switch (type) {
+        case protobuf_1.ScalarType.BYTES:
+        case protobuf_1.ScalarType.STRING:
+            wireType = protobuf_1.WireType.LengthDelimited;
+            break;
+        case protobuf_1.ScalarType.DOUBLE:
+        case protobuf_1.ScalarType.FIXED64:
+        case protobuf_1.ScalarType.SFIXED64:
+            wireType = protobuf_1.WireType.Bit64;
+            break;
+        case protobuf_1.ScalarType.FIXED32:
+        case protobuf_1.ScalarType.SFIXED32:
+        case protobuf_1.ScalarType.FLOAT:
+            wireType = protobuf_1.WireType.Bit32;
+            break;
+    }
+    const method = protobuf_1.ScalarType[type].toLowerCase();
+    return [wireType, method];
+}
+function writeMapEntry(writer, options, field, key, value) {
+    writer.tag(field.no, protobuf_1.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 protobuf_1.ScalarType.INT32:
+        case protobuf_1.ScalarType.FIXED32:
+        case protobuf_1.ScalarType.UINT32:
+        case protobuf_1.ScalarType.SFIXED32:
+        case protobuf_1.ScalarType.SINT32:
+            keyValue = Number.parseInt(key);
+            break;
+        case protobuf_1.ScalarType.BOOL:
+            (0, assert_js_1.assert)(key == "true" || key == "false");
+            keyValue = key == "true";
+            break;
+    }
+    // write key, expecting key field number = 1
+    writeScalar(writer, field.K, 1, keyValue);
+    // write value, expecting value field number = 2
+    switch (field.V.kind) {
+        case "scalar":
+            writeScalar(writer, field.V.T, 2, value);
+            break;
+        case "enum":
+            writeScalar(writer, protobuf_1.ScalarType.INT32, 2, value);
+            break;
+        case "message":
+            (0, assert_js_1.assert)(value !== undefined);
+            writer.tag(2, protobuf_1.WireType.LengthDelimited).bytes(value.toBinary(options));
+            break;
+    }
+    writer.join();
+}
+exports.writeMapEntry = writeMapEntry;

package/dist/editions.js

@@ -0,0 +1,26 @@
+"use strict";
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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.getNonEditionRuntime = void 0;
+/**
+ * For syntax "editions", this function raises and error.
+ */
+function getNonEditionRuntime(schema, file) {
+    if (file.syntax === "editions") {
+        throw new Error(`${file.proto.name ?? ""}: syntax "editions" is not supported`);
+    }
+    return schema.runtime[file.syntax];
+}
+exports.getNonEditionRuntime = getNonEditionRuntime;

package/dist/field-wrapper.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapField = void 0;
+/**
+ * Wrap a primitive message field value in its corresponding wrapper
+ * message. This function is idempotent.
+ */
+function wrapField(fieldWrapper, value) {
+    if (!fieldWrapper) {
+        return value;
+    }
+    return fieldWrapper.wrapField(value);
+}
+exports.wrapField = wrapField;