@flowscripter/dynamic-cli-framework 1.4.19 → 1.6.0

package/tests/service/treePrinter/DefaultTreePrinterService.test.ts

@@ -1,142 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import DefaultTreePrinterService from "../../../src/service/treePrinter/DefaultTreePrinterService.ts";
-
-describe("DefaultTreePrinterService tests", () => {
-  test("Single root, no children", () => {
-    const service = new DefaultTreePrinterService();
-    service.colorEnabled = false;
-
-    expect(service.print({ label: "Root" })).toEqual("Root");
-  });
-
-  test("Root with string children uses correct connectors", () => {
-    const service = new DefaultTreePrinterService();
-    service.colorEnabled = false;
-
-    const result = service.print({
-      label: "Root",
-      children: ["Alpha", "Beta", "Gamma"],
-    });
-
-    const lines = result.split("\n");
-    expect(lines[0]).toEqual("Root");
-    expect(lines[1]).toEqual("├── Alpha");
-    expect(lines[2]).toEqual("├── Beta");
-    expect(lines[3]).toEqual("└── Gamma");
-  });
-
-  test("Root with TreeNode children uses correct connectors", () => {
-    const service = new DefaultTreePrinterService();
-    service.colorEnabled = false;
-
-    const result = service.print({
-      label: "Root",
-      children: [
-        { label: "Child1", children: ["Leaf1", "Leaf2"] },
-        {
-          label: "Child2",
-        },
-      ],
-    });
-
-    const lines = result.split("\n");
-    expect(lines[0]).toEqual("Root");
-    expect(lines[1]).toEqual("├── Child1");
-    expect(lines[2]).toEqual("│   ├── Leaf1");
-    expect(lines[3]).toEqual("│   └── Leaf2");
-    expect(lines[4]).toEqual("└── Child2");
-  });
-
-  test("Mixed children (strings and nodes at same level)", () => {
-    const service = new DefaultTreePrinterService();
-    service.colorEnabled = false;
-
-    const result = service.print({
-      label: "Root",
-      children: ["StringChild", { label: "NodeChild", children: ["Nested"] }, "Last"],
-    });
-
-    const lines = result.split("\n");
-    expect(lines[0]).toEqual("Root");
-    expect(lines[1]).toEqual("├── StringChild");
-    expect(lines[2]).toEqual("├── NodeChild");
-    expect(lines[3]).toEqual("│   └── Nested");
-    expect(lines[4]).toEqual("└── Last");
-  });
-
-  test("Deep nesting propagates continuation chars correctly", () => {
-    const service = new DefaultTreePrinterService();
-    service.colorEnabled = false;
-
-    const result = service.print({
-      label: "Root",
-      children: [
-        {
-          label: "L1",
-          children: [
-            {
-              label: "L2",
-              children: ["L3a", "L3b"],
-            },
-            "L2sibling",
-          ],
-        },
-        "RootSibling",
-      ],
-    });
-
-    const lines = result.split("\n");
-    expect(lines[0]).toEqual("Root");
-    expect(lines[1]).toEqual("├── L1");
-    expect(lines[2]).toEqual("│   ├── L2");
-    expect(lines[3]).toEqual("│   │   ├── L3a");
-    expect(lines[4]).toEqual("│   │   └── L3b");
-    expect(lines[5]).toEqual("│   └── L2sibling");
-    expect(lines[6]).toEqual("└── RootSibling");
-  });
-
-  test("Last child uses └── and others use ├──", () => {
-    const service = new DefaultTreePrinterService();
-    service.colorEnabled = false;
-
-    const result = service.print({
-      label: "Root",
-      children: ["A", "B", "C"],
-    });
-
-    const lines = result.split("\n");
-    expect(lines[1]!.startsWith("├── ")).toBe(true);
-    expect(lines[2]!.startsWith("├── ")).toBe(true);
-    expect(lines[3]!.startsWith("└── ")).toBe(true);
-  });
-
-  test("colorEnabled=true wraps labels via colorFunction", () => {
-    const service = new DefaultTreePrinterService();
-    service.colorEnabled = true;
-    service.colorFunction = (text, _color) => `[${text}]`;
-
-    const result = service.print({
-      label: "Root",
-      children: ["Child"],
-    });
-
-    const lines = result.split("\n");
-    expect(lines[0]).toEqual("[Root]");
-    expect(lines[1]).toEqual("└── [Child]");
-  });
-
-  test("colorEnabled=false returns plain text", () => {
-    const service = new DefaultTreePrinterService();
-    service.colorEnabled = false;
-    service.colorFunction = (text, _color) => `[${text}]`;
-
-    const result = service.print({
-      label: "Root",
-      children: ["Child"],
-    });
-
-    const lines = result.split("\n");
-    expect(lines[0]).toEqual("Root");
-    expect(lines[1]).toEqual("└── Child");
-  });
-});

