@flowscripter/dynamic-cli-framework 1.7.2 → 1.7.4

package/dist/src/service/plugin/command/PluginUpgradeSubCommand.js

@@ -0,0 +1,25 @@
+import { Icon, PRINTER_SERVICE_ID } from "../../../api/service/core/PrinterService.js";
+import { PLUGIN_SERVICE_ID } from "../../../api/service/core/PluginService.js";
+import { getPluginId } from "./getPluginId.js";
+export class PluginUpgradeSubCommand {
+    name = "upgrade";
+    description = "Upgrade locally installed plugins";
+    enableConfiguration = false;
+    options = [];
+    positionals = [];
+    async execute(context, _argumentValues) {
+        const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+        const pluginService = context.getServiceById(PLUGIN_SERVICE_ID);
+        let upgraded = 0;
+        for await (const update of pluginService.checkForUpdates()) {
+            const id = getPluginId(update.descriptor);
+            await printerService.info(`Upgrading ${id} to ${update.availableVersion}...\n`, Icon.INFORMATION);
+            await pluginService.install(update.descriptor);
+            await printerService.print(`Upgraded ${id} to ${update.availableVersion}.\n`, Icon.SUCCESS);
+            upgraded++;
+        }
+        if (upgraded === 0) {
+            await printerService.print("All plugins are up to date.\n");
+        }
+    }
+}

package/dist/src/service/plugin/command/getPluginId.d.ts

@@ -0,0 +1,3 @@
+import type { VersionedPluginDescriptor } from "@flowscripter/dynamic-plugin-framework";
+export declare function getPluginId(descriptor: VersionedPluginDescriptor): string;
+//# sourceMappingURL=getPluginId.d.ts.map

package/dist/src/service/plugin/command/getPluginId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPluginId.d.ts","sourceRoot":"","sources":["../../../../../src/service/plugin/command/getPluginId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AAExF,wBAAgB,WAAW,CAAC,UAAU,EAAE,yBAAyB,GAAG,MAAM,CAEzE"}

package/dist/src/service/plugin/command/getPluginId.js

@@ -0,0 +1,3 @@
+export function getPluginId(descriptor) {
+    return descriptor.scope ? `@${descriptor.scope}/${descriptor.name}` : descriptor.name;
+}

package/dist/src/service/prettyPrinter/DefaultPrettyPrinterService.js

@@ -0,0 +1,45 @@
+import * as prettier from "prettier";
+/**
+ * Default implementation of {@link PrettyPrinterService} which provides by default the
+ * syntaxes built into prettier.
+ */
+export default class DefaultPrettyPrinterService {
+    #registeredSyntaxes = new Array();
+    #syntaxNameToPluginnMap = new Map();
+    async #populateBuiltInSyntaxes() {
+        const languages = (await prettier.getSupportInfo()).languages;
+        this.#registeredSyntaxes = languages.map((language) => language.name.toLowerCase());
+    }
+    async getRegisteredSyntaxes() {
+        if (this.#registeredSyntaxes.length === 0) {
+            await this.#populateBuiltInSyntaxes();
+        }
+        return this.#registeredSyntaxes;
+    }
+    async prettify(text, syntaxName) {
+        if (this.#registeredSyntaxes.length === 0) {
+            await this.#populateBuiltInSyntaxes();
+        }
+        const name = syntaxName.toLowerCase();
+        if (!this.#registeredSyntaxes.includes(name)) {
+            throw new Error(`Syntax name is not registered: ${name}`);
+        }
+        const options = { parser: syntaxName };
+        const syntaxPlugin = this.#syntaxNameToPluginnMap.get(name);
+        if (syntaxPlugin) {
+            options.plugins = [syntaxPlugin];
+        }
+        return prettier.format(text, options);
+    }
+    async registerSyntax(syntaxName, syntaxPlugin) {
+        if (this.#registeredSyntaxes.length === 0) {
+            await this.#populateBuiltInSyntaxes();
+        }
+        const name = syntaxName.toLowerCase();
+        if (this.#registeredSyntaxes.includes(name)) {
+            throw new Error(`Syntax name already registered: ${name}`);
+        }
+        this.#registeredSyntaxes.push(name);
+        this.#syntaxNameToPluginnMap.set(name, syntaxPlugin);
+    }
+}

package/dist/src/service/prettyPrinter/PrettyPrinterServiceProvider.js

