@player-tools/cli 0.0.2-next.0

package/README.md

@@ -0,0 +1,65 @@
+# Player CLI
+
+## Config
+
+Config files are able to customize the behavior of the CLI commands without requiring args. Behavior specific to execution can leverage `plugins`, which can be composed together using `presets`. Full configs can also be shared using `extensions`.
+
+To resolve a full configuration, the `extension` is taken as the base, the `presets` are applied in order, then local `plugins`.
+The format is similar to `eslint`, `babel` and other .rc/json/js based approaches.
+
+Config files are searched using cosmiconfig, which will look for:
+
+- a `player` property in package.json
+- a `.playerrc` file in JSON or YAML format
+- a `.player.json`, `.playerrc.yaml`, `.playerrc.yml`, `.playerrc.js`, or `.playerrc.cjs` file
+- a `player.config.js` or `player.config.cjs` CommonJS module exporting an object
+
+Example:
+
+```js
+module.exports = {
+  extends: '@my-scope/base',
+  plugins: [
+    'plugin-npm-package',
+    ['some-plugin-with-config', { config: true }],
+    {
+      // Plugins can also be defined inline
+      handler: () => {},
+    },
+  ],
+};
+```
+
+Options defined via the CLI arguments will take precedence over the config files (for things that overlap).
+
+## Plugins
+
+Plugins are the way to change runtime behavior of the CLI actions. This includes augmenting the behavior of the DSL compiler, language-service, and more.
+
+# Commands
+
+<!-- commands -->
+
+- [`player dsl compile`](#player-dsl-compile)
+
+## `player dsl compile`
+
+Compile Player DSL files into JSON
+
+```
+USAGE
+  $ player dsl compile -i <value> [-c <value>] [-o <value>] [--skip-validation]
+
+FLAGS
+  -c, --config=<value>  Path to a specific config file to load.
+                        By default, will automatically search for an rc or config file to load
+  -i, --input=<value>   (required) An input directory to compile.
+                        Any jsx/ts/tsx files will be loaded via babel-require automatically.
+  -o, --output=<value>  [default: _out] Output directory to write results to
+  --skip-validation     Option to skip validating the generated JSON
+
+DESCRIPTION
+  Compile Player DSL files into JSON
+```
+
+<!-- commandsstop -->

package/bin/run

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+const oclif = require('@oclif/core')
+process.env.NODE_ENV = 'production'
+
+oclif.run().then(require('@oclif/core/flush')).catch(require('@oclif/core/handle'))

package/dist/commands/dsl/compile.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../utils/base-command';
+/** A command to compile player DSL content into JSON */
+export default class DSLCompile extends BaseCommand {
+    static description: string;
+    static flags: {
+        input: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'skip-validation': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        exp: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+    };
+    private getOptions;
+    run(): Promise<{
+        /** the status code */
+        exitCode: number;
+    }>;
+}
+//# sourceMappingURL=compile.d.ts.map

package/dist/commands/dsl/compile.js

@@ -0,0 +1,146 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-await-in-loop */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable global-require */
+/* eslint-disable import/no-dynamic-require */
+const core_1 = require("@oclif/core");
+const globby_1 = __importDefault(require("globby"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const mkdirp_1 = __importDefault(require("mkdirp"));
+const log_symbols_1 = __importDefault(require("log-symbols"));
+const figures_1 = __importDefault(require("figures"));
+const chalk_1 = __importDefault(require("chalk"));
+const base_command_1 = require("../../utils/base-command");
+const fs_2 = require("../../utils/fs");
+const babel_register_1 = require("../../utils/babel-register");
+const validate_1 = __importDefault(require("../json/validate"));
+/** A command to compile player DSL content into JSON */
+class DSLCompile extends base_command_1.BaseCommand {
+    getOptions() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(DSLCompile);
+            const config = yield this.getPlayerConfig();
+            const input = (_a = flags.input) !== null && _a !== void 0 ? _a : (_b = config.dsl) === null || _b === void 0 ? void 0 : _b.src;
+            const { exp } = flags;
+            if (!input) {
+                throw new Error(`Input files are required for DSL compilation`);
+            }
+            return {
+                input,
+                output: (_e = (_c = flags.output) !== null && _c !== void 0 ? _c : (_d = config.dsl) === null || _d === void 0 ? void 0 : _d.outDir) !== null && _e !== void 0 ? _e : '_out',
+                skipValidation: (_h = (_f = flags['skip-validation']) !== null && _f !== void 0 ? _f : (_g = config.dsl) === null || _g === void 0 ? void 0 : _g.skipValidation) !== null && _h !== void 0 ? _h : false,
+                exp,
+            };
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { input, output, skipValidation, exp } = yield this.getOptions();
+            const files = yield (0, globby_1.default)((0, fs_2.convertToFileGlob)([input], '**/*.(tsx|jsx|js|ts)'), {
+                expandDirectories: true,
+            });
+            (0, babel_register_1.registerForPaths)();
+            this.debug('Found %i files to process', files.length);
+            const results = {
+                exitCode: 0,
+            };
+            /** Compile a file from the DSL format into JSON */
+            const compileFile = (file) => __awaiter(this, void 0, void 0, function* () {
+                const compiler = yield this.createDSLCompiler();
+                const requiredModule = require(path_1.default.resolve(file));
+                const defaultExport = requiredModule.default;
+                if (!defaultExport) {
+                    return;
+                }
+                let relativePath = path_1.default.relative(input, file);
+                if (!relativePath) {
+                    relativePath = path_1.default.basename(file);
+                }
+                const outputFile = path_1.default.join(output, path_1.default.format(Object.assign(Object.assign({}, path_1.default.parse(relativePath)), { base: undefined, ext: '.json' })));
+                this.log(`${log_symbols_1.default.info} Compiling %s ${figures_1.default.arrowRight} %s`, (0, fs_2.normalizePath)(file), (0, fs_2.normalizePath)(outputFile));
+                const { value, contentType } = yield compiler.serialize(defaultExport);
+                const contentStr = JSON.stringify(value, null, 2);
+                yield (0, mkdirp_1.default)(path_1.default.dirname(outputFile));
+                yield fs_1.promises.writeFile(outputFile, contentStr);
+                return {
+                    contentType,
+                    outputFile,
+                    inputFile: file,
+                };
+            });
+            const compilerResults = [];
+            // This has to be done serially b/c of the way React logs messages to console.error
+            // Otherwise the errors in console will be randomly interspersed between update messages
+            for (let fIndex = 0; fIndex < files.length; fIndex += 1) {
+                const file = files[fIndex];
+                try {
+                    const result = yield compileFile(file);
+                    compilerResults.push({
+                        output: result,
+                        state: 'completed',
+                    });
+                }
+                catch (e) {
+                    results.exitCode = 100;
+                    console.log('');
+                    console.log(chalk_1.default.red(`${log_symbols_1.default.error} Error compiling ${file}: ${e.message}`));
+                    this.debug(e);
+                    compilerResults.push({
+                        state: 'completed',
+                        error: e,
+                    });
+                }
+            }
+            if (!skipValidation) {
+                console.log('');
+                const hasOutput = compilerResults.some((r) => { var _a; return ((_a = r.output) === null || _a === void 0 ? void 0 : _a.contentType) === 'flow'; });
+                if (hasOutput) {
+                    yield validate_1.default.run([
+                        '-f',
+                        ...compilerResults
+                            .filter((r) => { var _a; return ((_a = r.output) === null || _a === void 0 ? void 0 : _a.contentType) === 'flow'; })
+                            .map((result) => {
+                            var _a, _b;
+                            return (_b = (_a = result.output) === null || _a === void 0 ? void 0 : _a.outputFile) !== null && _b !== void 0 ? _b : '';
+                        }),
+                        ...(exp ? ['--exp'] : []),
+                    ]);
+                }
+                else {
+                    console.log('No output to validate');
+                }
+            }
+            this.exit(results.exitCode);
+            return results;
+        });
+    }
+}
+exports.default = DSLCompile;
+DSLCompile.description = 'Compile Player DSL files into JSON';
+DSLCompile.flags = Object.assign(Object.assign({}, base_command_1.BaseCommand.flags), { input: core_1.Flags.string({
+        char: 'i',
+        description: 'An input directory to compile.\nAny jsx/ts/tsx files will be loaded via babel-require automatically.',
+    }), output: core_1.Flags.string({
+        char: 'o',
+        description: 'Output directory to write results to.',
+    }), 'skip-validation': core_1.Flags.boolean({
+        description: 'Option to skip validating the generated JSON',
+    }), exp: core_1.Flags.boolean({
+        description: 'Use experimental language features',
+        default: false,
+    }) });

