@flowscripter/dynamic-cli-framework 1.0.0

package/src/service/configuration/command/DumpConfigCommand.ts

@@ -0,0 +1,47 @@
+import type Context from "../../../api/Context.ts";
+import type GlobalCommand from "../../../api/command/GlobalCommand.ts";
+import type ConfigurationServiceProvider from "../ConfigurationServiceProvider.ts";
+import type PrinterService from "../../../api/service/core/PrinterService.ts";
+import {
+  PRINTER_SERVICE_ID,
+} from "../../../api/service/core/PrinterService.ts";
+import type SyntaxHighlighterService from "../../../api/service/core/SyntaxHighlighterService.ts";
+import {
+  SYNTAX_HIGHLIGHTER_SERVICE_ID,
+} from "../../../api/service/core/SyntaxHighlighterService.ts";
+
+/**
+ * Command which dumps the configuration loaded by the {@link ConfigurationServiceProvider}.
+ */
+export default class DumpConfigCommand implements GlobalCommand {
+  readonly name = "dump-config";
+  readonly description = "Dump configuration values";
+
+  readonly #configurationServiceProvider: ConfigurationServiceProvider;
+
+  public constructor(
+    configurationServiceProvider: ConfigurationServiceProvider,
+  ) {
+    this.#configurationServiceProvider = configurationServiceProvider;
+  }
+
+  public async execute(
+    context: Context,
+  ): Promise<void> {
+    const printerService = context.getServiceById(
+      PRINTER_SERVICE_ID,
+    ) as PrinterService;
+    const syntaxHighlighterService = context.getServiceById(
+      SYNTAX_HIGHLIGHTER_SERVICE_ID,
+    ) as SyntaxHighlighterService;
+
+    await printerService.print(
+      `${
+        syntaxHighlighterService.highlight(
+          this.#configurationServiceProvider.getConfigString(),
+          "json",
+        )
+      }\n`,
+    );
+  }
+}

package/src/service/printer/DefaultPrinterService.ts