package/tests/service/treePrinter/TreePrinterServiceProvider.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import DefaultContext from "../../../src/runtime/DefaultContext.ts";
-import { getCLIConfig } from "../../fixtures/CLIConfig.ts";
-import TreePrinterServiceProvider from "../../../src/service/treePrinter/TreePrinterServiceProvider.ts";
-import { PRINTER_SERVICE_ID } from "../../../src/api/service/core/PrinterService.ts";
-import DefaultPrinterService from "../../../src/service/printer/DefaultPrinterService.ts";
-import StreamString from "../../fixtures/StreamString.ts";
-import TtyTerminal from "../../../src/terminal/TtyTerminal.ts";
-import TtyStyler from "../../../src/terminal/TtyStyler.ts";
-
-describe("TreePrinterServiceProvider tests", () => {
-  test("getServiceInfo returns service and empty commands", async () => {
-    const treePrinterServiceProvider = new TreePrinterServiceProvider(100);
-    const cliConfig = getCLIConfig();
-
-    const serviceInfo = await treePrinterServiceProvider.getServiceInfo(cliConfig);
-    expect(serviceInfo.commands.length).toEqual(0);
-    expect(serviceInfo.service).toBeDefined();
-  });
-
-  test("initService sets colorEnabled and colorFunction from PrinterService", async () => {
-    const dummyStdout = new StreamString();
-    const dummyStderr = new StreamString();
-    const treePrinterServiceProvider = new TreePrinterServiceProvider(100);
-    const cliConfig = getCLIConfig();
-    const context = new DefaultContext(cliConfig);
-
-    context.addServiceInstance(
-      PRINTER_SERVICE_ID,
-      new DefaultPrinterService(
-        dummyStdout.writableStream,
-        dummyStderr.writableStream,
-        true,
-        true,
-        new TtyTerminal(dummyStdout.writeStream),
-        new TtyTerminal(dummyStderr.writeStream),
-        new TtyStyler(3),
-      ),
-    );
-
-    const serviceInfo = await treePrinterServiceProvider.getServiceInfo(cliConfig);
-    expect(serviceInfo.commands.length).toEqual(0);
-
-    await treePrinterServiceProvider.initService(context);
-
-    const service =
-      serviceInfo.service as import("../../../src/service/treePrinter/DefaultTreePrinterService.ts").default;
-    expect(service.colorEnabled).toBe(true);
-    expect(typeof service.colorFunction).toBe("function");
-  });
-});

package/tests/terminal/ImageRenderer.test.ts

