protobufjs 6.11.1 → 7.0.0

package/cli/pbjs.js

@@ -1,330 +0,0 @@
-"use strict";
-var path     = require("path"),
-    fs       = require("fs"),
-    pkg      = require("./package.json"),
-    util     = require("./util");
-
-util.setup();
-
-var protobuf = require(util.pathToProtobufJs),
-    minimist = require("minimist"),
-    chalk    = require("chalk"),
-    glob     = require("glob");
-
-var targets  = util.requireAll("./targets");
-
-/**
- * Runs pbjs programmatically.
- * @param {string[]} args Command line arguments
- * @param {function(?Error, string=)} [callback] Optional completion callback
- * @returns {number|undefined} Exit code, if known
- */
-exports.main = function main(args, callback) {
-    var lintDefault = "eslint-disable " + [
-        "block-scoped-var",
-        "id-length",
-        "no-control-regex",
-        "no-magic-numbers",
-        "no-prototype-builtins",
-        "no-redeclare",
-        "no-shadow",
-        "no-var",
-        "sort-vars"
-    ].join(", ");
-    var argv = minimist(args, {
-        alias: {
-            target: "t",
-            out: "o",
-            path: "p",
-            wrap: "w",
-            root: "r",
-            lint: "l",
-            // backward compatibility:
-            "force-long": "strict-long",
-            "force-message": "strict-message"
-        },
-        string: [ "target", "out", "path", "wrap", "dependency", "root", "lint" ],
-        boolean: [ "create", "encode", "decode", "verify", "convert", "delimited", "beautify", "comments", "service", "es6", "sparse", "keep-case", "force-long", "force-number", "force-enum-string", "force-message" ],
-        default: {
-            target: "json",
-            create: true,
-            encode: true,
-            decode: true,
-            verify: true,
-            convert: true,
-            delimited: true,
-            beautify: true,
-            comments: true,
-            service: true,
-            es6: null,
-            lint: lintDefault,
-            "keep-case": false,
-            "force-long": false,
-            "force-number": false,
-            "force-enum-string": false,
-            "force-message": false
-        }
-    });
-
-    var target = targets[argv.target],
-        files  = argv._,
-        paths  = typeof argv.path === "string" ? [ argv.path ] : argv.path || [];
-
-    // alias hyphen args in camel case
-    Object.keys(argv).forEach(function(key) {
-        var camelKey = key.replace(/-([a-z])/g, function($0, $1) { return $1.toUpperCase(); });
-        if (camelKey !== key)
-            argv[camelKey] = argv[key];
-    });
-
-    // protobuf.js package directory contains additional, otherwise non-bundled google types
-    paths.push(path.relative(process.cwd(), path.join(__dirname, "..")) || ".");
-
-    if (!files.length) {
-        var descs = Object.keys(targets).filter(function(key) { return !targets[key].private; }).map(function(key) {
-            return "                   " + util.pad(key, 14, true) + targets[key].description;
-        });
-        if (callback)
-            callback(Error("usage")); // eslint-disable-line callback-return
-        else
-            process.stderr.write([
-                "protobuf.js v" + pkg.version + " CLI for JavaScript",
-                "",
-                chalk.bold.white("Translates between file formats and generates static code."),
-                "",
-                "  -t, --target     Specifies the target format. Also accepts a path to require a custom target.",
-                "",
-                descs.join("\n"),
-                "",
-                "  -p, --path       Adds a directory to the include path.",
-                "",
-                "  -o, --out        Saves to a file instead of writing to stdout.",
-                "",
-                "  --sparse         Exports only those types referenced from a main file (experimental).",
-                "",
-                chalk.bold.gray("  Module targets only:"),
-                "",
-                "  -w, --wrap       Specifies the wrapper to use. Also accepts a path to require a custom wrapper.",
-                "",
-                "                   default   Default wrapper supporting both CommonJS and AMD",
-                "                   commonjs  CommonJS wrapper",
-                "                   amd       AMD wrapper",
-                "                   es6       ES6 wrapper (implies --es6)",
-                "                   closure   A closure adding to protobuf.roots where protobuf is a global",
-                "",
-                "  --dependency     Specifies which version of protobuf to require. Accepts any valid module id",
-                "",
-                "  -r, --root       Specifies an alternative protobuf.roots name.",
-                "",
-                "  -l, --lint       Linter configuration. Defaults to protobuf.js-compatible rules:",
-                "",
-                "                   " + lintDefault,
-                "",
-                "  --es6            Enables ES6 syntax (const/let instead of var)",
-                "",
-                chalk.bold.gray("  Proto sources only:"),
-                "",
-                "  --keep-case      Keeps field casing instead of converting to camel case.",
-                "",
-                chalk.bold.gray("  Static targets only:"),
-                "",
-                "  --no-create      Does not generate create functions used for reflection compatibility.",
-                "  --no-encode      Does not generate encode functions.",
-                "  --no-decode      Does not generate decode functions.",
-                "  --no-verify      Does not generate verify functions.",
-                "  --no-convert     Does not generate convert functions like from/toObject",
-                "  --no-delimited   Does not generate delimited encode/decode functions.",
-                "  --no-beautify    Does not beautify generated code.",
-                "  --no-comments    Does not output any JSDoc comments.",
-                "  --no-service     Does not output service classes.",
-                "",
-                "  --force-long     Enfores the use of 'Long' for s-/u-/int64 and s-/fixed64 fields.",
-                "  --force-number   Enfores the use of 'number' for s-/u-/int64 and s-/fixed64 fields.",
-                "  --force-message  Enfores the use of message instances instead of plain objects.",
-                "",
-                "usage: " + chalk.bold.green("pbjs") + " [options] file1.proto file2.json ..." + chalk.gray("  (or pipe)  ") + "other | " + chalk.bold.green("pbjs") + " [options] -",
-                ""
-            ].join("\n"));
-        return 1;
-    }
-
-    if (typeof argv["strict-long"] === "boolean")
-        argv["force-long"] = argv["strict-long"];
-
-    // Resolve glob expressions
-    for (var i = 0; i < files.length;) {
-        if (glob.hasMagic(files[i])) {
-            var matches = glob.sync(files[i]);
-            Array.prototype.splice.apply(files, [i, 1].concat(matches));
-            i += matches.length;
-        } else
-            ++i;
-    }
-
-    // Require custom target
-    if (!target)
-        target = require(path.resolve(process.cwd(), argv.target));
-
-    var root = new protobuf.Root();
-
-    var mainFiles = [];
-
-    // Search include paths when resolving imports
-    root.resolvePath = function pbjsResolvePath(origin, target) {
-        var normOrigin = protobuf.util.path.normalize(origin),
-            normTarget = protobuf.util.path.normalize(target);
-        if (!normOrigin)
-            mainFiles.push(normTarget);
-
-        var resolved = protobuf.util.path.resolve(normOrigin, normTarget, true);
-        var idx = resolved.lastIndexOf("google/protobuf/");
-        if (idx > -1) {
-            var altname = resolved.substring(idx);
-            if (altname in protobuf.common)
-                resolved = altname;
-        }
-
-        if (fs.existsSync(resolved))
-            return resolved;
-
-        for (var i = 0; i < paths.length; ++i) {
-            var iresolved = protobuf.util.path.resolve(paths[i] + "/", target);
-            if (fs.existsSync(iresolved))
-                return iresolved;
-        }
-
-        return resolved;
-    };
-
-    // `--wrap es6` implies `--es6` but not the other way around. You can still use e.g. `--es6 --wrap commonjs`
-    if (argv.wrap === "es6") {
-        argv.es6 = true;
-    }
-
-    var parseOptions = {
-        "keepCase": argv["keep-case"] || false
-    };
-
-    // Read from stdin
-    if (files.length === 1 && files[0] === "-") {
-        var data = [];
-        process.stdin.on("data", function(chunk) {
-            data.push(chunk);
-        });
-        process.stdin.on("end", function() {
-            var source = Buffer.concat(data).toString("utf8");
-            try {
-                if (source.charAt(0) !== "{") {
-                    protobuf.parse.filename = "-";
-                    protobuf.parse(source, root, parseOptions);
-                } else {
-                    var json = JSON.parse(source);
-                    root.setOptions(json.options).addJSON(json);
-                }
-                callTarget();
-            } catch (err) {
-                if (callback) {
-                    callback(err);
-                    return;
-                }
-                throw err;
-            }
-        });
-
-    // Load from disk
-    } else {
-        try {
-            root.loadSync(files, parseOptions).resolveAll(); // sync is deterministic while async is not
-            if (argv.sparse)
-                sparsify(root);
-            callTarget();
-        } catch (err) {
-            if (callback) {
-                callback(err);
-                return undefined;
-            }
-            throw err;
-        }
-    }
-
-    function markReferenced(tobj) {
-        tobj.referenced = true;
-        // also mark a type's fields and oneofs
-        if (tobj.fieldsArray)
-            tobj.fieldsArray.forEach(function(fobj) {
-                fobj.referenced = true;
-            });
-        if (tobj.oneofsArray)
-            tobj.oneofsArray.forEach(function(oobj) {
-                oobj.referenced = true;
-            });
-        // also mark an extension field's extended type, but not its (other) fields
-        if (tobj.extensionField)
-            tobj.extensionField.parent.referenced = true;
-    }
-
-    function sparsify(root) {
-
-        // 1. mark directly or indirectly referenced objects
-        util.traverse(root, function(obj) {
-            if (!obj.filename)
-                return;
-            if (mainFiles.indexOf(obj.filename) > -1)
-                util.traverseResolved(obj, markReferenced);
-        });
-
-        // 2. empty unreferenced objects
-        util.traverse(root, function(obj) {
-            var parent = obj.parent;
-            if (!parent || obj.referenced) // root or referenced
-                return;
-            // remove unreferenced namespaces
-            if (obj instanceof protobuf.Namespace) {
-                var hasReferenced = false;
-                util.traverse(obj, function(iobj) {
-                    if (iobj.referenced)
-                        hasReferenced = true;
-                });
-                if (hasReferenced) { // replace with plain namespace if a namespace subclass
-                    if (obj instanceof protobuf.Type || obj instanceof protobuf.Service) {
-                        var robj = new protobuf.Namespace(obj.name, obj.options);
-                        robj.nested = obj.nested;
-                        parent.add(robj);
-                    }
-                } else // remove completely if nothing inside is referenced
-                    parent.remove(obj);
-
-            // remove everything else unreferenced
-            } else if (!(obj instanceof protobuf.Namespace))
-                parent.remove(obj);
-        });
-
-        // 3. validate that everything is fine
-        root.resolveAll();
-    }
-
-    function callTarget() {
-        target(root, argv, function targetCallback(err, output) {
-            if (err) {
-                if (callback)
-                    return callback(err);
-                throw err;
-            }
-            try {
-                if (argv.out)
-                    fs.writeFileSync(argv.out, output, { encoding: "utf8" });
-                else if (!callback)
-                    process.stdout.write(output, "utf8");
-                return callback
-                    ? callback(null, output)
-                    : undefined;
-            } catch (err) {
-                if (callback)
-                    return callback(err);
-                throw err;
-            }
-        });
-    }
-
-    return undefined;
-};