@@ -0,0 +1,256 @@
+import { default as Spinner } from "./terminal/Spinner.ts";
+import { default as Progress } from "./terminal/Progress.ts";
+import type PrinterService from "../../api/service/core/PrinterService.ts";
+import { type Icon, Level } from "../../api/service/core/PrinterService.ts";
+import Terminal from "./terminal/Terminal.ts";
+import { Color } from "./terminal/Color.ts";
+import { getDarkModeTheme, getLightModeTheme } from "./terminal/Theme.ts";
+import { WritableStream } from "node:stream/web";
+import Styler from "./terminal/Styler.ts";
+
+export default class DefaultPrinterService implements PrinterService {
+  readonly stdoutWritable: WritableStream;
+  readonly stderrWritable: WritableStream;
+  #stdoutIsColor: boolean;
+  #stderrTerminal: Terminal;
+  #styler: Styler;
+  #isDarkMode = true;
+  #threshold = Level.INFO;
+  #iconDefinitions: Array<string> = [];
+  #theme: Array<number> = [];
+  #encoder = new TextEncoder();
+  #spinner: Spinner;
+  #progress: Progress;
+
+  async #log(
+    level: number,
+    message: string,
+    icon?: Icon,
+  ): Promise<void> {
+    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();
+  }
+
+  public constructor(
+    stdoutWritableStream: WritableStream,
+    stderrWritableStream: WritableStream,
+    stdoutIsColor: boolean,
+    stderrIsColor: boolean,
+    stderrTerminal: Terminal,
+    styler: Styler,
+  ) {
+    this.stdoutWritable = stdoutWritableStream;
+    this.stderrWritable = stderrWritableStream;
+    this.#stdoutIsColor = stdoutIsColor;
+    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: boolean) {
+    this.#styler.colorEnabled = enabled;
+    this.#stdoutIsColor = enabled;
+    if (enabled) {
+      this.#iconDefinitions = [
+        this.green("✔"),
+        this.red("✖"),
+        this.yellow("‼"),
+        this.blue("ℹ"),
+      ];
+    } else {
+      this.#iconDefinitions = [
+        "✔",
+        "✖",
+        "‼",
+        "ℹ",
+      ];
+    }
+  }
+
+  get colorEnabled(): boolean {
+    return this.#styler.colorEnabled;
+  }
+
+  set darkMode(isDarkMode: boolean) {
+    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(): boolean {
+    return this.#isDarkMode;
+  }
+
+  public primary(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.PRIMARY]);
+  }
+
+  public secondary(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.SECONDARY]);
+  }
+
+  public emphasised(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.EMPHASISED]);
+  }
+
+  public selected(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.SELECTED]);
+  }
+
+  public italic(message: string): string {
+    return this.#styler.italicText(message);
+  }
+
+  public yellow(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.YELLOW]);
+  }
+
+  public orange(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.ORANGE]);
+  }
+
+  public red(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.RED]);
+  }
+
+  public magenta(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.MAGENTA]);
+  }
+
+  public violet(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.VIOLET]);
+  }
+
+  public blue(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.BLUE]);
+  }
+
+  public cyan(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.CYAN]);
+  }
+
+  public green(message: string): string {
+    return this.#styler.colorText(message, this.#theme[Color.GREEN]);
+  }
+
+  public async debug(message: string, icon?: Icon): Promise<void> {
+    await this.#log(Level.DEBUG, this.secondary(message), icon);
+  }
+
+  public async info(message: string, icon?: Icon): Promise<void> {
+    await this.#log(Level.INFO, this.primary(message), icon);
+  }
+
+  public async warn(message: string, icon?: Icon): Promise<void> {
+    await this.#log(Level.WARN, this.yellow(message), icon);
+  }
+
+  public async error(message: string, icon?: Icon): Promise<void> {
+    await this.#log(Level.ERROR, this.red(message), icon);
+  }
+
+  public async print(message: string, icon?: Icon): Promise<void> {
+    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();
+  }
+
+  public async setLevel(level: Level): Promise<void> {
+    if (this.#threshold > Level.INFO) {
+      await this.#spinner.hide();
+      await this.#progress.hideAll();
+    }
+    this.#threshold = level;
+  }
+
+  public getLevel(): Level {
+    return this.#threshold;
+  }
+
+  public async showSpinner(message?: string): Promise<void> {
+    await this.#progress.hideAll();
+    if (this.#threshold > Level.INFO) {
+      return;
+    }
+    await this.#spinner.show(message);
+  }
+
+  public async hideSpinner(): Promise<void> {
+    await this.#spinner.hide();
+  }
+
+  public async showProgressBar(
+    units: string,
+    message = "",
+    total = 100,
+    current = 0,
+  ): Promise<number> {
+    await this.#spinner.hide();
+    if (this.#threshold > Level.INFO) {
+      return -1;
+    }
+
+    return this.#progress.add(units, message, total, current);
+  }
+
+  public async hideProgressBar(handle: number): Promise<void> {
+    await this.#progress.hide(handle);
+  }
+
+  public async hideAllProgressBars(): Promise<void> {
+    await this.#progress.hideAll();
+  }
+
+  public updateProgressBar(
+    handle: number,
+    current: number,
+    message?: string,
+  ): void {
+    if (this.#threshold > Level.INFO) {
+      return;
+    }
+    this.#progress.update(handle, current, message);
+  }
+}

package/src/service/printer/PrinterServiceProvider.ts