package/dist/commands/json/validate.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../utils/base-command';
+/** A command to validate JSON content */
+export default class Validate extends BaseCommand {
+    static description: string;
+    static flags: {
+        files: import("@oclif/core/lib/interfaces").OptionFlag<string[]>;
+        exp: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+    };
+    private getOptions;
+    run(): Promise<{
+        /** the status code */
+        exitCode: number;
+    }>;
+}
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/json/validate.js

@@ -0,0 +1,91 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const globby_1 = __importDefault(require("globby"));
+const fs_1 = require("fs");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const base_command_1 = require("../../utils/base-command");
+const diag_renderer_1 = require("../../utils/diag-renderer");
+const fs_2 = require("../../utils/fs");
+const task_runner_1 = require("../../utils/task-runner");
+/** A command to validate JSON content */
+class Validate extends base_command_1.BaseCommand {
+    getOptions() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(Validate);
+            const config = yield this.getPlayerConfig();
+            const files = flags.files && flags.files.length > 0 ? flags.files : (_a = config.json) === null || _a === void 0 ? void 0 : _a.src;
+            const { exp } = flags;
+            if (!files) {
+                throw new Error('JSON validation requires a file list');
+            }
+            return {
+                files: Array.isArray(files) ? files : [files],
+                exp,
+            };
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { files: inputFiles, exp } = yield this.getOptions();
+            const expandedFilesList = (0, fs_2.convertToFileGlob)(inputFiles, '**/*.json');
+            this.debug('Searching for files using: %o', expandedFilesList);
+            const files = yield (0, globby_1.default)(expandedFilesList, {
+                expandDirectories: true,
+            });
+            this.debug('Found %i files to process', files.length);
+            const results = {
+                exitCode: 0,
+            };
+            const taskRunner = (0, task_runner_1.createTaskRunner)({
+                renderer: diag_renderer_1.validationRenderer,
+                tasks: files.map((f) => ({
+                    data: {
+                        file: f,
+                    },
+                    run: () => __awaiter(this, void 0, void 0, function* () {
+                        var _a;
+                        const contents = yield fs_1.promises.readFile(f, 'utf-8');
+                        const lsp = yield this.createLanguageService(exp);
+                        const validations = (_a = (yield lsp.validateTextDocument(vscode_languageserver_textdocument_1.TextDocument.create(`file://${f}`, 'json', 1, contents)))) !== null && _a !== void 0 ? _a : [];
+                        return validations;
+                    }),
+                })),
+            });
+            const taskResults = yield taskRunner.run();
+            taskResults.forEach((t) => {
+                if (t.error ||
+                    t.output.some((d) => d.severity === vscode_languageserver_types_1.DiagnosticSeverity.Error)) {
+                    results.exitCode = 100;
+                }
+            });
+            this.debug('finished');
+            this.exit(results.exitCode);
+            return results;
+        });
+    }
+}
+exports.default = Validate;
+Validate.description = 'Validate Player JSON content';
+Validate.flags = Object.assign(Object.assign({}, base_command_1.BaseCommand.flags), { files: core_1.Flags.string({
+        char: 'f',
+        description: 'A list of files or globs to validate',
+        multiple: true,
+    }), exp: core_1.Flags.boolean({
+        description: 'Use experimental language features',
+        default: false,
+    }) });

