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

package/dist/utils/diag-renderer.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationRenderer = exports.getTaskSymbol = void 0;
+exports.getSummary = getSummary;
+exports.formatDiagnosticResults = formatDiagnosticResults;
+const tslib_1 = require("tslib");
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_symbols_1 = tslib_1.__importDefault(require("log-symbols"));
+const elegant_spinner_1 = tslib_1.__importDefault(require("elegant-spinner"));
+const fs_1 = require("./fs");
+const source_map_js_1 = tslib_1.__importDefault(require("source-map-js"));
+/** Compare the ranges and return the one that starts of finishes first */
+function rangeComparator(first, second) {
+    if (first.start.line < second.start.line) {
+        return -1;
+    }
+    if (first.start.line > second.start.line) {
+        return 1;
+    }
+    if (first.start.character < second.start.character) {
+        return -1;
+    }
+    if (first.start.character > second.start.character) {
+        return 1;
+    }
+    return 0;
+}
+/** Sort a list of digs by position */
+const sortDiagnostics = (validations) => {
+    // Sort the validations by line/char number
+    return validations.sort((a, b) => {
+        return rangeComparator(a.range, b.range);
+    });
+};
+/** Get the text representing the line range */
+function getLineRange(range) {
+    return `${range.start.line + 1}:${range.start.character + 1}`;
+}
+/** Fix the plurality of a word */
+function maybePlural(word, count) {
+    return count > 1 ? `${word}s` : word;
+}
+/** Get the lines representing the summary of the results */
+function getSummary({ errors, warnings, skipped, fileCount, duration, }) {
+    return [
+        "\n",
+        (errors > 0 || warnings === 0) &&
+            chalk_1.default.red(`${errors} ${maybePlural("error", errors)}`),
+        warnings > 0 &&
+            chalk_1.default.yellow(`${warnings} ${maybePlural("warning", warnings)}`),
+        skipped !== undefined &&
+            skipped > 0 &&
+            chalk_1.default.gray(`${skipped} ${maybePlural("skipped", skipped)}`),
+        chalk_1.default.gray(`in ${fileCount} ${maybePlural("file", fileCount)}`),
+        chalk_1.default.gray(`took ${duration}ms`),
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+/** Format a diag for printing on the console */
+function formatDiagnostic(diag, longestLine, fName) {
+    let type;
+    if (diag.severity === vscode_languageserver_types_1.DiagnosticSeverity.Error) {
+        type = chalk_1.default.red(`${log_symbols_1.default.error}  `);
+    }
+    else if (diag.severity === vscode_languageserver_types_1.DiagnosticSeverity.Warning) {
+        type = chalk_1.default.yellow(`${log_symbols_1.default.warning}  `);
+    }
+    else if (diag.severity === vscode_languageserver_types_1.DiagnosticSeverity.Information) {
+        type = chalk_1.default.blue(`${log_symbols_1.default.info}  `);
+    }
+    else if (diag.severity === vscode_languageserver_types_1.DiagnosticSeverity.Hint) {
+        type = chalk_1.default.gray(`${log_symbols_1.default.info}  `);
+    }
+    else {
+        type = chalk_1.default.green(`${log_symbols_1.default.info}  `);
+    }
+    const msg = chalk_1.default.bold(diag.message);
+    const range = getLineRange(diag.range);
+    return [
+        `${type}`,
+        range.padEnd(longestLine),
+        msg,
+        `${fName}:${range.padEnd(longestLine)}`,
+    ].join(" ");
+}
+function mapDiagnosticBackToSourceLine(diag, mapper) {
+    const { line, character } = diag.range.start;
+    if (mapper && line && character >= 1) {
+        const sourceNode = mapper.originalPositionFor({
+            line,
+            column: character,
+        });
+        if (sourceNode.source) {
+            return {
+                diagnostic: {
+                    ...diag,
+                    range: {
+                        ...diag.range,
+                        start: {
+                            line: sourceNode.line,
+                            character: sourceNode.column,
+                        },
+                    },
+                },
+                sourceFile: sourceNode.source,
+            };
+        }
+    }
+}
+/** Format the results for printing on the console */
+function formatDiagnosticResults(filePath, results, loglevel) {
+    const count = {
+        errors: 0,
+        warnings: 0,
+        info: 0,
+        trace: 0,
+    };
+    const linePrefix = "  ";
+    const longestLine = Math.max(...results.map((r) => getLineRange(r.range).length));
+    //try and load map file
+    const mapFile = (0, fs_1.tryAndLoadSourceMap)(filePath);
+    let sourceMapper;
+    if (mapFile) {
+        sourceMapper = new source_map_js_1.default.SourceMapConsumer(JSON.parse(mapFile));
+    }
+    let lines = results
+        .map((diag) => {
+        if (diag.severity === vscode_languageserver_types_1.DiagnosticSeverity.Error) {
+            count.errors += 1;
+        }
+        else if (diag.severity === vscode_languageserver_types_1.DiagnosticSeverity.Warning) {
+            count.warnings += 1;
+        }
+        else if (diag.severity === vscode_languageserver_types_1.DiagnosticSeverity.Information) {
+            count.info += 1;
+        }
+        else if (diag.severity === vscode_languageserver_types_1.DiagnosticSeverity.Hint) {
+            count.trace += 1;
+        }
+        const { diagnostic, sourceFile } = mapDiagnosticBackToSourceLine(diag, sourceMapper) ?? { diagnostic: diag, sourceFile: filePath };
+        if (diag.severity && loglevel >= diag.severity) {
+            return (linePrefix + formatDiagnostic(diagnostic, longestLine + 1, sourceFile));
+        }
+        return "";
+    })
+        .filter((line) => line !== "");
+    if (count.errors > 0) {
+        lines = ["", `${chalk_1.default.red(log_symbols_1.default.error)} ${filePath}`, ...lines, ""];
+    }
+    else if (count.warnings > 0 && loglevel >= vscode_languageserver_types_1.DiagnosticSeverity.Warning) {
+        lines = [
+            "",
+            `${chalk_1.default.yellow(log_symbols_1.default.warning)} ${filePath}`,
+            ...lines,
+            "",
+        ];
+    }
+    else if (count.info > 0 && loglevel >= vscode_languageserver_types_1.DiagnosticSeverity.Information) {
+        lines = ["", `${chalk_1.default.blue(log_symbols_1.default.info)} ${filePath}`, ...lines, ""];
+    }
+    else if (count.trace > 0 && loglevel >= vscode_languageserver_types_1.DiagnosticSeverity.Hint) {
+        lines = ["", `${chalk_1.default.gray(log_symbols_1.default.info)} ${filePath}`, ...lines, ""];
+    }
+    else {
+        lines = [`${chalk_1.default.green(log_symbols_1.default.success)} ${filePath}`, ...lines];
+    }
+    return {
+        ...count,
+        lines,
+    };
+}
+const spinnerState = new WeakMap();
+/** Get the symbol for a given task */
+const getTaskSymbol = (task) => {
+    if (task.state === "pending" || task.state === "idle") {
+        const spinner = spinnerState.get(task) ?? (0, elegant_spinner_1.default)();
+        spinnerState.set(task, spinner);
+        return chalk_1.default.yellow(spinner());
+    }
+    if (task.state === "completed" && task.error) {
+        return log_symbols_1.default.error;
+    }
+    if (task.state === "completed") {
+        return chalk_1.default.yellow(log_symbols_1.default.success);
+    }
+    return " ";
+};
+exports.getTaskSymbol = getTaskSymbol;
+exports.validationRenderer = {
+    onUpdate(ctx) {
+        const { tasks } = ctx;
+        const output = ["Validating content"];
+        tasks.forEach((task) => {
+            if (task.state === "completed" && task.output) {
+                const formattedDiags = formatDiagnosticResults(task.data?.file ? (0, fs_1.normalizePath)(task.data.file) : "", sortDiagnostics(task.output), ctx.loglevel);
+                output.push(...formattedDiags.lines);
+            }
+            else {
+                output.push(`${(0, exports.getTaskSymbol)(task)} ${task.data?.file ? (0, fs_1.normalizePath)(task.data.file) : ""}`);
+            }
+        });
+        return output.join("\n");
+    },
+    onEnd(ctx) {
+        const count = {
+            errors: 0,
+            warnings: 0,
+            skipped: 0,
+            fileCount: ctx.tasks.length,
+            duration: ctx.duration,
+        };
+        ctx.tasks.forEach((t) => {
+            if (t.state === "completed" && t.output) {
+                const formattedDiags = formatDiagnosticResults(t.data?.file ?? "", t.output, ctx.loglevel);
+                count.errors += formattedDiags.errors;
+                count.warnings += formattedDiags.warnings;
+            }
+        });
+        return [exports.validationRenderer.onUpdate(ctx), getSummary(count)].join("\n");
+    },
+};
+//# sourceMappingURL=diag-renderer.js.map

package/dist/utils/fs.d.ts

@@ -0,0 +1,9 @@
+/** Check if an input is a directory, if it is, then swap it to a globbed path */
+export declare const convertToFileGlob: (input: string[], glob: string) => string[];
+/** Normalize a path for display */
+export declare const normalizePath: (p: string) => string;
+/**
+ * Tries to load a source map file
+ */
+export declare const tryAndLoadSourceMap: (f: string) => string | undefined;
+//# sourceMappingURL=fs.d.ts.map

package/dist/utils/fs.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryAndLoadSourceMap = exports.normalizePath = exports.convertToFileGlob = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+/** To handle globby issue on windows https://github.com/sindresorhus/globby/issues/152 */
+function forcePathSeparatorToPosix(input) {
+    return path_1.default.sep === path_1.default.win32.sep
+        ? input.split(path_1.default.sep).join(path_1.default.posix.sep)
+        : input;
+}
+/** Check if an input is a directory, if it is, then swap it to a globbed path */
+const convertToFileGlob = (input, glob) => {
+    return input.map((i) => {
+        if (fs_1.default.statSync(i, { throwIfNoEntry: false })?.isDirectory()) {
+            return forcePathSeparatorToPosix(path_1.default.join(i, glob));
+        }
+        return forcePathSeparatorToPosix(i);
+    });
+};
+exports.convertToFileGlob = convertToFileGlob;
+/** Normalize a path for display */
+const normalizePath = (p) => {
+    return path_1.default.relative(process.cwd(), p);
+};
+exports.normalizePath = normalizePath;
+/**
+ * Tries to load a source map file
+ */
+const tryAndLoadSourceMap = (f) => {
+    const mapFileName = f + ".map";
+    if (fs_1.default.existsSync(mapFileName)) {
+        return fs_1.default.readFileSync(mapFileName, "utf8");
+    }
+    return undefined;
+};
+exports.tryAndLoadSourceMap = tryAndLoadSourceMap;
+//# sourceMappingURL=fs.js.map

package/dist/utils/log-levels.d.ts

@@ -0,0 +1,11 @@
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+export declare const LogLevelsMap: {
+    error: 1;
+    warn: 2;
+    info: 3;
+    trace: 4;
+};
+export type LogLevelsType = keyof typeof LogLevelsMap;
+export declare const LogLevels: string[];
+export declare function stringToLogLevel(level: string): DiagnosticSeverity;
+//# sourceMappingURL=log-levels.d.ts.map

package/dist/utils/log-levels.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevels = exports.LogLevelsMap = void 0;
+exports.stringToLogLevel = stringToLogLevel;
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+exports.LogLevelsMap = {
+    error: vscode_languageserver_types_1.DiagnosticSeverity.Error,
+    warn: vscode_languageserver_types_1.DiagnosticSeverity.Warning,
+    info: vscode_languageserver_types_1.DiagnosticSeverity.Information,
+    trace: vscode_languageserver_types_1.DiagnosticSeverity.Hint,
+};
+exports.LogLevels = Object.keys(exports.LogLevelsMap);
+function isValidLogLevel(level) {
+    return exports.LogLevels.includes(level);
+}
+function stringToLogLevel(level) {
+    return isValidLogLevel(level)
+        ? exports.LogLevelsMap[level]
+        : vscode_languageserver_types_1.DiagnosticSeverity.Warning;
+}
+//# sourceMappingURL=log-levels.js.map

package/dist/utils/task-runner.d.ts

@@ -0,0 +1,59 @@
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+interface BaseTask<Results, Data> {
+    /** The state of the task */
+    state: "idle" | "pending";
+    /** A function to run */
+    run: () => Promise<Results>;
+    /** other metadata about the task */
+    data?: Data;
+}
+export type CompletedTask<Results, Data> = Omit<BaseTask<Results, Data>, "state"> & {
+    /** The state of the task */
+    state: "completed";
+} & ({
+    /** The results */
+    output: Results;
+    /** An error if any */
+    error?: never;
+} | {
+    /** The error if any */
+    error: Error;
+    /** No output on error */
+    output?: never;
+});
+export type Task<ResultsType, Data> = BaseTask<ResultsType, Data> | CompletedTask<ResultsType, Data>;
+export interface TaskProgressRenderer<ResultType, Data = unknown> {
+    /** Call back to paint update on the page */
+    onUpdate: (ctx: {
+        /** The tasks that are running */
+        tasks: Array<Task<ResultType, Data>>;
+        /** What level of information to log */
+        loglevel: DiagnosticSeverity;
+    }) => string;
+    /** Called for a summary */
+    onEnd: (ctx: {
+        /** The completed tasks */
+        tasks: Array<CompletedTask<ResultType, Data>>;
+        /** Number of ms it took to run */
+        duration: number;
+        /** What level of information to log */
+        loglevel: DiagnosticSeverity;
+    }) => string;
+}
+interface TaskRunner<R, Data> {
+    /** The list of tasks */
+    tasks: Array<Task<R, Data>>;
+    /** A trigger to start it */
+    run: () => Promise<Array<CompletedTask<R, Data>>>;
+}
+/** Create a runner to kick off tasks in parallel */
+export declare const createTaskRunner: <R, D>({ tasks, renderer, loglevel, }: {
+    /** A list of tasks to run */
+    tasks: Array<Pick<BaseTask<R, D>, "data" | "run">>;
+    /** How to report progress */
+    renderer: TaskProgressRenderer<R, D>;
+    /** What level of logs to write */
+    loglevel: DiagnosticSeverity;
+}) => TaskRunner<R, D>;
+export {};
+//# sourceMappingURL=task-runner.d.ts.map

package/dist/utils/task-runner.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskRunner = void 0;
+const tslib_1 = require("tslib");
+const log_update_1 = tslib_1.__importDefault(require("log-update"));
+/** Create a runner to kick off tasks in parallel */
+const createTaskRunner = ({ tasks, renderer, loglevel, }) => {
+    const statefulTasks = tasks.map((t) => {
+        return {
+            ...t,
+            state: "idle",
+        };
+    });
+    /** Kick off the task list */
+    const run = async () => {
+        const startTime = Date.now();
+        let ended = false;
+        const paintInterval = setInterval(() => {
+            if (ended) {
+                return;
+            }
+            const output = renderer.onUpdate({ tasks: statefulTasks, loglevel });
+            if (process.stdout.isTTY) {
+                (0, log_update_1.default)(output);
+            }
+        }, 10);
+        await Promise.all(statefulTasks.map(async (t) => {
+            t.state = "pending";
+            try {
+                const r = await t.run();
+                t.state = "completed";
+                t.output = r;
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    t.state = "completed";
+                    t.error = e;
+                }
+            }
+        }));
+        ended = true;
+        clearInterval(paintInterval);
+        const duration = Date.now() - startTime;
+        const output = renderer.onEnd({
+            duration,
+            tasks: statefulTasks,
+            loglevel,
+        });
+        console.log(output);
+        log_update_1.default.done();
+        return statefulTasks;
+    };
+    return {
+        tasks: statefulTasks,
+        run,
+    };
+};
+exports.createTaskRunner = createTaskRunner;
+//# sourceMappingURL=task-runner.js.map

package/dist/utils/xlr/consts.d.ts

@@ -0,0 +1,7 @@
+export declare const PLAYER_PLUGIN_INTERFACE_NAME = "ExtendedPlayerPlugin";
+export declare const customPrimitives: string[];
+export declare enum Mode {
+    PLUGIN = "plugin",
+    TYPES = "types"
+}
+//# sourceMappingURL=consts.d.ts.map

package/dist/utils/xlr/consts.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mode = exports.customPrimitives = exports.PLAYER_PLUGIN_INTERFACE_NAME = void 0;
+exports.PLAYER_PLUGIN_INTERFACE_NAME = "ExtendedPlayerPlugin";
+exports.customPrimitives = [
+    "Expression",
+    "Asset",
+    "Binding",
+    "AssetWrapper",
+    "Schema.DataType",
+    "ExpressionHandler",
+];
+var Mode;
+(function (Mode) {
+    Mode["PLUGIN"] = "plugin";
+    Mode["TYPES"] = "types";
+})(Mode || (exports.Mode = Mode = {}));
+//# sourceMappingURL=consts.js.map

package/dist/utils/xlr/visitors/file.d.ts

@@ -0,0 +1,5 @@
+import type { Manifest } from "@player-tools/xlr";
+import type { VisitorProps } from "./types";
+/** export all exported types in the file */
+export declare function fileVisitor(args: VisitorProps): Manifest | undefined;
+//# sourceMappingURL=file.d.ts.map

package/dist/utils/xlr/visitors/file.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileVisitor = fileVisitor;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+/** export all exported types in the file */
+function fileVisitor(args) {
+    const { sourceFile, converter, outputDirectory } = args;
+    const convertedTypes = converter.convertSourceFile(sourceFile);
+    if (convertedTypes.data.types.length === 0) {
+        return undefined;
+    }
+    const capabilities = {
+        pluginName: "Types",
+    };
+    convertedTypes.data.types.forEach((type) => {
+        fs_1.default.writeFileSync(path_1.default.join(outputDirectory, `${type.name}.json`), JSON.stringify(type, undefined, 4));
+    });
+    capabilities.capabilities = new Map([
+        ["Types", convertedTypes.convertedTypes],
+    ]);
+    return capabilities;
+}
+//# sourceMappingURL=file.js.map

package/dist/utils/xlr/visitors/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./file";
+export * from "./plugin";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/xlr/visitors/index.js

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

package/dist/utils/xlr/visitors/plugin.d.ts

@@ -0,0 +1,5 @@
+import type { Manifest } from "@player-tools/xlr";
+import type { VisitorProps } from "./types";
+/** visit nodes finding exported classes */
+export declare function pluginVisitor(args: VisitorProps): Manifest | undefined;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/utils/xlr/visitors/plugin.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginVisitor = pluginVisitor;
+const tslib_1 = require("tslib");
+const xlr_utils_1 = require("@player-tools/xlr-utils");
+const path_1 = tslib_1.__importDefault(require("path"));
+const typescript_1 = tslib_1.__importDefault(require("typescript"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const consts_1 = require("../consts");
+/**
+ * Follows references to get the actual underlying declaration
+ */
+function getUnderlyingNode(element, checker) {
+    let referencedSymbol;
+    if (typescript_1.default.isTypeReferenceNode(element)) {
+        referencedSymbol = checker.getSymbolAtLocation(element.typeName);
+    }
+    else {
+        referencedSymbol = checker.getSymbolAtLocation(element.exprName);
+    }
+    const alias = referencedSymbol
+        ? checker.getAliasedSymbol(referencedSymbol)
+        : undefined;
+    let varDecl;
+    /**
+     * The TypeChecker will return the interface/type declaration or the variable statement
+     * so if we are getting a variable, we need to grab the variable declaration
+     */
+    if (typescript_1.default.isTypeReferenceNode(element)) {
+        varDecl = alias?.declarations?.[0];
+    }
+    else {
+        varDecl = alias?.declarations?.[0].parent.parent;
+    }
+    if (varDecl && (0, xlr_utils_1.isTopLevelNode)(varDecl)) {
+        return varDecl;
+    }
+}
+/**
+ * Fixes ExpressionHandler ref nodes that don't have argument names because some way of writing ExpressionHandler prevent the ts compiler from inferring them
+ */
+function fixExpressionArgNames(sourceNode, generatedTypeRef, checker) {
+    const typeRefCopy = { ...generatedTypeRef };
+    const { initializer } = sourceNode.declarationList.declarations[0];
+    let offset;
+    let arrowFunction;
+    if (initializer &&
+        typescript_1.default.isCallExpression(initializer) &&
+        typescript_1.default.isArrowFunction(initializer.arguments[0])) {
+        // handles the case of `withoutContext` expression where the types are provided by the generic
+        offset = 0;
+        arrowFunction = initializer.arguments[0];
+    }
+    else {
+        // handles the case of a direct `ExpressionHandler` where the types are provided by the generic
+        offset = 1;
+        arrowFunction = initializer;
+    }
+    const paramsNode = typeRefCopy.genericArguments?.[0];
+    if (paramsNode && paramsNode.type === "array") {
+        const functionArg = arrowFunction.parameters?.[offset];
+        if (!paramsNode.name && functionArg) {
+            paramsNode.name = functionArg.name.getText();
+        }
+    }
+    else if (paramsNode && paramsNode.type === "tuple") {
+        paramsNode.elementTypes?.forEach((gArg, index) => {
+            const functionArg = arrowFunction.parameters?.[index + offset];
+            if (!gArg.name && functionArg) {
+                gArg.name = functionArg.name.getText();
+            }
+        });
+    }
+    return typeRefCopy;
+}
+/**
+ * Player specific modifications that we need to do to massage generic XLR conversion because of our weird types
+ * Most of this is _definitely not_ best practice.
+ */
+function runPlayerPostProcessing(node, xlr, checker) {
+    if (xlr.type === "ref" &&
+        xlr.ref.includes("ExpressionHandler") &&
+        typescript_1.default.isVariableStatement(node)) {
+        return fixExpressionArgNames(node, xlr, checker);
+    }
+    return xlr;
+}
+/**
+ * Generated the XLR for a Capability, writes it to the specified path, and returns the name
+ */
+function generateXLR(node, checker, converter, outputDirectory) {
+    if (typescript_1.default.isTypeReferenceNode(node) || typescript_1.default.isTypeQueryNode(node)) {
+        const varDecl = getUnderlyingNode(node, checker);
+        if (varDecl) {
+            let capabilityDescription = converter.convertTopLevelNode(varDecl);
+            capabilityDescription = runPlayerPostProcessing(varDecl, capabilityDescription, checker);
+            const capabilityName = capabilityDescription?.name ?? "error";
+            fs_1.default.writeFileSync(path_1.default.join(outputDirectory, `${capabilityName}.json`), JSON.stringify(capabilityDescription, undefined, 4));
+            return capabilityName;
+        }
+    }
+    throw new Error(`Can't export non reference type ${node.getText()}`);
+}
+/** visit nodes finding exported classes */
+function pluginVisitor(args) {
+    const { sourceFile, checker, converter, outputDirectory } = args;
+    let capabilities;
+    typescript_1.default.forEachChild(sourceFile, (node) => {
+        // Only consider exported nodes
+        if (!(0, xlr_utils_1.isNodeExported)(node)) {
+            return;
+        }
+        // Plugins are classes so filter those
+        if (typescript_1.default.isClassDeclaration(node) && node.name) {
+            const symbol = checker.getSymbolAtLocation(node.name);
+            if (symbol) {
+                // look at what they implement
+                node.heritageClauses?.forEach((heritage) => {
+                    heritage.types.forEach((hInterface) => {
+                        // check if heritage is right one
+                        if (hInterface.expression.getText() !== consts_1.PLAYER_PLUGIN_INTERFACE_NAME) {
+                            return;
+                        }
+                        capabilities = {
+                            pluginName: "Unknown Plugin",
+                        };
+                        // Get registration name of plugin
+                        const nameProperty = node.members.find((member) => typescript_1.default.isPropertyDeclaration(member) &&
+                            member.name?.getText() === "name");
+                        if (nameProperty && nameProperty.initializer) {
+                            capabilities.pluginName = nameProperty.initializer
+                                ?.getText()
+                                .replace(/[""]+/g, "");
+                        }
+                        const provides = new Map();
+                        const typeArgs = hInterface.typeArguments;
+                        const pluginDec = checker.getTypeAtLocation(hInterface).symbol
+                            ?.declarations?.[0];
+                        // process type parameters to figure out what capabilities are provided
+                        pluginDec?.typeParameters?.forEach((param, index) => {
+                            const capabilityType = param.name.getText();
+                            if (index < (typeArgs?.length ?? 0)) {
+                                const exportedCapabilities = typeArgs?.[index];
+                                // if its an array process each type
+                                if (typescript_1.default.isTupleTypeNode(exportedCapabilities)) {
+                                    const capabilityNames = exportedCapabilities.elements.map((element) => generateXLR(element, checker, converter, outputDirectory));
+                                    provides.set(capabilityType, capabilityNames);
+                                }
+                                else if (typescript_1.default.isTypeReferenceNode(exportedCapabilities) ||
+                                    typescript_1.default.isTypeQueryNode(exportedCapabilities)) {
+                                    const capabilityName = generateXLR(exportedCapabilities, checker, converter, outputDirectory);
+                                    provides.set(capabilityType, [capabilityName]);
+                                }
+                                else {
+                                    throw new Error(`Can't figure out type ${capabilityType}`);
+                                }
+                            }
+                        });
+                        capabilities.capabilities = provides;
+                    });
+                });
+            }
+        }
+    });
+    return capabilities;
+}
+//# sourceMappingURL=plugin.js.map