@@ -0,0 +1,61 @@
+import type Context from "../../api/Context.ts";
+import LogLevelCommand from "./command/LogLevelCommand.ts";
+import type {
+  ServiceInfo,
+  ServiceProvider,
+} from "../../api/service/ServiceProvider.ts";
+import PrinterService, {
+  PRINTER_SERVICE_ID,
+} from "../../api/service/core/PrinterService.ts";
+import DarkModeCommand from "./command/DarkModeCommand.ts";
+import NoColorCommand from "./command/NoColorCommand.ts";
+import type CLIConfig from "../../api/CLIConfig.ts";
+import ShutdownService, {
+  SHUTDOWN_SERVICE_ID,
+} from "../../api/service/core/ShutdownService.ts";
+
+/**
+ * Provides a {@link PrinterService}.
+ */
+export default class PrinterServiceProvider implements ServiceProvider {
+  readonly serviceId: string = PRINTER_SERVICE_ID;
+  readonly servicePriority: number;
+  readonly printerService: 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.
+   */
+  public constructor(
+    servicePriority: number,
+    printerService: PrinterService,
+  ) {
+    this.servicePriority = servicePriority;
+    this.printerService = printerService;
+  }
+
+  public provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+    return Promise.resolve({
+      service: this.printerService,
+      commands: [
+        new DarkModeCommand(this, this.servicePriority + 2),
+        new NoColorCommand(this, this.servicePriority + 1),
+        new LogLevelCommand(this, this.servicePriority),
+      ],
+    });
+  }
+
+  initService(context: Context): Promise<void> {
+    const shutdownService = context.getServiceById(
+      SHUTDOWN_SERVICE_ID,
+    ) as ShutdownService;
+    shutdownService.addShutdownListener(async () => {
+      await this.printerService.hideSpinner();
+      await this.printerService.hideAllProgressBars();
+    });
+
+    return Promise.resolve();
+  }
+}

package/src/service/printer/command/DarkModeCommand.ts

@@ -0,0 +1,43 @@
+import type GlobalModifierCommand from "../../../api/command/GlobalModifierCommand.ts";
+import type GlobalCommandArgument from "../../../api/argument/GlobalCommandArgument.ts";
+import {
+  type ArgumentSingleValueType,
+  ArgumentValueTypeName,
+} from "../../../api/argument/ArgumentValueTypes.ts";
+import type Context from "../../../api/Context.ts";
+import type PrinterServiceProvider from "../PrinterServiceProvider.ts";
+
+/**
+ * Command allowing the specification of dark/light mode for {@link PrinterServiceProvider}.
+ */
+export default class DarkModeCommand implements GlobalModifierCommand {
+  readonly name = "dark-mode";
+  readonly description = "Enable dark mode for output";
+  readonly enableConfiguration = true;
+  readonly argument: GlobalCommandArgument = {
+    type: ArgumentValueTypeName.BOOLEAN,
+    defaultValue: false,
+    configurationKey: "DARK_MODE",
+  };
+  readonly executePriority: number;
+
+  readonly #printerServiceProvider: PrinterServiceProvider;
+
+  public constructor(
+    printerServiceProvider: PrinterServiceProvider,
+    executePriority: number,
+  ) {
+    this.#printerServiceProvider = printerServiceProvider;
+    this.executePriority = executePriority;
+  }
+
+  public execute(
+    _context: Context,
+    argumentValue: ArgumentSingleValueType,
+  ): Promise<void> {
+    this.#printerServiceProvider.printerService!.darkMode =
+      argumentValue as boolean;
+
+    return Promise.resolve();
+  }
+}

package/src/service/printer/command/LogLevelCommand.ts

