@decaf-ts/cli 0.0.14 → 0.3.0

package/dist/cli.esm.cjs

@@ -0,0 +1,240 @@
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * @description The name for decaf cli modules where each library must export
+ * a single {@link CliModule}
+ *
+ * @constant
+ * @memberOf module:CLI.cli
+ */
+const CLI_FILE_NAME = "cli-module";
+
+/**
+ * @description util class to retrieve versions and other information
+ *
+ * @class CLIUtils
+ * @static
+ */
+class CLIUtils {
+    /**
+     * @description Dynamically imports a cjs file into a decaf module
+     * @param {string} path
+     * @static
+     */
+    static async loadFromFile(path) {
+        try {
+            return CLIUtils.normalizeImport(import(path));
+        }
+        catch (e) {
+            throw new Error(`Failed to load from ${path}: ${e instanceof Error ? e.message : e}`);
+        }
+    }
+    /**
+     * @description allows safe dynamic imports
+     * @summary property imports JS files regardless of esm status
+     *
+     * @typeParam T
+     * @param {Promise} importPromise
+     * @private
+     */
+    static async normalizeImport(importPromise) {
+        // CommonJS's `module.exports` is wrapped as `default` in ESModule.
+        return importPromise.then((m) => (m.default || m));
+    }
+    /**
+     * @description initializes the Cli object
+     *
+     * @param {Command} command
+     * @param {string} [basePath] defaults to the current working directory
+     */
+    static initialize(command, basePath) {
+        const name = CLIUtils.packageName(basePath);
+        command
+            .name(name)
+            .description(`Runs ${name} related commands`)
+            .version(CLIUtils.packageVersion(basePath));
+    }
+    /**
+     * @description retrieves and parses the package.json file
+     *
+     * @param {string} basePath
+     * @private
+     */
+    static getPackage(basePath) {
+        try {
+            return JSON.parse(fs.readFileSync(path.join(basePath, "package.json"), "utf8"));
+        }
+        catch (e) {
+            throw new Error(`Unable to read version from ${basePath}: ${e}`);
+        }
+    }
+    /**
+     * @description returns the package version
+     * @param {string} [basePath] defaults to current working dir
+     */
+    static packageVersion(basePath) {
+        return CLIUtils.getPackage(basePath)["version"];
+    }
+    /**
+     * @description returns the package name
+     * @param {string} [basePath] defaults to current working dir
+     */
+    static packageName(basePath) {
+        return CLIUtils.getPackage(basePath)["name"].split("/")[1];
+    }
+}
+
+/**
+ * @summary Util class to handle CLI functionality from all Decaf modules
+ * @description CLI handler class
+ *
+ * @param {string} [basepath] the base path to look for modules in. defaults to `./`
+ * @param {string} [crawlLevels] folders to crawl to find modules from the basePath. defaults to 4
+ *
+ * @class CliWrapper
+ */
+class CliWrapper {
+    constructor(basePath = "./", crawlLevels = 4) {
+        this.basePath = basePath;
+        this.crawlLevels = crawlLevels;
+        this.modules = {};
+    }
+    /**
+     * @description Retrieves and initializes the {@link Command} object
+     * @private
+     */
+    get command() {
+        if (!this._command) {
+            this._command = new Command();
+            CLIUtils.initialize(this._command, this.basePath);
+        }
+        return this._command;
+    }
+    /**
+     * @description loads and registers module from a file
+     *
+     * @param {string} filePath path to look for modules
+     * @param {string} rootPath repo root to find the package.json
+     * @return {string} the module name
+     *
+     * @private
+     */
+    async load(filePath, rootPath) {
+        let name;
+        try {
+            const module = await CLIUtils.loadFromFile(filePath);
+            name = module.name;
+            const cmd = new Command();
+            CLIUtils.initialize(cmd, path.dirname(rootPath));
+            let m = module();
+            if (m instanceof Promise)
+                m = await m;
+            this.modules[name] = m;
+        }
+        catch (e) {
+            throw new Error(`failed to load module ${name || "unnamed"} under ${filePath}: ${e instanceof Error ? e.message : e}`);
+        }
+        return name;
+    }
+    /**
+     * @description finds all the cli modules in the basePath via {@link CliWrapper.crawl}
+     * and loads them
+     * @private
+     */
+    async boot() {
+        const basePath = path.join(process.cwd(), this.basePath);
+        const modules = this.crawl(basePath, this.crawlLevels);
+        for (const module of modules) {
+            if (module.includes("@decaf-ts/cli")) {
+                continue;
+            }
+            let name;
+            try {
+                name = await this.load(module, process.cwd());
+            }
+            catch (e) {
+                console.error(e);
+                continue;
+            }
+            if (!this.command.commands.find((c) => c["_name"] === name))
+                try {
+                    this.command.command(name).addCommand(this.modules[name]);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+        }
+        console.log(`loaded modules:\n${Object.keys(this.modules)
+            .map((k) => `- ${k}`)
+            .join("\n")}`);
+    }
+    /**
+     * @description crawls the basePath up for 'levels' folders to find a module,eg a {@link CLI_FILE_NAME} named file
+     * @param {string} basePath the relative base batch to start searching in
+     * @param {number} [levels] the max number of levels to crawl. defaults to 2
+     * @private
+     */
+    crawl(basePath, levels = 2) {
+        if (levels <= 0)
+            return [];
+        return fs.readdirSync(basePath).reduce((accum, file) => {
+            file = path.join(basePath, file);
+            if (fs.statSync(file).isDirectory()) {
+                accum.push(...this.crawl(file, levels - 1));
+            }
+            else if (file.match(new RegExp(`${CLI_FILE_NAME}.[cm]?js$`, "gm"))) {
+                accum.push(file);
+            }
+            return accum;
+        }, []);
+    }
+    /**
+     * @description runs the given command
+     *
+     * @param {string[]} [args] args to run. defaults to process.argv
+     */
+    async run(args = process.argv) {
+        await this.boot();
+        return this.command.parseAsync(args);
+    }
+}
+
+/**
+ * @description Decaf-ts' CLI module
+ * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}
+ * within the @decaf-ts namespace and load then as subcommands
+ *
+ * @example
+ * run module command     - $ npx decaf <module name> <module command> ...<module command options>
+ * get module help        - $ npx decaf help <module name>;
+ * list imported modules  - $ npx decaf list;
+ * get cli help           - $ npx decaf help;
+ *
+ * @module CLI
+ */
+/**
+ * @description Decaf-ts' CLI namespace
+ * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}
+ * within the @decaf-ts namespace and load then as subcommands
+ *
+ * @example
+ * run module command     - $ npx decaf <module name> <module command> ...<module command options>
+ * get module help        - $ npx decaf help <module name>;
+ * list imported modules  - $ npx decaf list;
+ * get cli help           - $ npx decaf help;
+ *
+ * @namespace cli
+ * @memberOf module:CLI
+ */
+/**
+ * @summary stores the current package version
+ * @description this is how you should document a constant
+ * @const VERSION
+ * @memberOf module:CLI
+ */
+const VERSION = "0.2.0";
+
+export { CliWrapper, VERSION };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"cli.esm.cjs","sources":["../src/constants.ts","../src/utils.ts","../src/CliWrapper.ts","../src/index.ts"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport { CliModule } from \"./types\";\n\n/**\n * @description The name for decaf cli modules where each library must export\n * a single {@link CliModule}\n *\n * @constant\n * @memberOf module:CLI.cli\n */\nexport const CLI_FILE_NAME = \"cli-module\";\n","import path from \"path\";\nimport fs from \"fs\";\nimport { Command } from \"commander\";\nimport { CliModule } from \"./types\";\n\n/**\n * @description util class to retrieve versions and other information\n *\n * @class CLIUtils\n * @static\n */\nexport class CLIUtils {\n  /**\n   * @description Dynamically imports a cjs file into a decaf module\n   * @param {string} path\n   * @static\n   */\n  static async loadFromFile(path: string): Promise<CliModule> {\n    try {\n      return CLIUtils.normalizeImport(import(path));\n    } catch (e: unknown) {\n      throw new Error(\n        `Failed to load from ${path}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n  }\n\n  /**\n   * @description allows safe dynamic imports\n   * @summary property imports JS files regardless of esm status\n   *\n   * @typeParam T\n   * @param {Promise} importPromise\n   * @private\n   */\n  static async normalizeImport<T>(importPromise: Promise<T>): Promise<T> {\n    // CommonJS's `module.exports` is wrapped as `default` in ESModule.\n    return importPromise.then(\n      (m: unknown) => ((m as { default: T }).default || m) as T\n    );\n  }\n\n  /**\n   * @description initializes the Cli object\n   *\n   * @param {Command} command\n   * @param {string} [basePath] defaults to the current working directory\n   */\n  static initialize(command: Command, basePath: string) {\n    const name = CLIUtils.packageName(basePath);\n    command\n      .name(name)\n      .description(`Runs ${name} related commands`)\n      .version(CLIUtils.packageVersion(basePath));\n  }\n\n  /**\n   * @description retrieves and parses the package.json file\n   *\n   * @param {string} basePath\n   * @private\n   */\n  private static getPackage(basePath: string): Record<string, unknown> {\n    try {\n      return JSON.parse(\n        fs.readFileSync(path.join(basePath, \"package.json\"), \"utf8\")\n      );\n    } catch (e: unknown) {\n      throw new Error(`Unable to read version from ${basePath}: ${e}`);\n    }\n  }\n\n  /**\n   * @description returns the package version\n   * @param {string} [basePath] defaults to current working dir\n   */\n  static packageVersion(basePath: string): string {\n    return CLIUtils.getPackage(basePath)[\"version\"] as string;\n  }\n\n  /**\n   * @description returns the package name\n   * @param {string} [basePath] defaults to current working dir\n   */\n  static packageName(basePath: string): string {\n    return (CLIUtils.getPackage(basePath)[\"name\"] as string).split(\"/\")[1];\n  }\n}\n","import { Command } from \"commander\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport { CLI_FILE_NAME } from \"./constants\";\nimport { CLIUtils } from \"./utils\";\n\n/**\n * @summary Util class to handle CLI functionality from all Decaf modules\n * @description CLI handler class\n *\n * @param {string} [basepath] the base path to look for modules in. defaults to `./`\n * @param {string} [crawlLevels] folders to crawl to find modules from the basePath. defaults to 4\n *\n * @class CliWrapper\n */\nexport class CliWrapper {\n  private _command?: Command;\n  private modules: Record<string, Command> = {};\n\n  constructor(\n    private basePath: string = \"./\",\n    private crawlLevels = 4\n  ) {}\n\n  /**\n   * @description Retrieves and initializes the {@link Command} object\n   * @private\n   */\n  private get command() {\n    if (!this._command) {\n      this._command = new Command();\n      CLIUtils.initialize(this._command, this.basePath);\n    }\n    return this._command;\n  }\n\n  /**\n   * @description loads and registers module from a file\n   *\n   * @param {string} filePath path to look for modules\n   * @param {string} rootPath repo root to find the package.json\n   * @return {string} the module name\n   *\n   * @private\n   */\n  private async load(filePath: string, rootPath: string): Promise<string> {\n    let name;\n    try {\n      const module = await CLIUtils.loadFromFile(filePath);\n      name = module.name;\n      const cmd = new Command();\n      CLIUtils.initialize(cmd, path.dirname(rootPath));\n      let m = module();\n      if (m instanceof Promise) m = await m;\n      this.modules[name] = m;\n    } catch (e: unknown) {\n      throw new Error(\n        `failed to load module ${name || \"unnamed\"} under ${filePath}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n    return name;\n  }\n\n  /**\n   * @description finds all the cli modules in the basePath via {@link CliWrapper.crawl}\n   * and loads them\n   * @private\n   */\n  private async boot() {\n    const basePath = path.join(process.cwd(), this.basePath);\n    const modules = this.crawl(basePath, this.crawlLevels);\n    for (const module of modules) {\n      if (module.includes(\"@decaf-ts/cli\")) {\n        continue;\n      }\n      let name: string;\n      try {\n        name = await this.load(module, process.cwd());\n      } catch (e: unknown) {\n        console.error(e);\n        continue;\n      }\n\n      if (\n        !this.command.commands.find(\n          (c) => (c as unknown as Record<string, string>)[\"_name\"] === name\n        )\n      )\n        try {\n          this.command.command(name).addCommand(this.modules[name]);\n        } catch (e: unknown) {\n          console.error(e);\n        }\n    }\n    console.log(\n      `loaded modules:\\n${Object.keys(this.modules)\n        .map((k) => `- ${k}`)\n        .join(\"\\n\")}`\n    );\n  }\n\n  /**\n   * @description crawls the basePath up for 'levels' folders to find a module,eg a {@link CLI_FILE_NAME} named file\n   * @param {string} basePath the relative base batch to start searching in\n   * @param {number} [levels] the max number of levels to crawl. defaults to 2\n   * @private\n   */\n  private crawl(basePath: string, levels: number = 2) {\n    if (levels <= 0) return [];\n    return fs.readdirSync(basePath).reduce((accum: string[], file) => {\n      file = path.join(basePath, file);\n      if (fs.statSync(file).isDirectory()) {\n        accum.push(...this.crawl(file, levels - 1));\n      } else if (file.match(new RegExp(`${CLI_FILE_NAME}.[cm]?js$`, \"gm\"))) {\n        accum.push(file);\n      }\n      return accum;\n    }, []);\n  }\n\n  /**\n   * @description runs the given command\n   *\n   * @param {string[]} [args] args to run. defaults to process.argv\n   */\n  async run(args: string[] = process.argv) {\n    await this.boot();\n    return this.command.parseAsync(args);\n  }\n}\n","export * from \"./CliWrapper\";\n\n/**\n * @description Decaf-ts' CLI module\n * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}\n * within the @decaf-ts namespace and load then as subcommands\n *\n * @example\n * run module command     - $ npx decaf <module name> <module command> ...<module command options>\n * get module help        - $ npx decaf help <module name>;\n * list imported modules  - $ npx decaf list;\n * get cli help           - $ npx decaf help;\n *\n * @module CLI\n */\n\n/**\n * @description Decaf-ts' CLI namespace\n * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}\n * within the @decaf-ts namespace and load then as subcommands\n *\n * @example\n * run module command     - $ npx decaf <module name> <module command> ...<module command options>\n * get module help        - $ npx decaf help <module name>;\n * list imported modules  - $ npx decaf list;\n * get cli help           - $ npx decaf help;\n *\n * @namespace cli\n * @memberOf module:CLI\n */\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:CLI\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":[],"mappings":"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"}

package/lib/CliWrapper.cjs

@@ -124,3 +124,4 @@ class CliWrapper {
     }
 }
 exports.CliWrapper = CliWrapper;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CliWrapper.js","sourceRoot":"","sources":["../src/CliWrapper.ts"],"names":[],"mappings":"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","sourcesContent":["import { Command } from \"commander\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport { CLI_FILE_NAME } from \"./constants\";\nimport { CLIUtils } from \"./utils\";\n\n/**\n * @summary Util class to handle CLI functionality from all Decaf modules\n * @description CLI handler class\n *\n * @param {string} [basepath] the base path to look for modules in. defaults to `./`\n * @param {string} [crawlLevels] folders to crawl to find modules from the basePath. defaults to 4\n *\n * @class CliWrapper\n */\nexport class CliWrapper {\n  private _command?: Command;\n  private modules: Record<string, Command> = {};\n\n  constructor(\n    private basePath: string = \"./\",\n    private crawlLevels = 4\n  ) {}\n\n  /**\n   * @description Retrieves and initializes the {@link Command} object\n   * @private\n   */\n  private get command() {\n    if (!this._command) {\n      this._command = new Command();\n      CLIUtils.initialize(this._command, this.basePath);\n    }\n    return this._command;\n  }\n\n  /**\n   * @description loads and registers module from a file\n   *\n   * @param {string} filePath path to look for modules\n   * @param {string} rootPath repo root to find the package.json\n   * @return {string} the module name\n   *\n   * @private\n   */\n  private async load(filePath: string, rootPath: string): Promise<string> {\n    let name;\n    try {\n      const module = await CLIUtils.loadFromFile(filePath);\n      name = module.name;\n      const cmd = new Command();\n      CLIUtils.initialize(cmd, path.dirname(rootPath));\n      let m = module();\n      if (m instanceof Promise) m = await m;\n      this.modules[name] = m;\n    } catch (e: unknown) {\n      throw new Error(\n        `failed to load module ${name || \"unnamed\"} under ${filePath}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n    return name;\n  }\n\n  /**\n   * @description finds all the cli modules in the basePath via {@link CliWrapper.crawl}\n   * and loads them\n   * @private\n   */\n  private async boot() {\n    const basePath = path.join(process.cwd(), this.basePath);\n    const modules = this.crawl(basePath, this.crawlLevels);\n    for (const module of modules) {\n      if (module.includes(\"@decaf-ts/cli\")) {\n        continue;\n      }\n      let name: string;\n      try {\n        name = await this.load(module, process.cwd());\n      } catch (e: unknown) {\n        console.error(e);\n        continue;\n      }\n\n      if (\n        !this.command.commands.find(\n          (c) => (c as unknown as Record<string, string>)[\"_name\"] === name\n        )\n      )\n        try {\n          this.command.command(name).addCommand(this.modules[name]);\n        } catch (e: unknown) {\n          console.error(e);\n        }\n    }\n    console.log(\n      `loaded modules:\\n${Object.keys(this.modules)\n        .map((k) => `- ${k}`)\n        .join(\"\\n\")}`\n    );\n  }\n\n  /**\n   * @description crawls the basePath up for 'levels' folders to find a module,eg a {@link CLI_FILE_NAME} named file\n   * @param {string} basePath the relative base batch to start searching in\n   * @param {number} [levels] the max number of levels to crawl. defaults to 2\n   * @private\n   */\n  private crawl(basePath: string, levels: number = 2) {\n    if (levels <= 0) return [];\n    return fs.readdirSync(basePath).reduce((accum: string[], file) => {\n      file = path.join(basePath, file);\n      if (fs.statSync(file).isDirectory()) {\n        accum.push(...this.crawl(file, levels - 1));\n      } else if (file.match(new RegExp(`${CLI_FILE_NAME}.[cm]?js$`, \"gm\"))) {\n        accum.push(file);\n      }\n      return accum;\n    }, []);\n  }\n\n  /**\n   * @description runs the given command\n   *\n   * @param {string[]} [args] args to run. defaults to process.argv\n   */\n  async run(args: string[] = process.argv) {\n    await this.boot();\n    return this.command.parseAsync(args);\n  }\n}\n"]}

