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

package/dist/plugins/LSPAssetsPlugin.js

@@ -0,0 +1,47 @@
+"use strict";
+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 {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async onCreateLanguageService(lsp, exp) {
+        if (Array.isArray(this.config)) {
+            await Promise.all(this.config.map((c) => {
+                this.loadConfig(c, lsp);
+            }));
+        }
+        else {
+            await this.loadConfig(this.config, lsp);
+        }
+    }
+    async loadConfig(config, lsp) {
+        if (config.type === "manifest" || config.type === undefined) {
+            await lsp.setAssetTypes([config.path]);
+        }
+        else if (config.type === "module") {
+            await lsp.setAssetTypesFromModule([config.manifest]);
+        }
+        else {
+            throw Error(`Unknown config type: ${config.type}`);
+        }
+    }
+}
+exports.LSPAssetsPlugin = LSPAssetsPlugin;
+//# sourceMappingURL=LSPAssetsPlugin.js.map

package/dist/plugins/LSPPluginPlugin.d.ts

@@ -0,0 +1,11 @@
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "@player-tools/json-language-service";
+import type { PlayerCLIPlugin } from "./index";
+/**
+ * Handles adding a LSP Plugin to the LSP
+ */
+export declare class LSPPluginPlugin implements PlayerCLIPlugin {
+    private plugin;
+    constructor(plugin: PlayerLanguageServicePlugin | Array<PlayerLanguageServicePlugin>);
+    onCreateLanguageService(lsp: PlayerLanguageService, exp: boolean): Promise<void>;
+}
+//# sourceMappingURL=LSPPluginPlugin.d.ts.map

package/dist/plugins/LSPPluginPlugin.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LSPPluginPlugin = void 0;
+/**
+ * Handles adding a LSP Plugin to the LSP
+ */
+class LSPPluginPlugin {
+    plugin;
+    constructor(plugin) {
+        this.plugin = plugin;
+    }
+    async onCreateLanguageService(lsp, exp) {
+        if (Array.isArray(this.plugin)) {
+            this.plugin.forEach((p) => lsp.addLSPPlugin(p));
+        }
+        else {
+            lsp.addLSPPlugin(this.plugin);
+        }
+    }
+}
+exports.LSPPluginPlugin = LSPPluginPlugin;
+//# sourceMappingURL=LSPPluginPlugin.js.map

package/dist/plugins/LSPTransformsPlugin.d.ts

@@ -0,0 +1,12 @@
+import type { PlayerLanguageService } from "@player-tools/json-language-service";
+import type { TransformFunction } from "@player-tools/xlr";
+import type { PlayerCLIPlugin } from "./index";
+/**
+ * Handles adding XLR transforms to the LSP's XLR SDK
+ */
+export declare class LSPTransformsPlugin implements PlayerCLIPlugin {
+    private functionsToLoad;
+    constructor(functionsToLoad: Record<string, TransformFunction>);
+    onCreateLanguageService(lsp: PlayerLanguageService, exp: boolean): Promise<void>;
+}
+//# sourceMappingURL=LSPTransformsPlugin.d.ts.map

package/dist/plugins/LSPTransformsPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LSPTransformsPlugin = void 0;
+/**
+ * Handles adding XLR transforms to the LSP's XLR SDK
+ */
+class LSPTransformsPlugin {
+    functionsToLoad;
+    constructor(functionsToLoad) {
+        this.functionsToLoad = functionsToLoad;
+    }
+    async onCreateLanguageService(lsp, exp) {
+        lsp.addXLRTransforms(this.functionsToLoad);
+    }
+}
+exports.LSPTransformsPlugin = LSPTransformsPlugin;
+//# sourceMappingURL=LSPTransformsPlugin.js.map

package/dist/plugins/index.d.ts