@@ -0,0 +1,28 @@
+import DefaultPrettyPrinterService from "./DefaultPrettyPrinterService.js";
+import { PRETTY_PRINTER_SERVICE_ID } from "../../api/service/core/PrettyPrinterService.js";
+/**
+ * Provides a {@link PrettyPrinterService}.
+ */
+export default class PrettyPrinterServiceProvider {
+    servicePriority;
+    serviceId = PRETTY_PRINTER_SERVICE_ID;
+    #defaultPrettyPrinterService;
+    /**
+     * Create an instance of the service provider with the specified details.
+     *
+     * @param servicePriority the priority of the service.
+     */
+    constructor(servicePriority) {
+        this.servicePriority = servicePriority;
+        this.#defaultPrettyPrinterService = new DefaultPrettyPrinterService();
+    }
+    getServiceInfo(_cliConfig) {
+        return Promise.resolve({
+            service: this.#defaultPrettyPrinterService,
+            commands: [],
+        });
+    }
+    initService(_context) {
+        return Promise.resolve(undefined);
+    }
+}

package/dist/src/service/printer/DefaultPrinterService.js

@@ -0,0 +1,250 @@
+import { default as Spinner } from "./terminal/Spinner.js";
+import { default as Progress } from "./terminal/Progress.js";
+import { Level, } from "../../api/service/core/PrinterService.js";
+import { Color } from "./terminal/Color.js";
+import { getDarkModeTheme, getLightModeTheme } from "./terminal/Theme.js";
+import { WritableStream } from "node:stream/web";
+export default class DefaultPrinterService {
+    stdoutWritable;
+    stderrWritable;
+    #stdoutIsColor;
+    #stdoutTerminal;
+    #stderrTerminal;
+    #styler;
+    #isDarkMode = true;
+    #threshold = Level.INFO;
+    #iconDefinitions = [];
+    #theme = [];
+    #encoder = new TextEncoder();
+    #spinner;
+    #progress;
+    async #log(level, message, icon) {
+        if (this.#threshold > level) {
+            return;
+        }
+        await this.#spinner.pause();
+        await this.#progress.pause();
+        await this.#stderrTerminal.write(`${icon !== undefined ? `${this.#iconDefinitions[icon]} ` : ""}${message}`);
+        this.#spinner.resume();
+        this.#progress.resume();
+    }
+    constructor(stdoutWritableStream, stderrWritableStream, stdoutIsColor, stderrIsColor, stdoutTerminal, stderrTerminal, styler) {
+        this.stdoutWritable = stdoutWritableStream;
+        this.stderrWritable = stderrWritableStream;
+        this.#stdoutIsColor = stdoutIsColor;
+        this.#stdoutTerminal = stdoutTerminal;
+        this.#stderrTerminal = stderrTerminal;
+        this.#styler = styler;
+        this.#styler.colorEnabled = stderrIsColor;
+        this.#spinner = new Spinner(this.#stderrTerminal, this.#styler);
+        this.#progress = new Progress(this.#stderrTerminal, this.#styler);
+        this.darkMode = false;
+        this.#iconDefinitions = [this.green("✔"), this.red("✖"), this.yellow("‼"), this.blue("ℹ")];
+    }
+    set colorEnabled(enabled) {
+        this.#styler.colorEnabled = enabled;
+        this.#stdoutIsColor = enabled;
+        if (enabled) {
+            this.#iconDefinitions = [this.green("✔"), this.red("✖"), this.yellow("‼"), this.blue("ℹ")];
+        }
+        else {
+            this.#iconDefinitions = ["✔", "✖", "‼", "ℹ"];
+        }
+    }
+    get colorEnabled() {
+        return this.#styler.colorEnabled;
+    }
+    set hyperlinksEnabled(enabled) {
+        this.#styler.hyperlinksEnabled = enabled;
+    }
+    get hyperlinksEnabled() {
+        return this.#styler.hyperlinksEnabled;
+    }
+    hyperlink(text, url) {
+        return this.#styler.hyperlink(text, url);
+    }
+    stdoutColumns() {
+        return this.#stdoutTerminal.columns();
+    }
+    stderrColumns() {
+        return this.#stderrTerminal.columns();
+    }
+    set darkMode(isDarkMode) {
+        this.#isDarkMode = isDarkMode;
+        if (isDarkMode) {
+            this.#theme = getDarkModeTheme();
+        }
+        else {
+            this.#theme = getLightModeTheme();
+        }
+        this.#spinner.spinnerColor = this.#theme[Color.EMPHASISED];
+        this.#spinner.messageColor = this.#theme[Color.PRIMARY];
+        this.#progress.completeColor = this.#theme[Color.GREEN];
+        this.#progress.remainingColor = this.#theme[Color.SECONDARY];
+        this.#progress.labelColor = this.#theme[Color.SECONDARY];
+        this.#progress.valueColor = this.#theme[Color.PRIMARY];
+    }
+    get darkMode() {
+        return this.#isDarkMode;
+    }
+    primary(message) {
+        return this.#styler.colorText(message, this.#theme[Color.PRIMARY]);
+    }
+    secondary(message) {
+        return this.#styler.colorText(message, this.#theme[Color.SECONDARY]);
+    }
+    emphasised(message) {
+        return this.#styler.colorText(message, this.#theme[Color.EMPHASISED]);
+    }
+    selected(message) {
+        return this.#styler.colorText(message, this.#theme[Color.SELECTED]);
+    }
+    italic(message) {
+        return this.#styler.italicText(message);
+    }
+    yellow(message) {
+        return this.#styler.colorText(message, this.#theme[Color.YELLOW]);
+    }
+    orange(message) {
+        return this.#styler.colorText(message, this.#theme[Color.ORANGE]);
+    }
+    red(message) {
+        return this.#styler.colorText(message, this.#theme[Color.RED]);
+    }
+    magenta(message) {
+        return this.#styler.colorText(message, this.#theme[Color.MAGENTA]);
+    }
+    violet(message) {
+        return this.#styler.colorText(message, this.#theme[Color.VIOLET]);
+    }
+    blue(message) {
+        return this.#styler.colorText(message, this.#theme[Color.BLUE]);
+    }
+    cyan(message) {
+        return this.#styler.colorText(message, this.#theme[Color.CYAN]);
+    }
+    green(message) {
+        return this.#styler.colorText(message, this.#theme[Color.GREEN]);
+    }
+    #parseHexColor(hexFormattedColor) {
+        if (hexFormattedColor.length !== 7 || !hexFormattedColor.toLowerCase().startsWith("#")) {
+            throw new Error(`Invalid color: ${hexFormattedColor}`);
+        }
+        const colorValue = parseInt(hexFormattedColor.slice(1), 16);
+        if (isNaN(colorValue) || colorValue < 0 || colorValue > 0xffffff) {
+            throw new Error(`Invalid color: ${hexFormattedColor}`);
+        }
+        return colorValue;
+    }
+    color(message, hexFormattedColor) {
+        return this.#styler.colorText(message, this.#parseHexColor(hexFormattedColor));
+    }
+    backgroundPrimary(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.PRIMARY]);
+    }
+    backgroundSecondary(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.SECONDARY]);
+    }
+    backgroundEmphasised(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.EMPHASISED]);
+    }
+    backgroundSelected(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.SELECTED]);
+    }
+    backgroundYellow(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.YELLOW]);
+    }
+    backgroundOrange(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.ORANGE]);
+    }
+    backgroundRed(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.RED]);
+    }
+    backgroundMagenta(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.MAGENTA]);
+    }
+    backgroundViolet(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.VIOLET]);
+    }
+    backgroundBlue(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.BLUE]);
+    }
+    backgroundCyan(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.CYAN]);
+    }
+    backgroundGreen(message) {
+        return this.#styler.backgroundColorText(message, this.#theme[Color.GREEN]);
+    }
+    backgroundColor(message, hexFormattedColor) {
+        return this.#styler.backgroundColorText(message, this.#parseHexColor(hexFormattedColor));
+    }
+    async debug(message, icon) {
+        await this.#log(Level.DEBUG, this.secondary(message), icon);
+    }
+    async info(message, icon) {
+        await this.#log(Level.INFO, this.primary(message), icon);
+    }
+    async warn(message, icon) {
+        await this.#log(Level.WARN, this.yellow(message), icon);
+    }
+    async error(message, icon) {
+        await this.#log(Level.ERROR, this.red(message), icon);
+    }
+    async print(message, icon) {
+        await this.#spinner.pause();
+        await this.#progress.pause();
+        const writer = this.stdoutWritable.getWriter();
+        const colorMessage = this.#stdoutIsColor ? this.primary(message) : message;
+        const encoded = this.#encoder.encode(`${icon !== undefined ? `${this.#iconDefinitions[icon]} ` : ""}${colorMessage}`);
+        await writer.ready;
+        await writer.write(encoded);
+        writer.releaseLock();
+        this.#spinner.resume();
+        this.#progress.resume();
+    }
+    async setLevel(level) {
+        if (this.#threshold > Level.INFO) {
+            await this.#spinner.hide();
+            await this.#progress.hideAll();
+        }
+        this.#threshold = level;
+    }
+    getLevel() {
+        return this.#threshold;
+    }
+    async showSpinner(message, style) {
+        await this.#progress.hideAll();
+        if (this.#threshold > Level.INFO) {
+            return;
+        }
+        if (style != null) {
+            this.#spinner.spinnerStyle = style;
+        }
+        await this.#spinner.show(message);
+    }
+    async hideSpinner() {
+        await this.#spinner.hide();
+    }
+    async showProgressBar(units, message = "", total = 100, current = 0, style) {
+        await this.#spinner.hide();
+        if (this.#threshold > Level.INFO) {
+            return -1;
+        }
+        if (style != null) {
+            this.#progress.progressStyle = style;
+        }
+        return this.#progress.add(units, message, total, current);
+    }
+    async hideProgressBar(handle) {
+        await this.#progress.hide(handle);
+    }
+    async hideAllProgressBars() {
+        await this.#progress.hideAll();
+    }
+    updateProgressBar(handle, current, message) {
+        if (this.#threshold > Level.INFO) {
+            return;
+        }
+        this.#progress.update(handle, current, message);
+    }
+}

