protobufjs 7.4.0 → 8.0.0-experimental

package/index.d.ts

@@ -179,9 +179,21 @@ export class Enum extends ReflectionObject {
     /** Values options, if any */
     public valuesOptions?: { [k: string]: { [k: string]: any } };
 
+    /** Resolved values features, if any */
+    public _valuesFeatures?: { [k: string]: { [k: string]: any } };
+
+    /** Unresolved values features, if any */
+    public _valuesProtoFeatures?: { [k: string]: { [k: string]: any } };
+
     /** Reserved ranges, if any. */
     public reserved: (number[]|string)[];
 
+    /**
+     * Resolves value features
+     * @returns `this`
+     */
+    public resolve(): Enum;
+
     /**
      * Constructs an enum from an enum descriptor.
      * @param name Enum name
@@ -267,9 +279,24 @@ export class Field extends FieldBase {
      */
     public static fromJSON(name: string, json: IField): Field;
 
-    /** Determines whether this field is packed. Only relevant when repeated and working with proto2. */
+    /** Determines whether this field is required. */
+    public readonly required: boolean;
+
+    /** Determines whether this field is not required. */
+    public readonly optional: boolean;
+
+    /**
+     * Determines whether this field uses tag-delimited encoding.  In proto2 this
+     * corresponded to group syntax.
+     */
+    public readonly delimited: boolean;
+
+    /** Determines whether this field is packed. Only relevant when repeated. */
     public readonly packed: boolean;
 
+    /** Determines whether this field tracks presence. */
+    public readonly hasPresence: boolean;
+
     /**
      * Field decorator (TypeScript).
      * @param fieldId Field id
@@ -314,12 +341,6 @@ export class FieldBase extends ReflectionObject {
     /** Extended type if different from parent. */
     public extend?: string;
 
-    /** Whether this field is required. */
-    public required: boolean;
-
-    /** Whether this field is optional. */
-    public optional: boolean;
-
     /** Whether this field is repeated. */
     public repeated: boolean;
 
@@ -369,6 +390,14 @@ export class FieldBase extends ReflectionObject {
      * @throws {Error} If any reference cannot be resolved
      */
     public resolve(): Field;
+
+    /**
+     * Infers field features from legacy syntax that may have been specified differently.
+     * in older editions.
+     * @param edition The edition this proto is on, or undefined if pre-editions
+     * @returns The feature values to override
+     */
+    public _inferLegacyProtoFeatures(edition: (string|undefined)): object;
 }
 
 /** Field descriptor. */
@@ -877,6 +906,12 @@ export abstract class ReflectionObject {
     /** Unique name within its namespace. */
     public name: string;
 
+    /** Resolved Features. */
+    public _features: any;
+
+    /** Unresolved Features. */
+    public _protoFeatures: any;
+
     /** Parent namespace. */
     public parent: (Namespace|null);
 
@@ -919,6 +954,17 @@ export abstract class ReflectionObject {
      */
     public resolve(): ReflectionObject;
 
+    /** Resolves child features from parent features */
+    public _resolveFeatures(): void;
+
+    /**
+     * Infers features from legacy syntax that may have been specified differently.
+     * in older editions.
+     * @param edition The edition this proto is on, or undefined if pre-editions
+     * @returns The feature values to override
+     */
+    public _inferLegacyProtoFeatures(edition: (string|undefined)): object;
+
     /**
      * Gets an option value.
      * @param name Option name
@@ -1010,6 +1056,13 @@ export class OneOf extends ReflectionObject {
      */
     public remove(field: Field): OneOf;
 
+    /**
+     * Determines whether this field corresponds to a synthetic oneof created for
+     * a proto3 optional field.  No behavioral logic should depend on this, but it
+     * can be relevant for reflection.
+     */
+    public readonly isProto3Optional: boolean;
+
     /**
      * OneOf decorator (TypeScript).
      * @param fieldNames Field names
@@ -1255,7 +1308,7 @@ export class Root extends NamespaceBase {
 
     /**
      * Loads a namespace descriptor into a root namespace.
-     * @param json Nameespace descriptor
+     * @param json Namespace descriptor
      * @param [root] Root namespace, defaults to create a new one if omitted
      * @returns Root namespace
      */
@@ -2194,9 +2247,10 @@ export namespace util {
      * @param dst Destination object
      * @param path dot '.' delimited path of the property to set
      * @param value the value to set
+     * @param overWrite whether or not to concatenate the values into an array or overwrite; defaults to false.
      * @returns Destination object
      */
-    function setProperty(dst: { [k: string]: any }, path: string, value: object): { [k: string]: any };
+    function setProperty(dst: { [k: string]: any }, path: string, value: object, overWrite: boolean): { [k: string]: any };
 
     /** Decorator root (TypeScript). */
     let decorateRoot: Root;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protobufjs",
-  "version": "7.4.0",
+  "version": "8.0.0-experimental",
   "versionScheme": "~",
   "description": "Protocol Buffers for JavaScript (& TypeScript).",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",

package/src/decoder.js

@@ -16,16 +16,14 @@ function missing(field) {
  */
 function decoder(mtype) {
     /* eslint-disable no-unexpected-multiline */
-    var gen = util.codegen(["r", "l"], mtype.name + "$decode")
+    var gen = util.codegen(["r", "l", "e"], mtype.name + "$decode")
     ("if(!(r instanceof Reader))")
         ("r=Reader.create(r)")
     ("var c=l===undefined?r.len:r.pos+l,m=new this.ctor" + (mtype.fieldsArray.filter(function(field) { return field.map; }).length ? ",k,value" : ""))
     ("while(r.pos<c){")
-        ("var t=r.uint32()");
-    if (mtype.group) gen
-        ("if((t&7)===4)")
-            ("break");
-    gen
+        ("var t=r.uint32()")
+        ("if(t===e)")
+            ("break")
         ("switch(t>>>3){");
 
     var i = 0;
@@ -91,15 +89,15 @@ function decoder(mtype) {
                 ("}else");
 
             // Non-packed
-            if (types.basic[type] === undefined) gen(field.resolvedType.group
-                    ? "%s.push(types[%i].decode(r))"
+            if (types.basic[type] === undefined) gen(field.delimited
+                    ? "%s.push(types[%i].decode(r,undefined,((t&~7)|4)))"
                     : "%s.push(types[%i].decode(r,r.uint32()))", ref, i);
             else gen
                     ("%s.push(r.%s())", ref, type);
 
         // Non-repeated
-        } else if (types.basic[type] === undefined) gen(field.resolvedType.group
-                ? "%s=types[%i].decode(r)"
+        } else if (types.basic[type] === undefined) gen(field.delimited
+                ? "%s=types[%i].decode(r,undefined,((t&~7)|4))"
                 : "%s=types[%i].decode(r,r.uint32())", ref, i);
         else gen
                 ("%s=r.%s()", ref, type);

package/src/encoder.js

@@ -15,7 +15,7 @@ var Enum     = require("./enum"),
  * @ignore
  */
 function genTypePartial(gen, field, fieldIndex, ref) {
-    return field.resolvedType.group
+    return field.delimited
         ? gen("types[%i].encode(%s,w.uint32(%i)).uint32(%i)", fieldIndex, ref, (field.id << 3 | 3) >>> 0, (field.id << 3 | 4) >>> 0)
         : gen("types[%i].encode(%s,w.uint32(%i).fork()).ldelim()", fieldIndex, ref, (field.id << 3 | 2) >>> 0);
 }

package/src/enum.js

@@ -56,6 +56,18 @@ function Enum(name, values, options, comment, comments, valuesOptions) {
      */
     this.valuesOptions = valuesOptions;
 
+    /**
+     * Resolved values features, if any
+     * @type {Object<string, Object<string, *>>|undefined}
+     */
+    this._valuesFeatures = {};
+
+    /**
+     * Unresolved values features, if any
+     * @type {Object<string, Object<string, *>>|undefined}
+     */
+    this._valuesProtoFeatures = {};
+
     /**
      * Reserved ranges, if any.
      * @type {Array.<number[]|string>}
@@ -72,6 +84,22 @@ function Enum(name, values, options, comment, comments, valuesOptions) {
                 this.valuesById[ this.values[keys[i]] = values[keys[i]] ] = keys[i];
 }
 
+/**
+ * Resolves value features
+ * @returns {Enum} `this`
+ */
+Enum.prototype.resolve = function resolve() {
+    ReflectionObject.prototype.resolve.call(this);
+
+    for (var key of Object.keys(this._valuesProtoFeatures)) {
+        var parentFeaturesCopy = Object.assign({}, this._features);
+        this._valuesFeatures[key] = Object.assign(parentFeaturesCopy, this._valuesProtoFeatures[key] || {});
+    }
+
+    return this;
+};
+
+
 /**
  * Enum descriptor.
  * @interface IEnum
@@ -148,6 +176,21 @@ Enum.prototype.add = function add(name, id, comment, options) {
         if (this.valuesOptions === undefined)
             this.valuesOptions = {};
         this.valuesOptions[name] = options || null;
+
+        for (var key of Object.keys(this.valuesOptions)) {
+            var features = Array.isArray(this.valuesOptions[key]) ? this.valuesOptions[key].find(x => {return Object.prototype.hasOwnProperty.call(x, "features");}) : this.valuesOptions[key] === "features";
+            if (features) {
+                this._valuesProtoFeatures[key] = features.features;
+            } else {
+                this._valuesProtoFeatures[key] = {};
+            }
+        }
+    }
+
+    for (var enumValue of Object.keys(this.values)) {
+        if (!this._valuesProtoFeatures[enumValue]) {
+            this._valuesProtoFeatures[enumValue] = {};
+        }
     }
 
     this.comments[name] = comment || null;

package/src/field.js

@@ -105,18 +105,6 @@ function Field(name, id, type, rule, extend, options, comment) {
      */
     this.extend = extend || undefined; // toJSON
 
-    /**
-     * Whether this field is required.
-     * @type {boolean}
-     */
-    this.required = rule === "required";
-
-    /**
-     * Whether this field is optional.
-     * @type {boolean}
-     */
-    this.optional = !this.required;
-
     /**
      * Whether this field is repeated.
      * @type {boolean}
@@ -183,13 +171,6 @@ function Field(name, id, type, rule, extend, options, comment) {
      */
     this.declaringField = null;
 
-    /**
-     * Internally remembers whether this field is packed.
-     * @type {boolean|null}
-     * @private
-     */
-    this._packed = null;
-
     /**
      * Comment for this field.
      * @type {string|null}
@@ -198,17 +179,69 @@ function Field(name, id, type, rule, extend, options, comment) {
 }
 
 /**
- * Determines whether this field is packed. Only relevant when repeated and working with proto2.
+ * Determines whether this field is required.
+ * @name Field#required
+ * @type {boolean}
+ * @readonly
+ */
+Object.defineProperty(Field.prototype, "required", {
+    get: function() {
+        return this._features.field_presence === "LEGACY_REQUIRED";
+    }
+});
+
+/**
+ * Determines whether this field is not required.
+ * @name Field#optional
+ * @type {boolean}
+ * @readonly
+ */
+Object.defineProperty(Field.prototype, "optional", {
+    get: function() {
+        return !this.required;
+    }
+});
+
+/**
+ * Determines whether this field uses tag-delimited encoding.  In proto2 this
+ * corresponded to group syntax.
+ * @name Field#delimited
+ * @type {boolean}
+ * @readonly
+ */
+Object.defineProperty(Field.prototype, "delimited", {
+    get: function() {
+        return this.resolvedType instanceof Type &&
+            this._features.message_encoding === "DELIMITED";
+    }
+});
+
+/**
+ * Determines whether this field is packed. Only relevant when repeated.
  * @name Field#packed
  * @type {boolean}
  * @readonly
  */
 Object.defineProperty(Field.prototype, "packed", {
     get: function() {
-        // defaults to packed=true if not explicity set to false
-        if (this._packed === null)
-            this._packed = this.getOption("packed") !== false;
-        return this._packed;
+        return this._features.repeated_field_encoding === "PACKED";
+    }
+});
+
+/**
+ * Determines whether this field tracks presence.
+ * @name Field#hasPresence
+ * @type {boolean}
+ * @readonly
+ */
+Object.defineProperty(Field.prototype, "hasPresence", {
+    get: function() {
+        if (this.repeated || this.map) {
+            return false;
+        }
+        return this.partOf || // oneofs
+            this.declaringField || this.extensionField || // extensions
+            this._features.field_presence !== "IMPLICIT";
     }
 });
 
@@ -216,8 +249,6 @@ Object.defineProperty(Field.prototype, "packed", {
  * @override
  */
 Field.prototype.setOption = function setOption(name, value, ifNotSet) {
-    if (name === "packed") // clear cached before setting
-        this._packed = null;
     return ReflectionObject.prototype.setOption.call(this, name, value, ifNotSet);
 };
 
@@ -284,7 +315,7 @@ Field.prototype.resolve = function resolve() {
 
     // remove unnecessary options
     if (this.options) {
-        if (this.options.packed === true || this.options.packed !== undefined && this.resolvedType && !(this.resolvedType instanceof Enum))
+        if (this.options.packed !== undefined && this.resolvedType && !(this.resolvedType instanceof Enum))
             delete this.options.packed;
         if (!Object.keys(this.options).length)
             this.options = undefined;
@@ -322,6 +353,30 @@ Field.prototype.resolve = function resolve() {
     return ReflectionObject.prototype.resolve.call(this);
 };
 
+/**
+ * Infers field features from legacy syntax that may have been specified differently.
+ * in older editions.
+ * @param {string|undefined} edition The edition this proto is on, or undefined if pre-editions
+ * @returns {object} The feature values to override
+ */
+Field.prototype._inferLegacyProtoFeatures = function _inferLegacyProtoFeatures(edition) {
+    if (edition) return {};
+
+    var features = {};
+    if (this.rule === "required") {
+        features.field_presence = "LEGACY_REQUIRED";
+    }
+    if (this.resolvedType instanceof Type && this.resolvedType.group) {
+        features.message_encoding = "DELIMITED";
+    }
+    if (this.getOption("packed") === true) {
+        features.repeated_field_encoding = "PACKED";
+    } else if (this.getOption("packed") === false) {
+        features.repeated_field_encoding = "EXPANDED";
+    }
+    return features;
+};
+
 /**
  * Decorator function as returned by {@link Field.d} and {@link MapField.d} (TypeScript).
  * @typedef FieldDecorator

package/src/namespace.js

@@ -302,12 +302,13 @@ Namespace.prototype.define = function define(path, json) {
  */
 Namespace.prototype.resolveAll = function resolveAll() {
     var nested = this.nestedArray, i = 0;
+    this.resolve();
     while (i < nested.length)
         if (nested[i] instanceof Namespace)
             nested[i++].resolveAll();
         else
             nested[i++].resolve();
-    return this.resolve();
+    return this;
 };
 
 /**

package/src/object.js

@@ -3,10 +3,17 @@ module.exports = ReflectionObject;
 
 ReflectionObject.className = "ReflectionObject";
 
+const OneOf = require("./oneof");
 var util = require("./util");
 
 var Root; // cyclic
 
+/* eslint-disable no-warning-comments */
+// TODO: Replace with embedded proto.
+var editions2023Defaults = {enum_type: "OPEN", field_presence: "EXPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY"};
+var proto2Defaults = {enum_type: "CLOSED", field_presence: "EXPLICIT", json_format: "LEGACY_BEST_EFFORT", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "EXPANDED", utf8_validation: "NONE"};
+var proto3Defaults = {enum_type: "OPEN", field_presence: "IMPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY"};
+
 /**
  * Constructs a new reflection object instance.
  * @classdesc Base class of all reflection objects.
@@ -41,6 +48,16 @@ function ReflectionObject(name, options) {
      */
     this.name = name;
 
+    /**
+     * Resolved Features.
+     */
+    this._features = {};
+
+    /**
+     * Unresolved Features.
+     */
+    this._protoFeatures = null;
+
     /**
      * Parent namespace.
      * @type {Namespace|null}
@@ -146,11 +163,65 @@ ReflectionObject.prototype.onRemove = function onRemove(parent) {
 ReflectionObject.prototype.resolve = function resolve() {
     if (this.resolved)
         return this;
-    if (this.root instanceof Root)
-        this.resolved = true; // only if part of a root
+    if (this instanceof Root || this.parent && this.parent.resolved) {
+        this._resolveFeatures();
+        this.resolved = true;
+    }
     return this;
 };
 
+/**
+ * Resolves child features from parent features
+ * @returns {undefined}
+ */
+ReflectionObject.prototype._resolveFeatures = function _resolveFeatures() {
+    var defaults = {};
+
+    var edition = this.root.getOption("edition");
+    if (this instanceof Root) {
+        if (this.root.getOption("syntax") === "proto3") {
+            defaults = Object.assign({}, proto3Defaults);
+        } else if (edition === "2023") {
+            defaults = Object.assign({}, editions2023Defaults);
+        } else {
+            defaults = Object.assign({}, proto2Defaults);
+        }
+    }
+
+    var protoFeatures = Object.assign(Object.assign({}, this._protoFeatures), this._inferLegacyProtoFeatures(edition));
+
+    if (this instanceof Root) {
+        this._features = Object.assign(defaults, protoFeatures || {});
+    // fields in Oneofs aren't actually children of them, so we have to
+    // special-case it
+    } else if (this.partOf instanceof OneOf) {
+        var lexicalParentFeaturesCopy = Object.assign({}, this.partOf._features);
+        this._features = Object.assign(lexicalParentFeaturesCopy, protoFeatures || {});
+    } else if (this.declaringField) {
+        // Skip feature resolution of sister fields.
+    } else if (this.parent) {
+        var parentFeaturesCopy = Object.assign({}, this.parent._features);
+        this._features = Object.assign(parentFeaturesCopy, protoFeatures || {});
+    } else {
+        this._features = Object.assign({}, protoFeatures);
+    }
+    if (this.extensionField) {
+        // Sister fields should have the same features as their extensions.
+        this.extensionField._features = this._features;
+    }
+};
+
+/**
+ * Infers features from legacy syntax that may have been specified differently.
+ * in older editions.
+ * @param {string|undefined} edition The edition this proto is on, or undefined if pre-editions
+ * @returns {object} The feature values to override
+ * @abstract
+ */
+ReflectionObject.prototype._inferLegacyProtoFeatures = function _inferLegacyProtoFeatures(/*edition*/) {
+    return {};
+};
+
 /**
  * Gets an option value.
  * @param {string} name Option name
@@ -186,6 +257,7 @@ ReflectionObject.prototype.setParsedOption = function setParsedOption(name, valu
     if (!this.parsedOptions) {
         this.parsedOptions = [];
     }
+    var isFeature = /^features$/.test(name);
     var parsedOptions = this.parsedOptions;
     if (propName) {
         // If setting a sub property of an option then try to merge it
@@ -195,10 +267,11 @@ ReflectionObject.prototype.setParsedOption = function setParsedOption(name, valu
         });
         if (opt) {
             // If we found an existing option - just merge the property value
+            // (If it's a feature, will just write over)
             var newValue = opt[name];
             util.setProperty(newValue, propName, value);
         } else {
-            // otherwise, create a new option, set it's property and add it to the list
+            // otherwise, create a new option, set its property and add it to the list
             opt = {};
             opt[name] = util.setProperty({}, propName, value);
             parsedOptions.push(opt);
@@ -209,6 +282,13 @@ ReflectionObject.prototype.setParsedOption = function setParsedOption(name, valu
         newOpt[name] = value;
         parsedOptions.push(newOpt);
     }
+
+
+    if (isFeature) {
+        var features = parsedOptions.find(x => {return Object.prototype.hasOwnProperty.call(x, "features");});
+        this._protoFeatures = features.features || {};
+    }
+
     return this;
 };
 

package/src/oneof.js

@@ -171,6 +171,25 @@ OneOf.prototype.onRemove = function onRemove(parent) {
     ReflectionObject.prototype.onRemove.call(this, parent);
 };
 
+/**
+ * Determines whether this field corresponds to a synthetic oneof created for
+ * a proto3 optional field.  No behavioral logic should depend on this, but it
+ * can be relevant for reflection.
+ * @name OneOf#isProto3Optional
+ * @type {boolean}
+ * @readonly
+ */
+Object.defineProperty(OneOf.prototype, "isProto3Optional", {
+    get: function() {
+        if (this.fieldsArray == null || this.fieldsArray.length !== 1) {
+            return false;
+        }
+
+        var field = this.fieldsArray[0];
+        return field.options != null && field.options["proto3_optional"] === true;
+    }
+});
+
 /**
  * Decorator function as returned by {@link OneOf.d} (TypeScript).
  * @typedef OneOfDecorator