package/lib/bin/cli.cjs

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * BIN_CALL_PLACEHOLDER - DO NOT REMOVE
+ */
+/**
+ * @description Decaf-ts' CLI entry file
+ * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}
+ * within the @decaf-ts namespace and load then as subcommands
+ *
+ * @example
+ * run module command     - $ npx decaf <module name> <module command> ...<module command options>
+ * get module help        - $ npx decaf help <module name>;
+ * list imported modules  - $ npx decaf list;
+ * get cli help           - $ npx decaf help;
+ *
+ * @memberOf module:CLI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const CliWrapper_1 = require("../CliWrapper.cjs");
+new CliWrapper_1.CliWrapper()
+    .run(process.argv)
+    .then(() => {
+    console.log("Thank you for using decaf-ts' command line interface");
+})
+    .catch((e) => {
+    console.error(`${e instanceof Error ? e.message : e}`);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Jpbi9jbGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHO0FBQ0g7Ozs7Ozs7Ozs7OztHQVlHOztBQUVILDhDQUEyQztBQUMzQyxJQUFJLHVCQUFVLEVBQUU7S0FDYixHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQztLQUNqQixJQUFJLENBQUMsR0FBRyxFQUFFO0lBQ1QsT0FBTyxDQUFDLEdBQUcsQ0FBQyxzREFBc0QsQ0FBQyxDQUFDO0FBQ3RFLENBQUMsQ0FBQztLQUNELEtBQUssQ0FBQyxDQUFDLENBQVUsRUFBRSxFQUFFO0lBQ3BCLE9BQU8sQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZELE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDbEIsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEJJTl9DQUxMX1BMQUNFSE9MREVSIC0gRE8gTk9UIFJFTU9WRVxuICovXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBEZWNhZi10cycgQ0xJIGVudHJ5IGZpbGVcbiAqIEBzdW1tYXJ5IFRoaXMgZmlsZSB3aWxsIGNyYXdsIHRoZSBjdXJyZW50IHdvcmtpbmcgZGlyZWN0b3J5IGZvciBmaWxlcyBjYWxsZWQge0BsaW5rIENMSV9GSUxFX05BTUV9XG4gKiB3aXRoaW4gdGhlIEBkZWNhZi10cyBuYW1lc3BhY2UgYW5kIGxvYWQgdGhlbiBhcyBzdWJjb21tYW5kc1xuICpcbiAqIEBleGFtcGxlXG4gKiBydW4gbW9kdWxlIGNvbW1hbmQgICAgIC0gJCBucHggZGVjYWYgPG1vZHVsZSBuYW1lPiA8bW9kdWxlIGNvbW1hbmQ+IC4uLjxtb2R1bGUgY29tbWFuZCBvcHRpb25zPlxuICogZ2V0IG1vZHVsZSBoZWxwICAgICAgICAtICQgbnB4IGRlY2FmIGhlbHAgPG1vZHVsZSBuYW1lPjtcbiAqIGxpc3QgaW1wb3J0ZWQgbW9kdWxlcyAgLSAkIG5weCBkZWNhZiBsaXN0O1xuICogZ2V0IGNsaSBoZWxwICAgICAgICAgICAtICQgbnB4IGRlY2FmIGhlbHA7XG4gKlxuICogQG1lbWJlck9mIG1vZHVsZTpDTElcbiAqL1xuXG5pbXBvcnQgeyBDbGlXcmFwcGVyIH0gZnJvbSBcIi4uL0NsaVdyYXBwZXJcIjtcbm5ldyBDbGlXcmFwcGVyKClcbiAgLnJ1bihwcm9jZXNzLmFyZ3YpXG4gIC50aGVuKCgpID0+IHtcbiAgICBjb25zb2xlLmxvZyhcIlRoYW5rIHlvdSBmb3IgdXNpbmcgZGVjYWYtdHMnIGNvbW1hbmQgbGluZSBpbnRlcmZhY2VcIik7XG4gIH0pXG4gIC5jYXRjaCgoZTogdW5rbm93bikgPT4ge1xuICAgIGNvbnNvbGUuZXJyb3IoYCR7ZSBpbnN0YW5jZW9mIEVycm9yID8gZS5tZXNzYWdlIDogZX1gKTtcbiAgICBwcm9jZXNzLmV4aXQoMSk7XG4gIH0pO1xuIl19

package/lib/constants.cjs

@@ -9,3 +9,4 @@ exports.CLI_FILE_NAME = void 0;
  * @memberOf module:CLI.cli
  */
 exports.CLI_FILE_NAME = "cli-module";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFHQTs7Ozs7O0dBTUc7QUFDVSxRQUFBLGFBQWEsR0FBRyxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVudXNlZC12YXJzXG5pbXBvcnQgeyBDbGlNb2R1bGUgfSBmcm9tIFwiLi90eXBlc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBUaGUgbmFtZSBmb3IgZGVjYWYgY2xpIG1vZHVsZXMgd2hlcmUgZWFjaCBsaWJyYXJ5IG11c3QgZXhwb3J0XG4gKiBhIHNpbmdsZSB7QGxpbmsgQ2xpTW9kdWxlfVxuICpcbiAqIEBjb25zdGFudFxuICogQG1lbWJlck9mIG1vZHVsZTpDTEkuY2xpXG4gKi9cbmV4cG9ydCBjb25zdCBDTElfRklMRV9OQU1FID0gXCJjbGktbW9kdWxlXCI7XG4iXX0=

