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

package/dist/commands/dsl/validate.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const globby_1 = tslib_1.__importDefault(require("globby"));
+const log_symbols_1 = tslib_1.__importDefault(require("log-symbols"));
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const ts = tslib_1.__importStar(require("typescript"));
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../utils/base-command");
+const fs_2 = require("../../utils/fs");
+const compiler_options_1 = require("../../utils/compiler-options");
+/** A command thay runs TS typechecker against source ts and tsx files */
+class Validate extends base_command_1.BaseCommand {
+    static description = "Validate TSX files before they get compiled";
+    static flags = {
+        ...base_command_1.BaseCommand.flags,
+        files: core_1.Flags.string({
+            char: "f",
+            description: "A list of files or globs to validate",
+            multiple: true,
+        }),
+        severity: core_1.Flags.string({
+            char: "s",
+            description: "Setting the validation severity to 'warn' will change the validation step into a warning-only, not halting the process with code 1. That exposes an intermediate option between the default behaviour, where it will fail on errors, and skipping validation.",
+            options: ["error", "warn"],
+            default: "error",
+        }),
+    };
+    async getOptions() {
+        const { flags } = await this.parse(Validate);
+        const config = await this.getPlayerConfig();
+        const files = flags.files && flags.files.length > 0 ? flags.files : config.dsl?.src;
+        if (!files) {
+            throw new Error("DSL TSC typechecking requires a file list");
+        }
+        return {
+            inputFiles: Array.isArray(files) ? files : [files],
+            severity: flags.severity,
+        };
+    }
+    getTSConfig(filePath) {
+        const configFileLocation = ts.findConfigFile(filePath ?? ".", (fName) => {
+            return (0, fs_1.existsSync)(fName);
+        });
+        if (!configFileLocation) {
+            this.debug(`No TSConfig found`);
+            return;
+        }
+        const configContent = ts.readConfigFile(configFileLocation, (p) => {
+            return (0, fs_1.readFileSync)(p, "utf-8");
+        });
+        if (configContent.error) {
+            this.warn(ts.flattenDiagnosticMessageText(configContent.error.messageText, "\n"));
+            return;
+        }
+        const basePath = path_1.default.dirname(configFileLocation);
+        const parsedConfigContent = ts.parseJsonConfigFileContent(configContent.config, ts.sys, basePath);
+        if (parsedConfigContent.errors.length > 0) {
+            throw new Error(`Error while parsing tsconfig: ${parsedConfigContent.errors
+                .map((d) => {
+                return ts.flattenDiagnosticMessageText(d.messageText, "\n");
+            })
+                .join("\n\n")}`);
+        }
+        return parsedConfigContent.options;
+    }
+    async run() {
+        const { inputFiles, severity } = await this.getOptions();
+        const files = await (0, globby_1.default)((0, fs_2.convertToFileGlob)(inputFiles, "**/*.(tsx|jsx|js|ts)"), {
+            expandDirectories: true,
+        });
+        const TSConfig = this.getTSConfig() ?? compiler_options_1.DEFAULT_COMPILER_OPTIONS;
+        const program = ts.createProgram(files, TSConfig);
+        const allDiagnostics = ts.getPreEmitDiagnostics(program);
+        const groupedDiagnostics = allDiagnostics.reduce((acc, diagnostic) => {
+            const fileName = diagnostic.file?.fileName;
+            const category = diagnostic.category;
+            if (fileName && files.includes(fileName)) {
+                if (!acc[category][fileName]) {
+                    acc[category][fileName] = [];
+                }
+                acc[category][fileName].push(diagnostic);
+            }
+            return acc;
+        }, {
+            [ts.DiagnosticCategory.Error]: {},
+            [ts.DiagnosticCategory.Warning]: {},
+            [ts.DiagnosticCategory.Message]: {},
+            [ts.DiagnosticCategory.Suggestion]: {},
+        });
+        const diagnosticCategories = [
+            ts.DiagnosticCategory.Error,
+            ts.DiagnosticCategory.Warning,
+            ts.DiagnosticCategory.Message,
+            ts.DiagnosticCategory.Suggestion,
+        ];
+        diagnosticCategories.forEach((category) => {
+            const diagnosticsList = Object.keys(groupedDiagnostics[category]);
+            diagnosticsList.forEach((diagnosticGroup) => {
+                this.log(`${diagnosticGroup}`);
+                groupedDiagnostics[category][diagnosticGroup].forEach((diagnostic) => {
+                    if (diagnostic.file) {
+                        const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start ?? 0);
+                        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                        let logSymbol = log_symbols_1.default.info;
+                        switch (category) {
+                            case ts.DiagnosticCategory.Error:
+                                logSymbol = log_symbols_1.default.error;
+                                break;
+                            case ts.DiagnosticCategory.Warning:
+                                logSymbol = log_symbols_1.default.warning;
+                                break;
+                            case ts.DiagnosticCategory.Message:
+                                logSymbol = log_symbols_1.default.info;
+                                break;
+                            case ts.DiagnosticCategory.Suggestion:
+                                logSymbol = log_symbols_1.default.info;
+                                break;
+                        }
+                        this.log(`  ${logSymbol} (${line + 1},${character + 1}): ${message}`);
+                    }
+                    else {
+                        this.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+                    }
+                });
+            });
+        });
+        const errorsCount = Object.keys(groupedDiagnostics[ts.DiagnosticCategory.Error]).length;
+        if (errorsCount) {
+            this.log(`Type or syntax errors found in ${errorsCount} file${errorsCount > 1 ? "s" : ""}, exiting program`);
+            if (severity === "error") {
+                this.exit(1);
+            }
+        }
+        else {
+            this.log(`${log_symbols_1.default.success} No TSX types or errors found.`);
+        }
+    }
+}
+exports.default = Validate;
+//# sourceMappingURL=validate.js.map

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