package/dist/src/service/printer/PrinterServiceProvider.js

@@ -0,0 +1,43 @@
+import LogLevelCommand from "./command/LogLevelCommand.js";
+import { PRINTER_SERVICE_ID } from "../../api/service/core/PrinterService.js";
+import DarkModeCommand from "./command/DarkModeCommand.js";
+import NoColorCommand from "./command/NoColorCommand.js";
+import NoHyperlinksCommand from "./command/NoHyperlinksCommand.js";
+import { SHUTDOWN_SERVICE_ID } from "../../api/service/core/ShutdownService.js";
+/**
+ * Provides a {@link PrinterService}.
+ */
+export default class PrinterServiceProvider {
+    serviceId = PRINTER_SERVICE_ID;
+    servicePriority;
+    printerService;
+    /**
+     * Create an instance of the service provider with the specified details.
+     *
+     * @param servicePriority the priority of the service.
+     * @param printerService the PrinterService implementation to use.
+     */
+    constructor(servicePriority, printerService) {
+        this.servicePriority = servicePriority;
+        this.printerService = printerService;
+    }
+    getServiceInfo(_cliConfig) {
+        return Promise.resolve({
+            service: this.printerService,
+            commands: [
+                new NoHyperlinksCommand(this, this.servicePriority + 3),
+                new DarkModeCommand(this, this.servicePriority + 2),
+                new NoColorCommand(this, this.servicePriority + 1),
+                new LogLevelCommand(this, this.servicePriority),
+            ],
+        });
+    }
+    initService(context) {
+        const shutdownService = context.getServiceById(SHUTDOWN_SERVICE_ID);
+        shutdownService.addShutdownListener(async () => {
+            await this.printerService.hideSpinner();
+            await this.printerService.hideAllProgressBars();
+        });
+        return Promise.resolve();
+    }
+}