package/cli/pbts.d.ts

@@ -1,9 +0,0 @@
-type pbtsCallback = (err: Error|null, output?: string) => void;
-
-/**
- * Runs pbts programmatically.
- * @param {string[]} args Command line arguments
- * @param {function(?Error, string=)} [callback] Optional completion callback
- * @returns {number|undefined} Exit code, if known
- */
-export function main(args: string[], callback?: pbtsCallback): number|undefined;

package/cli/pbts.js

@@ -1,197 +0,0 @@
-"use strict";
-var child_process = require("child_process"),
-    path     = require("path"),
-    fs       = require("fs"),
-    pkg      = require("./package.json"),
-    util     = require("./util");
-
-util.setup();
-
-var minimist = require("minimist"),
-    chalk    = require("chalk"),
-    glob     = require("glob"),
-    tmp      = require("tmp");
-
-/**
- * Runs pbts programmatically.
- * @param {string[]} args Command line arguments
- * @param {function(?Error, string=)} [callback] Optional completion callback
- * @returns {number|undefined} Exit code, if known
- */
-exports.main = function(args, callback) {
-    var argv = minimist(args, {
-        alias: {
-            name: "n",
-            out : "o",
-            main: "m",
-            global: "g",
-            import: "i"
-        },
-        string: [ "name", "out", "global", "import" ],
-        boolean: [ "comments", "main" ],
-        default: {
-            comments: true,
-            main: false
-        }
-    });
-
-    var files  = argv._;
-
-    if (!files.length) {
-        if (callback)
-            callback(Error("usage")); // eslint-disable-line callback-return
-        else
-            process.stderr.write([
-                "protobuf.js v" + pkg.version + " CLI for TypeScript",
-                "",
-                chalk.bold.white("Generates TypeScript definitions from annotated JavaScript files."),
-                "",
-                "  -o, --out       Saves to a file instead of writing to stdout.",
-                "",
-                "  -g, --global    Name of the global object in browser environments, if any.",
-                "",
-                "  -i, --import    Comma delimited list of imports. Local names will equal camelCase of the basename.",
-                "",
-                "  --no-comments   Does not output any JSDoc comments.",
-                "",
-                chalk.bold.gray("  Internal flags:"),
-                "",
-                "  -n, --name      Wraps everything in a module of the specified name.",
-                "",
-                "  -m, --main      Whether building the main library without any imports.",
-                "",
-                "usage: " + chalk.bold.green("pbts") + " [options] file1.js file2.js ..." + chalk.bold.gray("  (or)  ") + "other | " + chalk.bold.green("pbts") + " [options] -",
-                ""
-            ].join("\n"));
-        return 1;
-    }
-
-    // Resolve glob expressions
-    for (var i = 0; i < files.length;) {
-        if (glob.hasMagic(files[i])) {
-            var matches = glob.sync(files[i]);
-            Array.prototype.splice.apply(files, [i, 1].concat(matches));
-            i += matches.length;
-        } else
-            ++i;
-    }
-
-    var cleanup = [];
-
-    // Read from stdin (to a temporary file)
-    if (files.length === 1 && files[0] === "-") {
-        var data = [];
-        process.stdin.on("data", function(chunk) {
-            data.push(chunk);
-        });
-        process.stdin.on("end", function() {
-            files[0] = tmp.tmpNameSync() + ".js";
-            fs.writeFileSync(files[0], Buffer.concat(data));
-            cleanup.push(files[0]);
-            callJsdoc();
-        });
-
-    // Load from disk
-    } else {
-        callJsdoc();
-    }
-
-    function callJsdoc() {
-
-        // There is no proper API for jsdoc, so this executes the CLI and pipes the output
-        var basedir = path.join(__dirname, ".");
-        var moduleName = argv.name || "null";
-        var nodePath = process.execPath;
-        var cmd = "\"" + nodePath + "\" \"" + require.resolve("jsdoc/jsdoc.js") + "\" -c \"" + path.join(basedir, "lib", "tsd-jsdoc.json") + "\" -q \"module=" + encodeURIComponent(moduleName) + "&comments=" + Boolean(argv.comments) + "\" " + files.map(function(file) { return "\"" + file + "\""; }).join(" ");
-        var child = child_process.exec(cmd, {
-            cwd: process.cwd(),
-            argv0: "node",
-            stdio: "pipe",
-            maxBuffer: 1 << 24 // 16mb
-        });
-        var out = [];
-        var ended = false;
-        var closed = false;
-        child.stdout.on("data", function(data) {
-            out.push(data);
-        });
-        child.stdout.on("end", function() {
-            if (closed) finish();
-            else ended = true;
-        });
-        child.stderr.pipe(process.stderr);
-        child.on("close", function(code) {
-            // clean up temporary files, no matter what
-            try { cleanup.forEach(fs.unlinkSync); } catch(e) {/**/} cleanup = [];
-
-            if (code) {
-                out = out.join("").replace(/\s*JSDoc \d+\.\d+\.\d+ [^$]+/, "");
-                process.stderr.write(out);
-                var err = Error("code " + code);
-                if (callback)
-                    return callback(err);
-                throw err;
-            }
-
-            if (ended) return finish();
-            closed = true;
-            return undefined;
-        });
-
-        function getImportName(importItem) {
-            return path.basename(importItem, ".js").replace(/([-_~.+]\w)/g, function(match) {
-                return match[1].toUpperCase();
-            });
-        }
-
-        function finish() {
-            var output = [];
-            if (argv.main)
-                output.push(
-                    "// DO NOT EDIT! This is a generated file. Edit the JSDoc in src/*.js instead and run 'npm run types'.",
-                    ""
-                );
-            if (argv.global)
-                output.push(
-                    "export as namespace " + argv.global + ";",
-                    ""
-                );
-
-            if (!argv.main) {
-                // Ensure we have a usable array of imports
-                var importArray = typeof argv.import === "string" ? argv.import.split(",") : argv.import || [];
-
-                // Build an object of imports and paths
-                var imports = {
-                    $protobuf: "protobufjs"
-                };
-                importArray.forEach(function(importItem) {
-                    imports[getImportName(importItem)] = importItem;
-                });
-
-                // Write out the imports
-                Object.keys(imports).forEach(function(key) {
-                    output.push("import * as " + key + " from \"" + imports[key] + "\";");
-                });
-            }
-
-            output = output.join("\n") + "\n" + out.join("");
-
-            try {
-                if (argv.out)
-                    fs.writeFileSync(argv.out, output, { encoding: "utf8" });
-                else if (!callback)
-                    process.stdout.write(output, "utf8");
-                return callback
-                    ? callback(null, output)
-                    : undefined;
-            } catch (err) {
-                if (callback)
-                    return callback(err);
-                throw err;
-            }
-        }
-    }
-
-    return undefined;
-};

