@flowscripter/dynamic-cli-framework 1.7.3 → 1.7.5

package/dist/src/service/prompter/prompt/promptSingleSelect.js

@@ -0,0 +1,73 @@
+import { SpecialKey } from "../../../terminal/KeyReader.js";
+import ShutdownServiceProvider from "../../shutdown/ShutdownServiceProvider.js";
+import { headerLineCount, renderPromptHeader } from "./PromptContext.js";
+export default async function promptSingleSelect(ctx, promptDef) {
+    const options = promptDef.options;
+    if (options.length === 0) {
+        throw new Error(`No options for prompt: ${promptDef.name}`);
+    }
+    let selectedIndex = 0;
+    if (promptDef.defaultOption) {
+        const idx = options.findIndex((o) => o.returnedValue === promptDef.defaultOption.returnedValue);
+        if (idx >= 0)
+            selectedIndex = idx;
+    }
+    let scrollOffset = 0;
+    const visibleCount = Math.min(ctx.config.scrollVisibleOptions, options.length);
+    ctx.keyReader.enableRawMode();
+    try {
+        await ctx.terminal.hideCursor();
+        let firstRender = true;
+        while (true) {
+            if (scrollOffset > selectedIndex) {
+                scrollOffset = selectedIndex;
+            }
+            else if (selectedIndex >= scrollOffset + visibleCount) {
+                scrollOffset = selectedIndex - visibleCount + 1;
+            }
+            const headerLines = headerLineCount(ctx.terminal, promptDef);
+            if (!firstRender) {
+                await ctx.terminal.clearUpLines(visibleCount + headerLines);
+            }
+            firstRender = false;
+            await renderPromptHeader(ctx, promptDef);
+            for (let i = scrollOffset; i < scrollOffset + visibleCount; i++) {
+                const option = options[i];
+                const isSelected = i === selectedIndex;
+                const prefix = isSelected ? ctx.config.inputPromptCharacters : "  ";
+                const text = prefix + option.displayValue;
+                await ctx.terminal.write(`${isSelected ? ctx.printerService.cyan(text) : ctx.printerService.secondary(text)}\n`);
+            }
+            const keyEvent = await ctx.keyReader.readKey();
+            if (keyEvent.specialKey === SpecialKey.UP && selectedIndex > 0) {
+                selectedIndex--;
+            }
+            else if (keyEvent.specialKey === SpecialKey.DOWN && selectedIndex < options.length - 1) {
+                selectedIndex++;
+            }
+            else if (keyEvent.specialKey === SpecialKey.ENTER) {
+                await ctx.terminal.showCursor();
+                const option = options[selectedIndex];
+                const validationError = option.validate ? option.validate(option.returnedValue) : undefined;
+                if (validationError) {
+                    await ctx.terminal.write(`${ctx.printerService.red(validationError)}\n`);
+                    firstRender = true;
+                    continue;
+                }
+                return { name: promptDef.name, value: option.returnedValue };
+            }
+            else if (keyEvent.specialKey === SpecialKey.ESCAPE) {
+                await ctx.terminal.showCursor();
+                throw new Error("Prompt cancelled");
+            }
+            else if (keyEvent.specialKey === SpecialKey.INTERRUPT) {
+                await ctx.terminal.showCursor();
+                ShutdownServiceProvider.onInterrupt();
+                throw new Error("Interrupted");
+            }
+        }
+    }
+    finally {
+        ctx.keyReader.disableRawMode();
+    }
+}

package/dist/src/service/prompter/prompt/promptText.js

