@depup/apollo__protobufjs 1.2.7-depup.0

package/ext/debug/README.md

@@ -0,0 +1,4 @@
+protobufjs/ext/debug
+=========================
+
+Experimental debugging extension.

package/ext/debug/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var protobuf = require("../..");
+
+/**
+ * Debugging utility functions. Only present in debug builds.
+ * @namespace
+ */
+var debug = protobuf.debug = module.exports = {};
+
+var codegen = protobuf.util.codegen;
+
+var debugFnRe = /function ([^(]+)\(([^)]*)\) {/g;
+
+// Counts number of calls to any generated function
+function codegen_debug() {
+    codegen_debug.supported = codegen.supported;
+    codegen_debug.verbose = codegen.verbose;
+    var gen = codegen.apply(null, Array.prototype.slice.call(arguments));
+    gen.str = (function(str) { return function str_debug() {
+        return str.apply(null, Array.prototype.slice.call(arguments)).replace(debugFnRe, "function $1($2) {\n\t$1.calls=($1.calls|0)+1");
+    };})(gen.str);
+    return gen;
+}
+
+/**
+ * Returns a list of unused types within the specified root.
+ * @param {NamespaceBase} ns Namespace to search
+ * @returns {Type[]} Unused types
+ */
+debug.unusedTypes = function unusedTypes(ns) {
+
+    /* istanbul ignore if */
+    if (!(ns instanceof protobuf.Namespace))
+        throw TypeError("ns must be a Namespace");
+
+    /* istanbul ignore if */
+    if (!ns.nested)
+        return [];
+
+    var unused = [];
+    for (var names = Object.keys(ns.nested), i = 0; i < names.length; ++i) {
+        var nested = ns.nested[names[i]];
+        if (nested instanceof protobuf.Type) {
+            var calls = (nested.encode.calls|0)
+                      + (nested.decode.calls|0)
+                      + (nested.verify.calls|0)
+                      + (nested.toObject.calls|0)
+                      + (nested.fromObject.calls|0);
+            if (!calls)
+                unused.push(nested);
+        } else if (nested instanceof protobuf.Namespace)
+            Array.prototype.push.apply(unused, unusedTypes(nested));
+    }
+    return unused;
+};
+
+/**
+ * Enables debugging extensions.
+ * @returns {undefined}
+ */
+debug.enable = function enable() {
+    protobuf.util.codegen = codegen_debug;
+};
+
+/**
+ * Disables debugging extensions.
+ * @returns {undefined}
+ */
+debug.disable = function disable() {
+    protobuf.util.codegen = codegen;
+};

package/ext/descriptor/README.md

@@ -0,0 +1,72 @@
+protobufjs/ext/descriptor
+=========================
+
+Experimental extension for interoperability with [descriptor.proto](https://github.com/google/protobuf/blob/master/src/google/protobuf/descriptor.proto) types.
+
+Usage
+-----
+
+```js
+var protobuf   = require("@apollo/protobufjs"), // requires the full library
+    descriptor = require("@apollo/protobufjs/ext/descriptor");
+
+var root = ...;
+
+// convert any existing root instance to the corresponding descriptor type
+var descriptorMsg = root.toDescriptor("proto2");
+// ^ returns a FileDescriptorSet message, see table below
+
+// encode to a descriptor buffer
+var buffer = descriptor.FileDescriptorSet.encode(descriptorMsg).finish();
+
+// decode from a descriptor buffer
+var decodedDescriptor = descriptor.FileDescriptorSet.decode(buffer);
+
+// convert any existing descriptor to a root instance
+root = protobuf.Root.fromDescriptor(decodedDescriptor);
+// ^ expects a FileDescriptorSet message or buffer, see table below
+
+// and start all over again
+```
+
+API
+---
+
+The extension adds `.fromDescriptor(descriptor[, syntax])` and `#toDescriptor([syntax])` methods to reflection objects and exports the `.google.protobuf` namespace of the internally used `Root` instance containing the following types present in descriptor.proto:
+
+| Descriptor type               | protobuf.js type | Remarks
+|-------------------------------|------------------|---------
+| **FileDescriptorSet**         | Root             |
+| FileDescriptorProto           |                  | dependencies are not supported
+| FileOptions                   |                  |
+| FileOptionsOptimizeMode       |                  |
+| SourceCodeInfo                |                  | not supported
+| SourceCodeInfoLocation        |                  |
+| GeneratedCodeInfo             |                  | not supported
+| GeneratedCodeInfoAnnotation   |                  |
+| **DescriptorProto**           | Type             |
+| MessageOptions                |                  |
+| DescriptorProtoExtensionRange |                  |
+| DescriptorProtoReservedRange  |                  |
+| **FieldDescriptorProto**      | Field            |
+| FieldDescriptorProtoLabel     |                  |
+| FieldDescriptorProtoType      |                  |
+| FieldOptions                  |                  |
+| FieldOptionsCType             |                  |
+| FieldOptionsJSType            |                  |
+| **OneofDescriptorProto**      | OneOf            |
+| OneofOptions                  |                  |
+| **EnumDescriptorProto**       | Enum             |
+| EnumOptions                   |                  |
+| EnumValueDescriptorProto      |                  |
+| EnumValueOptions              |                  | not supported
+| **ServiceDescriptorProto**    | Service          |
+| ServiceOptions                |                  |
+| **MethodDescriptorProto**     | Method           |
+| MethodOptions                 |                  |
+| UninterpretedOption           |                  | not supported
+| UninterpretedOptionNamePart   |                  |
+
+Note that not all features of descriptor.proto translate perfectly to a protobuf.js root instance. A root instance has only limited knowlege of packages or individual files for example, which is then compensated by guessing and generating fictional file names.
+
+When using TypeScript, the respective interface types can be used to reference specific message instances (i.e. `protobuf.Message<IDescriptorProto>`).

package/ext/descriptor/index.d.ts

@@ -0,0 +1,191 @@
+import * as $protobuf from "../..";
+export const FileDescriptorSet: $protobuf.Type;
+
+export const FileDescriptorProto: $protobuf.Type;
+
+export const DescriptorProto: $protobuf.Type & {
+    ExtensionRange: $protobuf.Type,
+    ReservedRange: $protobuf.Type
+};
+
+export const FieldDescriptorProto: $protobuf.Type & {
+    Label: $protobuf.Enum,
+    Type: $protobuf.Enum
+};
+
+export const OneofDescriptorProto: $protobuf.Type;
+
+export const EnumDescriptorProto: $protobuf.Type;
+
+export const ServiceDescriptorProto: $protobuf.Type;
+
+export const EnumValueDescriptorProto: $protobuf.Type;
+
+export const MethodDescriptorProto: $protobuf.Type;
+
+export const FileOptions: $protobuf.Type & {
+    OptimizeMode: $protobuf.Enum
+};
+
+export const MessageOptions: $protobuf.Type;
+
+export const FieldOptions: $protobuf.Type & {
+    CType: $protobuf.Enum,
+    JSType: $protobuf.Enum
+};
+
+export const OneofOptions: $protobuf.Type;
+
+export const EnumOptions: $protobuf.Type;
+
+export const EnumValueOptions: $protobuf.Type;
+
+export const ServiceOptions: $protobuf.Type;
+
+export const MethodOptions: $protobuf.Type;
+
+export const UninterpretedOption: $protobuf.Type & {
+    NamePart: $protobuf.Type
+};
+
+export const SourceCodeInfo: $protobuf.Type & {
+    Location: $protobuf.Type
+};
+
+export const GeneratedCodeInfo: $protobuf.Type & {
+    Annotation: $protobuf.Type
+};
+
+export interface IFileDescriptorSet {
+    file: IFileDescriptorProto[];
+}
+
+export interface IFileDescriptorProto {
+    name?: string;
+    package?: string;
+    dependency?: any;
+    publicDependency?: any;
+    weakDependency?: any;
+    messageType?: IDescriptorProto[];
+    enumType?: IEnumDescriptorProto[];
+    service?: IServiceDescriptorProto[];
+    extension?: IFieldDescriptorProto[];
+    options?: IFileOptions;
+    sourceCodeInfo?: any;
+    syntax?: string;
+}
+
+export interface IFileOptions {
+    javaPackage?: string;
+    javaOuterClassname?: string;
+    javaMultipleFiles?: boolean;
+    javaGenerateEqualsAndHash?: boolean;
+    javaStringCheckUtf8?: boolean;
+    optimizeFor?: IFileOptionsOptimizeMode;
+    goPackage?: string;
+    ccGenericServices?: boolean;
+    javaGenericServices?: boolean;
+    pyGenericServices?: boolean;
+    deprecated?: boolean;
+    ccEnableArenas?: boolean;
+    objcClassPrefix?: string;
+    csharpNamespace?: string;
+}
+
+type IFileOptionsOptimizeMode = number;
+
+export interface IDescriptorProto {
+    name?: string;
+    field?: IFieldDescriptorProto[];
+    extension?: IFieldDescriptorProto[];
+    nestedType?: IDescriptorProto[];
+    enumType?: IEnumDescriptorProto[];
+    extensionRange?: IDescriptorProtoExtensionRange[];
+    oneofDecl?: IOneofDescriptorProto[];
+    options?: IMessageOptions;
+    reservedRange?: IDescriptorProtoReservedRange[];
+    reservedName?: string[];
+}
+
+export interface IMessageOptions {
+    mapEntry?: boolean;
+}
+
+export interface IDescriptorProtoExtensionRange {
+    start?: number;
+    end?: number;
+}
+
+export interface IDescriptorProtoReservedRange {
+    start?: number;
+    end?: number;
+}
+
+export interface IFieldDescriptorProto {
+    name?: string;
+    number?: number;
+    label?: IFieldDescriptorProtoLabel;
+    type?: IFieldDescriptorProtoType;
+    typeName?: string;
+    extendee?: string;
+    defaultValue?: string;
+    oneofIndex?: number;
+    jsonName?: any;
+    options?: IFieldOptions;
+}
+
+type IFieldDescriptorProtoLabel = number;
+
+type IFieldDescriptorProtoType = number;
+
+export interface IFieldOptions {
+    packed?: boolean;
+    jstype?: IFieldOptionsJSType;
+}
+
+type IFieldOptionsJSType = number;
+
+export interface IEnumDescriptorProto {
+    name?: string;
+    value?: IEnumValueDescriptorProto[];
+    options?: IEnumOptions;
+}
+
+export interface IEnumValueDescriptorProto {
+    name?: string;
+    number?: number;
+    options?: any;
+}
+
+export interface IEnumOptions {
+    allowAlias?: boolean;
+    deprecated?: boolean;
+}
+
+export interface IOneofDescriptorProto {
+    name?: string;
+    options?: any;
+}
+
+export interface IServiceDescriptorProto {
+    name?: string;
+    method?: IMethodDescriptorProto[];
+    options?: IServiceOptions;
+}
+
+export interface IServiceOptions {
+    deprecated?: boolean;
+}
+
+export interface IMethodDescriptorProto {
+    name?: string;
+    inputType?: string;
+    outputType?: string;
+    options?: IMethodOptions;
+    clientStreaming?: boolean;
+    serverStreaming?: boolean;
+}
+
+export interface IMethodOptions {
+    deprecated?: boolean;
+}