package/dist/src/service/printer/command/DarkModeCommand.js

@@ -0,0 +1,24 @@
+import { ArgumentValueTypeName, } from "../../../api/argument/ArgumentValueTypes.js";
+/**
+ * Command allowing the specification of dark/light mode for {@link PrinterServiceProvider}.
+ */
+export default class DarkModeCommand {
+    name = "dark-mode";
+    description = "Enable dark mode for output";
+    enableConfiguration = true;
+    argument = {
+        type: ArgumentValueTypeName.BOOLEAN,
+        defaultValue: false,
+        configurationKey: "DARK_MODE",
+    };
+    executePriority;
+    #printerServiceProvider;
+    constructor(printerServiceProvider, executePriority) {
+        this.#printerServiceProvider = printerServiceProvider;
+        this.executePriority = executePriority;
+    }
+    execute(_context, argumentValue) {
+        this.#printerServiceProvider.printerService.darkMode = argumentValue;
+        return Promise.resolve();
+    }
+}

package/dist/src/service/printer/command/LogLevelCommand.js

@@ -0,0 +1,41 @@
+import { ArgumentValueTypeName, } from "../../../api/argument/ArgumentValueTypes.js";
+import { Level } from "../../../api/service/core/PrinterService.js";
+/**
+ * Command allowing the setting of the log level for {@link PrinterServiceProvider}.
+ */
+export default class LogLevelCommand {
+    name = "log-level";
+    description = "Set the logging threshold";
+    enableConfiguration = true;
+    argument = {
+        type: ArgumentValueTypeName.STRING,
+        allowableValues: ["DEBUG", "INFO", "WARN", "ERROR"],
+        isCaseInsensitive: true,
+        defaultValue: "INFO",
+        configurationKey: "LOG_LEVEL",
+    };
+    executePriority;
+    #printerServiceProvider;
+    constructor(printerServiceProvider, executePriority) {
+        this.#printerServiceProvider = printerServiceProvider;
+        this.executePriority = executePriority;
+    }
+    execute(_context, argumentValue) {
+        const logLevel = argumentValue;
+        switch (logLevel.toUpperCase()) {
+            case "DEBUG":
+                this.#printerServiceProvider.printerService.setLevel(Level.DEBUG);
+                break;
+            case "INFO":
+                this.#printerServiceProvider.printerService.setLevel(Level.INFO);
+                break;
+            case "WARN":
+                this.#printerServiceProvider.printerService.setLevel(Level.WARN);
+                break;
+            case "ERROR":
+                this.#printerServiceProvider.printerService.setLevel(Level.ERROR);
+                break;
+        }
+        return Promise.resolve();
+    }
+}