@@ -0,0 +1,75 @@
+import { SpecialKey } from "../../../terminal/KeyReader.js";
+import ShutdownServiceProvider from "../../shutdown/ShutdownServiceProvider.js";
+import { renderPromptHeader } from "./PromptContext.js";
+export default async function promptText(ctx, promptDef) {
+    ctx.keyReader.enableRawMode();
+    try {
+        while (true) {
+            await renderPromptHeader(ctx, promptDef);
+            const promptMarker = ctx.printerService.cyan(ctx.config.inputPromptCharacters);
+            await ctx.terminal.write(promptMarker);
+            let buffer = promptDef.defaultOption ? String(promptDef.defaultOption.returnedValue) : "";
+            if (buffer.length > 0) {
+                await ctx.terminal.write(buffer);
+            }
+            while (true) {
+                const keyEvent = await ctx.keyReader.readKey();
+                if (keyEvent.specialKey === SpecialKey.ENTER) {
+                    await ctx.terminal.write("\n");
+                    break;
+                }
+                else if (keyEvent.specialKey === SpecialKey.ESCAPE) {
+                    await ctx.terminal.write("\n");
+                    throw new Error("Prompt cancelled");
+                }
+                else if (keyEvent.specialKey === SpecialKey.INTERRUPT) {
+                    await ctx.terminal.write("\n");
+                    ShutdownServiceProvider.onInterrupt();
+                    throw new Error("Interrupted");
+                }
+                else if (keyEvent.specialKey === SpecialKey.BACKSPACE) {
+                    if (buffer.length > 0) {
+                        buffer = buffer.slice(0, -1);
+                        await ctx.terminal.write("\b \b");
+                    }
+                }
+                else if (keyEvent.key) {
+                    buffer += keyEvent.key;
+                    const isSecret = promptDef.options.length > 0 && promptDef.options[0].displayValue === "__SECRET__";
+                    await ctx.terminal.write(isSecret ? "*" : keyEvent.key);
+                }
+            }
+            if (buffer.length === 0 && !promptDef.defaultOption) {
+                await ctx.terminal.write(ctx.printerService.red("Value required\n"));
+                continue;
+            }
+            const value = buffer;
+            const validationOption = promptDef.options.length > 0 ? promptDef.options[0] : undefined;
+            if (validationOption?.validate) {
+                const error = validationOption.validate(value);
+                if (error) {
+                    await ctx.terminal.write(`${ctx.printerService.red(error)}\n`);
+                    continue;
+                }
+            }
+            if (validationOption?.min !== undefined && typeof value === "string") {
+                const num = Number(value);
+                if (!isNaN(num) && num < validationOption.min) {
+                    await ctx.terminal.write(ctx.printerService.red(`Value must be at least ${validationOption.min}\n`));
+                    continue;
+                }
+            }
+            if (validationOption?.max !== undefined && typeof value === "string") {
+                const num = Number(value);
+                if (!isNaN(num) && num > validationOption.max) {
+                    await ctx.terminal.write(ctx.printerService.red(`Value must be at most ${validationOption.max}\n`));
+                    continue;
+                }
+            }
+            return { name: promptDef.name, value };
+        }
+    }
+    finally {
+        ctx.keyReader.disableRawMode();
+    }
+}

package/dist/src/service/prompter/prompt/promptToggle.js

@@ -0,0 +1,21 @@
+import { PromptType, } from "../../../api/service/core/PrompterService.js";
+import promptSingleSelect from "./promptSingleSelect.js";
+export default function promptToggle(ctx, promptDef) {
+    const trueFalse = {
+        name: promptDef.name,
+        promptText: promptDef.promptText,
+        description: promptDef.description,
+        type: PromptType.SINGLE_SELECT,
+        defaultOption: promptDef.defaultOption ?? {
+            displayValue: "False",
+            returnedValue: false,
+        },
+        options: promptDef.options.length > 0
+            ? promptDef.options
+            : [
+                { displayValue: "True", returnedValue: true },
+                { displayValue: "False", returnedValue: false },
+            ],
+    };
+    return promptSingleSelect(ctx, trueFalse);
+}

package/dist/src/service/shutdown/DefaultShutdownService.js

@@ -0,0 +1,16 @@
+import { shutdownState } from "./ShutdownState.js";
+export default class DefaultShutdownService {
+    static callbacks = [];
+    addShutdownListener(callback) {
+        DefaultShutdownService.callbacks.push(callback);
+    }
+    enterLongRunningMode() {
+        shutdownState.longRunningMode = true;
+    }
+    leaveLongRunningMode() {
+        shutdownState.longRunningMode = false;
+    }
+    get isShutdownRequested() {
+        return shutdownState.shutdownRequested;
+    }
+}

package/dist/src/service/shutdown/ShutdownServiceProvider.js

