@flowscripter/dynamic-cli-framework 1.1.6 → 1.2.0

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

@@ -4,7 +4,7 @@ import { getCLIConfig } from "../../fixtures/CLIConfig.ts";
 import AsciiBannerGeneratorServiceProvider from "../../../src/service/asciiBannerGenerator/AsciiBannerGeneratorServiceProvider.ts";
 
 describe("AsciiBannerGeneratorServiceProvider tests", () => {
-  test("AsciiBannerGeneratorServiceProvider provide and initService works", async () => {
+  test("AsciiBannerGeneratorServiceProvider getServiceInfo and initService works", async () => {
     const asciiBannerGeneratorServiceProvider =
       new AsciiBannerGeneratorServiceProvider(
         100,
@@ -12,9 +12,10 @@ describe("AsciiBannerGeneratorServiceProvider tests", () => {
     const cliConfig = getCLIConfig();
     const context = new DefaultContext(cliConfig);
 
-    const serviceInfo = await asciiBannerGeneratorServiceProvider.provide(
-      cliConfig,
-    );
+    const serviceInfo = await asciiBannerGeneratorServiceProvider
+      .getServiceInfo(
+        cliConfig,
+      );
     expect(serviceInfo.commands.length).toEqual(0);
 
     await asciiBannerGeneratorServiceProvider.initService(context);

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

@@ -38,7 +38,8 @@ describe("DefaultAsciiBannerGeneratorService tests", () => {
     const asciiBannerGeneratorService =
       new DefaultAsciiBannerGeneratorService();
 
-    expect(asciiBannerGeneratorService.generate("foo", "small")).rejects
+    expect(asciiBannerGeneratorService.generate("foo", { fontName: "small" }))
+      .rejects
       .toThrow();
   });
 
@@ -50,7 +51,7 @@ describe("DefaultAsciiBannerGeneratorService tests", () => {
 
     const generated = await asciiBannerGeneratorService.generate(
       "foo",
-      "standard",
+      { fontName: "standard" },
     );
     expect(generated).toMatchSnapshot();
   });
@@ -63,8 +64,167 @@ describe("DefaultAsciiBannerGeneratorService tests", () => {
 
     const generated = await asciiBannerGeneratorService.generate(
       "foo",
-      "small",
+      { fontName: "small" },
     );
     expect(generated).toMatchSnapshot();
   });
+
+  test("subMessage is uppercased and double-spaced", async () => {
+    const service = new DefaultAsciiBannerGeneratorService();
+    const result = await service.generate("foo", {
+      fontName: "standard",
+      subMessage: "hello",
+    });
+    expect(result).toContain("H E L L O");
+  });
+
+  test("fixed foreground color effect adds ANSI codes to title chars", async () => {
+    const service = new DefaultAsciiBannerGeneratorService();
+    const result = await service.generate("foo", {
+      fontName: "standard",
+      colorEffects: {
+        messageForeground: { type: "fixed", color: "#ff0000" },
+      },
+    });
+    expect(result).toContain("\x1b[38;2;");
+    expect(result).toContain("\x1b[39m");
+  });
+
+  test("background color effect adds background ANSI codes", async () => {
+    const service = new DefaultAsciiBannerGeneratorService();
+    const result = await service.generate("foo", {
+      fontName: "standard",
+      colorEffects: {
+        background: { type: "fixed", color: "#0000ff" },
+      },
+    });
+    expect(result).toContain("\x1b[48;2;");
+    expect(result).toContain("\x1b[49m");
+  });
+
+  test("no ANSI codes when no color effects specified", async () => {
+    const service = new DefaultAsciiBannerGeneratorService();
+    const result = await service.generate("foo", { fontName: "standard" });
+    expect(result).not.toContain("\x1b[");
+  });
+
+  test("subMessage narrower than banner is padded to center", async () => {
+    const service = new DefaultAsciiBannerGeneratorService();
+    const result = await service.generate("foo", {
+      fontName: "standard",
+      subMessage: "hi",
+    });
+    const lines = result.trim().split("\n");
+    const subLine = lines[lines.length - 1]!;
+    expect(subLine.startsWith(" ")).toBe(true);
+  });
+
+  test("subMessage wider than banner pads title lines", async () => {
+    const service = new DefaultAsciiBannerGeneratorService();
+    const withoutSub = await service.generate("i", { fontName: "standard" });
+    const withSub = await service.generate("i", {
+      fontName: "standard",
+      subMessage: "x".repeat(40),
+    });
+    const withoutLines = withoutSub.trim().split("\n");
+    const withLines = withSub.trim().split("\n").slice(0, withoutLines.length);
+    const maxWith = Math.max(...withLines.map((l) => l.length));
+    const maxWithout = Math.max(...withoutLines.map((l) => l.length));
+    expect(maxWith).toBeGreaterThan(maxWithout);
+  });
+
+  test("gradient vertical applies different color per line", async () => {
+    const service = new DefaultAsciiBannerGeneratorService();
+    const result = await service.generate("foo", {
+      fontName: "standard",
+      colorEffects: {
+        messageForeground: {
+          type: "gradient",
+          colors: ["#ff0000", "#0000ff"],
+          direction: "vertical",
+        },
+      },
+    });
+    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 unique = new Set(firstCodes.filter(Boolean));
+    expect(unique.size).toBeGreaterThan(1);
+  });
+
+  test("gradient horizontal applies different color per char within a line", async () => {
+    const service = new DefaultAsciiBannerGeneratorService();
+    const result = await service.generate("foo", {
+      fontName: "standard",
+      colorEffects: {
+        messageForeground: {
+          type: "gradient",
+          colors: ["#ff0000", "#0000ff"],
+          direction: "horizontal",
+        },
+      },
+    });
+    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 unique = new Set(codes);
+    expect(unique.size).toBeGreaterThan(1);
+  });
+
+  test("rainbow horizontal applies ANSI codes varying per char", async () => {
+    const service = new DefaultAsciiBannerGeneratorService();
+    const result = await service.generate("foo", {
+      fontName: "standard",
+      colorEffects: {
+        messageForeground: {
+          type: "rainbow",
+          direction: "horizontal",
+          seed: 0.1,
+        },
+      },
+    });
+    expect(result).toContain("\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 unique = new Set(codes);
+    expect(unique.size).toBeGreaterThan(1);
+  });
+
+  test("rainbow vertical applies ANSI codes varying per line", async () => {
+    const service = new DefaultAsciiBannerGeneratorService();
+    const result = await service.generate("foo", {
+      fontName: "standard",
+      colorEffects: {
+        messageForeground: {
+          type: "rainbow",
+          direction: "vertical",
+          seed: 0.1,
+        },
+      },
+    });
+    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 unique = new Set(firstCodes.filter(Boolean));
+    expect(unique.size).toBeGreaterThan(1);
+  });
 });

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

@@ -1,4 +1,4 @@
-// Bun Snapshot v1, https://goo.gl/fbAQLP
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
 
 exports[`DefaultAsciiBannerGeneratorService tests Can generate with standard font 1`] = `
 "

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

@@ -6,9 +6,9 @@ import { PRINTER_SERVICE_ID } from "../../../src/api/service/core/PrinterService
 import DefaultContext from "../../../src/runtime/DefaultContext.ts";
 import { ASCII_BANNER_GENERATOR_SERVICE_ID } from "../../../src/api/service/core/AsciiBannerGeneratorService.ts";
 import DefaultAsciiBannerGeneratorService from "../../../src/service/asciiBannerGenerator/DefaultAsciiBannerGeneratorService.ts";
-import TtyTerminal from "../../../src/service/printer/terminal/TtyTerminal.ts";
+import TtyTerminal from "../../../src/terminal/TtyTerminal.ts";
 import StreamString from "../../fixtures/StreamString.ts";
-import TtyStyler from "../../../src/service/printer/terminal/TtyStyler.ts";
+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>" }`
@@ -17,9 +17,11 @@ import smallFont from "../asciiBannerGenerator/small.flf.json" with {
 };
 
 describe("BannerServiceProvider tests", () => {
-  test("BannerServiceProvider provide works", async () => {
+  test("BannerServiceProvider getServiceInfo works", async () => {
     const bannerServiceProvider = new BannerServiceProvider(100);
-    const serviceInfo = await bannerServiceProvider.provide(getCLIConfig());
+    const serviceInfo = await bannerServiceProvider.getServiceInfo(
+      getCLIConfig(),
+    );
     expect(serviceInfo.commands.length).toEqual(1);
   });
 
@@ -31,6 +33,7 @@ describe("BannerServiceProvider tests", () => {
       dummyStderr.writableStream,
       true,
       true,
+      new TtyTerminal(dummyStdout.writeStream),
       new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
     );
@@ -61,6 +64,7 @@ describe("BannerServiceProvider tests", () => {
       dummyStderr.writableStream,
       true,
       true,
+      new TtyTerminal(dummyStdout.writeStream),
       new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
     );

package/tests/service/chiselAsciiBannerGenerator/ChiselFontAsciiBannerGeneratorService.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, test } from "bun:test";
+import ChiselFontAsciiBannerGeneratorService from "../../../src/service/chiselAsciiBannerGenerator/ChiselFontAsciiBannerGeneratorService.ts";
+
+describe("ChiselFontAsciiBannerGeneratorService tests", () => {
+  test("registerFont throws", () => {
+    const service = new ChiselFontAsciiBannerGeneratorService();
+    expect(() => service.registerFont("anything", "definition")).toThrow();
+  });
+
+  test("getRegisteredFonts returns chisel only", () => {
+    const service = new ChiselFontAsciiBannerGeneratorService();
+    expect(service.getRegisteredFonts()).toEqual(["chisel"]);
+  });
+
+  test("generate returns non-empty string with ANSI codes", async () => {
+    const service = new ChiselFontAsciiBannerGeneratorService();
+    const result = await service.generate("HI");
+    expect(result.length).toBeGreaterThan(0);
+    expect(result).toContain("\x1b[");
+  });
+
+  test("custom chisel colors replace default ANSI codes", async () => {
+    const service = new ChiselFontAsciiBannerGeneratorService();
+    // Generate without custom colors to get baseline
+    const baseline = await service.generate("HI");
+    // Generate with custom colors
+    const result = await service.generate("HI", {
+      chiselColors: { shadowForeground: 33 },
+    });
+    // The result should differ from baseline (color replacement occurred)
+    // shadowForeground maps \x1b[90m -> \x1b[33m
+    expect(result).not.toContain("\x1b[90m");
+    expect(result).toContain("\x1b[33m");
+    expect(result).not.toEqual(baseline);
+  });
+
+  test("subMessage appears uppercased and double-spaced", async () => {
+    const service = new ChiselFontAsciiBannerGeneratorService();
+    const result = await service.generate("HI", { subMessage: "world" });
+    expect(result).toContain("W O R L D");
+  });
+
+  test("fixed foreground color effect adds ANSI codes", async () => {
+    const service = new ChiselFontAsciiBannerGeneratorService();
+    const result = await service.generate("HI", {
+      colorEffects: {
+        messageForeground: { type: "fixed", color: "#00ff00" },
+      },
+    });
+    expect(result).toContain("\x1b[38;2;");
+  });
+});