@@ -0,0 +1,33 @@
+import type { PlayerLanguageService } from "@player-tools/json-language-service";
+import type { DSLCompiler } from "@player-tools/dsl";
+import type { ExportTypes } from "@player-tools/xlr-sdk";
+import type { TransformFunction } from "@player-tools/xlr";
+import type { CompilationContext } from "../utils/compilation-context";
+export * from "./LSPAssetsPlugin";
+export * from "./LSPPluginPlugin";
+export * from "./LSPTransformsPlugin";
+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>;
+    /**
+     * Handler to expose hooks that influence how content is compiled
+     */
+    createCompilerContext?: (context: CompilationContext) => void | Promise<void>;
+}
+export type PlayerCLIClass = {
+    new (): PlayerCLIPlugin;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./LSPAssetsPlugin"), exports);
+tslib_1.__exportStar(require("./LSPPluginPlugin"), exports);
+tslib_1.__exportStar(require("./LSPTransformsPlugin"), exports);
+//# sourceMappingURL=index.js.map

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,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerForPaths = void 0;
+const tslib_1 = require("tslib");
+const register_1 = tslib_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: [
+            [require.resolve("@babel/preset-env"), { modules: "cjs" }],
+            require.resolve("@babel/preset-typescript"),
+            require.resolve("@babel/preset-react"),
+        ],
+        plugins: [require.resolve("@babel/plugin-transform-react-jsx-source")],
+    });
+};
+exports.registerForPaths = registerForPaths;
+//# sourceMappingURL=babel-register.js.map

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

@@ -0,0 +1,26 @@
+import { Command } from "@oclif/core";
+import { PlayerLanguageService } from "@player-tools/json-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";
+import { CompilationContext } from "./compilation-context";
+/** The common configs for all  */
+export declare abstract class BaseCommand extends Command {
+    static flags: {
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        loglevel: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+    };
+    static strict: boolean;
+    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>>;
+    createCompilerContext(): Promise<CompilationContext>;
+    exit(code?: number): void;
+}
+//# sourceMappingURL=base-command.d.ts.map

package/dist/utils/base-command.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommand = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const path_1 = tslib_1.__importDefault(require("path"));
+const cosmiconfig_1 = require("cosmiconfig");
+const json_language_service_1 = require("@player-tools/json-language-service");
+const dsl_1 = require("@player-tools/dsl");
+const compilation_context_1 = require("./compilation-context");
+const log_levels_1 = require("./log-levels");
+const configLoader = (0, cosmiconfig_1.cosmiconfig)("player");
+/** The common configs for all  */
+class BaseCommand extends core_1.Command {
+    static 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",
+        }),
+        loglevel: core_1.Flags.string({
+            char: "v",
+            description: "How verbose logs should be",
+            options: log_levels_1.LogLevels,
+            default: "warn",
+        }),
+    };
+    static strict = false;
+    resolvedConfig;
+    async loadConfig(configFilePath) {
+        if (configFilePath) {
+            try {
+                return await configLoader.load(configFilePath);
+            }
+            catch (e) {
+                this.warn(`Error loading config file: ${configFilePath}`);
+            }
+        }
+        return configLoader.search();
+    }
+    async resolveConfig(conf, relativePath) {
+        let config = {
+            ...(conf ?? {}),
+            plugins: [],
+        };
+        // If there's an extension load it
+        if (conf?.extends) {
+            let normalizedExtension;
+            if (typeof conf.extends === "string") {
+                const requiredExtendedConfig = await Promise.resolve(`${conf.extends}`).then(s => tslib_1.__importStar(require(s)));
+                normalizedExtension =
+                    requiredExtendedConfig.default ?? requiredExtendedConfig;
+            }
+            else {
+                normalizedExtension = conf.extends;
+            }
+            config = {
+                ...(await this.resolveConfig(normalizedExtension, relativePath)),
+            };
+        }
+        await Promise.all(conf?.presets?.map(async (preset) => {
+            if (typeof preset === "string") {
+                const requiredExtendedConfig = await Promise.resolve(`${preset}`).then(s => tslib_1.__importStar(require(s)));
+                const normalizedExtension = requiredExtendedConfig.default ?? requiredExtendedConfig;
+                const extendedConfig = await this.resolveConfig(normalizedExtension);
+                config.plugins = [...extendedConfig.plugins, ...config.plugins];
+                return;
+            }
+            const presetConfig = await this.resolveConfig(preset);
+            config.plugins = [...presetConfig.plugins, ...config.plugins];
+        }) ?? []);
+        // Go through each plugin and load/create it
+        if (conf?.plugins) {
+            await Promise.all(conf?.plugins?.map(async (pluginInfo) => {
+                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 ?? "", pluginName);
+                }
+                this.debug("loading plugin from %s", pluginLoadPath);
+                // Get the instance for the plugin
+                const required = await Promise.resolve(`${pluginLoadPath}`).then(s => tslib_1.__importStar(require(s)));
+                const PluginExport = required.default ?? required;
+                if (!PluginExport) {
+                    return;
+                }
+                const pluginInstance = typeof PluginExport === "object"
+                    ? PluginExport
+                    : new PluginExport(pluginArgs);
+                config.plugins.push(pluginInstance);
+            }));
+        }
+        return config;
+    }
+    async readConfig() {
+        const { flags } = await this.parse(BaseCommand);
+        const configFile = await this.loadConfig(flags.config);
+        return this.resolveConfig(configFile?.config);
+    }
+    async getPlayerConfig() {
+        if (this.resolvedConfig) {
+            return this.resolvedConfig;
+        }
+        const c = await this.readConfig();
+        this.resolvedConfig = c;
+        return c;
+    }
+    async createLanguageService(exp) {
+        const lsp = new json_language_service_1.PlayerLanguageService();
+        const { plugins } = await this.getPlayerConfig();
+        for (let i = 0; i < plugins.length; i++) {
+            await plugins[i].onCreateLanguageService?.(lsp, exp);
+        }
+        return lsp;
+    }
+    async createDSLCompiler() {
+        const compiler = new dsl_1.DSLCompiler({
+            error: this.error.bind(this),
+            warn: this.warn.bind(this),
+            log: this.log.bind(this),
+        });
+        const { plugins } = await this.getPlayerConfig();
+        for (let i = 0; i < plugins.length; i++) {
+            await plugins[i].onCreateDSLCompiler?.(compiler);
+        }
+        return compiler;
+    }
+    async getXLRTransforms(format) {
+        const transforms = [];
+        const { plugins } = await this.getPlayerConfig();
+        for (let i = 0; i < plugins.length; i++) {
+            await plugins[i].onConvertXLR?.(format, transforms);
+        }
+        return transforms;
+    }
+    async createCompilerContext() {
+        const compilerContext = new compilation_context_1.CompilationContext(await this.createDSLCompiler());
+        const { plugins } = await this.getPlayerConfig();
+        for (let i = 0; i < plugins.length; i++) {
+            await plugins[i].createCompilerContext?.(compilerContext);
+        }
+        return compilerContext;
+    }
+    exit(code) {
+        if (process.env.NODE_ENV !== "test") {
+            super.exit(code);
+        }
+    }
+}
+exports.BaseCommand = BaseCommand;
+//# sourceMappingURL=base-command.js.map

