@player-cli/cli 0.0.2--canary.6.49

package/README.md

@@ -0,0 +1,82 @@
+# 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
+```
+
+## `player dsl validate`
+
+Runs isolated TSC type-checking instance on authored Player DSL Typescript files.
+
+```
+USAGE
+  $ player dsl validate [-f <value>] [-c <value>] 
+
+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
+  -f, --files=<value>...  A list of files or globs to validate
+
+DESCRIPTION
+  Runs isolated TSC type-checking instance on authored Player DSL Typescript files.
+```
+
+<!-- commandsstop -->

package/bin/dev

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+const oclif = require("@oclif/core");
+
+const path = require("path");
+const project = path.join(__dirname, "..", "tsconfig.json");
+
+// In dev mode -> use ts-node and dev plugins
+process.env.NODE_ENV = "development";
+
+require("ts-node").register({ project });
+
+// In dev mode, always show stack traces
+oclif.settings.debug = true;
+
+// Start the CLI
+oclif.run().then(oclif.flush).catch(oclif.Errors.handle);

package/bin/run

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+const oclif = require("@oclif/core");
+
+// Setting this to production break source-map generation for dsl content
+process.env.NODE_ENV = "development";
+
+oclif
+  .run()
+  .then(require("@oclif/core/flush"))
+  .catch(require("@oclif/core/handle"));

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

@@ -0,0 +1,19 @@
+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>;
+        loglevel: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+    };
+    private getOptions;
+    run(): Promise<{
+        /** the status code */
+        exitCode: number;
+    }>;
+}
+//# sourceMappingURL=check.d.ts.map

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

@@ -0,0 +1,270 @@
+"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 {
+    static summary = "Checks for @player-ui/@player-tools dependency version mismatches and issues warnings/solutions accordingly";
+    static 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.
+  `;
+    static 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,
+        }),
+    };
+    async getOptions() {
+        const { flags } = await this.parse(DependencyVersionsCheck);
+        return {
+            verbose: flags.verbose,
+            path: flags.path,
+            ignore: flags.ignore,
+        };
+    }
+    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;
+    }
+}
+exports.default = DependencyVersionsCheck;
+//# sourceMappingURL=check.js.map

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

@@ -0,0 +1,20 @@
+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>;
+        severity: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        loglevel: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+    };
+    private getOptions;
+    run(): Promise<{
+        /** the status code */
+        exitCode: number;
+    }>;
+}
+//# sourceMappingURL=compile.d.ts.map

package/dist/commands/dsl/compile.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const globby_1 = tslib_1.__importDefault(require("globby"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = require("fs");
+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 = 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 {
+    static description = "Compile Player DSL files into JSON";
+    static 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,
+        }),
+        severity: core_1.Flags.string({
+            char: "s",
+            description: "The severity of validation issues",
+            options: ["error", "warn"],
+            default: "error",
+        }),
+    };
+    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,
+            severity: flags.severity,
+            loglevel: flags.loglevel,
+        };
+    }
+    async run() {
+        const { input, output, skipValidation, exp, severity, loglevel } = 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, "-s", severity]);
+        }
+        const context = await this.createCompilerContext();
+        /** Compile a file from the DSL format into JSON */
+        const compileFile = async (file) => {
+            // Check if any plugin wants to skip this file
+            const shouldSkipCompilation = await context.hooks.skipCompilation.call(file);
+            if (shouldSkipCompilation) {
+                this.log(`${log_symbols_1.default.info} Skipping compilation for %s`, (0, fs_2.normalizePath)(file));
+                return;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            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 { type: contentType, extension: ext } = (await context.hooks.identifyContentType.call(file, preProcessedValue)) || {
+                type: (0, dsl_1.fingerprintContent)(preProcessedValue, file) || "unknown",
+                extension: ".json",
+            };
+            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,
+            }));
+            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) {
+                await (0, mkdirp_1.default)(path_1.default.dirname(outputFile));
+                await fs_1.promises.writeFile(outputFile, compileResult.value);
+                if (compileResult.sourceMap) {
+                    await fs_1.promises.writeFile(`${outputFile}.map`, compileResult.sourceMap);
+                }
+                return {
+                    contentType,
+                    outputFile,
+                    inputFile: file,
+                };
+            }
+            else {
+                this.log(`${log_symbols_1.default.error} Error compiling %s, no result was returned by compiler`, (0, fs_2.normalizePath)(file));
+                throw new Error(`Error compiling file ${(0, fs_2.normalizePath)(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 = await 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.stack}`));
+                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"] : []),
+                    "-s",
+                    severity,
+                    "-v",
+                    loglevel,
+                ]);
+            }
+            else {
+                console.log("No output to validate");
+            }
+        }
+        this.exit(results.exitCode);
+        return results;
+    }
+}
+exports.default = DSLCompile;
+//# sourceMappingURL=compile.js.map

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

@@ -0,0 +1,15 @@
+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[]>;
+        severity: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        loglevel: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+    };
+    private getOptions;
+    private getTSConfig;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=validate.d.ts.map