@@ -0,0 +1,18 @@
+import { BaseCommand } from "../../utils/base-command";
+/** A command to validate JSON content */
+export default class Validate extends BaseCommand {
+    static description: string;
+    static flags: {
+        files: import("@oclif/core/lib/interfaces").OptionFlag<string[]>;
+        exp: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        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=validate.d.ts.map

package/dist/commands/json/validate.js

@@ -0,0 +1,91 @@
+"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 fs_1 = require("fs");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const base_command_1 = require("../../utils/base-command");
+const diag_renderer_1 = require("../../utils/diag-renderer");
+const fs_2 = require("../../utils/fs");
+const task_runner_1 = require("../../utils/task-runner");
+const log_levels_1 = require("../../utils/log-levels");
+/** A command to validate JSON content */
+class Validate extends base_command_1.BaseCommand {
+    static description = "Validate Player JSON content";
+    static flags = {
+        ...base_command_1.BaseCommand.flags,
+        files: core_1.Flags.string({
+            char: "f",
+            description: "A list of files or globs to validate",
+            multiple: true,
+        }),
+        exp: core_1.Flags.boolean({
+            description: "Use experimental language features",
+            default: false,
+        }),
+        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(Validate);
+        const config = await this.getPlayerConfig();
+        const files = flags.files && flags.files.length > 0 ? flags.files : config.json?.src;
+        const { exp } = flags;
+        if (!files) {
+            throw new Error("JSON validation requires a file list");
+        }
+        return {
+            files: Array.isArray(files) ? files : [files],
+            exp,
+            severity: flags.severity,
+            loglevel: flags.loglevel,
+        };
+    }
+    async run() {
+        const { files: inputFiles, exp, severity, loglevel, } = await this.getOptions();
+        const expandedFilesList = (0, fs_2.convertToFileGlob)(inputFiles, "**/*.json");
+        this.debug("Searching for files using: %o", expandedFilesList);
+        const files = await (0, globby_1.default)(expandedFilesList, {
+            expandDirectories: true,
+        });
+        this.debug("Found %i files to process", files.length);
+        const results = {
+            exitCode: 0,
+        };
+        const lsp = await this.createLanguageService(exp);
+        const taskRunner = (0, task_runner_1.createTaskRunner)({
+            renderer: diag_renderer_1.validationRenderer,
+            tasks: files.map((f) => ({
+                data: {
+                    file: f,
+                },
+                run: async () => {
+                    const contents = await fs_1.promises.readFile(f, "utf-8");
+                    const validations = (await lsp.validateTextDocument(vscode_languageserver_textdocument_1.TextDocument.create(`file://${f}`, "json", 1, contents))) ?? [];
+                    return validations;
+                },
+            })),
+            loglevel: (0, log_levels_1.stringToLogLevel)(loglevel),
+        });
+        const taskResults = await taskRunner.run();
+        if (severity !== "error") {
+            taskResults.forEach((t) => {
+                if (t.error ||
+                    t.output.some((d) => d.severity === vscode_languageserver_types_1.DiagnosticSeverity.Error)) {
+                    results.exitCode = 100;
+                }
+            });
+        }
+        this.debug("finished");
+        this.exit(results.exitCode);
+        return results;
+    }
+}
+exports.default = Validate;
+//# sourceMappingURL=validate.js.map

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

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

package/dist/commands/xlr/compile.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const typescript_1 = tslib_1.__importDefault(require("typescript"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const globby_1 = tslib_1.__importDefault(require("globby"));
+const log_symbols_1 = tslib_1.__importDefault(require("log-symbols"));
+const xlr_converters_1 = require("@player-tools/xlr-converters");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const base_command_1 = require("../../utils/base-command");
+const visitors_1 = require("../../utils/xlr/visitors");
+const consts_1 = require("../../utils/xlr/consts");
+/**
+ * Exports TS Interfaces/Types to XLR format
+ */
+class XLRCompile extends base_command_1.BaseCommand {
+    static description = "Compiles typescript files to XLRs format";
+    static flags = {
+        ...base_command_1.BaseCommand.flags,
+        input: core_1.Flags.string({
+            char: "i",
+            description: "An input directory to search for types to export",
+            default: "./src",
+        }),
+        output: core_1.Flags.string({
+            char: "o",
+            description: "Output directory to write results to.",
+            default: "./dist",
+        }),
+        mode: core_1.Flags.enum({
+            char: "m",
+            description: "Search strategy for types to export: plugin (default, looks for exported EnchancedPlayerPlugin classes) or type (all exported types)",
+            options: ["plugin", "types"],
+            default: "plugin",
+        }),
+    };
+    async getOptions() {
+        const { flags } = await this.parse(XLRCompile);
+        const config = await this.getPlayerConfig();
+        const input = config.xlr?.input ?? flags.input;
+        const output = config.xlr?.output ?? flags.output;
+        const modeValue = config.xlr?.mode ?? flags.mode;
+        return {
+            inputPath: input,
+            outputDir: path_1.default.join(output, "xlr"),
+            mode: modeValue === "plugin" ? consts_1.Mode.PLUGIN : consts_1.Mode.TYPES,
+        };
+    }
+    async run() {
+        const { inputPath, outputDir, mode } = await this.getOptions();
+        const inputFiles = globby_1.default.sync([
+            `${inputPath}/**/*.ts`,
+            `${inputPath}/**/*.tsx`,
+        ]);
+        try {
+            this.processTypes(inputFiles, outputDir, {}, mode);
+        }
+        catch (e) {
+            console.log("");
+            console.log(chalk_1.default.red(`${log_symbols_1.default.error} Error compiling XLRs: ${e.message}`));
+            console.log(chalk_1.default.red(`${e.stack}`));
+            this.exit(1);
+        }
+        return { exitCode: 0 };
+    }
+    /** Serializes ES6 Maps */
+    replacer(key, value) {
+        if (value instanceof Map) {
+            return Object.fromEntries(value.entries());
+        }
+        return value;
+    }
+    /** Generate extension manifest/description files from an Enhanced Player Plugin */
+    processTypes(fileNames, outputDirectory, options, mode = consts_1.Mode.PLUGIN) {
+        // Build a program using the set of root file names in fileNames
+        const program = typescript_1.default.createProgram(fileNames, options);
+        fs_1.default.mkdirSync(outputDirectory, { recursive: true });
+        // Get the checker, we will use it to find more about classes
+        const checker = program.getTypeChecker();
+        const converter = new xlr_converters_1.TsConverter(checker, consts_1.customPrimitives);
+        let capabilities;
+        // Visit every sourceFile in the program
+        program.getSourceFiles().forEach((sourceFile) => {
+            if (!sourceFile.isDeclarationFile) {
+                // Walk the tree to search for classes
+                let generatedCapabilites;
+                if (mode === consts_1.Mode.PLUGIN) {
+                    generatedCapabilites = (0, visitors_1.pluginVisitor)({
+                        sourceFile,
+                        converter,
+                        checker,
+                        outputDirectory,
+                    });
+                }
+                else if (mode === consts_1.Mode.TYPES) {
+                    generatedCapabilites = (0, visitors_1.fileVisitor)({
+                        sourceFile,
+                        converter,
+                        checker,
+                        outputDirectory,
+                    });
+                }
+                else {
+                    throw new Error(`Error: Option ${mode} not recognized. Valid options are: plugin or type`);
+                }
+                if (generatedCapabilites) {
+                    generatedCapabilites = {
+                        ...generatedCapabilites,
+                    };
+                    if (consts_1.customPrimitives) {
+                        generatedCapabilites = {
+                            ...generatedCapabilites,
+                            customPrimitives: consts_1.customPrimitives,
+                        };
+                    }
+                    capabilities = generatedCapabilites;
+                }
+            }
+        });
+        if (!capabilities) {
+            throw new Error("Error: Unable to parse any XLRs in package");
+        }
+        // print out the manifest files
+        const jsonManifest = JSON.stringify(capabilities, this.replacer, 4);
+        fs_1.default.writeFileSync(path_1.default.join(outputDirectory, "manifest.json"), jsonManifest);
+        const tsManifestFile = `${[...(capabilities.capabilities?.values() ?? [])]
+            .flat(2)
+            .map((capability) => {
+            return `const ${capability} = require("./${capability}.json")`;
+        })
+            .join("\n")}
+
+    module.exports = {
+      "pluginName": "${capabilities.pluginName}",
+      "capabilities": {
+        ${[...(capabilities.capabilities?.entries() ?? [])]
+            .map(([capabilityName, provides]) => {
+            return `"${capabilityName}":[${provides.join(",")}],`;
+        })
+            .join("\n\t\t")}
+      },
+      "customPrimitives": [
+        ${[capabilities.customPrimitives?.map((i) => `"${i}"`).join(",") ?? ""]}
+      ]
+    }
+`;
+        fs_1.default.writeFileSync(path_1.default.join(outputDirectory, "manifest.js"), tsManifestFile);
+    }
+}
+exports.default = XLRCompile;
+//# sourceMappingURL=compile.js.map

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

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

package/dist/commands/xlr/convert.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const xlr_sdk_1 = require("@player-tools/xlr-sdk");
+const log_symbols_1 = tslib_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 {
+    static description = "Exports XLRs files to a specific language";
+    static flags = {
+        ...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"],
+        }),
+    };
+    async getOptions() {
+        const { flags } = await 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,
+        };
+    }
+    async run() {
+        const { inputPath, outputDir, language } = await 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}`));
+            this.exit(1);
+        }
+        return { exitCode: 0 };
+    }
+}
+exports.default = XLRConvert;
+//# sourceMappingURL=convert.js.map

package/dist/config.d.ts

@@ -0,0 +1,39 @@
+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>;
+    /** Catch for any other things that may be in the config for plugged in functionality */
+    [key: string]: any;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=config.js.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { run } from "@oclif/core";
+export * from "./config";
+export * from "./plugins";
+export * from "./utils/base-command";
+export * from "./utils/compilation-context";
+export * from "./utils/log-levels";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const tslib_1 = require("tslib");
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });
+tslib_1.__exportStar(require("./config"), exports);
+tslib_1.__exportStar(require("./plugins"), exports);
+tslib_1.__exportStar(require("./utils/base-command"), exports);
+tslib_1.__exportStar(require("./utils/compilation-context"), exports);
+tslib_1.__exportStar(require("./utils/log-levels"), exports);
+//# sourceMappingURL=index.js.map

package/dist/plugins/LSPAssetsPlugin.d.ts

@@ -0,0 +1,50 @@
+import type { PlayerLanguageService } from "@player-tools/json-language-service";
+import type { PlayerCLIPlugin } from "./index";
+import { TSManifest } from "@player-tools/xlr";
+/** Loads XLRs into the LSP via the manifest.js file */
+export interface LSPAssetsPluginModuleConfig {
+    type: "module";
+    /** Result of module import/require of xlr manifest.js file */
+    manifest: TSManifest;
+}
+/** Loads XLRs to the LSP by specifying a filesystem location */
+export interface LSPAssetsPluginManifestConfig {
+    type: "manifest";
+    /** Path to dist folder for XLR enabled plugins */
+    path: string;
+}
+/**
+ * Legacy type for providing XLR manifest paths that assumes its a manifest
+ * @deprecated
+ * */
+export interface LSPAssetsPluginLegacyConfig {
+    type?: undefined;
+    path: string;
+}
+export type LSPAssetPluginConfigTypes = LSPAssetsPluginModuleConfig | LSPAssetsPluginManifestConfig | LSPAssetsPluginLegacyConfig;
+export type LSPAssetsPluginConfig = LSPAssetPluginConfigTypes & {
+    /** 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: LSPAssetsPluginConfig | Array<LSPAssetsPluginConfig>);
+    onCreateLanguageService(lsp: PlayerLanguageService, exp: boolean): Promise<void>;
+    loadConfig(config: LSPAssetPluginConfigTypes, lsp: PlayerLanguageService): Promise<void>;
+}
+//# sourceMappingURL=LSPAssetsPlugin.d.ts.map