package/dist/utils/compilation-context.d.ts

@@ -0,0 +1,53 @@
+import type { DSLCompiler, SerializeContext } from "@player-tools/dsl";
+import { AsyncSeriesBailHook } from "tapable-ts";
+export interface identifyContentReturn {
+    /** The identified type the content should be compiled as */
+    type: string;
+    /** The file extension the content should be written as */
+    extension: string;
+}
+export interface compileContentArgs extends Omit<SerializeContext, "type"> {
+    type: string;
+}
+export interface compilationResult {
+    /** the JSON value of the source */
+    value: string;
+    /** The sourcemap of the content */
+    sourceMap?: string;
+}
+/**
+ *
+ */
+export declare class CompilationContext {
+    /** Hooks to wrap the context of the compilation */
+    hooks: {
+        /**
+         * Function for determining a specific or desired content type given on the file contents or other conditions
+         *
+         * @param fileName - The relative name of the file
+         * @param content - The contents in the file
+         * @returns content type and extension
+         */
+        identifyContentType: AsyncSeriesBailHook<[string, any], identifyContentReturn, Record<string, any>>;
+        /**
+         * Function for returning the compile content given an specific type or condition
+         *
+         * @param context - Settings for the content to be compiled, such as type
+         * @param content - The contents in the file
+         * @param fileName - The relative name of the file
+         * @returns CompilerReturn object instance or undefined
+         */
+        compileContent: AsyncSeriesBailHook<[compileContentArgs, any, string], compilationResult, Record<string, any>>;
+        /**
+         * Function for determining if a file should be skipped during compilation
+         *
+         * @param fileName - The relative name of the file
+         * @returns true if the file should be skipped, false or undefined otherwise
+         */
+        skipCompilation: AsyncSeriesBailHook<[string], boolean, Record<string, any>>;
+    };
+    /** A DSL compiler instance */
+    dslCompiler: DSLCompiler;
+    constructor(dslCompiler: DSLCompiler);
+}
+//# sourceMappingURL=compilation-context.d.ts.map