package/lib/demo/cli-module.cjs

@@ -35,3 +35,4 @@ function demo() {
         console.log(`executed demo command with type variable: ${args}`);
     });
 }
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/CliWrapper.js

@@ -117,5 +117,4 @@ export class CliWrapper {
         return this.command.parseAsync(args);
     }
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/CliWrapper.ts"],"names":[],"mappings":"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","file":"CliWrapper.js","sourcesContent":["import { Command } from \"commander\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport { CLI_FILE_NAME } from \"./constants\";\nimport { CLIUtils } from \"./utils\";\n\n/**\n * @summary Util class to handle CLI functionality from all Decaf modules\n * @description CLI handler class\n *\n * @param {string} [basepath] the base path to look for modules in. defaults to `./`\n * @param {string} [crawlLevels] folders to crawl to find modules from the basePath. defaults to 4\n *\n * @class CliWrapper\n */\nexport class CliWrapper {\n  private _command?: Command;\n  private modules: Record<string, Command> = {};\n\n  constructor(\n    private basePath: string = \"./\",\n    private crawlLevels = 4\n  ) {}\n\n  /**\n   * @description Retrieves and initializes the {@link Command} object\n   * @private\n   */\n  private get command() {\n    if (!this._command) {\n      this._command = new Command();\n      CLIUtils.initialize(this._command, this.basePath);\n    }\n    return this._command;\n  }\n\n  /**\n   * @description loads and registers module from a file\n   *\n   * @param {string} filePath path to look for modules\n   * @param {string} rootPath repo root to find the package.json\n   * @return {string} the module name\n   *\n   * @private\n   */\n  private async load(filePath: string, rootPath: string): Promise<string> {\n    let name;\n    try {\n      const module = await CLIUtils.loadFromFile(filePath);\n      name = module.name;\n      const cmd = new Command();\n      CLIUtils.initialize(cmd, path.dirname(rootPath));\n      let m = module();\n      if (m instanceof Promise) m = await m;\n      this.modules[name] = m;\n    } catch (e: unknown) {\n      throw new Error(\n        `failed to load module ${name || \"unnamed\"} under ${filePath}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n    return name;\n  }\n\n  /**\n   * @description finds all the cli modules in the basePath via {@link CliWrapper.crawl}\n   * and loads them\n   * @private\n   */\n  private async boot() {\n    const basePath = path.join(process.cwd(), this.basePath);\n    const modules = this.crawl(basePath, this.crawlLevels);\n    for (const module of modules) {\n      if (module.includes(\"@decaf-ts/cli\")) {\n        continue;\n      }\n      let name: string;\n      try {\n        name = await this.load(module, process.cwd());\n      } catch (e: unknown) {\n        console.error(e);\n        continue;\n      }\n\n      if (\n        !this.command.commands.find(\n          (c) => (c as unknown as Record<string, string>)[\"_name\"] === name\n        )\n      )\n        try {\n          this.command.command(name).addCommand(this.modules[name]);\n        } catch (e: unknown) {\n          console.error(e);\n        }\n    }\n    console.log(\n      `loaded modules:\\n${Object.keys(this.modules)\n        .map((k) => `- ${k}`)\n        .join(\"\\n\")}`\n    );\n  }\n\n  /**\n   * @description crawls the basePath up for 'levels' folders to find a module,eg a {@link CLI_FILE_NAME} named file\n   * @param {string} basePath the relative base batch to start searching in\n   * @param {number} [levels] the max number of levels to crawl. defaults to 2\n   * @private\n   */\n  private crawl(basePath: string, levels: number = 2) {\n    if (levels <= 0) return [];\n    return fs.readdirSync(basePath).reduce((accum: string[], file) => {\n      file = path.join(basePath, file);\n      if (fs.statSync(file).isDirectory()) {\n        accum.push(...this.crawl(file, levels - 1));\n      } else if (file.match(new RegExp(`${CLI_FILE_NAME}.[cm]?js$`, \"gm\"))) {\n        accum.push(file);\n      }\n      return accum;\n    }, []);\n  }\n\n  /**\n   * @description runs the given command\n   *\n   * @param {string[]} [args] args to run. defaults to process.argv\n   */\n  async run(args: string[] = process.argv) {\n    await this.boot();\n    return this.command.parseAsync(args);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CliWrapper.js","sourceRoot":"","sources":["../../src/CliWrapper.ts"],"names":[],"mappings":"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","sourcesContent":["import { Command } from \"commander\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport { CLI_FILE_NAME } from \"./constants\";\nimport { CLIUtils } from \"./utils\";\n\n/**\n * @summary Util class to handle CLI functionality from all Decaf modules\n * @description CLI handler class\n *\n * @param {string} [basepath] the base path to look for modules in. defaults to `./`\n * @param {string} [crawlLevels] folders to crawl to find modules from the basePath. defaults to 4\n *\n * @class CliWrapper\n */\nexport class CliWrapper {\n  private _command?: Command;\n  private modules: Record<string, Command> = {};\n\n  constructor(\n    private basePath: string = \"./\",\n    private crawlLevels = 4\n  ) {}\n\n  /**\n   * @description Retrieves and initializes the {@link Command} object\n   * @private\n   */\n  private get command() {\n    if (!this._command) {\n      this._command = new Command();\n      CLIUtils.initialize(this._command, this.basePath);\n    }\n    return this._command;\n  }\n\n  /**\n   * @description loads and registers module from a file\n   *\n   * @param {string} filePath path to look for modules\n   * @param {string} rootPath repo root to find the package.json\n   * @return {string} the module name\n   *\n   * @private\n   */\n  private async load(filePath: string, rootPath: string): Promise<string> {\n    let name;\n    try {\n      const module = await CLIUtils.loadFromFile(filePath);\n      name = module.name;\n      const cmd = new Command();\n      CLIUtils.initialize(cmd, path.dirname(rootPath));\n      let m = module();\n      if (m instanceof Promise) m = await m;\n      this.modules[name] = m;\n    } catch (e: unknown) {\n      throw new Error(\n        `failed to load module ${name || \"unnamed\"} under ${filePath}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n    return name;\n  }\n\n  /**\n   * @description finds all the cli modules in the basePath via {@link CliWrapper.crawl}\n   * and loads them\n   * @private\n   */\n  private async boot() {\n    const basePath = path.join(process.cwd(), this.basePath);\n    const modules = this.crawl(basePath, this.crawlLevels);\n    for (const module of modules) {\n      if (module.includes(\"@decaf-ts/cli\")) {\n        continue;\n      }\n      let name: string;\n      try {\n        name = await this.load(module, process.cwd());\n      } catch (e: unknown) {\n        console.error(e);\n        continue;\n      }\n\n      if (\n        !this.command.commands.find(\n          (c) => (c as unknown as Record<string, string>)[\"_name\"] === name\n        )\n      )\n        try {\n          this.command.command(name).addCommand(this.modules[name]);\n        } catch (e: unknown) {\n          console.error(e);\n        }\n    }\n    console.log(\n      `loaded modules:\\n${Object.keys(this.modules)\n        .map((k) => `- ${k}`)\n        .join(\"\\n\")}`\n    );\n  }\n\n  /**\n   * @description crawls the basePath up for 'levels' folders to find a module,eg a {@link CLI_FILE_NAME} named file\n   * @param {string} basePath the relative base batch to start searching in\n   * @param {number} [levels] the max number of levels to crawl. defaults to 2\n   * @private\n   */\n  private crawl(basePath: string, levels: number = 2) {\n    if (levels <= 0) return [];\n    return fs.readdirSync(basePath).reduce((accum: string[], file) => {\n      file = path.join(basePath, file);\n      if (fs.statSync(file).isDirectory()) {\n        accum.push(...this.crawl(file, levels - 1));\n      } else if (file.match(new RegExp(`${CLI_FILE_NAME}.[cm]?js$`, \"gm\"))) {\n        accum.push(file);\n      }\n      return accum;\n    }, []);\n  }\n\n  /**\n   * @description runs the given command\n   *\n   * @param {string[]} [args] args to run. defaults to process.argv\n   */\n  async run(args: string[] = process.argv) {\n    await this.boot();\n    return this.command.parseAsync(args);\n  }\n}\n"]}

