@player-tools/cli 0.0.2-next.0

package/dist/commands/xlr/convert.js

@@ -0,0 +1,86 @@
+"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 path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const xlr_sdk_1 = require("@player-tools/xlr-sdk");
+const log_symbols_1 = __importDefault(require("log-symbols"));
+const base_command_1 = require("../../utils/base-command");
+const PlayerImportMap = new Map([
+    [
+        '@player-ui/types',
+        ['Expression', 'Asset', 'Binding', 'AssetWrapper', 'Schema.DataType'],
+    ],
+]);
+/**
+ * Converts XLRs into a specific language
+ */
+class XLRConvert extends base_command_1.BaseCommand {
+    getOptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(XLRConvert);
+            const { input, output } = flags;
+            if (!output) {
+                throw new Error(`Need to specify location to export to`);
+            }
+            const language = flags.lang;
+            if (!language) {
+                throw new Error(`Need to specifiy lanauge to export to`);
+            }
+            return {
+                inputPath: input,
+                outputDir: path_1.default.join(output, language),
+                language,
+            };
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { inputPath, outputDir, language } = yield this.getOptions();
+            try {
+                if (!fs_1.default.existsSync(outputDir)) {
+                    fs_1.default.mkdirSync(outputDir, { recursive: true });
+                }
+                const sdk = new xlr_sdk_1.XLRSDK();
+                sdk.loadDefinitionsFromDisk(inputPath);
+                const files = sdk.exportRegistry(language, PlayerImportMap);
+                files.forEach(([filename, fileContents]) => {
+                    fs_1.default.writeFileSync(path_1.default.join(outputDir, filename), fileContents, {});
+                });
+            }
+            catch (e) {
+                console.log('');
+                console.log(chalk_1.default.red(`${log_symbols_1.default.error} Error exporting XLRs: ${e.message}`));
+                return { exitCode: 1 };
+            }
+            return { exitCode: 0 };
+        });
+    }
+}
+exports.default = XLRConvert;
+XLRConvert.description = 'Exports XLRs files to a specific language';
+XLRConvert.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: './dist',
+    }), output: core_1.Flags.string({
+        char: 'o',
+        description: 'Output directory to write results to.',
+    }), lang: core_1.Flags.enum({
+        char: 'l',
+        description: 'Search strategy for types to export: plugin (default, looks for exported EnchancedPlayerPlugin classes) or type (all exported types)',
+        options: ['TypeScript'],
+    }) });

package/dist/config.d.ts

@@ -0,0 +1,37 @@
+import type { PlayerCLIPlugin } from './plugins';
+export interface PlayerConfigFileShape {
+    /** A base config to inherit defaults from */
+    extends?: string | PlayerConfigFileShape;
+    /** A list of plugins to apply */
+    plugins?: Array<string | [string, any] | PlayerCLIPlugin>;
+    /** A list of presets to apply */
+    presets?: Array<PlayerConfigFileShape | string>;
+}
+export interface PlayerConfigResolvedShape {
+    /** Options related to the DSL and compilation */
+    dsl?: {
+        /** An input directory for compilation */
+        src?: string;
+        /** An output directory to use */
+        outDir?: string;
+        /** Flag to omit validating the resulting JSON */
+        skipValidation?: boolean;
+    };
+    /** Options related to JSON and validation */
+    json?: {
+        /** An input file, directory, glob, or list of any of the above to use as inputs for validation */
+        src?: string | string[];
+    };
+    /** Options related to XLR compilation step */
+    xlr?: {
+        /** Path to start searching for types to import/export */
+        input?: string;
+        /** Where to write the resulting files */
+        output?: string;
+        /** When converting to XLR, what strategy to use */
+        mode?: 'plugin' | 'types';
+    };
+    /** Flattened list of plugins */
+    plugins: Array<PlayerCLIPlugin>;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { run } from '@oclif/core';
+export * from './config';
+export * from './plugins';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });
+__exportStar(require("./config"), exports);
+__exportStar(require("./plugins"), exports);

package/dist/plugins/LSPAssetsPlugin.d.ts

@@ -0,0 +1,29 @@
+import type { PlayerLanguageService } from '@player-tools/language-service';
+import type { PlayerCLIPlugin } from './index';
+export interface Config {
+    /** the path to the asset library to load */
+    path: string;
+    /** Provides experimental language features */
+    exp?: boolean;
+}
+/**
+ * Handles setting the assets when loading the LSP
+ *
+ * {
+ *   "plugins": [
+ *     [
+ *       "@cli/lsp-assets-plugin",
+ *       {
+ *         "path": "<url> or <path>"
+ *       }
+ *     ]
+ *   ]
+ * }
+ *
+ */
+export declare class LSPAssetsPlugin implements PlayerCLIPlugin {
+    private config;
+    constructor(config: Config);
+    onCreateLanguageService(lsp: PlayerLanguageService, exp: boolean): Promise<void>;
+}
+//# sourceMappingURL=LSPAssetsPlugin.d.ts.map