package/dist/src/service/printer/command/NoColorCommand.js

@@ -0,0 +1,24 @@
+import { ArgumentValueTypeName, } from "../../../api/argument/ArgumentValueTypes.js";
+/**
+ * Command allowing the disabling of color for {@link PrinterServiceProvider}.
+ */
+export default class NoColorCommand {
+    name = "no-color";
+    description = "Disable color for output";
+    enableConfiguration = true;
+    argument = {
+        type: ArgumentValueTypeName.BOOLEAN,
+        defaultValue: false,
+        configurationKey: "NO_COLOR",
+    };
+    executePriority;
+    #printerServiceProvider;
+    constructor(printerServiceProvider, executePriority) {
+        this.#printerServiceProvider = printerServiceProvider;
+        this.executePriority = executePriority;
+    }
+    execute(_context, argumentValue) {
+        this.#printerServiceProvider.printerService.colorEnabled = !argumentValue;
+        return Promise.resolve();
+    }
+}

package/dist/src/service/printer/command/NoHyperlinksCommand.js

@@ -0,0 +1,21 @@
+import { ArgumentValueTypeName, } from "../../../api/argument/ArgumentValueTypes.js";
+export default class NoHyperlinksCommand {
+    name = "no-hyperlinks";
+    description = "Disable hyperlinks for output";
+    enableConfiguration = true;
+    argument = {
+        type: ArgumentValueTypeName.BOOLEAN,
+        defaultValue: false,
+        configurationKey: "NO_HYPERLINKS",
+    };
+    executePriority;
+    #printerServiceProvider;
+    constructor(printerServiceProvider, executePriority) {
+        this.#printerServiceProvider = printerServiceProvider;
+        this.executePriority = executePriority;
+    }
+    execute(_context, argumentValue) {
+        this.#printerServiceProvider.printerService.hyperlinksEnabled = !argumentValue;
+        return Promise.resolve();
+    }
+}

package/dist/src/service/printer/terminal/Color.js

@@ -0,0 +1,15 @@
+export var Color;
+(function (Color) {
+    Color[Color["PRIMARY"] = 0] = "PRIMARY";
+    Color[Color["SECONDARY"] = 1] = "SECONDARY";
+    Color[Color["EMPHASISED"] = 2] = "EMPHASISED";
+    Color[Color["SELECTED"] = 3] = "SELECTED";
+    Color[Color["YELLOW"] = 4] = "YELLOW";
+    Color[Color["ORANGE"] = 5] = "ORANGE";
+    Color[Color["RED"] = 6] = "RED";
+    Color[Color["MAGENTA"] = 7] = "MAGENTA";
+    Color[Color["VIOLET"] = 8] = "VIOLET";
+    Color[Color["BLUE"] = 9] = "BLUE";
+    Color[Color["CYAN"] = 10] = "CYAN";
+    Color[Color["GREEN"] = 11] = "GREEN";
+})(Color || (Color = {}));