package/lib/esm/bin/cli.js

@@ -0,0 +1,27 @@
+/**
+ * BIN_CALL_PLACEHOLDER - DO NOT REMOVE
+ */
+/**
+ * @description Decaf-ts' CLI entry file
+ * @summary This file will crawl the current working directory for files called {@link CLI_FILE_NAME}
+ * within the @decaf-ts namespace and load then as subcommands
+ *
+ * @example
+ * run module command     - $ npx decaf <module name> <module command> ...<module command options>
+ * get module help        - $ npx decaf help <module name>;
+ * list imported modules  - $ npx decaf list;
+ * get cli help           - $ npx decaf help;
+ *
+ * @memberOf module:CLI
+ */
+import { CliWrapper } from "../CliWrapper";
+new CliWrapper()
+    .run(process.argv)
+    .then(() => {
+    console.log("Thank you for using decaf-ts' command line interface");
+})
+    .catch((e) => {
+    console.error(`${e instanceof Error ? e.message : e}`);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2Jpbi9jbGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSDs7Ozs7Ozs7Ozs7O0dBWUc7QUFFSCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLElBQUksVUFBVSxFQUFFO0tBQ2IsR0FBRyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUM7S0FDakIsSUFBSSxDQUFDLEdBQUcsRUFBRTtJQUNULE9BQU8sQ0FBQyxHQUFHLENBQUMsc0RBQXNELENBQUMsQ0FBQztBQUN0RSxDQUFDLENBQUM7S0FDRCxLQUFLLENBQUMsQ0FBQyxDQUFVLEVBQUUsRUFBRTtJQUNwQixPQUFPLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxZQUFZLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUN2RCxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ2xCLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBCSU5fQ0FMTF9QTEFDRUhPTERFUiAtIERPIE5PVCBSRU1PVkVcbiAqL1xuLyoqXG4gKiBAZGVzY3JpcHRpb24gRGVjYWYtdHMnIENMSSBlbnRyeSBmaWxlXG4gKiBAc3VtbWFyeSBUaGlzIGZpbGUgd2lsbCBjcmF3bCB0aGUgY3VycmVudCB3b3JraW5nIGRpcmVjdG9yeSBmb3IgZmlsZXMgY2FsbGVkIHtAbGluayBDTElfRklMRV9OQU1FfVxuICogd2l0aGluIHRoZSBAZGVjYWYtdHMgbmFtZXNwYWNlIGFuZCBsb2FkIHRoZW4gYXMgc3ViY29tbWFuZHNcbiAqXG4gKiBAZXhhbXBsZVxuICogcnVuIG1vZHVsZSBjb21tYW5kICAgICAtICQgbnB4IGRlY2FmIDxtb2R1bGUgbmFtZT4gPG1vZHVsZSBjb21tYW5kPiAuLi48bW9kdWxlIGNvbW1hbmQgb3B0aW9ucz5cbiAqIGdldCBtb2R1bGUgaGVscCAgICAgICAgLSAkIG5weCBkZWNhZiBoZWxwIDxtb2R1bGUgbmFtZT47XG4gKiBsaXN0IGltcG9ydGVkIG1vZHVsZXMgIC0gJCBucHggZGVjYWYgbGlzdDtcbiAqIGdldCBjbGkgaGVscCAgICAgICAgICAgLSAkIG5weCBkZWNhZiBoZWxwO1xuICpcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Q0xJXG4gKi9cblxuaW1wb3J0IHsgQ2xpV3JhcHBlciB9IGZyb20gXCIuLi9DbGlXcmFwcGVyXCI7XG5uZXcgQ2xpV3JhcHBlcigpXG4gIC5ydW4ocHJvY2Vzcy5hcmd2KVxuICAudGhlbigoKSA9PiB7XG4gICAgY29uc29sZS5sb2coXCJUaGFuayB5b3UgZm9yIHVzaW5nIGRlY2FmLXRzJyBjb21tYW5kIGxpbmUgaW50ZXJmYWNlXCIpO1xuICB9KVxuICAuY2F0Y2goKGU6IHVua25vd24pID0+IHtcbiAgICBjb25zb2xlLmVycm9yKGAke2UgaW5zdGFuY2VvZiBFcnJvciA/IGUubWVzc2FnZSA6IGV9YCk7XG4gICAgcHJvY2Vzcy5leGl0KDEpO1xuICB9KTtcbiJdfQ==

package/lib/esm/constants.js

@@ -6,5 +6,4 @@
  * @memberOf module:CLI.cli
  */
 export const CLI_FILE_NAME = "cli-module";
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0E7Ozs7OztHQU1HO0FBQ0gsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFHLFlBQVksQ0FBQyIsImZpbGUiOiJjb25zdGFudHMuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVudXNlZC12YXJzXG5pbXBvcnQgeyBDbGlNb2R1bGUgfSBmcm9tIFwiLi90eXBlc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBUaGUgbmFtZSBmb3IgZGVjYWYgY2xpIG1vZHVsZXMgd2hlcmUgZWFjaCBsaWJyYXJ5IG11c3QgZXhwb3J0XG4gKiBhIHNpbmdsZSB7QGxpbmsgQ2xpTW9kdWxlfVxuICpcbiAqIEBjb25zdGFudFxuICogQG1lbWJlck9mIG1vZHVsZTpDTEkuY2xpXG4gKi9cbmV4cG9ydCBjb25zdCBDTElfRklMRV9OQU1FID0gXCJjbGktbW9kdWxlXCI7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQTs7Ozs7O0dBTUc7QUFDSCxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby11bnVzZWQtdmFyc1xuaW1wb3J0IHsgQ2xpTW9kdWxlIH0gZnJvbSBcIi4vdHlwZXNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gVGhlIG5hbWUgZm9yIGRlY2FmIGNsaSBtb2R1bGVzIHdoZXJlIGVhY2ggbGlicmFyeSBtdXN0IGV4cG9ydFxuICogYSBzaW5nbGUge0BsaW5rIENsaU1vZHVsZX1cbiAqXG4gKiBAY29uc3RhbnRcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Q0xJLmNsaVxuICovXG5leHBvcnQgY29uc3QgQ0xJX0ZJTEVfTkFNRSA9IFwiY2xpLW1vZHVsZVwiO1xuIl19

package/lib/esm/demo/cli-module.js

@@ -32,5 +32,4 @@ export default function demo() {
         console.log(`executed demo command with type variable: ${args}`);
     });
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/index.d.ts

@@ -32,4 +32,4 @@ export * from "./CliWrapper";
  * @const VERSION
  * @memberOf module:CLI
  */
-export declare const VERSION = "0.0.13";
+export declare const VERSION = "0.2.0";

package/lib/esm/index.js

@@ -32,6 +32,5 @@ export * from "./CliWrapper";
  * @const VERSION
  * @memberOf module:CLI
  */
-export const VERSION = "0.0.13";
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+export const VERSION = "0.2.0";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/types.js

@@ -1,3 +1,2 @@
 export {};
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwiZmlsZSI6InR5cGVzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbWFuZCB9IGZyb20gXCJjb21tYW5kZXJcIjtcbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdW51c2VkLXZhcnNcbmltcG9ydCB7IENMSV9GSUxFX05BTUUgfSBmcm9tIFwiLi9jb25zdGFudHNcIjtcblxuLyoqXG4gKiBAZGVzY3JpcHRpb24gZGVzY3JpYmVzIHRoZSBmdW5jdGlvbiB0eXBlIGVhY2ggZGVjYWYgbW9kdWxlIG11c3QgZXhwb3NlIHVuZGVyIHtAbGluayBDTElfRklMRV9OQU1FfVxuICogQHR5cGUgQ2xpTW9kdWxlXG4gKlxuICogQG1lbWJlck9mIG1vZHVsZS5DTEkuY2xpXG4gKi9cbmV4cG9ydCB0eXBlIENsaU1vZHVsZSA9ICgpID0+IENvbW1hbmQgfCBQcm9taXNlPENvbW1hbmQ+O1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1hbmQgfSBmcm9tIFwiY29tbWFuZGVyXCI7XG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVudXNlZC12YXJzXG5pbXBvcnQgeyBDTElfRklMRV9OQU1FIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIGRlc2NyaWJlcyB0aGUgZnVuY3Rpb24gdHlwZSBlYWNoIGRlY2FmIG1vZHVsZSBtdXN0IGV4cG9zZSB1bmRlciB7QGxpbmsgQ0xJX0ZJTEVfTkFNRX1cbiAqIEB0eXBlIENsaU1vZHVsZVxuICpcbiAqIEBtZW1iZXJPZiBtb2R1bGUuQ0xJLmNsaVxuICovXG5leHBvcnQgdHlwZSBDbGlNb2R1bGUgPSAoKSA9PiBDb21tYW5kIHwgUHJvbWlzZTxDb21tYW5kPjtcbiJdfQ==

package/lib/esm/utils.js

@@ -74,5 +74,4 @@ export class CLIUtils {
         return CLIUtils.getPackage(basePath)["name"].split("/")[1];
     }
 }
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.cjs