@@ -0,0 +1,60 @@
+import process from "node:process";
+import DefaultShutdownService from "./DefaultShutdownService.js";
+import { SHUTDOWN_SERVICE_ID } from "../../api/service/core/ShutdownService.js";
+import getLogger from "../../util/logger.js";
+import { shutdownState } from "./ShutdownState.js";
+const logger = getLogger("ShutdownServiceProvider");
+export default class ShutdownServiceProvider {
+    servicePriority;
+    serviceId = SHUTDOWN_SERVICE_ID;
+    #shutdownService;
+    static #shutdownInProgress = false;
+    constructor(servicePriority) {
+        this.servicePriority = servicePriority;
+        this.#shutdownService = new DefaultShutdownService();
+        process.on("beforeExit", ShutdownServiceProvider.shutdown);
+        process.on("SIGINT", ShutdownServiceProvider.onInterrupt);
+        process.on("SIGTERM", ShutdownServiceProvider.onTerminate);
+    }
+    getServiceInfo(_cliConfig) {
+        return Promise.resolve({
+            service: this.#shutdownService,
+            commands: [],
+        });
+    }
+    initService(_context) {
+        return Promise.resolve(undefined);
+    }
+    static onInterrupt() {
+        shutdownState.interruptCount++;
+        if (!shutdownState.longRunningMode || shutdownState.interruptCount >= 3) {
+            ShutdownServiceProvider.shutdown().then(() => {
+                process.exit(130);
+            });
+        }
+        else {
+            shutdownState.shutdownRequested = true;
+        }
+    }
+    static onTerminate() {
+        ShutdownServiceProvider.shutdown().then(() => {
+            process.exit(143);
+        });
+    }
+    static async shutdown() {
+        if (ShutdownServiceProvider.#shutdownInProgress)
+            return;
+        ShutdownServiceProvider.#shutdownInProgress = true;
+        try {
+            process.removeListener("beforeExit", ShutdownServiceProvider.shutdown);
+            process.removeListener("SIGINT", ShutdownServiceProvider.onInterrupt);
+            process.removeListener("SIGTERM", ShutdownServiceProvider.onTerminate);
+            for await (const callback of DefaultShutdownService.callbacks) {
+                await callback();
+            }
+        }
+        catch (error) {
+            logger.error("shutdown error: %s", error.message);
+        }
+    }
+}

package/dist/src/service/shutdown/ShutdownState.js

@@ -0,0 +1,5 @@
+export const shutdownState = {
+    longRunningMode: false,
+    shutdownRequested: false,
+    interruptCount: 0,
+};

package/dist/src/service/syntaxHighlighter/DefaultSyntaxHighlighterService.js

@@ -0,0 +1,54 @@
+import { createEmphasize } from "emphasize";
+import json from "highlight.js/lib/languages/json";
+/**
+ * Default implementation of {@link SyntaxHighlighterService} which has a syntax definition
+ * for JSON already registered.
+ */
+export default class DefaultSyntaxHighlighterService {
+    colorEnabled = true;
+    colorFunction = (text) => text;
+    #emphasize;
+    constructor() {
+        this.#emphasize = createEmphasize();
+        this.registerSyntax("json", json);
+    }
+    getRegisteredSyntaxes() {
+        return this.#emphasize.listLanguages();
+    }
+    highlight(text, syntaxName, colorScheme) {
+        const name = syntaxName.toLowerCase();
+        if (!this.#emphasize.registered(name)) {
+            throw new Error(`Syntax name is not registered: ${name}`);
+        }
+        // skip highlighting if color disabled
+        if (!this.colorEnabled) {
+            return text;
+        }
+        let sheet;
+        // if a color scheme is provided, create a sheet of color functions
+        if (colorScheme && this.colorFunction) {
+            sheet = {};
+            for (const [key, value] of Object.entries(colorScheme)) {
+                if (!value) {
+                    throw new Error(`Invalid color for entry: ${key}`);
+                }
+                if (value.length !== 7 || !value.toLowerCase().startsWith("#")) {
+                    throw new Error(`Invalid color: ${value}`);
+                }
+                const colorValue = parseInt(value.slice(1), 16);
+                if (isNaN(colorValue) || colorValue < 0 || colorValue > 0xffffff) {
+                    throw new Error(`Invalid color: ${value}`);
+                }
+                sheet[key] = (text) => this.colorFunction(text, value);
+            }
+        }
+        return this.#emphasize.highlight(name, text, sheet).value;
+    }
+    registerSyntax(syntaxName, syntaxDefinition) {
+        const name = syntaxName.toLowerCase();
+        if (this.#emphasize.registered(name)) {
+            throw new Error(`Syntax name already registered: ${name}`);
+        }
+        this.#emphasize.register(name, syntaxDefinition);
+    }
+}

package/dist/src/service/syntaxHighlighter/SyntaxHighlighterServiceProvider.js

@@ -0,0 +1,32 @@
+import DefaultSyntaxHighlighterService from "./DefaultSyntaxHighlighterService.js";
+import { SYNTAX_HIGHLIGHTER_SERVICE_ID } from "../../api/service/core/SyntaxHighlighterService.js";
+import { PRINTER_SERVICE_ID } from "../../api/service/core/PrinterService.js";
+/**
+ * Provides a {@link SyntaxHighlighterService}.
+ */
+export default class SyntaxHighlighterServiceProvider {
+    servicePriority;
+    serviceId = SYNTAX_HIGHLIGHTER_SERVICE_ID;
+    #defaultSyntaxHighlighterService;
+    /**
+     * Create an instance of the service provider with the specified details.
+     *
+     * @param servicePriority the priority of the service.
+     */
+    constructor(servicePriority) {
+        this.servicePriority = servicePriority;
+        this.#defaultSyntaxHighlighterService = new DefaultSyntaxHighlighterService();
+    }
+    getServiceInfo(_cliConfig) {
+        return Promise.resolve({
+            service: this.#defaultSyntaxHighlighterService,
+            commands: [],
+        });
+    }
+    initService(context) {
+        const printerService = context.getServiceById(PRINTER_SERVICE_ID);
+        this.#defaultSyntaxHighlighterService.colorEnabled = printerService.colorEnabled;
+        this.#defaultSyntaxHighlighterService.colorFunction = printerService.color.bind(printerService);
+        return Promise.resolve(undefined);
+    }
+}

package/dist/src/service/tableGenerator/DefaultTableGeneratorService.d.ts

@@ -1,10 +1,12 @@
 import type TableGeneratorService from "../../api/service/core/TableGeneratorService.ts";
-import type Table from "../../api/service/core/Table.ts";
+import type { TableOptions } from "../../api/service/core/TableGeneratorService.ts";
+import Table from "../../api/service/core/Table.ts";
 export default class DefaultTableGeneratorService implements TableGeneratorService {
     #private;
     colorEnabled: boolean;
     colorFunction: (text: string, hexFormattedColor: string) => string;
     backgroundColorFunction: (text: string, hexFormattedColor: string) => string;
+    createTable(rowCount: number, columnCount: number, options?: TableOptions): Table;
     render(table: Table): string;
 }
 //# sourceMappingURL=DefaultTableGeneratorService.d.ts.map

package/dist/src/service/tableGenerator/DefaultTableGeneratorService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DefaultTableGeneratorService.d.ts","sourceRoot":"","sources":["../../../../src/service/tableGenerator/DefaultTableGeneratorService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,qBAAqB,MAAM,iDAAiD,CAAC;AAEzF,OAAO,KAAK,KAAK,MAAM,iCAAiC,CAAC;AAkBzD,MAAM,CAAC,OAAO,OAAO,4BAA6B,YAAW,qBAAqB;;IAChF,YAAY,UAAQ;IACpB,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,KAAK,MAAM,CAAkB;IACpF,uBAAuB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,KAAK,MAAM,CAAkB;IAmQ9F,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;CA4G7B"}
+{"version":3,"file":"DefaultTableGeneratorService.d.ts","sourceRoot":"","sources":["../../../../src/service/tableGenerator/DefaultTableGeneratorService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,qBAAqB,MAAM,iDAAiD,CAAC;AAEzF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iDAAiD,CAAC;AACpF,OAAO,KAAK,MAAM,iCAAiC,CAAC;AAkBpD,MAAM,CAAC,OAAO,OAAO,4BAA6B,YAAW,qBAAqB;;IAChF,YAAY,UAAQ;IACpB,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,KAAK,MAAM,CAAkB;IACpF,uBAAuB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,KAAK,MAAM,CAAkB;IAE9F,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,KAAK;IAqQjF,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;CA4G7B"}