package/dist/plugins/LSPAssetsPlugin.js

@@ -0,0 +1,40 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LSPAssetsPlugin = void 0;
+/**
+ * Handles setting the assets when loading the LSP
+ *
+ * {
+ *   "plugins": [
+ *     [
+ *       "@cli/lsp-assets-plugin",
+ *       {
+ *         "path": "<url> or <path>"
+ *       }
+ *     ]
+ *   ]
+ * }
+ *
+ */
+class LSPAssetsPlugin {
+    constructor(config) {
+        this.config = config;
+    }
+    onCreateLanguageService(lsp, exp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (exp === this.config.exp) {
+                yield lsp.setAssetTypes([this.config.path]);
+            }
+        });
+    }
+}
+exports.LSPAssetsPlugin = LSPAssetsPlugin;

package/dist/plugins/index.d.ts

@@ -0,0 +1,26 @@
+import type { PlayerLanguageService } from '@player-tools/language-service';
+import type { DSLCompiler } from '@player-tools/dsl';
+import type { ExportTypes } from '@player-tools/xlr-sdk';
+import type { TransformFunction } from '@player-tools/xlr';
+export * from './LSPAssetsPlugin';
+export interface PlayerCLIPlugin {
+    /**
+     * Handler when an LSP instance is created
+     * Use this to add custom rule-sets, load asset types, etc
+     */
+    onCreateLanguageService?: (lsp: PlayerLanguageService, exp: boolean) => void | Promise<void>;
+    /**
+     * Handler when a DSL compiler is created
+     * Use this to change how content is generated
+     */
+    onCreateDSLCompiler?: (compiler: DSLCompiler) => void | Promise<void>;
+    /**
+     * Handler for when context is being converted from XLRs to a language specific representation
+     * Append the transforms to apply to the passed in array based on the provided format
+     */
+    onConvertXLR?: (format: ExportTypes, transforms: Array<TransformFunction>) => void | Promise<void>;
+}
+export declare type PlayerCLIClass = {
+    new (): PlayerCLIPlugin;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LSPAssetsPlugin"), exports);

package/dist/utils/babel-register.d.ts

@@ -0,0 +1,3 @@
+/** Register a `require()` loader for any of the given paths */
+export declare const registerForPaths: () => void;
+//# sourceMappingURL=babel-register.d.ts.map

package/dist/utils/babel-register.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerForPaths = void 0;
+const register_1 = __importDefault(require("@babel/register"));
+/** Register a `require()` loader for any of the given paths */
+const registerForPaths = () => {
+    (0, register_1.default)({
+        extensions: ['.es6', '.es', '.jsx', '.js', '.mjs', '.tsx', '.ts'],
+        presets: [
+            ['@babel/preset-env', { modules: 'cjs' }],
+            '@babel/preset-typescript',
+            '@babel/preset-react',
+        ],
+        plugins: ['@babel/plugin-transform-react-jsx-source'],
+    });
+};
+exports.registerForPaths = registerForPaths;

package/dist/utils/base-command.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+import { PlayerLanguageService } from '@player-tools/language-service';
+import { DSLCompiler } from '@player-tools/dsl';
+import type { ExportTypes } from '@player-tools/xlr-sdk';
+import type { TransformFunction } from '@player-tools/xlr';
+import type { PlayerConfigResolvedShape } from '../config';
+/** The common configs for all  */
+export declare abstract class BaseCommand extends Command {
+    static flags: {
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+    };
+    private resolvedConfig;
+    private loadConfig;
+    private resolveConfig;
+    private readConfig;
+    protected getPlayerConfig(): Promise<PlayerConfigResolvedShape>;
+    createLanguageService(exp: boolean): Promise<PlayerLanguageService>;
+    createDSLCompiler(): Promise<DSLCompiler>;
+    getXLRTransforms(format: ExportTypes): Promise<Array<TransformFunction>>;
+    exit(code?: number): void;
+}
+//# sourceMappingURL=base-command.d.ts.map

package/dist/utils/base-command.js

@@ -0,0 +1,162 @@
+"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 });
+exports.BaseCommand = void 0;
+/* eslint-disable import/no-dynamic-require */
+/* eslint-disable global-require */
+/* eslint-disable @typescript-eslint/no-var-requires */
+const core_1 = require("@oclif/core");
+const path_1 = __importDefault(require("path"));
+const cosmiconfig_1 = require("cosmiconfig");
+const language_service_1 = require("@player-tools/language-service");
+const dsl_1 = require("@player-tools/dsl");
+const configLoader = (0, cosmiconfig_1.cosmiconfig)('player');
+/** The common configs for all  */
+class BaseCommand extends core_1.Command {
+    loadConfig(configFilePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (configFilePath) {
+                try {
+                    return yield configLoader.load(configFilePath);
+                }
+                catch (e) {
+                    this.warn(`Error loading config file: ${configFilePath}`);
+                }
+            }
+            return configLoader.search();
+        });
+    }
+    resolveConfig(conf, relativePath) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            let config = Object.assign(Object.assign({}, (conf !== null && conf !== void 0 ? conf : {})), { plugins: [] });
+            // If there's an extension load it
+            if (conf === null || conf === void 0 ? void 0 : conf.extends) {
+                let normalizedExtension;
+                if (typeof conf.extends === 'string') {
+                    const requiredExtendedConfig = require(conf.extends);
+                    normalizedExtension =
+                        (_a = requiredExtendedConfig.default) !== null && _a !== void 0 ? _a : requiredExtendedConfig;
+                }
+                else {
+                    normalizedExtension = conf.extends;
+                }
+                config = Object.assign({}, (yield this.resolveConfig(normalizedExtension, relativePath)));
+            }
+            yield Promise.all((_c = (_b = conf === null || conf === void 0 ? void 0 : conf.presets) === null || _b === void 0 ? void 0 : _b.map((preset) => __awaiter(this, void 0, void 0, function* () {
+                var _e;
+                if (typeof preset === 'string') {
+                    const requiredExtendedConfig = require(preset);
+                    const normalizedExtension = (_e = requiredExtendedConfig.default) !== null && _e !== void 0 ? _e : requiredExtendedConfig;
+                    const extendedConfig = yield this.resolveConfig(normalizedExtension);
+                    config.plugins = [...extendedConfig.plugins, ...config.plugins];
+                    return;
+                }
+                const presetConfig = yield this.resolveConfig(preset);
+                config.plugins = [...presetConfig.plugins, ...config.plugins];
+            }))) !== null && _c !== void 0 ? _c : []);
+            // Go through each plugin and load/create it
+            (_d = conf === null || conf === void 0 ? void 0 : conf.plugins) === null || _d === void 0 ? void 0 : _d.forEach((pluginInfo) => {
+                var _a;
+                if (typeof pluginInfo === 'object' && !Array.isArray(pluginInfo)) {
+                    config.plugins.push(pluginInfo);
+                    return;
+                }
+                const pluginName = typeof pluginInfo === 'string' ? pluginInfo : pluginInfo[0];
+                const pluginArgs = typeof pluginInfo === 'string' ? undefined : pluginInfo[1];
+                let pluginLoadPath = pluginName;
+                if (pluginName.startsWith('.')) {
+                    pluginLoadPath = path_1.default.resolve(relativePath !== null && relativePath !== void 0 ? relativePath : '', pluginName);
+                }
+                this.debug('loading plugin from %s', pluginLoadPath);
+                // Get the instance for the plugin
+                const required = require(pluginLoadPath);
+                const PluginExport = (_a = required.default) !== null && _a !== void 0 ? _a : required;
+                if (!PluginExport) {
+                    return;
+                }
+                const pluginInstance = typeof PluginExport === 'object'
+                    ? PluginExport
+                    : new PluginExport(pluginArgs);
+                config.plugins.push(pluginInstance);
+            });
+            return config;
+        });
+    }
+    readConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse();
+            const configFile = yield this.loadConfig(flags.config);
+            return this.resolveConfig(configFile === null || configFile === void 0 ? void 0 : configFile.config);
+        });
+    }
+    getPlayerConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.resolvedConfig) {
+                return this.resolvedConfig;
+            }
+            const c = yield this.readConfig();
+            this.resolvedConfig = c;
+            return c;
+        });
+    }
+    createLanguageService(exp) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const lsp = new language_service_1.PlayerLanguageService();
+            const { plugins } = yield this.getPlayerConfig();
+            for (let i = 0; i < plugins.length; i++) {
+                // eslint-disable-next-line no-await-in-loop
+                yield ((_b = (_a = plugins[i]).onCreateLanguageService) === null || _b === void 0 ? void 0 : _b.call(_a, lsp, exp));
+            }
+            return lsp;
+        });
+    }
+    createDSLCompiler() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const compiler = new dsl_1.DSLCompiler();
+            const { plugins } = yield this.getPlayerConfig();
+            for (let i = 0; i < plugins.length; i++) {
+                // eslint-disable-next-line no-await-in-loop
+                yield ((_b = (_a = plugins[i]).onCreateDSLCompiler) === null || _b === void 0 ? void 0 : _b.call(_a, compiler));
+            }
+            return compiler;
+        });
+    }
+    getXLRTransforms(format) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const transforms = [];
+            const { plugins } = yield this.getPlayerConfig();
+            for (let i = 0; i < plugins.length; i++) {
+                // eslint-disable-next-line no-await-in-loop
+                yield ((_b = (_a = plugins[i]).onConvertXLR) === null || _b === void 0 ? void 0 : _b.call(_a, format, transforms));
+            }
+            return transforms;
+        });
+    }
+    exit(code) {
+        if (process.env.NODE_ENV !== 'test') {
+            super.exit(code);
+        }
+    }
+}
+exports.BaseCommand = BaseCommand;
+BaseCommand.flags = {
+    config: core_1.Flags.string({
+        description: 'Path to a specific config file to load.\nBy default, will automatically search for an rc or config file to load',
+        char: 'c',
+    }),
+};