package/dist/utils/compilation-context.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompilationContext = void 0;
+const dsl_1 = require("@player-tools/dsl");
+const tapable_ts_1 = require("tapable-ts");
+/**
+ *
+ */
+class CompilationContext {
+    /** Hooks to wrap the context of the compilation */
+    hooks = {
+        /**
+         * Function for determining a specific or desired content type given on the file contents or other conditions
+         *
+         * @param fileName - The relative name of the file
+         * @param content - The contents in the file
+         * @returns content type and extension
+         */
+        identifyContentType: new tapable_ts_1.AsyncSeriesBailHook(),
+        /**
+         * Function for returning the compile content given an specific type or condition
+         *
+         * @param context - Settings for the content to be compiled, such as type
+         * @param content - The contents in the file
+         * @param fileName - The relative name of the file
+         * @returns CompilerReturn object instance or undefined
+         */
+        compileContent: new tapable_ts_1.AsyncSeriesBailHook(),
+        /**
+         * Function for determining if a file should be skipped during compilation
+         *
+         * @param fileName - The relative name of the file
+         * @returns true if the file should be skipped, false or undefined otherwise
+         */
+        skipCompilation: new tapable_ts_1.AsyncSeriesBailHook(),
+    };
+    /** A DSL compiler instance */
+    dslCompiler;
+    constructor(dslCompiler) {
+        this.dslCompiler = dslCompiler;
+        this.hooks.compileContent.tap("default", async ({ type }, content) => {
+            if ((0, dsl_1.isDefaultCompilerContentType)(type)) {
+                const compilationResults = await this.dslCompiler.serialize(content, {
+                    type,
+                });
+                if (compilationResults) {
+                    return {
+                        value: JSON.stringify(compilationResults.value, null, 2),
+                        sourceMap: compilationResults.sourceMap,
+                    };
+                }
+            }
+        });
+    }
+}
+exports.CompilationContext = CompilationContext;
+//# sourceMappingURL=compilation-context.js.map

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,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileRenderer = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const figures_1 = tslib_1.__importDefault(require("figures"));
+const diag_renderer_1 = require("./diag-renderer");
+exports.compileRenderer = {
+    onUpdate: (ctx) => {
+        const output = [""];
+        ctx.tasks.forEach((task) => {
+            const outputType = task.state === "completed" && task.output?.contentType
+                ? task.output.contentType
+                : undefined;
+            let titleLine = [
+                (0, diag_renderer_1.getTaskSymbol)(task),
+                outputType && `(${outputType})`,
+                task.data?.file,
+            ]
+                .filter(Boolean)
+                .join(" ");
+            if (task.data?.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");
+    },
+};
+//# sourceMappingURL=compile-renderer.js.map

package/dist/utils/compiler-options.d.ts

@@ -0,0 +1,3 @@
+import ts from "typescript";
+export declare const DEFAULT_COMPILER_OPTIONS: ts.CompilerOptions;
+//# sourceMappingURL=compiler-options.d.ts.map

package/dist/utils/compiler-options.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_COMPILER_OPTIONS = void 0;
+const tslib_1 = require("tslib");
+const typescript_1 = tslib_1.__importDefault(require("typescript"));
+exports.DEFAULT_COMPILER_OPTIONS = {
+    strict: true,
+    target: typescript_1.default.ScriptTarget.ES2016,
+    allowJs: false,
+    jsx: typescript_1.default.JsxEmit.ReactJSX,
+    moduleResolution: typescript_1.default.ModuleResolutionKind.NodeJs,
+    allowSyntheticDefaultImports: true,
+    module: typescript_1.default.ModuleKind.ES2015,
+    skipLibCheck: true,
+};
+//# sourceMappingURL=compiler-options.js.map

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

@@ -0,0 +1,31 @@
+import { Diagnostic } from "vscode-languageserver-types";
+import { DiagnosticSeverity } 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[], loglevel: DiagnosticSeverity): {
+    lines: string[];
+    errors: number;
+    warnings: number;
+    info: number;
+    trace: 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