@@ -1,152 +0,0 @@
-import { deflateSync } from "node:zlib";
-import { describe, expect, test } from "bun:test";
-import supportsTerminalGraphics from "supports-terminal-graphics";
-import ImageRenderer from "../../src/terminal/ImageRenderer.ts";
-import type Terminal from "../../src/terminal/Terminal.ts";
-
-// Build a proper PNG with valid CRC values
-function crc32Table(): Uint32Array {
-  const table = new Uint32Array(256);
-  for (let n = 0; n < 256; n++) {
-    let c = n;
-    for (let k = 0; k < 8; k++) {
-      if (c & 1) {
-        c = 0xedb88320 ^ (c >>> 1);
-      } else {
-        c = c >>> 1;
-      }
-    }
-    table[n] = c;
-  }
-  return table;
-}
-
-const CRC_TABLE = crc32Table();
-
-function crc32(data: Uint8Array): number {
-  let crc = 0xffffffff;
-  for (let i = 0; i < data.length; i++) {
-    crc = CRC_TABLE[(crc ^ data[i]!) & 0xff]! ^ (crc >>> 8);
-  }
-  return (crc ^ 0xffffffff) >>> 0;
-}
-
-function buildValidPng(width: number, height: number, colorType: number = 6): Uint8Array {
-  const parts: number[] = [];
-
-  // PNG signature
-  parts.push(137, 80, 78, 71, 13, 10, 26, 10);
-
-  function addChunk(type: string, data: Uint8Array) {
-    // Length (4 bytes big-endian)
-    const len = data.length;
-    parts.push((len >>> 24) & 0xff, (len >>> 16) & 0xff, (len >>> 8) & 0xff, len & 0xff);
-
-    // Type (4 bytes)
-    const typeBytes = new TextEncoder().encode(type);
-    for (const b of typeBytes) parts.push(b);
-
-    // Data
-    for (const b of data) parts.push(b);
-
-    // CRC over type + data
-    const crcInput = new Uint8Array(4 + data.length);
-    crcInput.set(typeBytes, 0);
-    crcInput.set(data, 4);
-    const crcVal = crc32(crcInput);
-    parts.push(
-      (crcVal >>> 24) & 0xff,
-      (crcVal >>> 16) & 0xff,
-      (crcVal >>> 8) & 0xff,
-      crcVal & 0xff,
-    );
-  }
-
-  // IHDR
-  const ihdr = new Uint8Array(13);
-  const ihdrView = new DataView(ihdr.buffer);
-  ihdrView.setUint32(0, width);
-  ihdrView.setUint32(4, height);
-  ihdr[8] = 8; // bit depth
-  ihdr[9] = colorType;
-  ihdr[10] = 0; // compression
-  ihdr[11] = 0; // filter
-  ihdr[12] = 0; // interlace
-  addChunk("IHDR", ihdr);
-
-  // IDAT
-  const bpp = colorType === 6 ? 4 : 3;
-  const stride = width * bpp;
-  const raw = new Uint8Array(height * (1 + stride));
-  let offset = 0;
-  for (let y = 0; y < height; y++) {
-    raw[offset++] = 0; // filter: none
-    for (let x = 0; x < width; x++) {
-      raw[offset++] = (x * 80 + y * 40) & 0xff; // R
-      raw[offset++] = (x * 60 + y * 30) & 0xff; // G
-      raw[offset++] = (x * 40 + y * 20) & 0xff; // B
-      if (bpp === 4) {
-        raw[offset++] = 255; // A
-      }
-    }
-  }
-  const compressed = deflateSync(raw);
-  addChunk("IDAT", new Uint8Array(compressed));
-
-  // IEND
-  addChunk("IEND", new Uint8Array(0));
-
-  return new Uint8Array(parts);
-}
-
-function createMockTerminal(columns: number = 80, rows: number = 24): Terminal {
-  return {
-    clearLine: () => Promise.resolve(),
-    clearUpLines: () => Promise.resolve(),
-    hideCursor: () => Promise.resolve(),
-    showCursor: () => Promise.resolve(),
-    write: () => Promise.resolve(),
-    columns: () => columns,
-    rows: () => rows,
-  };
-}
-
-describe("ImageRenderer", () => {
-  test("renderImage returns a string with correct protocol markers", async () => {
-    const terminal = createMockTerminal(40, 20);
-    const renderer = new ImageRenderer(terminal);
-    const png = buildValidPng(4, 4, 6);
-
-    const result = await renderer.renderImage(png, 50);
-    expect(typeof result).toBe("string");
-    expect(result.length).toBeGreaterThan(0);
-
-    if (supportsTerminalGraphics.stdout.kitty) {
-      expect(result).toContain("\x1b_Gf=100");
-    } else if (supportsTerminalGraphics.stdout.iterm2) {
-      expect(result).toContain("\x1b]1337;File=inline=1;width=50%:");
-    } else {
-      expect(result).toContain("\n");
-    }
-  });
-
-  test("renderImage with default widthPercentage", async () => {
-    const terminal = createMockTerminal(80, 24);
-    const renderer = new ImageRenderer(terminal);
-    const png = buildValidPng(2, 2, 6);
-
-    const result = await renderer.renderImage(png);
-    expect(typeof result).toBe("string");
-    expect(result.length).toBeGreaterThan(0);
-  });
-
-  test("renderImage with RGB image (colorType=2)", async () => {
-    const terminal = createMockTerminal(40, 20);
-    const renderer = new ImageRenderer(terminal);
-    const png = buildValidPng(4, 4, 2);
-
-    const result = await renderer.renderImage(png, 50);
-    expect(typeof result).toBe("string");
-    expect(result.length).toBeGreaterThan(0);
-  });
-});

