@flowscripter/dynamic-cli-framework 1.2.2 → 1.3.1

package/tests/service/argumentPrompter/ArgumentPrompterServiceProvider.test.ts

@@ -13,20 +13,14 @@ function getMockArgumentPrompterService(): ArgumentPrompterService {
 
 describe("ArgumentPrompterServiceProvider tests", () => {
   test("ArgumentPrompterServiceProvider has correct serviceId", () => {
-    const provider = new ArgumentPrompterServiceProvider(
-      100,
-      getMockArgumentPrompterService(),
-    );
+    const provider = new ArgumentPrompterServiceProvider(100, getMockArgumentPrompterService());
 
     expect(provider.serviceId).toEqual(ARGUMENT_PROMPTER_SERVICE_ID);
   });
 
   test("ArgumentPrompterServiceProvider getServiceInfo returns no commands", async () => {
     const argPrompterService = getMockArgumentPrompterService();
-    const provider = new ArgumentPrompterServiceProvider(
-      100,
-      argPrompterService,
-    );
+    const provider = new ArgumentPrompterServiceProvider(100, argPrompterService);
     const cliConfig = getCLIConfig();
 
     const serviceInfo = await provider.getServiceInfo(cliConfig);
@@ -36,10 +30,7 @@ describe("ArgumentPrompterServiceProvider tests", () => {
   });
 
   test("ArgumentPrompterServiceProvider initService resolves", async () => {
-    const provider = new ArgumentPrompterServiceProvider(
-      100,
-      getMockArgumentPrompterService(),
-    );
+    const provider = new ArgumentPrompterServiceProvider(100, getMockArgumentPrompterService());
     const context = new DefaultContext(getCLIConfig());
 
     await expect(provider.initService(context)).resolves.toBeUndefined();

package/tests/service/argumentPrompter/DefaultArgumentPrompterService.test.ts

@@ -1,10 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import DefaultArgumentPrompterService from "../../../src/service/argumentPrompter/DefaultArgumentPrompterService.ts";
 import type PrompterService from "../../../src/api/service/core/PrompterService.ts";
-import type {
-  Prompt,
-  PromptResult,
-} from "../../../src/api/service/core/PrompterService.ts";
+import type { Prompt, PromptResult } from "../../../src/api/service/core/PrompterService.ts";
 import type { ParseResult } from "../../../src/runtime/parser.ts";
 import { InvalidArgumentReason } from "../../../src/api/RunResult.ts";
 import {
@@ -26,16 +23,12 @@ class MockPrompterService implements PrompterService {
   prompt(promptDef: Prompt): Promise<PromptResult> {
     const result = this.#responses.get(promptDef.name);
     if (!result) {
-      return Promise.reject(
-        new Error(`No mock response for prompt: ${promptDef.name}`),
-      );
+      return Promise.reject(new Error(`No mock response for prompt: ${promptDef.name}`));
     }
     return Promise.resolve(result);
   }
 
-  async promptAll(
-    prompts: ReadonlyArray<Prompt>,
-  ): Promise<ReadonlyArray<PromptResult>> {
+  async promptAll(prompts: ReadonlyArray<Prompt>): Promise<ReadonlyArray<PromptResult>> {
     const results: PromptResult[] = [];
     for (const p of prompts) {
       results.push(await this.prompt(p));
@@ -168,9 +161,7 @@ describe("DefaultArgumentPrompterService tests", () => {
 
     const result = await service.promptForMissingArguments(parseResult);
     expect(result.invalidArguments.length).toEqual(0);
-    expect(
-      (result.populatedArgumentValues as Record<string, unknown>)["foo"],
-    ).toEqual("bar");
+    expect((result.populatedArgumentValues as Record<string, unknown>)["foo"]).toEqual("bar");
   });
 
   test("missing BOOLEAN option prompts TOGGLE", async () => {
@@ -201,9 +192,7 @@ describe("DefaultArgumentPrompterService tests", () => {
 
     const result = await service.promptForMissingArguments(parseResult);
     expect(result.invalidArguments.length).toEqual(0);
-    expect(
-      (result.populatedArgumentValues as Record<string, unknown>)["flag"],
-    ).toEqual(true);
+    expect((result.populatedArgumentValues as Record<string, unknown>)["flag"]).toEqual(true);
   });
 
   test("missing option with allowableValues prompts SINGLE_SELECT", async () => {
@@ -235,9 +224,7 @@ describe("DefaultArgumentPrompterService tests", () => {
 
     const result = await service.promptForMissingArguments(parseResult);
     expect(result.invalidArguments.length).toEqual(0);
-    expect(
-      (result.populatedArgumentValues as Record<string, unknown>)["color"],
-    ).toEqual("blue");
+    expect((result.populatedArgumentValues as Record<string, unknown>)["color"]).toEqual("blue");
   });
 
   test("missing INTEGER option coerces string to number", async () => {
@@ -268,9 +255,7 @@ describe("DefaultArgumentPrompterService tests", () => {
 
     const result = await service.promptForMissingArguments(parseResult);
     expect(result.invalidArguments.length).toEqual(0);
-    expect(
-      (result.populatedArgumentValues as Record<string, unknown>)["count"],
-    ).toEqual(42);
+    expect((result.populatedArgumentValues as Record<string, unknown>)["count"]).toEqual(42);
   });
 
   test("SubCommand with multiple missing values prompts for each", async () => {
@@ -417,10 +402,9 @@ describe("DefaultArgumentPrompterService tests", () => {
       ],
     };
 
-    const command = makeSubCommand(
-      "test",
-      [complexOption as unknown as SubCommand["options"][number]],
-    );
+    const command = makeSubCommand("test", [
+      complexOption as unknown as SubCommand["options"][number],
+    ]);
 
     const parseResult: ParseResult = {
       command,
@@ -468,10 +452,9 @@ describe("DefaultArgumentPrompterService tests", () => {
       ],
     };
 
-    const command = makeSubCommand(
-      "test",
-      [complexOption as unknown as SubCommand["options"][number]],
-    );
+    const command = makeSubCommand("test", [
+      complexOption as unknown as SubCommand["options"][number],
+    ]);
 
     const parseResult: ParseResult = {
       command,
@@ -546,13 +529,17 @@ describe("DefaultArgumentPrompterService tests", () => {
     prompter.addResponse("file", "/tmp/data.txt");
     const service = new DefaultArgumentPrompterService(prompter);
 
-    const command = makeSubCommand("test", [], [
-      {
-        name: "file",
-        description: "file path",
-        type: ArgumentValueTypeName.STRING,
-      },
-    ]);
+    const command = makeSubCommand(
+      "test",
+      [],
+      [
+        {
+          name: "file",
+          description: "file path",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+    );
 
     const parseResult: ParseResult = {
       command,
@@ -725,14 +712,18 @@ describe("DefaultArgumentPrompterService tests", () => {
       return Promise.resolve(resp as PromptResult);
     };
 
-    const command = makeSubCommand("test", [], [
-      {
-        name: "files",
-        description: "file paths",
-        type: ArgumentValueTypeName.STRING,
-        isVarargMultiple: true,
-      },
-    ]);
+    const command = makeSubCommand(
+      "test",
+      [],
+      [
+        {
+          name: "files",
+          description: "file paths",
+          type: ArgumentValueTypeName.STRING,
+          isVarargMultiple: true,
+        },
+      ],
+    );
 
     const parseResult: ParseResult = {
       command,

package/tests/service/asciiBannerGenerator/AsciiBannerGeneratorServiceProvider.test.ts

@@ -5,17 +5,11 @@ import AsciiBannerGeneratorServiceProvider from "../../../src/service/asciiBanne
 
 describe("AsciiBannerGeneratorServiceProvider tests", () => {
   test("AsciiBannerGeneratorServiceProvider getServiceInfo and initService works", async () => {
-    const asciiBannerGeneratorServiceProvider =
-      new AsciiBannerGeneratorServiceProvider(
-        100,
-      );
+    const asciiBannerGeneratorServiceProvider = new AsciiBannerGeneratorServiceProvider(100);
     const cliConfig = getCLIConfig();
     const context = new DefaultContext(cliConfig);
 
-    const serviceInfo = await asciiBannerGeneratorServiceProvider
-      .getServiceInfo(
-        cliConfig,
-      );
+    const serviceInfo = await asciiBannerGeneratorServiceProvider.getServiceInfo(cliConfig);
     expect(serviceInfo.commands.length).toEqual(0);
 
     await asciiBannerGeneratorServiceProvider.initService(context);

package/tests/service/asciiBannerGenerator/DefaultAsciiBannerGeneratorService.test.ts

@@ -5,67 +5,49 @@ import DefaultAsciiBannerGeneratorService from "../../../src/service/asciiBanner
 import smallFont from "./small.flf.json" with { type: "json" };
 describe("DefaultAsciiBannerGeneratorService tests", () => {
   test("standard font registered by default", () => {
-    const asciiBannerGeneratorService =
-      new DefaultAsciiBannerGeneratorService();
+    const asciiBannerGeneratorService = new DefaultAsciiBannerGeneratorService();
 
-    expect(asciiBannerGeneratorService.getRegisteredFonts()).toEqual([
-      "standard",
-    ]);
+    expect(asciiBannerGeneratorService.getRegisteredFonts()).toEqual(["standard"]);
   });
 
   test("Cannot register a font if already registered", () => {
-    const asciiBannerGeneratorService =
-      new DefaultAsciiBannerGeneratorService();
+    const asciiBannerGeneratorService = new DefaultAsciiBannerGeneratorService();
 
-    expect(() =>
-      asciiBannerGeneratorService.registerFont("standard", smallFont.font)
-    )
-      .toThrow();
+    expect(() => asciiBannerGeneratorService.registerFont("standard", smallFont.font)).toThrow();
   });
 
   test("Can register new font", () => {
-    const asciiBannerGeneratorService =
-      new DefaultAsciiBannerGeneratorService();
+    const asciiBannerGeneratorService = new DefaultAsciiBannerGeneratorService();
 
     asciiBannerGeneratorService.registerFont("small", smallFont.font);
-    expect(asciiBannerGeneratorService.getRegisteredFonts()).toEqual([
-      "standard",
-      "small",
-    ]);
+    expect(asciiBannerGeneratorService.getRegisteredFonts()).toEqual(["standard", "small"]);
   });
 
   test("Cannot generate with unknown font", () => {
-    const asciiBannerGeneratorService =
-      new DefaultAsciiBannerGeneratorService();
+    const asciiBannerGeneratorService = new DefaultAsciiBannerGeneratorService();
 
-    expect(asciiBannerGeneratorService.generate("foo", { fontName: "small" }))
-      .rejects
-      .toThrow();
+    expect(asciiBannerGeneratorService.generate("foo", { fontName: "small" })).rejects.toThrow();
   });
 
   test("Can generate with standard font", async () => {
-    const asciiBannerGeneratorService =
-      new DefaultAsciiBannerGeneratorService();
+    const asciiBannerGeneratorService = new DefaultAsciiBannerGeneratorService();
 
     asciiBannerGeneratorService.registerFont("small", smallFont.font);
 
-    const generated = await asciiBannerGeneratorService.generate(
-      "foo",
-      { fontName: "standard" },
-    );
+    const generated = await asciiBannerGeneratorService.generate("foo", {
+      fontName: "standard",
+    });
     expect(generated).toMatchSnapshot();
   });
 
   test("Can generate with newly registered font", async () => {
-    const asciiBannerGeneratorService =
-      new DefaultAsciiBannerGeneratorService();
+    const asciiBannerGeneratorService = new DefaultAsciiBannerGeneratorService();
 
     asciiBannerGeneratorService.registerFont("small", smallFont.font);
 
-    const generated = await asciiBannerGeneratorService.generate(
-      "foo",
-      { fontName: "small" },
-    );
+    const generated = await asciiBannerGeneratorService.generate("foo", {
+      fontName: "small",
+    });
     expect(generated).toMatchSnapshot();
   });
 
@@ -145,13 +127,12 @@ describe("DefaultAsciiBannerGeneratorService tests", () => {
         },
       },
     });
-    const lines = result.trim().split("\n").filter((l) =>
-      l.includes("\x1b[38;2;")
-    );
-    const firstCodes = lines.map((l) =>
-      // deno-lint-ignore no-control-regex
-      l.match(/\x1b\[38;2;(\d+;\d+;\d+)m/)?.[1]
-    );
+    const lines = result
+      .trim()
+      .split("\n")
+      .filter((l) => l.includes("\x1b[38;2;"));
+    const ansiRe = /\x1b\[38;2;(\d+;\d+;\d+)m/; // oxlint-disable-line no-control-regex
+    const firstCodes = lines.map((l) => l.match(ansiRe)?.[1]);
     const unique = new Set(firstCodes.filter(Boolean));
     expect(unique.size).toBeGreaterThan(1);
   });
@@ -168,14 +149,13 @@ describe("DefaultAsciiBannerGeneratorService tests", () => {
         },
       },
     });
-    const lines = result.trim().split("\n").filter((l) =>
-      l.includes("\x1b[38;2;")
-    );
+    const lines = result
+      .trim()
+      .split("\n")
+      .filter((l) => l.includes("\x1b[38;2;"));
     const firstLine = lines[0]!;
-    // deno-lint-ignore no-control-regex
-    const codes = [...firstLine.matchAll(/\x1b\[38;2;(\d+;\d+;\d+)m/g)].map((
-      m,
-    ) => m[1]);
+    const ansiReG = /\x1b\[38;2;(\d+;\d+;\d+)m/g; // oxlint-disable-line no-control-regex
+    const codes = [...firstLine.matchAll(ansiReG)].map((m) => m[1]);
     const unique = new Set(codes);
     expect(unique.size).toBeGreaterThan(1);
   });
@@ -193,14 +173,13 @@ describe("DefaultAsciiBannerGeneratorService tests", () => {
       },
     });
     expect(result).toContain("\x1b[38;2;");
-    const lines = result.trim().split("\n").filter((l) =>
-      l.includes("\x1b[38;2;")
-    );
+    const lines = result
+      .trim()
+      .split("\n")
+      .filter((l) => l.includes("\x1b[38;2;"));
     const firstLine = lines[0]!;
-    // deno-lint-ignore no-control-regex
-    const codes = [...firstLine.matchAll(/\x1b\[38;2;(\d+;\d+;\d+)m/g)].map((
-      m,
-    ) => m[1]);
+    const ansiReG2 = /\x1b\[38;2;(\d+;\d+;\d+)m/g; // oxlint-disable-line no-control-regex
+    const codes = [...firstLine.matchAll(ansiReG2)].map((m) => m[1]);
     const unique = new Set(codes);
     expect(unique.size).toBeGreaterThan(1);
   });
@@ -217,13 +196,12 @@ describe("DefaultAsciiBannerGeneratorService tests", () => {
         },
       },
     });
-    const lines = result.trim().split("\n").filter((l) =>
-      l.includes("\x1b[38;2;")
-    );
-    const firstCodes = lines.map((l) =>
-      // deno-lint-ignore no-control-regex
-      l.match(/\x1b\[38;2;(\d+;\d+;\d+)m/)?.[1]
-    );
+    const lines = result
+      .trim()
+      .split("\n")
+      .filter((l) => l.includes("\x1b[38;2;"));
+    const ansiRe2 = /\x1b\[38;2;(\d+;\d+;\d+)m/; // oxlint-disable-line no-control-regex
+    const firstCodes = lines.map((l) => l.match(ansiRe2)?.[1]);
     const unique = new Set(firstCodes.filter(Boolean));
     expect(unique.size).toBeGreaterThan(1);
   });

package/tests/service/banner/BannerServiceProvider.test.ts

@@ -12,16 +12,12 @@ import TtyStyler from "../../../src/terminal/TtyStyler.ts";
 import { getConfigurationServiceProvider } from "../../fixtures/ConfigurationServiceProvider.ts";
 
 // FIGlet font is converted to a JSON string and embedded in a simple JSON file: `{ "font": "<figlet font definition>" }`
-import smallFont from "../asciiBannerGenerator/small.flf.json" with {
-  type: "json",
-};
+import smallFont from "../asciiBannerGenerator/small.flf.json" with { type: "json" };
 
 describe("BannerServiceProvider tests", () => {
   test("BannerServiceProvider getServiceInfo works", async () => {
     const bannerServiceProvider = new BannerServiceProvider(100);
-    const serviceInfo = await bannerServiceProvider.getServiceInfo(
-      getCLIConfig(),
-    );
+    const serviceInfo = await bannerServiceProvider.getServiceInfo(getCLIConfig());
     expect(serviceInfo.commands.length).toEqual(1);
   });
 
@@ -43,10 +39,7 @@ describe("BannerServiceProvider tests", () => {
     const context = new DefaultContext(getCLIConfig());
 
     context.addServiceInstance(PRINTER_SERVICE_ID, printer);
-    context.addServiceInstance(
-      ASCII_BANNER_GENERATOR_SERVICE_ID,
-      asciiBannerGenerator,
-    );
+    context.addServiceInstance(ASCII_BANNER_GENERATOR_SERVICE_ID, asciiBannerGenerator);
 
     const bannerServiceProvider = new BannerServiceProvider(100);
     await bannerServiceProvider.initService(context);
@@ -74,17 +67,11 @@ describe("BannerServiceProvider tests", () => {
     const context = new DefaultContext(getCLIConfig("mpeg-sdl-tool"));
 
     context.addServiceInstance(PRINTER_SERVICE_ID, printer);
-    context.addServiceInstance(
-      ASCII_BANNER_GENERATOR_SERVICE_ID,
-      asciiBannerGenerator,
-    );
+    context.addServiceInstance(ASCII_BANNER_GENERATOR_SERVICE_ID, asciiBannerGenerator);
 
     asciiBannerGenerator.registerFont("small", smallFont.font);
 
-    const configurationServiceProvider = getConfigurationServiceProvider(
-      100,
-      new Map(),
-    );
+    const configurationServiceProvider = getConfigurationServiceProvider(100, new Map());
     configurationServiceProvider.configLocation = "config.yaml";
 
     const bannerServiceProvider = new BannerServiceProvider(

package/tests/service/banner/command/NoBannerCommand.test.ts

@@ -11,10 +11,7 @@ describe("NoBannerCommand tests", () => {
 
     expect(bannerServiceProvider.printBanner).toBeTrue();
 
-    await noBannerCommand.execute(
-      new DefaultContext(getCLIConfig()),
-      true,
-    );
+    await noBannerCommand.execute(new DefaultContext(getCLIConfig()), true);
 
     expect(bannerServiceProvider.printBanner).toBeFalse();
   });