@@ -49,4 +49,5 @@ __exportStar(require("./CliWrapper.cjs"), exports);
  * @const VERSION
  * @memberOf module:CLI
  */
-exports.VERSION = "0.0.13";
+exports.VERSION = "0.2.0";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -32,4 +32,4 @@ export * from "./CliWrapper";
  * @const VERSION
  * @memberOf module:CLI
  */
-export declare const VERSION = "0.0.13";
+export declare const VERSION = "0.2.0";

package/lib/types.cjs

@@ -1,2 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1hbmQgfSBmcm9tIFwiY29tbWFuZGVyXCI7XG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVudXNlZC12YXJzXG5pbXBvcnQgeyBDTElfRklMRV9OQU1FIH0gZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIGRlc2NyaWJlcyB0aGUgZnVuY3Rpb24gdHlwZSBlYWNoIGRlY2FmIG1vZHVsZSBtdXN0IGV4cG9zZSB1bmRlciB7QGxpbmsgQ0xJX0ZJTEVfTkFNRX1cbiAqIEB0eXBlIENsaU1vZHVsZVxuICpcbiAqIEBtZW1iZXJPZiBtb2R1bGUuQ0xJLmNsaVxuICovXG5leHBvcnQgdHlwZSBDbGlNb2R1bGUgPSAoKSA9PiBDb21tYW5kIHwgUHJvbWlzZTxDb21tYW5kPjtcbiJdfQ==

package/lib/utils.cjs

@@ -114,3 +114,4 @@ class CLIUtils {
     }
 }
 exports.CLIUtils = CLIUtils;
+//# sourceMappingURL=data:application/json;base64,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