package/tests/terminal/PngDecoder.test.ts

@@ -1,219 +0,0 @@
-import { deflateSync } from "node:zlib";
-import { describe, expect, test } from "bun:test";
-import { decodePngToRGBA } from "../../src/terminal/PngDecoder.ts";
-
-// Helper to build a minimal PNG from raw components
-function buildPng(chunks: Array<{ type: string; data: Uint8Array }>): Uint8Array {
-  const parts: Uint8Array[] = [];
-  // PNG signature
-  parts.push(new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]));
-
-  for (const chunk of chunks) {
-    const typeBytes = new TextEncoder().encode(chunk.type);
-    const lengthBuf = new ArrayBuffer(4);
-    new DataView(lengthBuf).setUint32(0, chunk.data.length);
-
-    // CRC placeholder (4 bytes of zeros - decoder doesn't validate CRC)
-    const crc = new Uint8Array(4);
-
-    parts.push(new Uint8Array(lengthBuf));
-    parts.push(typeBytes);
-    parts.push(chunk.data);
-    parts.push(crc);
-  }
-
-  const totalLength = parts.reduce((sum, p) => sum + p.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const p of parts) {
-    result.set(p, offset);
-    offset += p.length;
-  }
-  return result;
-}
-
-function makeIHDR(
-  width: number,
-  height: number,
-  bitDepth: number,
-  colorType: number,
-  interlace: number = 0,
-): Uint8Array {
-  const buf = new ArrayBuffer(13);
-  const view = new DataView(buf);
-  view.setUint32(0, width);
-  view.setUint32(4, height);
-  const bytes = new Uint8Array(buf);
-  bytes[8] = bitDepth;
-  bytes[9] = colorType;
-  bytes[10] = 0; // compression
-  bytes[11] = 0; // filter method
-  bytes[12] = interlace;
-  return bytes;
-}
-
-// Build raw scanline data for a simple image with a given filter type
-function makeRawScanlines(
-  width: number,
-  height: number,
-  bpp: number,
-  filterType: number,
-): Uint8Array {
-  const stride = width * bpp;
-  const raw = new Uint8Array(height * (1 + stride));
-  let offset = 0;
-  for (let y = 0; y < height; y++) {
-    raw[offset++] = filterType;
-    for (let x = 0; x < stride; x++) {
-      // Simple pixel values
-      raw[offset++] = ((y * stride + x) * 37 + 100) & 0xff;
-    }
-  }
-  return raw;
-}
-
-function buildSimplePng(
-  width: number,
-  height: number,
-  colorType: number,
-  filterType: number = 0,
-): Uint8Array {
-  const bpp = colorType === 6 ? 4 : 3;
-  const rawData = makeRawScanlines(width, height, bpp, filterType);
-  const compressed = deflateSync(rawData);
-
-  return buildPng([
-    { type: "IHDR", data: makeIHDR(width, height, 8, colorType) },
-    { type: "IDAT", data: new Uint8Array(compressed) },
-    { type: "IEND", data: new Uint8Array(0) },
-  ]);
-}
-
-describe("decodePngToRGBA", () => {
-  test("decodes a simple RGBA (colorType=6) PNG", () => {
-    const png = buildSimplePng(2, 2, 6, 0);
-    const result = decodePngToRGBA(png);
-    expect(result.width).toBe(2);
-    expect(result.height).toBe(2);
-    expect(result.pixels.length).toBe(2 * 2 * 4);
-  });
-
-  test("decodes a simple RGB (colorType=2) PNG and sets alpha to 255", () => {
-    const png = buildSimplePng(2, 2, 2, 0);
-    const result = decodePngToRGBA(png);
-    expect(result.width).toBe(2);
-    expect(result.height).toBe(2);
-    expect(result.pixels.length).toBe(2 * 2 * 4);
-    // Every 4th byte (alpha) should be 255
-    for (let i = 3; i < result.pixels.length; i += 4) {
-      expect(result.pixels[i]).toBe(255);
-    }
-  });
-
-  test("handles filter type 1 (Sub)", () => {
-    const png = buildSimplePng(3, 2, 6, 1);
-    const result = decodePngToRGBA(png);
-    expect(result.width).toBe(3);
-    expect(result.height).toBe(2);
-  });
-
-  test("handles filter type 2 (Up)", () => {
-    const png = buildSimplePng(3, 2, 6, 2);
-    const result = decodePngToRGBA(png);
-    expect(result.width).toBe(3);
-    expect(result.height).toBe(2);
-  });
-
-  test("handles filter type 3 (Average)", () => {
-    const png = buildSimplePng(3, 2, 6, 3);
-    const result = decodePngToRGBA(png);
-    expect(result.width).toBe(3);
-    expect(result.height).toBe(2);
-  });
-
-  test("handles filter type 4 (Paeth)", () => {
-    const png = buildSimplePng(3, 2, 6, 4);
-    const result = decodePngToRGBA(png);
-    expect(result.width).toBe(3);
-    expect(result.height).toBe(2);
-  });
-
-  test("handles filter type 4 (Paeth) with RGB colorType", () => {
-    const png = buildSimplePng(3, 3, 2, 4);
-    const result = decodePngToRGBA(png);
-    expect(result.width).toBe(3);
-    expect(result.height).toBe(3);
-    // Alpha should be 255 for RGB
-    for (let i = 3; i < result.pixels.length; i += 4) {
-      expect(result.pixels[i]).toBe(255);
-    }
-  });
-
-  test("throws on invalid PNG signature", () => {
-    const data = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0]);
-    expect(() => decodePngToRGBA(data)).toThrow("Invalid PNG signature");
-  });
-
-  test("throws on unsupported bit depth", () => {
-    const png = buildPng([
-      { type: "IHDR", data: makeIHDR(1, 1, 16, 2) },
-      { type: "IEND", data: new Uint8Array(0) },
-    ]);
-    expect(() => decodePngToRGBA(png)).toThrow("Unsupported bit depth: 16");
-  });
-
-  test("throws on unsupported color type", () => {
-    const png = buildPng([
-      { type: "IHDR", data: makeIHDR(1, 1, 8, 0) },
-      { type: "IEND", data: new Uint8Array(0) },
-    ]);
-    expect(() => decodePngToRGBA(png)).toThrow("Unsupported color type: 0");
-  });
-
-  test("throws on interlaced PNG", () => {
-    const png = buildPng([
-      { type: "IHDR", data: makeIHDR(1, 1, 8, 6, 1) },
-      { type: "IEND", data: new Uint8Array(0) },
-    ]);
-    expect(() => decodePngToRGBA(png)).toThrow("Interlaced PNGs are not supported");
-  });
-
-  test("throws on unknown filter type", () => {
-    // Build raw scanlines with invalid filter type 5
-    const width = 1;
-    const height = 1;
-    const bpp = 4;
-    const stride = width * bpp;
-    const raw = new Uint8Array(height * (1 + stride));
-    raw[0] = 5; // invalid filter
-    for (let i = 1; i <= stride; i++) raw[i] = 128;
-    const compressed = deflateSync(raw);
-
-    const png = buildPng([
-      { type: "IHDR", data: makeIHDR(width, height, 8, 6) },
-      { type: "IDAT", data: new Uint8Array(compressed) },
-      { type: "IEND", data: new Uint8Array(0) },
-    ]);
-    expect(() => decodePngToRGBA(png)).toThrow("Unknown filter type: 5");
-  });
-
-  test("handles multiple IDAT chunks", () => {
-    const bpp = 4;
-    const rawData = makeRawScanlines(2, 2, bpp, 0);
-    const compressed = new Uint8Array(deflateSync(rawData));
-    // Split compressed data into two chunks
-    const mid = Math.floor(compressed.length / 2);
-    const chunk1 = compressed.subarray(0, mid);
-    const chunk2 = compressed.subarray(mid);
-
-    const png = buildPng([
-      { type: "IHDR", data: makeIHDR(2, 2, 8, 6) },
-      { type: "IDAT", data: chunk1 },
-      { type: "IDAT", data: chunk2 },
-      { type: "IEND", data: new Uint8Array(0) },
-    ]);
-    const result = decodePngToRGBA(png);
-    expect(result.width).toBe(2);
-    expect(result.height).toBe(2);
-  });
-});