@flowscripter/dynamic-cli-framework 1.1.6 → 1.2.1

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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,161 @@
+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

@@ -0,0 +1,223 @@
+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);
+  });
+});

package/tests/terminal/supportsHyperlinks.test.ts

@@ -0,0 +1,149 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import supportsHyperlinks from "../../src/terminal/supportsHyperlinks.ts";
+import type { WriteStream } from "node:tty";
+
+const envKeys = [
+  "CI",
+  "CURSOR_TRACE_ID",
+  "FORCE_HYPERLINK",
+  "TEAMCITY_VERSION",
+  "TERM_PROGRAM",
+  "TERM_PROGRAM_VERSION",
+  "VTE_VERSION",
+  "TERM",
+  "WT_SESSION",
+];
+
+let savedEnv: Record<string, string | undefined>;
+
+function ttyStream(): WriteStream {
+  return { isTTY: true } as WriteStream;
+}
+
+function nonTtyStream(): WriteStream {
+  return { isTTY: false } as WriteStream;
+}
+
+beforeEach(() => {
+  savedEnv = {};
+  for (const key of envKeys) {
+    savedEnv[key] = process.env[key];
+    delete process.env[key];
+  }
+});
+
+afterEach(() => {
+  for (const key of envKeys) {
+    if (savedEnv[key] === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = savedEnv[key];
+    }
+  }
+});
+
+describe("supportsHyperlinks", () => {
+  test("returns false for non-TTY stream", () => {
+    expect(supportsHyperlinks(nonTtyStream())).toBe(false);
+  });
+
+  test("returns false for unknown terminal", () => {
+    expect(supportsHyperlinks(ttyStream())).toBe(false);
+  });
+
+  test("FORCE_HYPERLINK=1 overrides to true", () => {
+    process.env.FORCE_HYPERLINK = "1";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("FORCE_HYPERLINK=0 overrides to false", () => {
+    process.env.FORCE_HYPERLINK = "0";
+    expect(supportsHyperlinks(ttyStream())).toBe(false);
+  });
+
+  test("FORCE_HYPERLINK=1 works even for non-TTY", () => {
+    process.env.FORCE_HYPERLINK = "1";
+    expect(supportsHyperlinks(nonTtyStream())).toBe(true);
+  });
+
+  test("returns true for Windows Terminal", () => {
+    process.env.WT_SESSION = "some-session-id";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("returns true for iTerm.app >= 3.1", () => {
+    process.env.TERM_PROGRAM = "iTerm.app";
+    process.env.TERM_PROGRAM_VERSION = "3.1.0";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("returns false for iTerm.app < 3.1", () => {
+    process.env.TERM_PROGRAM = "iTerm.app";
+    process.env.TERM_PROGRAM_VERSION = "3.0.0";
+    expect(supportsHyperlinks(ttyStream())).toBe(false);
+  });
+
+  test("returns true for vscode >= 1.72", () => {
+    process.env.TERM_PROGRAM = "vscode";
+    process.env.TERM_PROGRAM_VERSION = "1.72.0";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("returns false for vscode < 1.72", () => {
+    process.env.TERM_PROGRAM = "vscode";
+    process.env.TERM_PROGRAM_VERSION = "1.71.0";
+    expect(supportsHyperlinks(ttyStream())).toBe(false);
+  });
+
+  test("returns true for Cursor (vscode + CURSOR_TRACE_ID)", () => {
+    process.env.TERM_PROGRAM = "vscode";
+    process.env.CURSOR_TRACE_ID = "some-id";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("returns true for ghostty", () => {
+    process.env.TERM_PROGRAM = "ghostty";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("returns true for zed", () => {
+    process.env.TERM_PROGRAM = "zed";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("returns true for WezTerm", () => {
+    process.env.TERM_PROGRAM = "WezTerm";
+    process.env.TERM_PROGRAM_VERSION = "20200620";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("returns true for VTE >= 0.50 (excluding 0.50.0)", () => {
+    process.env.VTE_VERSION = "0.50.1";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("returns false for VTE 0.50.0 (segfault bug)", () => {
+    process.env.VTE_VERSION = "0.50.0";
+    expect(supportsHyperlinks(ttyStream())).toBe(false);
+  });
+
+  test("returns true for alacritty", () => {
+    process.env.TERM = "alacritty";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("returns true for xterm-kitty", () => {
+    process.env.TERM = "xterm-kitty";
+    expect(supportsHyperlinks(ttyStream())).toBe(true);
+  });
+
+  test("returns false in CI", () => {
+    process.env.CI = "true";
+    expect(supportsHyperlinks(ttyStream())).toBe(false);
+  });
+
+  test("returns false for TeamCity", () => {
+    process.env.TEAMCITY_VERSION = "2023.1";
+    expect(supportsHyperlinks(ttyStream())).toBe(false);
+  });
+});

package/tests/util/configHelper.test.ts

@@ -56,7 +56,7 @@ describe("configHelper tests", () => {
 
     expect(
       getSubCommandArgumentConfigurationKey(getCLIConfig(), command, [
-        command.positionals![0],
+        command.positionals![0]!,
       ]),
     ).toBeUndefined();
 
@@ -70,7 +70,7 @@ describe("configHelper tests", () => {
 
     expect(
       getSubCommandArgumentConfigurationKey(getCLIConfig(), command, [
-        command.positionals![0],
+        command.positionals![0]!,
       ]),
     ).toEqual(
       "FOO_BLAH_FOO",
@@ -86,7 +86,7 @@ describe("configHelper tests", () => {
 
     expect(
       getSubCommandArgumentConfigurationKey(getCLIConfig(), command, [
-        command.positionals![0],
+        command.positionals![0]!,
       ]),
     ).toEqual(
       "FOO_BLAH_FOO[_<index>]",
@@ -103,7 +103,7 @@ describe("configHelper tests", () => {
 
     expect(
       getSubCommandArgumentConfigurationKey(getCLIConfig(), command, [
-        command.positionals![0],
+        command.positionals![0]!,
       ]),
     ).toEqual(
       "FOO_BAR[_<index>]",

package/tests/util/logger.test.ts

@@ -1,4 +1,4 @@
-import { describe, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
 import getLogger from "../../src/util/logger.ts";
 
 describe("logger tests", () => {
@@ -31,4 +31,26 @@ describe("logger tests", () => {
 
     logger.error("foo: %s %O", "bar", { foo1: "bar1", func: () => "foobar" });
   });
+
+  test("Logger name padding is updated when a longer name is used", () => {
+    const shortLogger = getLogger("short");
+    const longLogger = getLogger("very-long-logger-name");
+    // Both should be valid logger instances
+    expect(shortLogger).toBeDefined();
+    expect(longLogger).toBeDefined();
+    // Calling all levels to exercise non-debug path
+    shortLogger.trace("trace msg");
+    shortLogger.debug("debug msg");
+    shortLogger.info("info msg");
+    shortLogger.warn("warn msg");
+    shortLogger.error("error msg");
+  });
+
+  test("Logger with same-length name reuses existing padding", () => {
+    // Create two loggers with same length names to hit the else-if branch
+    const logger1 = getLogger("aaa");
+    const logger2 = getLogger("bbb");
+    expect(logger1).toBeDefined();
+    expect(logger2).toBeDefined();
+  });
 });

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    "types": ["bun", "node"],
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

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

@@ -1,10 +0,0 @@
-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";