package/dist/utils/compile-renderer.d.ts

@@ -0,0 +1,13 @@
+import type { SerializeType } from '@player-tools/dsl';
+import type { TaskProgressRenderer } from './task-runner';
+export interface DSLCompileFileData {
+    /** the file name */
+    file: string;
+    /** the name of the output file */
+    outputFile?: string;
+}
+export declare const compileRenderer: TaskProgressRenderer<{
+    /** the type of content generated */
+    contentType: SerializeType;
+} | undefined, DSLCompileFileData>;
+//# sourceMappingURL=compile-renderer.d.ts.map

package/dist/utils/compile-renderer.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileRenderer = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const diag_renderer_1 = require("./diag-renderer");
+exports.compileRenderer = {
+    onUpdate: (ctx) => {
+        const output = [''];
+        ctx.tasks.forEach((task) => {
+            var _a, _b, _c;
+            const outputType = task.state === 'completed' && ((_a = task.output) === null || _a === void 0 ? void 0 : _a.contentType)
+                ? task.output.contentType
+                : undefined;
+            let titleLine = [
+                (0, diag_renderer_1.getTaskSymbol)(task),
+                outputType && `(${outputType})`,
+                (_b = task.data) === null || _b === void 0 ? void 0 : _b.file,
+            ]
+                .filter(Boolean)
+                .join(' ');
+            if ((_c = task.data) === null || _c === void 0 ? void 0 : _c.outputFile) {
+                titleLine = [
+                    titleLine,
+                    figures_1.default.arrowRight,
+                    task.data.outputFile,
+                ].join(' ');
+            }
+            output.push(titleLine);
+            if (task.state === 'completed') {
+                if (task.error) {
+                    output.push(`  ${figures_1.default.arrowRight} ${chalk_1.default.red('bad')}`);
+                }
+            }
+        });
+        return output.join('\n');
+    },
+    onEnd: (ctx) => {
+        return [exports.compileRenderer.onUpdate(ctx)].join('\n');
+    },
+};

package/dist/utils/diag-renderer.d.ts

@@ -0,0 +1,28 @@
+import type { Diagnostic } from 'vscode-languageserver-types';
+import type { Task, TaskProgressRenderer } from './task-runner';
+/** Get the lines representing the summary of the results */
+export declare function getSummary({ errors, warnings, skipped, fileCount, duration, }: {
+    /** Error count */
+    errors: number;
+    /** Warning count */
+    warnings: number;
+    /** number of skipped files */
+    skipped?: number;
+    /** File Count */
+    fileCount: number;
+    /** How long this took */
+    duration: number | undefined;
+}): string;
+/** Format the results for printing on the console */
+export declare function formatDiagnosticResults(filePath: string, results: Diagnostic[], verbose?: boolean): {
+    lines: string[];
+    errors: number;
+    warnings: number;
+};
+/** Get the symbol for a given task */
+export declare const getTaskSymbol: (task: Task<any, any>) => string;
+export declare const validationRenderer: TaskProgressRenderer<Diagnostic[], {
+    /** the file name */
+    file: string;
+}>;
+//# sourceMappingURL=diag-renderer.d.ts.map