package/cli/targets/json-module.js

@@ -1,38 +0,0 @@
-"use strict";
-module.exports = json_module;
-
-var util = require("../util");
-
-var protobuf = require("../..");
-
-json_module.description = "JSON representation as a module";
-
-function jsonSafeProp(json) {
-    return json.replace(/^( +)"(\w+)":/mg, function($0, $1, $2) {
-        return protobuf.util.safeProp($2).charAt(0) === "."
-            ? $1 + $2 + ":"
-            : $0;
-    });
-}
-
-function json_module(root, options, callback) {
-    try {
-        var rootProp = protobuf.util.safeProp(options.root || "default");
-        var output = [
-            (options.es6 ? "const" : "var") + " $root = ($protobuf.roots" + rootProp + " || ($protobuf.roots" + rootProp + " = new $protobuf.Root()))\n"
-        ];
-        if (root.options) {
-            var optionsJson = jsonSafeProp(JSON.stringify(root.options, null, 2));
-            output.push(".setOptions(" + optionsJson + ")\n");
-        }
-        var json = jsonSafeProp(JSON.stringify(root.nested, null, 2).trim());
-        output.push(".addJSON(" + json + ");");
-        output = util.wrap(output.join(""), protobuf.util.merge({ dependency: "protobufjs/light" }, options));
-        process.nextTick(function() {
-            callback(null, output);
-        });
-    } catch (e) {
-        return callback(e);
-    }
-    return undefined;
-}

package/cli/targets/json.js

@@ -1,8 +0,0 @@
-"use strict";
-module.exports = json_target;
-
-json_target.description = "JSON representation";
-
-function json_target(root, options, callback) {
-    callback(null, JSON.stringify(root, null, 2));
-}