@@ -0,0 +1,68 @@
+import type GlobalCommandArgument from "../../../api/argument/GlobalCommandArgument.ts";
+import {
+  type ArgumentSingleValueType,
+  ArgumentValueTypeName,
+} from "../../../api/argument/ArgumentValueTypes.ts";
+import type GlobalModifierCommand from "../../../api/command/GlobalModifierCommand.ts";
+import type Context from "../../../api/Context.ts";
+import type PrinterServiceProvider from "../PrinterServiceProvider.ts";
+import { Level } from "../../../api/service/core/PrinterService.ts";
+
+/**
+ * Command allowing the setting of the log level for {@link PrinterServiceProvider}.
+ */
+export default class LogLevelCommand implements GlobalModifierCommand {
+  readonly name = "log-level";
+  readonly description = "Set the logging threshold";
+  readonly enableConfiguration = true;
+  readonly argument: GlobalCommandArgument = {
+    type: ArgumentValueTypeName.STRING,
+    allowableValues: [
+      "DEBUG",
+      "INFO",
+      "WARN",
+      "ERROR",
+    ],
+    defaultValue: "INFO",
+    configurationKey: "LOG_LEVEL",
+  };
+  readonly executePriority: number;
+
+  readonly #printerServiceProvider: PrinterServiceProvider;
+
+  public constructor(
+    printerServiceProvider: PrinterServiceProvider,
+    executePriority: number,
+  ) {
+    this.#printerServiceProvider = printerServiceProvider;
+    this.executePriority = executePriority;
+  }
+
+  public execute(
+    _context: Context,
+    argumentValue: ArgumentSingleValueType,
+  ): Promise<void> {
+    const logLevel = argumentValue as string;
+
+    switch (logLevel) {
+      case "DEBUG":
+        return this.#printerServiceProvider.printerService!.setLevel(
+          Level.DEBUG,
+        );
+      case "INFO":
+        return this.#printerServiceProvider.printerService!.setLevel(
+          Level.INFO,
+        );
+      case "WARN":
+        return this.#printerServiceProvider.printerService!.setLevel(
+          Level.WARN,
+        );
+      case "ERROR":
+        return this.#printerServiceProvider.printerService!.setLevel(
+          Level.ERROR,
+        );
+    }
+
+    return Promise.resolve();
+  }
+}

package/src/service/printer/command/NoColorCommand.ts

@@ -0,0 +1,43 @@
+import type GlobalModifierCommand from "../../../api/command/GlobalModifierCommand.ts";
+import type GlobalCommandArgument from "../../../api/argument/GlobalCommandArgument.ts";
+import {
+  type ArgumentSingleValueType,
+  ArgumentValueTypeName,
+} from "../../../api/argument/ArgumentValueTypes.ts";
+import type Context from "../../../api/Context.ts";
+import type PrinterServiceProvider from "../PrinterServiceProvider.ts";
+
+/**
+ * Command allowing the disabling of color for {@link PrinterServiceProvider}.
+ */
+export default class NoColorCommand implements GlobalModifierCommand {
+  readonly name = "no-color";
+  readonly description = "Disable color for output";
+  readonly enableConfiguration = true;
+  readonly argument: GlobalCommandArgument = {
+    type: ArgumentValueTypeName.BOOLEAN,
+    defaultValue: false,
+    configurationKey: "NO_COLOR",
+  };
+  readonly executePriority: number;
+
+  readonly #printerServiceProvider: PrinterServiceProvider;
+
+  public constructor(
+    printerServiceProvider: PrinterServiceProvider,
+    executePriority: number,
+  ) {
+    this.#printerServiceProvider = printerServiceProvider;
+    this.executePriority = executePriority;
+  }
+
+  public execute(
+    _context: Context,
+    argumentValue: ArgumentSingleValueType,
+  ): Promise<void> {
+    this.#printerServiceProvider.printerService!.colorEnabled =
+      !argumentValue as boolean;
+
+    return Promise.resolve();
+  }
+}

package/src/service/printer/terminal/Ansi.ts

@@ -0,0 +1,10 @@
+const CSI = "\x1b[";
+
+export const CLEAR_LINE = CSI + "2K";
+export const CURSOR_LEFT = CSI + "G";
+export const CURSOR_UP = CSI + "1A";
+export const HIDE_CURSOR = CSI + "?25l";
+export const SHOW_CURSOR = CSI + "?25h";
+export const ITALIC_START = CSI + "3m";
+export const ITALIC_END = CSI + "23m";
+export const COLOR_END = CSI + "39m";

package/src/service/printer/terminal/Color.ts

@@ -0,0 +1,14 @@
+export enum Color {
+  PRIMARY,
+  SECONDARY,
+  EMPHASISED,
+  SELECTED,
+  YELLOW,
+  ORANGE,
+  RED,
+  MAGENTA,
+  VIOLET,
+  BLUE,
+  CYAN,
+  GREEN,
+}