package/dist/commands/xlr/compile.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../utils/base-command';
+/**
+ * Exports TS Interfaces/Types to XLR format
+ */
+export default class XLRCompile extends BaseCommand {
+    static description: string;
+    static flags: {
+        input: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+    };
+    private getOptions;
+    run(): Promise<{
+        /** the status code */
+        exitCode: number;
+    }>;
+    /** Serializes ES6 Maps */
+    private replacer;
+    /** Generate extension manifest/description files from an Enhanced Player Plugin */
+    private processPlugin;
+}
+//# sourceMappingURL=compile.d.ts.map

package/dist/commands/xlr/compile.js

@@ -0,0 +1,233 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const typescript_1 = __importDefault(require("typescript"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const globby_1 = __importDefault(require("globby"));
+const log_symbols_1 = __importDefault(require("log-symbols"));
+const xlr_converters_1 = require("@player-tools/xlr-converters");
+const xlr_utils_1 = require("@player-tools/xlr-utils");
+const chalk_1 = __importDefault(require("chalk"));
+const base_command_1 = require("../../utils/base-command");
+const PLAYER_PLUGIN_INTERFACE_NAME = 'ExtendedPlayerPlugin';
+const customPrimitives = [
+    'Expression',
+    'Asset',
+    'Binding',
+    'AssetWrapper',
+    'Schema.DataType',
+];
+var Mode;
+(function (Mode) {
+    Mode["PLUGIN"] = "plugin";
+    Mode["TYPES"] = "types";
+})(Mode || (Mode = {}));
+/**
+ * Exports TS Interfaces/Types to XLR format
+ */
+class XLRCompile extends base_command_1.BaseCommand {
+    getOptions() {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(XLRCompile);
+            const config = yield this.getPlayerConfig();
+            const input = (_b = (_a = config.xlr) === null || _a === void 0 ? void 0 : _a.input) !== null && _b !== void 0 ? _b : flags.input;
+            const output = (_d = (_c = config.xlr) === null || _c === void 0 ? void 0 : _c.output) !== null && _d !== void 0 ? _d : flags.output;
+            const modeValue = (_f = (_e = config.xlr) === null || _e === void 0 ? void 0 : _e.mode) !== null && _f !== void 0 ? _f : flags.mode;
+            return {
+                inputPath: input,
+                outputDir: path_1.default.join(output, 'xlr'),
+                mode: modeValue === 'plugin' ? Mode.PLUGIN : Mode.TYPES,
+            };
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { inputPath, outputDir, mode } = yield this.getOptions();
+            const inputFiles = globby_1.default.sync([
+                `${inputPath}/**/*.ts`,
+                `${inputPath}/**/*.tsx`,
+            ]);
+            try {
+                this.processPlugin(inputFiles, outputDir, {}, mode);
+            }
+            catch (e) {
+                console.log('');
+                console.log(chalk_1.default.red(`${log_symbols_1.default.error} Error compiling XLRs: ${e.message}`));
+                console.log(chalk_1.default.red(`${e.stack}`));
+                return {
+                    exitCode: 1,
+                };
+            }
+            return { exitCode: 0 };
+        });
+    }
+    /** Serializes ES6 Maps */
+    replacer(key, value) {
+        if (value instanceof Map) {
+            return Object.fromEntries(value.entries());
+        }
+        return value;
+    }
+    /** Generate extension manifest/description files from an Enhanced Player Plugin */
+    processPlugin(fileNames, outputDir, options, mode = Mode.PLUGIN) {
+        var _a, _b, _c, _d;
+        // Build a program using the set of root file names in fileNames
+        const program = typescript_1.default.createProgram(fileNames, options);
+        fs_1.default.mkdirSync(outputDir, { recursive: true });
+        // Get the checker, we will use it to find more about classes
+        const checker = program.getTypeChecker();
+        const capabilities = {
+            pluginName: 'Unknown Plugin',
+        };
+        const converter = new xlr_converters_1.TsConverter(checker, customPrimitives);
+        /** visit nodes finding exported classes */
+        function pluginVisitor(node) {
+            var _a;
+            // Only consider exported nodes
+            if (!(0, xlr_utils_1.isNodeExported)(node)) {
+                return;
+            }
+            // Plugins are classes so filter those
+            if (typescript_1.default.isClassDeclaration(node) && node.name) {
+                const symbol = checker.getSymbolAtLocation(node.name);
+                if (symbol) {
+                    // look at what they implement
+                    (_a = node.heritageClauses) === null || _a === void 0 ? void 0 : _a.forEach((heritage) => {
+                        var _a;
+                        capabilities.pluginName =
+                            ((_a = node.name) === null || _a === void 0 ? void 0 : _a.text) || capabilities.pluginName;
+                        heritage.types.forEach((hInterface) => {
+                            var _a, _b, _c;
+                            // check if heritage is right one
+                            if (hInterface.expression.getText() !== PLAYER_PLUGIN_INTERFACE_NAME) {
+                                return;
+                            }
+                            const provides = new Map();
+                            const typeArgs = hInterface.typeArguments;
+                            const pluginDec = (_b = (_a = checker.getTypeAtLocation(hInterface).symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0];
+                            // process type parameters to figure out what capabilities are provided
+                            (_c = pluginDec === null || pluginDec === void 0 ? void 0 : pluginDec.typeParameters) === null || _c === void 0 ? void 0 : _c.forEach((param, index) => {
+                                var _a;
+                                const capabilityType = param.name.getText();
+                                if (index < ((_a = typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) !== null && _a !== void 0 ? _a : 0)) {
+                                    const exportedCapabilities = typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs[index];
+                                    // if its an array process each type
+                                    if (typescript_1.default.isTupleTypeNode(exportedCapabilities)) {
+                                        const capabilityNames = exportedCapabilities.elements.map((element) => {
+                                            var _a, _b;
+                                            if (typescript_1.default.isTypeReferenceNode(element)) {
+                                                const referenceSymbol = checker.getSymbolAtLocation(element.typeName);
+                                                const alias = referenceSymbol
+                                                    ? checker.getAliasedSymbol(referenceSymbol)
+                                                    : undefined;
+                                                const varDecl = (_a = alias === null || alias === void 0 ? void 0 : alias.declarations) === null || _a === void 0 ? void 0 : _a[0];
+                                                if (varDecl &&
+                                                    (typescript_1.default.isInterfaceDeclaration(varDecl) ||
+                                                        typescript_1.default.isTypeAliasDeclaration(varDecl))) {
+                                                    const capabilityDescription = converter.convertDeclaration(varDecl);
+                                                    const capabilityName = (_b = capabilityDescription === null || capabilityDescription === void 0 ? void 0 : capabilityDescription.name) !== null && _b !== void 0 ? _b : 'error';
+                                                    fs_1.default.writeFileSync(path_1.default.join(outputDir, `${capabilityName}.json`), JSON.stringify(capabilityDescription, undefined, 4));
+                                                    return capabilityName;
+                                                }
+                                            }
+                                            throw new Error(`Can't export non reference type ${element.getText()}`);
+                                        });
+                                        provides.set(capabilityType, capabilityNames);
+                                    }
+                                    else if (typescript_1.default.isTypeReferenceNode(exportedCapabilities)) {
+                                        const capabilityName = exportedCapabilities.typeName.getText();
+                                        const capabilityDescription = converter.convertTsTypeNode(exportedCapabilities);
+                                        fs_1.default.writeFileSync(path_1.default.join(outputDir, `${capabilityName}.json`), JSON.stringify(capabilityDescription, undefined, 4));
+                                        provides.set(capabilityType, [capabilityName]);
+                                    }
+                                    else {
+                                        throw new Error(`Can't figure out type ${capabilityType}`);
+                                    }
+                                }
+                            });
+                            capabilities.capabilities = provides;
+                        });
+                    });
+                }
+            }
+        }
+        /** export all exported types in the file */
+        function fileVisitor(file) {
+            const convertedTypes = converter.convertSourceFile(file);
+            convertedTypes.data.types.forEach((type) => {
+                fs_1.default.writeFileSync(path_1.default.join(outputDir, `${type.name}.json`), JSON.stringify(type, undefined, 4));
+            });
+            capabilities.capabilities = new Map([
+                ['Types', convertedTypes.convertedTypes],
+            ]);
+        }
+        // Visit every sourceFile in the program
+        program.getSourceFiles().forEach((sourceFile) => {
+            if (!sourceFile.isDeclarationFile) {
+                // Walk the tree to search for classes
+                if (mode === Mode.PLUGIN) {
+                    typescript_1.default.forEachChild(sourceFile, pluginVisitor);
+                }
+                else if (mode === Mode.TYPES) {
+                    capabilities.pluginName = 'Types';
+                    fileVisitor(sourceFile);
+                }
+                else {
+                    throw new Error(`Error: Option ${mode} not recognized. Valid options are: plugin or type`);
+                }
+            }
+        });
+        // print out the manifest files
+        const jsonManifest = JSON.stringify(capabilities, this.replacer, 4);
+        fs_1.default.writeFileSync(path_1.default.join(outputDir, 'manifest.json'), jsonManifest);
+        const tsManifestFile = `${[...((_b = (_a = capabilities.capabilities) === null || _a === void 0 ? void 0 : _a.values()) !== null && _b !== void 0 ? _b : [])]
+            .flat(2)
+            .map((capability) => {
+            return `import ${capability} from './${capability}.json'`;
+        })
+            .join('\n')}
+
+export default {
+  "pluginName": "${capabilities.pluginName}",
+  "capabilities": {
+    ${[...((_d = (_c = capabilities.capabilities) === null || _c === void 0 ? void 0 : _c.entries()) !== null && _d !== void 0 ? _d : [])]
+            .map(([capabilityName, provides]) => {
+            return `"${capabilityName}":[${provides.join(',')}],`;
+        })
+            .join('\n\t\t')}
+  }
+}
+`;
+        fs_1.default.writeFileSync(path_1.default.join(outputDir, 'manifest.js'), tsManifestFile);
+    }
+}
+exports.default = XLRCompile;
+XLRCompile.description = 'Compiles typescript files to XLRs format';
+XLRCompile.flags = Object.assign(Object.assign({}, base_command_1.BaseCommand.flags), { input: core_1.Flags.string({
+        char: 'i',
+        description: 'An input directory to search for types to export',
+        default: './src',
+    }), output: core_1.Flags.string({
+        char: 'o',
+        description: 'Output directory to write results to.',
+        default: './dist',
+    }), mode: core_1.Flags.enum({
+        char: 'm',
+        description: 'Search strategy for types to export: plugin (default, looks for exported EnchancedPlayerPlugin classes) or type (all exported types)',
+        options: ['plugin', 'types'],
+        default: 'plugin',
+    }) });

package/dist/commands/xlr/convert.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../utils/base-command';
+/**
+ * Converts XLRs into a specific language
+ */
+export default class XLRConvert extends BaseCommand {
+    static description: string;
+    static flags: {
+        input: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+        output: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        lang: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+    };
+    private getOptions;
+    run(): Promise<{
+        /** the status code */
+        exitCode: number;
+    }>;
+}
+//# sourceMappingURL=convert.d.ts.map