@aptre/protobuf-es-lite 0.1.0

package/dist/field.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeFieldInfos = exports.InternalOneofInfo = exports.localOneofName = exports.safeObjectProperty = exports.localFieldName = exports.fieldJsonName = exports.isFieldSet = exports.protoCamelCase = exports.newFieldList = exports.FieldList = void 0;
+const protobuf_1 = require("@bufbuild/protobuf");
+const assert_js_1 = require("./assert.js");
+const scalar_js_1 = require("./scalar.js");
+/**
+ * Provides convenient access to field information of a message type.
+ */
+class FieldList {
+    constructor(fields, normalizer) {
+        this._fields = fields;
+        this._normalizer = normalizer;
+    }
+    /**
+     * Find field information by field name or json_name.
+     */
+    findJsonName(jsonName) {
+        if (!this.jsonNames) {
+            const t = {};
+            for (const f of this.list()) {
+                t[f.jsonName] = t[f.name] = f;
+            }
+            this.jsonNames = t;
+        }
+        return this.jsonNames[jsonName];
+    }
+    /**
+     * Find field information by proto field number.
+     */
+    find(fieldNo) {
+        if (!this.numbers) {
+            const t = {};
+            for (const f of this.list()) {
+                t[f.no] = f;
+            }
+            this.numbers = t;
+        }
+        return this.numbers[fieldNo];
+    }
+    /**
+     * Return field information in the order they appear in the source.
+     */
+    list() {
+        if (!this.all) {
+            this.all = this._normalizer(this._fields);
+        }
+        return this.all;
+    }
+    /**
+     * Return field information ordered by field number ascending.
+     */
+    byNumber() {
+        if (!this.numbersAsc) {
+            this.numbersAsc = this.list()
+                .concat()
+                .sort((a, b) => a.no - b.no);
+        }
+        return this.numbersAsc;
+    }
+    /**
+     * In order of appearance in the source, list fields and
+     * oneof groups.
+     */
+    byMember() {
+        if (!this.members) {
+            this.members = [];
+            const a = this.members;
+            let o;
+            for (const f of this.list()) {
+                if (f.oneof) {
+                    if (f.oneof !== o) {
+                        o = f.oneof;
+                        a.push(o);
+                    }
+                }
+                else {
+                    a.push(f);
+                }
+            }
+        }
+        return this.members;
+    }
+}
+exports.FieldList = FieldList;
+// newFieldList constructs a new field list.
+function newFieldList(fields, packedByDefault) {
+    return new FieldList(fields, (source) => normalizeFieldInfos(source, packedByDefault));
+}
+exports.newFieldList = newFieldList;
+/*
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
+function protoCamelCase(snakeCase) {
+    let capNext = false;
+    const b = [];
+    for (let i = 0; i < snakeCase.length; i++) {
+        let c = snakeCase.charAt(i);
+        switch (c) {
+            case "_":
+                capNext = true;
+                break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9":
+                b.push(c);
+                capNext = false;
+                break;
+            default:
+                if (capNext) {
+                    capNext = false;
+                    c = c.toUpperCase();
+                }
+                b.push(c);
+                break;
+        }
+    }
+    return b.join("");
+}
+exports.protoCamelCase = protoCamelCase;
+/**
+ * Returns true if the field is set.
+ */
+function isFieldSet(field, target) {
+    const localName = field.localName;
+    if (field.repeated) {
+        return target[localName].length > 0;
+    }
+    if (field.oneof) {
+        return target[field.oneof.localName].case === localName; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
+    }
+    switch (field.kind) {
+        case "enum":
+        case "scalar":
+            if (field.opt || field.req) {
+                // explicit presence
+                return target[localName] !== undefined;
+            }
+            // implicit presence
+            if (field.kind == "enum") {
+                return target[localName] !== field.T.values[0].no;
+            }
+            return !(0, scalar_js_1.isScalarZeroValue)(field.T, target[localName]);
+        case "message":
+            return target[localName] !== undefined;
+        case "map":
+            return Object.keys(target[localName]).length > 0; // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    }
+}
+exports.isFieldSet = isFieldSet;
+/**
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
+ */
+exports.fieldJsonName = protoCamelCase;
+/**
+ * Returns the name of a field in generated code.
+ */
+function localFieldName(protoName, inOneof) {
+    const name = protoCamelCase(protoName);
+    if (inOneof) {
+        // oneof member names are not properties, but values of the `case` property.
+        return name;
+    }
+    return (0, exports.safeObjectProperty)(safeMessageProperty(name));
+}
+exports.localFieldName = localFieldName;
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+const reservedObjectProperties = new Set([
+    // names reserved by JavaScript
+    "constructor",
+    "toString",
+    "toJSON",
+    "valueOf",
+]);
+/*
+ * Names that cannot be used for object properties because they are reserved
+ * by the runtime.
+ */
+const reservedMessageProperties = new Set([
+    // names reserved by the runtime
+    "getType",
+    "clone",
+    "equals",
+    "fromBinary",
+    "fromJson",
+    "fromJsonString",
+    "toBinary",
+    "toJson",
+    "toJsonString",
+    // names reserved by the runtime for the future
+    "toObject",
+]);
+const fallback = (name) => `${name}$`;
+/**
+ * Will wrap names that are Object prototype properties or names reserved
+ * for `Message`s.
+ */
+const safeMessageProperty = (name) => {
+    if (reservedMessageProperties.has(name)) {
+        return fallback(name);
+    }
+    return name;
+};
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+const safeObjectProperty = (name) => {
+    if (reservedObjectProperties.has(name)) {
+        return fallback(name);
+    }
+    return name;
+};
+exports.safeObjectProperty = safeObjectProperty;
+/**
+ * Returns the name of a oneof group in generated code.
+ */
+function localOneofName(protoName) {
+    return localFieldName(protoName, false);
+}
+exports.localOneofName = localOneofName;
+// InternarlOneofInfo implements OneofInfo.
+class InternalOneofInfo {
+    constructor(name) {
+        this.kind = "oneof";
+        this.repeated = false;
+        this.packed = false;
+        this.opt = false;
+        this.req = false;
+        this.default = undefined;
+        this.fields = [];
+        this.name = name;
+        this.localName = localOneofName(name);
+    }
+    addField(field) {
+        (0, assert_js_1.assert)(field.oneof === this, `field ${field.name} not one of ${this.name}`);
+        this.fields.push(field);
+    }
+    findField(localName) {
+        if (!this._lookup) {
+            this._lookup = Object.create(null);
+            for (let i = 0; i < this.fields.length; i++) {
+                this._lookup[this.fields[i].localName] = this.fields[i];
+            }
+        }
+        return this._lookup[localName];
+    }
+}
+exports.InternalOneofInfo = InternalOneofInfo;
+/**
+ * Convert a collection of field info to an array of normalized FieldInfo.
+ *
+ * The argument `packedByDefault` specifies whether fields that do not specify
+ * `packed` should be packed (proto3) or unpacked (proto2).
+ */
+function normalizeFieldInfos(fieldInfos, packedByDefault) {
+    const r = [];
+    let o;
+    for (const field of typeof fieldInfos == "function"
+        ? fieldInfos()
+        : fieldInfos) {
+        const f = field;
+        f.localName = localFieldName(field.name, field.oneof !== undefined);
+        f.jsonName = field.jsonName ?? (0, exports.fieldJsonName)(field.name);
+        f.repeated = field.repeated ?? false;
+        if (field.kind == "scalar") {
+            f.L = field.L ?? protobuf_1.LongType.BIGINT;
+        }
+        f.delimited = field.delimited ?? false;
+        f.req = field.req ?? false;
+        f.opt = field.opt ?? false;
+        if (field.packed === undefined) {
+            if (packedByDefault) {
+                f.packed =
+                    field.kind == "enum" ||
+                        (field.kind == "scalar" &&
+                            field.T != protobuf_1.ScalarType.BYTES &&
+                            field.T != protobuf_1.ScalarType.STRING);
+            }
+            else {
+                f.packed = false;
+            }
+        }
+        // We do not surface options at this time
+        // f.options = field.options ?? emptyReadonlyObject;
+        if (field.oneof !== undefined) {
+            const ooname = typeof field.oneof == "string" ? field.oneof : field.oneof.name;
+            if (!o || o.name != ooname) {
+                o = new InternalOneofInfo(ooname);
+            }
+            f.oneof = o;
+            o.addField(f);
+        }
+        r.push(f);
+    }
+    return r;
+}
+exports.normalizeFieldInfos = normalizeFieldInfos;

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScalarZeroValue = exports.scalarZeroValue = exports.scalarEquals = exports.localOneofName = exports.localFieldName = exports.fieldJsonName = exports.FieldList = exports.newFieldList = exports.createMessageType = exports.compareMessages = void 0;
+var message_js_1 = require("./message.js");
+Object.defineProperty(exports, "compareMessages", { enumerable: true, get: function () { return message_js_1.compareMessages; } });
+Object.defineProperty(exports, "createMessageType", { enumerable: true, get: function () { return message_js_1.createMessageType; } });
+var field_js_1 = require("./field.js");
+Object.defineProperty(exports, "newFieldList", { enumerable: true, get: function () { return field_js_1.newFieldList; } });
+Object.defineProperty(exports, "FieldList", { enumerable: true, get: function () { return field_js_1.FieldList; } });
+Object.defineProperty(exports, "fieldJsonName", { enumerable: true, get: function () { return field_js_1.fieldJsonName; } });
+Object.defineProperty(exports, "localFieldName", { enumerable: true, get: function () { return field_js_1.localFieldName; } });
+Object.defineProperty(exports, "localOneofName", { enumerable: true, get: function () { return field_js_1.localOneofName; } });
+var scalar_js_1 = require("./scalar.js");
+Object.defineProperty(exports, "scalarEquals", { enumerable: true, get: function () { return scalar_js_1.scalarEquals; } });
+Object.defineProperty(exports, "scalarZeroValue", { enumerable: true, get: function () { return scalar_js_1.scalarZeroValue; } });
+Object.defineProperty(exports, "isScalarZeroValue", { enumerable: true, get: function () { return scalar_js_1.isScalarZeroValue; } });

package/dist/is-message.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCompleteMessage = void 0;
+/**
+ * Check whether the given partial has all fields present recursively.
+ */
+function isCompleteMessage(arg, fields) {
+    if (arg == null || typeof arg !== "object") {
+        return false;
+    }
+    return fields.every((fi) => {
+        // eslint-disable-line @typescript-eslint/no-explicit-any -- `any` is the best choice for dynamic access
+        const value = arg[fi.localName];
+        if (fi.repeated) {
+            return (Array.isArray(value) && value.every((item) => isCompleteField(item, fi)));
+        }
+        else {
+            return isCompleteField(value, fi);
+        }
+    });
+}
+exports.isCompleteMessage = isCompleteMessage;
+/**
+ * Check whether the given partial field has a full value present recursively.
+ */
+function isCompleteField(value, field) {
+    if (field.oneof) {
+        // For oneof fields, only one field should be set
+        const oneofFields = field.oneof.fields;
+        const setField = oneofFields.find((f) => value[f.localName] !== undefined);
+        return setField === field;
+    }
+    if (value === undefined) {
+        return false;
+    }
+    const fieldKind = field.kind;
+    switch (fieldKind) {
+        case "scalar":
+            return true;
+        case "message":
+            return isCompleteMessage(value, field.T.fields.list());
+        case "enum":
+            return typeof value === "number";
+        case "map":
+            return Object.values(value).every((val) => {
+                const valueKind = field.V.kind;
+                switch (valueKind) {
+                    case "scalar":
+                        return true;
+                    case "enum":
+                        return typeof val === "number";
+                    case "message":
+                        return isCompleteMessage(val, field.V.T.fields.list());
+                    default:
+                        return valueKind;
+                }
+            });
+        default:
+            return fieldKind;
+    }
+}