@player-tools/cli 0.4.2-next.1 → 0.5.0-next.0

package/dist/commands/dependency-versions/check.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from "../../utils/base-command";
+/** A command to get @player-ui/@player-tools dependency versions and issue warnings/recommendations based on them */
+export default class DependencyVersionsCheck extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static flags: {
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        path: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        ignore: 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=check.d.ts.map

package/dist/commands/dependency-versions/check.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const globby_1 = tslib_1.__importDefault(require("globby"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra")); // fse rather than fs makes unit testing easier with mocking
+const easy_table_1 = tslib_1.__importDefault(require("easy-table"));
+const child_process_1 = tslib_1.__importDefault(require("child_process"));
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../utils/base-command");
+/** A command to get @player-ui/@player-tools dependency versions and issue warnings/recommendations based on them */
+class DependencyVersionsCheck extends base_command_1.BaseCommand {
+    async getOptions() {
+        const { flags } = await this.parse(DependencyVersionsCheck);
+        return {
+            verbose: flags.verbose,
+            path: flags.path,
+            ignore: flags.ignore,
+        };
+    }
+    /* eslint-disable complexity */
+    async run() {
+        const results = {
+            exitCode: 0,
+        };
+        // Note: please do not easily change these exit codes, they are used for exit code detection in Jenkins pipeline(s)
+        const WARNING_EXIT_CODE = 1;
+        const NOT_RUN_AT_REPO_ROOT_EXIT_CODE = 2;
+        const chalkNegative = chalk_1.default.bgRed.white;
+        const chalkPositive = chalk_1.default.bgGreen;
+        const localGithubRepoRoot = child_process_1.default
+            .execSync("git rev-parse --show-toplevel")
+            .toString()
+            .trimEnd();
+        const currentDirectory = process.cwd();
+        if (localGithubRepoRoot !== currentDirectory) {
+            console.log(`${chalkNegative("ERROR:")} cannot run the CLI in ${currentDirectory}`);
+            console.log(`Please run the CLI in the root of the repository, ${localGithubRepoRoot}`);
+            results.exitCode = NOT_RUN_AT_REPO_ROOT_EXIT_CODE;
+            this.exit(results.exitCode);
+            return results;
+        }
+        const { verbose, path, ignore } = await this.getOptions();
+        console.log("Consider using the --help flag for more information about this command.");
+        if (!verbose) {
+            console.log("For more comprehensive logging, consider adding the -v flag.");
+        }
+        if (!path) {
+            console.log("For logging with full path to the dependency rather than with '➡', consider adding the -p flag.");
+        }
+        if (ignore) {
+            console.log("All output based on the versions/dependencies yielded after eliminating the patterns specified by the -i flag.");
+        }
+        else {
+            console.log("To add string pattern(s) for files to exclude, consider adding them after the -i flag.");
+        }
+        console.log("Inspecting the @player-ui/@player-tools dependencies in the current repository...");
+        let packageJsons = globby_1.default.sync("**/node_modules/{@player,@player-language,@web-player}/*/package.json");
+        if (ignore) {
+            // It is necessary to filter here rather than to pass extra options to globSync.
+            // This is because we need want to filter based on partial matches of the file path string
+            // whereas any filtering of globSync itself is heavily based on the file path as part of the system
+            // and not the file as a simple string.
+            packageJsons = packageJsons.filter((packageJson) => {
+                return !ignore.some((patternToIgnore) => packageJson.includes(patternToIgnore));
+            });
+        }
+        // Initialize the maps storing the dependency versions mapping to the packages with that version
+        const versionToTopLevelDependencyMap = {};
+        const versionToNestedDependencyMap = {};
+        // Populate the dependency maps
+        for (const packageJsonFile of packageJsons) {
+            const { version } = JSON.parse(fs_extra_1.default.readFileSync(packageJsonFile, "utf8"));
+            // top-level dependencies only have `node_modules` occurring once in their path
+            const isTopLevelDependency = (packageJsonFile.match(/node_modules/g) || []).length === 1;
+            const mapToUpdate = isTopLevelDependency
+                ? versionToTopLevelDependencyMap
+                : versionToNestedDependencyMap;
+            if (version in mapToUpdate) {
+                mapToUpdate[version].push(packageJsonFile);
+            }
+            else {
+                mapToUpdate[version] = [packageJsonFile];
+            }
+        }
+        const topLevelVersions = Object.keys(versionToTopLevelDependencyMap);
+        const nestedVersions = Object.keys(versionToNestedDependencyMap);
+        /**
+         * copied from https://www.npmjs.com/package/semver-compare?activeTab=code
+         * rather than yarn-installed since its short.
+         *
+         * @returns the result of comparison
+         */
+        function cmp(a, b) {
+            const pa = a.split(".");
+            const pb = b.split(".");
+            for (let i = 0; i < 3; i++) {
+                const na = Number(pa[i]);
+                const nb = Number(pb[i]);
+                if (na > nb)
+                    return 1;
+                if (nb > na)
+                    return -1;
+                if (!isNaN(na) && isNaN(nb))
+                    return 1;
+                if (isNaN(na) && !isNaN(nb))
+                    return -1;
+            }
+            return 0;
+        }
+        const sortedTopLevelVersions = topLevelVersions.sort(cmp);
+        const sortedNestedVersions = nestedVersions.sort(cmp);
+        const topLevelDependenciesTable = new easy_table_1.default();
+        const nestedDependenciesTable = new easy_table_1.default();
+        const highestTopLevelVersion = sortedTopLevelVersions[sortedTopLevelVersions.length - 1];
+        const highestNestedVersion = sortedNestedVersions[sortedNestedVersions.length - 1];
+        const singleVersionsExist = topLevelVersions.length === 1 && nestedVersions.length === 1;
+        const singleVersionsMatch = singleVersionsExist && topLevelVersions[0] === nestedVersions[0];
+        const singleVersionsMismatch = singleVersionsExist && topLevelVersions[0] !== nestedVersions[0];
+        const topLevelVersionsExist = topLevelVersions.length > 0;
+        const nestedVersionsExist = nestedVersions.length > 0;
+        const multipleTopLevelVersionsDetected = topLevelVersions.length > 1;
+        const multipleNestedVersionsDetected = nestedVersions.length > 1;
+        /**
+         * Formats the path to the dependency
+         *
+         * @param fullPath
+         * @returns the formatted path with ➡ arrows for the CLI user to follow
+         */
+        function formatDependencyPath(fullPath) {
+            const pathArrayWithoutNodeModules = fullPath.split("node_modules/");
+            let formattedPath = "";
+            for (let i = 0; i < pathArrayWithoutNodeModules.length; i++) {
+                if (pathArrayWithoutNodeModules[i] !== "") {
+                    formattedPath += ` ➡ ${pathArrayWithoutNodeModules[i]}`;
+                }
+            }
+            formattedPath = formattedPath.replace("/package.json", ""); // remove /package.json at the end
+            return formattedPath;
+        }
+        /**
+         * Prints the formatted dependencyTable
+         *
+         * @param printsTopLevelTable - whether to print the top-level table or not
+         */
+        function printTable(versionToDependencyMap, sortedVersions, table) {
+            sortedVersions.forEach(function (version) {
+                const dependencies = versionToDependencyMap[version];
+                const msg = path
+                    ? "Path to dependency's package.json"
+                    : "How to find dependency";
+                const firstDependency = path
+                    ? dependencies[0]
+                    : formatDependencyPath(dependencies[0]);
+                table.cell("Version", version);
+                table.cell(msg, firstDependency);
+                table.newRow();
+                const maxNumberOfDepsToPrint = verbose
+                    ? dependencies.length
+                    : Math.min(3, dependencies.length); // in non-verbose, print out at most 3 dependencies
+                const numberOfDepsNotPrintedInNonVerbose = dependencies.length - maxNumberOfDepsToPrint;
+                for (let i = 1; i < maxNumberOfDepsToPrint; i++) {
+                    table.cell("Version", "");
+                    const dependency = path
+                        ? dependencies[i]
+                        : formatDependencyPath(dependencies[i]);
+                    table.cell(msg, dependency);
+                    table.newRow();
+                }
+                if (numberOfDepsNotPrintedInNonVerbose > 0) {
+                    table.cell("Version", "");
+                    const notPrintedMsg = `... ${numberOfDepsNotPrintedInNonVerbose} other dependencies not printed in non-verbose mode.`;
+                    table.cell(msg, notPrintedMsg);
+                    table.newRow();
+                }
+            });
+            console.log(table.toString());
+        }
+        if (topLevelVersionsExist) {
+            console.log("\nTOP-LEVEL @player-ui/@player-tools DEPENDENCIES:");
+            printTable(versionToTopLevelDependencyMap, sortedTopLevelVersions, topLevelDependenciesTable);
+        }
+        if (nestedVersionsExist) {
+            console.log("\nNESTED @player-ui/@player-tools DEPENDENCIES:");
+            printTable(versionToNestedDependencyMap, sortedNestedVersions, nestedDependenciesTable);
+        }
+        if ((!topLevelVersionsExist && nestedVersions.length === 1) ||
+            (!nestedVersionsExist && topLevelVersions.length === 1) ||
+            (!nestedVersionsExist && !topLevelVersionsExist) ||
+            singleVersionsMatch) {
+            if (singleVersionsMatch) {
+                console.log("Unique top-level and nested @player-ui/@player-tools versions match. ");
+            }
+            if (!topLevelVersionsExist && nestedVersions.length === 1) {
+                console.log(`No top-level @player-ui/@player-tools dependencies exist. Only a single nested @player-ui/@player-tools version exists, ${nestedVersions[0]}`);
+            }
+            if (!nestedVersionsExist && topLevelVersions.length === 1) {
+                console.log(`No nested @player-ui/@player-tools dependencies exist. Only a single top-level @player-ui/@player-tools version exists, ${topLevelVersions[0]}`);
+            }
+            if (!nestedVersionsExist && !topLevelVersionsExist) {
+                console.log("No @player-ui/@player-tools dependencies exist.");
+            }
+            console.log("There are no issues related to @player-ui/@player-tools dependency versioning. You are good to go! ");
+            this.exit(results.exitCode);
+            return results;
+        }
+        console.log(chalkNegative("WARNINGS:"));
+        if (multipleTopLevelVersionsDetected) {
+            console.log("- There are multiple top-level @player-ui/@player-tools dependency versions.");
+        }
+        if (multipleNestedVersionsDetected) {
+            console.log("- There are multiple nested @player-ui/@player-tools dependency versions.");
+        }
+        if (singleVersionsMismatch) {
+            console.log("- Mismatch between the top-level and the nested @player-ui/@player-tools dependency.");
+        }
+        console.log(chalkPositive("RECOMMENDATIONS:"));
+        if (multipleTopLevelVersionsDetected) {
+            console.log(`- Resolve all top-level @player-ui/@player-tools dependencies to the same version. Consider updating them to the latest player version you have, ${highestTopLevelVersion}. When all top-level @player-ui/@player-tools dependencies are resolved, run the current CLI again to obtain recommendations about nested @player-ui/@player-tools dependencies.`);
+        }
+        else if (highestTopLevelVersion && highestNestedVersion) {
+            // highestTopLevelVersion && highestNestedVersion defined means: single top-level version, one or more nested versions
+            if (cmp(highestTopLevelVersion, highestNestedVersion) >= 1) {
+                // when only a single top-level version is detected, it is simply the highest
+                console.log(`- The highest @player-ui/@player-tools version is ${highestTopLevelVersion} at the top level. Please add resolutions for all nested @player-ui/@player-tools versions to this version or bump the nested versions to it.`);
+            }
+            else {
+                console.log(`- The highest @player-ui/@player-tools version is ${highestNestedVersion} at the nested level. Please bump the top-level version, ${highestTopLevelVersion}, to ${highestNestedVersion}.`);
+                if (multipleNestedVersionsDetected) {
+                    console.log(`- Also, please add resolutions or bump the versions for nested @player-ui/@player-tools dependencies whose version is not ${highestNestedVersion}.`);
+                }
+            }
+        }
+        else if (highestNestedVersion && multipleNestedVersionsDetected) {
+            // no top-level version defined, multiple nested versions
+            console.log(`- The highest @player-ui/@player-tools version is ${highestNestedVersion} at the nested level. Please add resolutions for all nested @player-ui/@player-tools versions to this version or bump the nested versions to it.`);
+        }
+        // Although no errors have occurred when the code reaches here, a non-zero exit code of WARNING_EXIT_CODE = 1 is still used to indicate
+        // the idea of "warnings" being issued due to dependency version discrepancies
+        results.exitCode = WARNING_EXIT_CODE;
+        this.exit(results.exitCode);
+        return results;
+    }
+}
+DependencyVersionsCheck.summary = "Checks for @player-ui/@player-tools dependency version mismatches and issues warnings/solutions accordingly";
+DependencyVersionsCheck.description = `Consider the following:
+  - The interpretation of TOP-LEVEL and NESTED dependencies is as follows:
+    a. TOP-LEVEL dependencies only have one 'node_modules' in their path
+    b. NESTED dependencies have more than one 'node_modules' in their path
+  - @player-ui/@player-tools dependencies are fetched not only from inside the 'node_modules' at the top of the repository in which it is run but also from 'node_modules' in sub-directories.
+  For example, if you have some 'node_modules' inside of a 'packages' folder that contains @player-ui/@player-tools dependencies, then these will also be fetched.
+  The display of such dependencies also depends on the first bullet point.
+  `;
+DependencyVersionsCheck.flags = {
+    ...base_command_1.BaseCommand.flags,
+    verbose: core_1.Flags.boolean({
+        char: "v",
+        description: "Give verbose description",
+    }),
+    path: core_1.Flags.boolean({
+        char: "p",
+        description: "Outputs full path to dependency",
+    }),
+    ignore: core_1.Flags.string({
+        char: "i",
+        description: "Ignore the specified pattern(s) when outputting results. Note multiple patterns can be passed",
+        multiple: true,
+    }),
+};
+exports.default = DependencyVersionsCheck;
+//# sourceMappingURL=check.js.map

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

@@ -1,11 +1,11 @@
-import { BaseCommand } from '../../utils/base-command';
+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>;
+        "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>;
     };

package/dist/commands/dsl/compile.js

@@ -1,164 +1,159 @@
 "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 tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
-const globby_1 = __importDefault(require("globby"));
-const path_1 = __importDefault(require("path"));
+const globby_1 = tslib_1.__importDefault(require("globby"));
+const path_1 = tslib_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 mkdirp_1 = tslib_1.__importDefault(require("mkdirp"));
+const log_symbols_1 = tslib_1.__importDefault(require("log-symbols"));
+const figures_1 = tslib_1.__importDefault(require("figures"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const dsl_1 = require("@player-tools/dsl");
 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"));
+const validate_1 = tslib_1.__importDefault(require("../json/validate"));
+const validate_2 = tslib_1.__importDefault(require("./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,
-            };
-        });
+    async getOptions() {
+        const { flags } = await this.parse(DSLCompile);
+        const config = await this.getPlayerConfig();
+        const input = flags.input ?? config.dsl?.src;
+        const { exp } = flags;
+        if (!input) {
+            throw new Error(`Input files are required for DSL compilation`);
+        }
+        return {
+            input,
+            output: flags.output ?? config.dsl?.outDir ?? "_out",
+            skipValidation: flags["skip-validation"] ?? config.dsl?.skipValidation ?? 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,
-            };
-            const context = yield this.createCompilerContext();
-            /** Compile a file from the DSL format into JSON */
-            const compileFile = (file) => __awaiter(this, void 0, void 0, function* () {
-                const requiredModule = require(path_1.default.resolve(file));
-                const defaultExport = requiredModule.default;
-                if (!defaultExport) {
-                    return;
-                }
-                const preProcessedValue = yield context.dslCompiler.hooks.preProcessFlow.call(defaultExport);
-                const contentType = (yield context.hooks.identifyContentType.call(file, preProcessedValue)) ||
-                    (0, dsl_1.fingerprintContent)(preProcessedValue, file) ||
-                    'unknown';
-                let relativePath = path_1.default.relative(input, file);
-                if (!relativePath) {
-                    relativePath = path_1.default.basename(file);
+    async run() {
+        const { input, output, skipValidation, exp } = await this.getOptions();
+        const files = await (0, globby_1.default)((0, fs_2.convertToFileGlob)([input], "**/*.(tsx|jsx|js|ts)"), {
+            expandDirectories: true,
+        });
+        const results = {
+            exitCode: 0,
+        };
+        (0, babel_register_1.registerForPaths)();
+        this.debug("Found %i files to process", files.length);
+        if (!skipValidation) {
+            await validate_2.default.run(["-f", input]);
+        }
+        const context = await this.createCompilerContext();
+        /** Compile a file from the DSL format into JSON */
+        const compileFile = async (file) => {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const requiredModule = require(path_1.default.resolve(file));
+            const defaultExport = requiredModule.default;
+            if (!defaultExport) {
+                return;
+            }
+            const preProcessedValue = await context.dslCompiler.hooks.preProcessFlow.call(defaultExport);
+            const contentType = (await context.hooks.identifyContentType.call(file, preProcessedValue)) ||
+                (0, dsl_1.fingerprintContent)(preProcessedValue, file) ||
+                "unknown";
+            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({
+                ...path_1.default.parse(relativePath),
+                base: undefined,
+                ext: ".json",
+            }));
+            this.log(`${log_symbols_1.default.info} Compiling %s ${figures_1.default.arrowRight} %s as type %s`, (0, fs_2.normalizePath)(file), (0, fs_2.normalizePath)(outputFile), contentType);
+            const compileResult = await context.hooks.compileContent.call({ type: contentType }, preProcessedValue, file);
+            if (compileResult) {
+                const contentStr = JSON.stringify(compileResult.value, null, 2);
+                await (0, mkdirp_1.default)(path_1.default.dirname(outputFile));
+                await fs_1.promises.writeFile(outputFile, contentStr);
+                if (compileResult.sourceMap) {
+                    await fs_1.promises.writeFile(`${outputFile}.map`, compileResult.sourceMap);
                 }
-                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 as type %s`, (0, fs_2.normalizePath)(file), (0, fs_2.normalizePath)(outputFile), contentType);
-                const compileResult = yield context.hooks.compileContent.call({ type: contentType }, defaultExport, file);
-                if (compileResult) {
-                    const contentStr = JSON.stringify(compileResult.value, null, 2);
-                    yield (0, mkdirp_1.default)(path_1.default.dirname(outputFile));
-                    yield fs_1.promises.writeFile(outputFile, contentStr);
-                    if (compileResult.sourceMap) {
-                        yield fs_1.promises.writeFile(`${outputFile}.map`, compileResult.sourceMap);
-                    }
-                    if (contentType) {
-                        return {
-                            contentType,
-                            outputFile,
-                            inputFile: file,
-                        };
-                    }
+                if (contentType) {
                     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;
-                    this.log('');
-                    this.log(chalk_1.default.red(`${log_symbols_1.default.error} Error compiling ${file}: ${e.message}`));
-                    this.debug(e);
-                    compilerResults.push({
-                        state: 'completed',
-                        error: e,
-                    });
-                }
+                return {
+                    contentType,
+                    outputFile,
+                    inputFile: file,
+                };
             }
-            yield context.dslCompiler.hooks.onEnd.call({ output });
-            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');
-                }
+        };
+        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 = await compileFile(file);
+                compilerResults.push({
+                    output: result,
+                    state: "completed",
+                });
             }
-            this.exit(results.exitCode);
-            return results;
-        });
+            catch (e) {
+                results.exitCode = 100;
+                this.log("");
+                this.log(chalk_1.default.red(`${log_symbols_1.default.error} Error compiling ${file}: ${e.message}`));
+                this.debug(e);
+                compilerResults.push({
+                    state: "completed",
+                    error: e,
+                });
+            }
+        }
+        await context.dslCompiler.hooks.onEnd.call({ output });
+        if (!skipValidation) {
+            console.log("");
+            const hasOutput = compilerResults.some((r) => r.output?.contentType === "flow");
+            if (hasOutput) {
+                await validate_1.default.run([
+                    "-f",
+                    ...compilerResults
+                        .filter((r) => r.output?.contentType === "flow")
+                        .map((result) => {
+                        return result.output?.outputFile ?? "";
+                    }),
+                    ...(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',
+DSLCompile.description = "Compile Player DSL files into JSON";
+DSLCompile.flags = {
+    ...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,
-    }) });
+    }),
+};
+exports.default = DSLCompile;
+//# sourceMappingURL=compile.js.map

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

@@ -0,0 +1,12 @@
+import { BaseCommand } from "../../utils/base-command";
+/** A command thay runs TS typechecker against source ts and tsx files */
+export default class Validate extends BaseCommand {
+    static description: string;
+    static flags: {
+        files: import("@oclif/core/lib/interfaces").OptionFlag<string[]>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+    };
+    private getOptions;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=validate.d.ts.map