protobufjs 8.2.0 → 8.3.0

package/ext/descriptor.js

@@ -221,9 +221,14 @@ var unnamedMessageIndex = 0;
  * @param {IDescriptorProto|Reader|Uint8Array} descriptor Descriptor
  * @param {string} [edition="proto2"] The syntax or edition to use
  * @param {boolean} [nested=false] Whether or not this is a nested object
+ * @param {number} [depth] Current nesting depth, defaults to `0`
  * @returns {Type} Type instance
  */
-Type.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {
+Type.fromDescriptor = function fromDescriptor(descriptor, edition, nested, depth) {
+    if (depth === undefined)
+        depth = 0;
+    if (depth > $protobuf.util.nestingLimit)
+        throw Error("max depth exceeded");
     descriptor = decodeDescriptor(descriptor, exports.DescriptorProto);
 
     var type = new Type(descriptor.name.length ? descriptor.name : "Type" + unnamedMessageIndex++, fromDescriptorOptions(descriptor.options, exports.MessageOptions)),
@@ -255,7 +260,7 @@ Type.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {
         for (i = 0; i < descriptor.nestedType.length; ++i) {
             if (descriptor.nestedType[i].options && descriptor.nestedType[i].options.mapEntry)
                 continue;
-            type.add(Type.fromDescriptor(descriptor.nestedType[i], edition, true));
+            type.add(Type.fromDescriptor(descriptor.nestedType[i], edition, true, depth + 1));
         }
     /* Nested enums */ if (descriptor.enumType)
         for (i = 0; i < descriptor.enumType.length; ++i)
@@ -604,6 +609,16 @@ Field.prototype.toDescriptor = function toDescriptor(edition) {
  * @property {IEnumValueOptions} [options] Enum value options
  */
 
+/**
+ * Properties of an EnumValueOptions message.
+ * @interface IEnumValueOptions
+ * @property {boolean} [deprecated]
+ * @property {IFeatureSet} [features]
+ * @property {boolean} [debugRedact]
+ * @property {*} [featureSupport]
+ * @property {Array.<*>} [uninterpretedOption]
+ */
+
 /**
  * Properties of an EnumOptions message.
  * @interface IEnumOptions
@@ -611,6 +626,19 @@ Field.prototype.toDescriptor = function toDescriptor(edition) {
  * @property {boolean} [deprecated]
  */
 
+/**
+ * Properties of a FeatureSet message.
+ * @interface IFeatureSet
+ * @property {number} [fieldPresence]
+ * @property {number} [enumType]
+ * @property {number} [repeatedFieldEncoding]
+ * @property {number} [utf8Validation]
+ * @property {number} [messageEncoding]
+ * @property {number} [jsonFormat]
+ * @property {number} [enforceNamingStyle]
+ * @property {number} [defaultSymbolVisibility]
+ */
+
 var unnamedEnumIndex = 0;
 
 /**
@@ -687,6 +715,13 @@ Enum.prototype.toDescriptor = function toDescriptor() {
  * @property {IOneofOptions} [options] Oneof options
  */
 
+/**
+ * Properties of a OneofOptions message.
+ * @interface IOneofOptions
+ * @property {IFeatureSet} [features]
+ * @property {Array.<*>} [uninterpretedOption]
+ */
+
 var unnamedOneofIndex = 0;
 
 /**
@@ -1051,186 +1086,181 @@ function editionToDescriptor(edition, fileDescriptor) {
 /**
  * Reflected file descriptor set.
  * @name FileDescriptorSet
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected file descriptor proto.
  * @name FileDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected descriptor proto.
  * @name DescriptorProto
- * @type {Type}
- * @property {Type} ExtensionRange
- * @property {Type} ReservedRange
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     ExtensionRange: $protobuf.Type,
  *     ReservedRange: $protobuf.Type
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected field descriptor proto.
  * @name FieldDescriptorProto
- * @type {Type}
- * @property {Enum} Label
- * @property {Enum} Type
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     Label: $protobuf.Enum,
  *     Type: $protobuf.Enum
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected oneof descriptor proto.
  * @name OneofDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected enum descriptor proto.
  * @name EnumDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected service descriptor proto.
  * @name ServiceDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected enum value descriptor proto.
  * @name EnumValueDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected method descriptor proto.
  * @name MethodDescriptorProto
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected file options.
  * @name FileOptions
- * @type {Type}
- * @property {Enum} OptimizeMode
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     OptimizeMode: $protobuf.Enum
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected message options.
  * @name MessageOptions
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected field options.
  * @name FieldOptions
- * @type {Type}
- * @property {Enum} CType
- * @property {Enum} JSType
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     CType: $protobuf.Enum,
  *     JSType: $protobuf.Enum
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected oneof options.
  * @name OneofOptions
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected enum options.
  * @name EnumOptions
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected enum value options.
  * @name EnumValueOptions
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected service options.
  * @name ServiceOptions
- * @type {Type}
+ * @type {$protobuf.Type}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected method options.
  * @name MethodOptions
- * @type {Type}
+ * @type {$protobuf.Type}
+ * @const
+ */
+
+/**
+ * Reflected feature set.
+ * @name FeatureSet
+ * @type {$protobuf.Type & {
+ *     FieldPresence: $protobuf.Enum,
+ *     EnumType: $protobuf.Enum,
+ *     RepeatedFieldEncoding: $protobuf.Enum,
+ *     Utf8Validation: $protobuf.Enum,
+ *     MessageEncoding: $protobuf.Enum,
+ *     JsonFormat: $protobuf.Enum,
+ *     EnforceNamingStyle: $protobuf.Enum,
+ *     VisibilityFeature: $protobuf.Type
+ * }}
+ * @const
+ */
+
+/**
+ * Reflected feature set defaults.
+ * @name FeatureSetDefaults
+ * @type {$protobuf.Type & {
+ *     FeatureSetEditionDefault: $protobuf.Type
+ * }}
  * @const
- * @tstype $protobuf.Type
  */
 
 /**
  * Reflected uninterpretet option.
  * @name UninterpretedOption
- * @type {Type}
- * @property {Type} NamePart
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     NamePart: $protobuf.Type
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected source code info.
  * @name SourceCodeInfo
- * @type {Type}
- * @property {Type} Location
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     Location: $protobuf.Type
- * }
+ * }}
+ * @const
  */
 
 /**
  * Reflected generated code info.
  * @name GeneratedCodeInfo
- * @type {Type}
- * @property {Type} Annotation
- * @const
- * @tstype $protobuf.Type & {
+ * @type {$protobuf.Type & {
  *     Annotation: $protobuf.Type
- * }
+ * }}
+ * @const
  */

package/ext/textformat.d.ts

@@ -1,21 +1,10 @@
 import * as $protobuf from "..";
+import { ITextFormatOptions } from "./textformat.generated";
 
-export interface ITextFormatOptions {
-    /** Also includes and formats unknown fields. */
-    unknowns?: boolean;
-}
-
-/** Maximum recursion depth for text format parsing and formatting. Defaults to util.recursionLimit. */
-export let recursionLimit: number;
-
-/** Maximum recursion depth for formatting length-delimited unknown fields. */
-export let unknownRecursionLimit: number;
+export * from "./textformat.generated";
 
 declare module ".." {
     namespace textformat {
-        /** Maximum recursion depth for text format parsing and formatting. Defaults to util.recursionLimit. */
-        let recursionLimit: number;
-
         /** Maximum recursion depth for formatting length-delimited unknown fields. */
         let unknownRecursionLimit: number;
     }

package/ext/textformat.generated.d.ts

@@ -0,0 +1,11 @@
+// DO NOT EDIT! This is a generated file. Edit the source file instead and regenerate.
+
+/** Maximum recursion depth for formatting length-delimited unknown fields. */
+export let unknownRecursionLimit: number;
+
+/** Text format options. */
+export interface ITextFormatOptions {
+
+    /** Also includes and formats unknown fields. */
+    unknowns?: boolean;
+}

package/ext/textformat.js

@@ -10,23 +10,9 @@ var Type    = protobuf.Type,
 
 var textformat = protobuf.textformat = module.exports = {};
 
-var recursionLimit;
-
-/**
- * Maximum recursion depth for text format parsing and formatting. Defaults to util.recursionLimit.
- * @type {number}
- */
-Object.defineProperty(textformat, "recursionLimit", {
-    get: function get() {
-        return recursionLimit === undefined ? util.recursionLimit : recursionLimit;
-    },
-    set: function set(value) {
-        recursionLimit = value == null ? undefined : value;
-    }
-});
-
 /**
  * Maximum recursion depth for formatting length-delimited unknown fields.
+ * @name unknownRecursionLimit
  * @type {number}
  */
 textformat.unknownRecursionLimit = 10;
@@ -59,6 +45,7 @@ var identRe = /^[A-Za-z_][A-Za-z0-9_]*$/,
  * @param {Type} type Reflected message type
  * @param {string} text Text format input
  * @returns {Message<{}>} Message instance
+ * @private
  */
 function parseText(type, text) {
     if (!(type instanceof Type))
@@ -75,20 +62,26 @@ function parseText(type, text) {
     return message;
 }
 
+/**
+ * Text format options.
+ * @interface ITextFormatOptions
+ * @property {boolean} [unknowns=false] Also includes and formats unknown fields.
+ */
+
 /**
  * Formats a message as protobuf text format using the specified reflected type.
  * @param {Type} type Reflected message type
  * @param {Message<{}>|Object.<string,*>} message Message instance or plain object
- * @param {Object} [options] Text format options
- * @param {boolean} [options.unknowns=false] Includes and formats unknown fields
+ * @param {ITextFormatOptions} [options] Text format options
  * @returns {string} Text format output
+ * @private
  */
 function formatText(type, message, options) {
     if (!(type instanceof Type))
         throw TypeError("type must be a Type");
     type.root.resolveAll();
     var lines = [];
-    writeMessage(type, message, lines, 0, options || {}, 0, textformat.recursionLimit);
+    writeMessage(type, message, lines, 0, options || {}, 0);
     return lines.join("\n");
 }
 
@@ -104,7 +97,7 @@ Type.prototype.fromText = function fromText(text) {
 /**
  * Formats a message of this type as protobuf text format.
  * @param {Message<{}>|Object.<string,*>} message Message instance or plain object
- * @param {Object} [options] Text format options
+ * @param {ITextFormatOptions} [options] Text format options
  * @returns {string} Text format output
  */
 Type.prototype.toText = function toText(message, options) {
@@ -318,7 +311,6 @@ Tokenizer.prototype.readCodePoint = function readCodePoint(size) {
 
 function Parser(source) {
     this.tn = new Tokenizer(source);
-    this.recursionLimit = textformat.recursionLimit;
 }
 
 Parser.prototype.error = function error(message) {
@@ -331,13 +323,9 @@ Parser.prototype.expectEnd = function expectEnd() {
         this.error("unexpected token '" + token.value + "'");
 };
 
-Parser.prototype.checkRecursion = function checkRecursion(depth) {
-    if (depth > this.recursionLimit)
-        this.error("max depth exceeded");
-};
-
 Parser.prototype.parseMessage = function parseMessage(type, end, depth) {
-    this.checkRecursion(depth);
+    if (depth > util.recursionLimit)
+        this.error("max depth exceeded");
     var object = {},
         seen = {};
     for (;;) {
@@ -473,7 +461,8 @@ Parser.prototype.parseMessageFieldDelimiter = function parseMessageFieldDelimite
 };
 
 Parser.prototype.parseMapEntry = function parseMapEntry(field, depth) {
-    this.checkRecursion(depth);
+    if (depth > util.recursionLimit)
+        this.error("max depth exceeded");
     var end;
     if (this.tn.skip("{"))
         end = "}";
@@ -617,7 +606,7 @@ Parser.prototype.skipBalanced = function skipBalanced(open, close, depth) {
         if (!token)
             this.error("expected '" + close + "'");
         if (token.value === open) {
-            if (depth + ++balance > this.recursionLimit)
+            if (depth + ++balance > util.recursionLimit)
                 this.error("max depth exceeded");
         }
         else if (token.value === close)
@@ -855,13 +844,9 @@ function parseIntegerBigInt(digits, radix, sign, unsigned, bits) {
     return Number(value);
 }
 
-function checkRecursion(depth, recursionLimit) {
-    if (depth > recursionLimit)
+function writeMessage(type, message, lines, indent, options, depth) {
+    if (depth > util.recursionLimit)
         throw Error("max depth exceeded");
-}
-
-function writeMessage(type, message, lines, indent, options, depth, recursionLimit) {
-    checkRecursion(depth, recursionLimit);
     var fields = type.fieldsArray.slice().sort(util.compareFieldsById);
     for (var i = 0; i < fields.length; ++i) {
         var field = fields[i].resolve(),
@@ -869,25 +854,26 @@ function writeMessage(type, message, lines, indent, options, depth, recursionLim
         if (value == null || !Object.prototype.hasOwnProperty.call(message, field.name))
             continue;
         if (field.map)
-            writeMapField(field, value, lines, indent, options, depth, recursionLimit);
+            writeMapField(field, value, lines, indent, options, depth);
         else if (field.repeated)
             for (var j = 0; j < value.length; ++j)
-                writeField(field, value[j], lines, indent, options, depth, recursionLimit);
+                writeField(field, value[j], lines, indent, options, depth);
         else
-            writeField(field, value, lines, indent, options, depth, recursionLimit);
+            writeField(field, value, lines, indent, options, depth);
     }
     if (options.unknowns && message.$unknowns != null && Object.prototype.hasOwnProperty.call(message, "$unknowns"))
         writeUnknowns(message.$unknowns, lines, indent);
 }
 
-function writeMapField(field, map, lines, indent, options, depth, recursionLimit) {
+function writeMapField(field, map, lines, indent, options, depth) {
     var keys = Object.keys(map).sort(),
         keyField = mapKeyField(field),
         valueField = mapValueField(field),
         name = formatFieldName(field),
         sp = spaces(indent);
     for (var i = 0; i < keys.length; ++i) {
-        checkRecursion(depth + 1, recursionLimit);
+        if (depth + 1 > util.recursionLimit)
+            throw Error("max depth exceeded");
         var key = keyField.long ? util.longFromKey(keys[i], keyField.type === "uint64" || keyField.type === "fixed64") : keys[i];
         if (keyField.type === "bool")
             key = util.boolFromKey(keys[i]);
@@ -895,7 +881,7 @@ function writeMapField(field, map, lines, indent, options, depth, recursionLimit
         lines.push(spaces(indent + 2) + "key: " + formatScalar(keyField, key));
         if (valueField.resolvedType instanceof Type) {
             lines.push(spaces(indent + 2) + "value {");
-            writeMessage(valueField.resolvedType, map[keys[i]], lines, indent + 4, options, depth + 2, recursionLimit);
+            writeMessage(valueField.resolvedType, map[keys[i]], lines, indent + 4, options, depth + 2);
             lines.push(spaces(indent + 2) + "}");
         } else
             lines.push(spaces(indent + 2) + "value: " + formatScalar(valueField, map[keys[i]]));
@@ -903,12 +889,12 @@ function writeMapField(field, map, lines, indent, options, depth, recursionLimit
     }
 }
 
-function writeField(field, value, lines, indent, options, depth, recursionLimit) {
+function writeField(field, value, lines, indent, options, depth) {
     var name = formatFieldName(field),
         sp = spaces(indent);
     if (field.resolvedType instanceof Type) {
         lines.push(sp + name + " {");
-        writeMessage(field.resolvedType, value, lines, indent + 2, options, depth + 1, recursionLimit);
+        writeMessage(field.resolvedType, value, lines, indent + 2, options, depth + 1);
         lines.push(sp + "}");
     } else
         lines.push(sp + name + ": " + formatScalar(field, value));