pdfdancer-client-typescript 1.0.4 → 1.0.6

package/src/__tests__/e2e/paragraph.test.ts

@@ -1,22 +1,21 @@
 /**
- * E2E tests for paragraph operations
+ * E2E tests for paragraph operations — new PDFDancer API
  */
 
-import {ClientV1, Color, Font, Position} from '../../index';
+import {Color, PDFDancer} from '../../index';
 import {readFontFixture, requireEnvAndFixture} from './test-helpers';
-import {expectWithin} from "../assertions";
+import {expectWithin} from '../assertions';
 
-describe('Paragraph E2E Tests', () => {
-    // Tests should fail properly if environment is not configured
+describe('Paragraph E2E Tests (v2 API)', () => {
 
     test('find paragraphs by position', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const paras = await client.findParagraphs();
+        const paras = await pdf.selectParagraphs();
         expect(paras).toHaveLength(172);
 
-        const parasPage0 = await client.findParagraphs(Position.atPage(0));
+        const parasPage0 = await pdf.page(0).selectParagraphs();
         expect(parasPage0).toHaveLength(2);
 
         const first = parasPage0[0];
@@ -34,10 +33,9 @@ describe('Paragraph E2E Tests', () => {
 
     test('find paragraphs by text', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const pos = Position.atPage(0).withTextStarts('The Complete');
-        const paras = await client.findParagraphs(pos);
+        const paras = await pdf.page(0).selectParagraphsStartingWith('The Complete');
         expect(paras).toHaveLength(1);
 
         const p = paras[0];
@@ -47,147 +45,155 @@ describe('Paragraph E2E Tests', () => {
         expectWithin(p.position.boundingRect?.y, 496, 2);
     });
 
+    test('find paragraphs by pattern', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const paras = await pdf.page(0).selectParagraphsMatching('.*Complete.*');
+        expect(paras).toHaveLength(1);
+        const p = paras[0];
+        expect(p.internalId).toBe('PARAGRAPH_000004');
+
+        const paras2 = await pdf.page(0).selectParagraphsMatching('.*NOT FOUND.*');
+        expect(paras2).toHaveLength(0);
+
+        const paras3 = await pdf.page(0).selectParagraphsMatching('.*');
+        expect(paras3).toHaveLength(2);
+    });
+
     test('delete paragraph', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const posDel = Position.atPage(0).withTextStarts('The Complete');
-        const ref = (await client.findParagraphs(posDel))[0];
-        expect(await client.delete(ref)).toBe(true);
+        const [target] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+        await target.delete();
 
-        const posDel2 = Position.atPage(0).withTextStarts('The Complete');
-        expect(await client.findParagraphs(posDel2)).toHaveLength(0);
+        const remaining = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+        expect(remaining).toHaveLength(0);
     });
 
     test('move paragraph', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const posMove = Position.atPage(0).withTextStarts('The Complete');
-        const ref = (await client.findParagraphs(posMove))[0];
-        const newPos = Position.atPageCoordinates(0, 0.1, 300);
-        expect(await client.move(ref, newPos)).toBe(true);
+        const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+        await para.moveTo(0.1, 300);
 
-        const ref2 = (await client.findParagraphs(newPos))[0];
-        expect(ref2).toBeDefined();
+        const moved = await pdf.page(0).selectParagraphsAt(0.1, 300);
+        expect(moved.length).toBeGreaterThan(0);
     });
 
-    async function assertNewParagraphExists(client: ClientV1): Promise<void> {
-        // Validate via find_text_lines for text starting with 'Awesomely'
-        const pos = Position.atPage(0).withTextStarts('Awesomely');
-        const lines = await client.findTextLines(pos);
+    async function assertNewParagraphExists(pdf: PDFDancer) {
+        const lines = await pdf.page(0).selectTextLinesStartingWith('Awesomely');
         expect(lines.length).toBeGreaterThanOrEqual(1);
     }
 
     test('modify paragraph', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const posMod = Position.atPage(0).withTextStarts('The Complete');
-        const ref = (await client.findParagraphs(posMod))[0];
+        const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
 
-        const newParagraph = client.paragraphBuilder()
-            .fromString('Awesomely\\nObvious!')
-            .withFont(new Font('Helvetica', 14))
-            .withLineSpacing(0.7)
-            .withPosition(Position.atPageCoordinates(0, 300.1, 500))
-            .build();
+        await para.edit().replace('Awesomely\nObvious!')
+            .font("Helvetica", 12)
+            .lineSpacing(0.7)
+            .moveTo(300.1, 500)
+            .apply()
 
-        expect(await client.modifyParagraph(ref, newParagraph)).toBe(true);
-        await assertNewParagraphExists(client);
+        await assertNewParagraphExists(pdf);
     });
 
-    test('modify paragraph simple', async () => {
+    test('modify paragraph (simple)', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const posMod2 = Position.atPage(0).withTextStarts('The Complete');
-        const ref = (await client.findParagraphs(posMod2))[0];
-        expect(await client.modifyParagraph(ref, 'Awesomely\\nObvious!')).toBe(true);
-        await assertNewParagraphExists(client);
+        const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+        await para.edit().replace('Awesomely\nObvious!').apply();
+        await assertNewParagraphExists(pdf);
     });
 
-    test('add paragraph with custom font - expect not found', async () => {
+    test('add paragraph with missing font (expect error)', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
-
-        const pb = client.paragraphBuilder()
-            .fromString('Awesomely\\nObvious!')
-            .withFont(new Font('Roboto', 14))
-            .withLineSpacing(0.7)
-            .withPosition(Position.atPageCoordinates(0, 300.1, 500));
-
-        await expect(client.addParagraph(pb.build())).rejects.toThrow('Font not found');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        await expect(
+            pdf.page(0).newParagraph()
+                .text('Awesomely\nObvious!')
+                .font('Roboto', 14)
+                .lineSpacing(0.7)
+                .at(300.1, 500)
+                .apply()
+        ).rejects.toThrow('Font not found');
     });
 
-    test('add paragraph with custom font - Roboto-Regular', async () => {
+    test('add paragraph with known font', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const pb = client.paragraphBuilder()
-            .fromString('Awesomely\\nObvious!')
-            .withFont(new Font('Roboto-Regular', 14))
-            .withLineSpacing(0.7)
-            .withPosition(Position.atPageCoordinates(0, 300.1, 500));
+        const success = await pdf.page(0).newParagraph()
+            .text('Awesomely\nObvious!')
+            .font('Roboto-Regular', 14)
+            .lineSpacing(0.7)
+            .at(300.1, 500)
+            .apply()
 
-        expect(await client.addParagraph(pb.build())).toBe(true);
-        await assertNewParagraphExists(client);
+        expect(success).toBe(true);
+        await assertNewParagraphExists(pdf);
     });
 
-    test('add paragraph with found font', async () => {
+    test('add paragraph using font lookup', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const fonts = await client.findFonts('Roboto', 14);
+        const fonts = await pdf.findFonts('Roboto', 14);
         expect(fonts.length).toBeGreaterThan(0);
-        expect(fonts[0].name).toBe('Roboto-Regular');
-
         const roboto = fonts[0];
-        const pb = client.paragraphBuilder()
-            .fromString('Awesomely\\nObvious!')
-            .withFont(roboto)
-            .withLineSpacing(0.7)
-            .withPosition(Position.atPageCoordinates(0, 300.1, 500));
-
-        expect(await client.addParagraph(pb.build())).toBe(true);
-        await assertNewParagraphExists(client);
+
+        const success = await pdf.page(0).newParagraph()
+            .text('Awesomely\nObvious!')
+            .font(roboto)
+            .lineSpacing(0.7)
+            .at(300.1, 500)
+            .apply();
+
+        expect(success).toBe(true);
+        await assertNewParagraphExists(pdf);
     });
 
     test('add paragraph with Asimovian font', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const fonts = await client.findFonts('Asimovian', 14);
+        const fonts = await pdf.findFonts('Asimovian', 14);
         expect(fonts.length).toBeGreaterThan(0);
-        expect(fonts[0].name).toBe('Asimovian-Regular');
-
         const asimovian = fonts[0];
-        const pb = client.paragraphBuilder()
-            .fromString('Awesomely\\nObvious!')
-            .withFont(asimovian)
-            .withLineSpacing(0.7)
-            .withPosition(Position.atPageCoordinates(0, 300.1, 500));
-
-        expect(await client.addParagraph(pb.build())).toBe(true);
-        await assertNewParagraphExists(client);
+
+        const success = await pdf.page(0).newParagraph()
+            .text('Awesomely\nObvious!')
+            .font(asimovian)
+            .lineSpacing(0.7)
+            .at(300.1, 500)
+            .apply();
+
+        expect(success).toBe(true);
+        await assertNewParagraphExists(pdf);
     });
 
     test('add paragraph with custom TTF font', async () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
-        const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
-
-        // Use DancingScript-Regular.ttf from fixtures directory
-        const ttfData = readFontFixture('DancingScript-Regular.ttf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const pb = client.paragraphBuilder()
-            .fromString('Awesomely\\nObvious!')
-            .withLineSpacing(1.8)
-            .withColor(new Color(0, 0, 255))
-            .withPosition(Position.atPageCoordinates(0, 300.1, 500));
+        const ttf = readFontFixture('DancingScript-Regular.ttf');
 
-        await pb.withFontFile(ttfData, 24);
+        const success = await pdf.page(0).newParagraph()
+            .text('Awesomely\nObvious!')
+            .fontFile(ttf, 24)
+            .lineSpacing(1.8)
+            .color(new Color(0, 0, 255))
+            .at(300.1, 500)
+            .apply();
 
-        expect(await client.addParagraph(pb.build())).toBe(true);
-        await assertNewParagraphExists(client);
+        expect(success).toBe(true);
+        await assertNewParagraphExists(pdf);
     });
 });

package/src/__tests__/e2e/path.test.ts

@@ -1,68 +1,71 @@
 /**
- * E2E tests for path operations
+ * E2E tests for path operations (new PDFDancer API)
  */
 
-import { ClientV1, Position, ObjectType } from '../../index';
-import { requireEnvAndFixture } from './test-helpers';
-
-describe('Path E2E Tests', () => {
-  // Remove the misleading beforeAll - tests should fail properly if not configured
-
-  test('find paths', async () => {
-    const [baseUrl, token, pdfData] = await requireEnvAndFixture('basic-paths.pdf');
-    const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
-
-    const paths = await client.findPaths();
-    expect(paths).toHaveLength(9);
-    expect(paths[0].type).toBe(ObjectType.PATH);
-
-    const p1 = paths[0];
-    expect(p1).toBeDefined();
-    expect(p1.internalId).toBe('PATH_000001');
-    expect(p1.position.boundingRect?.x).toBeCloseTo(80, 1);
-    expect(p1.position.boundingRect?.y).toBeCloseTo(720, 1);
-  });
-
-  test('find paths by position', async () => {
-    const [baseUrl, token, pdfData] = await requireEnvAndFixture('basic-paths.pdf');
-    const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
-
-    const paths = await client.findPaths(Position.atPageCoordinates(0, 80, 720));
-    expect(paths).toHaveLength(1);
-    expect(paths[0].internalId).toBe('PATH_000001');
-  });
-
-  test('delete path', async () => {
-    const [baseUrl, token, pdfData] = await requireEnvAndFixture('basic-paths.pdf');
-    const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
-
-    let paths = await client.findPaths(Position.atPageCoordinates(0, 80, 720));
-    expect(paths).toHaveLength(1);
-    expect(paths[0].internalId).toBe('PATH_000001');
-    expect(await client.delete(paths[0])).toBe(true);
-
-    expect(await client.findPaths(Position.atPageCoordinates(0, 80, 720))).toHaveLength(0);
-    expect(await client.findPaths()).toHaveLength(8);
-  });
-
-  test('move path', async () => {
-    const [baseUrl, token, pdfData] = await requireEnvAndFixture('basic-paths.pdf');
-    const client = await ClientV1.create(token, pdfData, baseUrl, 30000);
-
-    let paths = await client.findPaths(Position.atPageCoordinates(0, 80, 720));
-    const ref = paths[0];
-    const pos = ref.position;
-    expect(pos.boundingRect?.x).toBeCloseTo(80, 1);
-    expect(pos.boundingRect?.y).toBeCloseTo(720, 1);
-
-    expect(await client.move(ref, Position.atPageCoordinates(0, 50.1, 100))).toBe(true);
-
-    expect(await client.findPaths(Position.atPageCoordinates(0, 80, 720))).toHaveLength(0);
-
-    paths = await client.findPaths(Position.atPageCoordinates(0, 50.1, 100));
-    const movedRef = paths[0];
-    const newPos = movedRef.position;
-    expect(newPos.boundingRect?.x).toBeCloseTo(50.1, 0.05);
-    expect(newPos.boundingRect?.y).toBeCloseTo(100, 0.05);
-  });
+import {requireEnvAndFixture} from './test-helpers';
+import {PDFDancer} from "../../pdfdancer_v1";
+
+describe('Path E2E Tests (New API)', () => {
+
+    test('select paths', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('basic-paths.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const paths = await pdf.selectPaths();
+        expect(paths).toHaveLength(9);
+        expect(paths[0].type).toBe('PATH');
+
+        const p1 = paths[0];
+        expect(p1).toBeDefined();
+        expect(p1.internalId).toBe('PATH_000001');
+        expect(p1.position.getX()).toBeCloseTo(80, 1);
+        expect(p1.position.getY()).toBeCloseTo(720, 1);
+    });
+
+    test('select paths by position', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('basic-paths.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const paths = await pdf.page(0).selectPathsAt(80, 720);
+        expect(paths).toHaveLength(1);
+        expect(paths[0].internalId).toBe('PATH_000001');
+    });
+
+    test('delete path', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('basic-paths.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        let paths = await pdf.page(0).selectPathsAt(80, 720);
+        expect(paths).toHaveLength(1);
+        expect(paths[0].internalId).toBe('PATH_000001');
+
+        const path = paths[0];
+        await path.delete();
+
+        const remainingAtOldPos = await pdf.page(0).selectPathsAt(80, 720);
+        expect(remainingAtOldPos).toHaveLength(0);
+
+        const allPaths = await pdf.selectPaths();
+        expect(allPaths).toHaveLength(8);
+    });
+
+    test('move path', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('basic-paths.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const [path] = await pdf.page(0).selectPathsAt(80, 720);
+        const pos = path.position;
+        expect(pos.getX()).toBeCloseTo(80, 1);
+        expect(pos.getY()).toBeCloseTo(720, 1);
+
+        await path.moveTo(50.1, 100);
+
+        const oldPos = await pdf.page(0).selectPathsAt(80, 720);
+        expect(oldPos).toHaveLength(0);
+
+        const moved = await pdf.page(0).selectPathsAt(50.1, 100);
+        const movedPos = moved[0].position;
+        expect(movedPos.getX()).toBeCloseTo(50.1, 1);
+        expect(movedPos.getY()).toBeCloseTo(100, 1);
+    });
 });

package/src/__tests__/e2e/test-helpers.ts

@@ -9,124 +9,128 @@ import * as path from 'path';
  * Get the base URL from environment variable or default
  */
 export function getBaseUrl(): string {
-  return process.env.PDFDANCER_BASE_URL || 'http://localhost:8080';
+    return process.env.PDFDANCER_BASE_URL || 'http://localhost:8080';
 }
 
 /**
  * Read authentication token from environment or token files
  */
 export function readToken(): string | null {
-  const token = process.env.PDFDANCER_TOKEN;
-  if (token) {
-    return token.trim();
-  }
+    const token = process.env.PDFDANCER_TOKEN;
+    if (token) {
+        return token.trim();
+    }
 
-  // Try common token files in project root
-  const projectRoot = path.resolve(__dirname, '../../..');
-  const candidates = findFiles(projectRoot, 'jwt-token-*.txt');
+    // Try common token files in project root
+    const projectRoot = path.resolve(__dirname, '../../..');
+    const candidates = findFiles(projectRoot, 'jwt-token-*.txt');
 
-  for (const file of candidates) {
-    try {
-      return fs.readFileSync(file, 'utf-8').trim();
-    } catch {
-      continue;
+    for (const file of candidates) {
+        try {
+            return fs.readFileSync(file, 'utf-8').trim();
+        } catch {
+            continue;
+        }
     }
-  }
 
-  return null;
+    return null;
 }
 
 /**
  * Check if server is up and running
  */
 export async function serverUp(baseUrl: string): Promise<boolean> {
-  try {
-    const response = await fetch(`${baseUrl}/ping`, {
-      signal: AbortSignal.timeout(3000)
-    });
-    const text = await response.text();
-    return response.status === 200 && text.includes('Pong');
-  } catch {
-    return false;
-  }
+    try {
+        const response = await fetch(`${baseUrl}/ping`, {
+            signal: AbortSignal.timeout(3000)
+        });
+        const text = await response.text();
+        return response.status === 200 && text.includes('Pong');
+    } catch {
+        return false;
+    }
 }
 
 /**
  * Helper to find files matching a pattern
  */
 function findFiles(dir: string, pattern: string): string[] {
-  try {
-    const files = fs.readdirSync(dir);
-    const regex = new RegExp(pattern.replace('*', '.*'));
-    return files
-      .filter(file => regex.test(file))
-      .map(file => path.join(dir, file));
-  } catch {
-    return [];
-  }
+    try {
+        const files = fs.readdirSync(dir);
+        const regex = new RegExp(pattern.replace('*', '.*'));
+        return files
+            .filter(file => regex.test(file))
+            .map(file => path.join(dir, file));
+    } catch {
+        return [];
+    }
 }
 
 /**
  * Require environment variables and PDF fixture for testing
  */
 export async function requireEnvAndFixture(pdfFilename: string): Promise<[string, string, Uint8Array]> {
-  const baseUrl = getBaseUrl();
-  const token = readToken();
+    const baseUrl = getBaseUrl();
+    const token = readToken();
 
-  if (!await serverUp(baseUrl)) {
-    throw new Error(`PDFDancer server not reachable at ${baseUrl}; set PDFDANCER_BASE_URL or start server`);
-  }
+    if (!await serverUp(baseUrl)) {
+        throw new Error(`PDFDancer server not reachable at ${baseUrl}; set PDFDANCER_BASE_URL or start server`);
+    }
 
-  if (!token) {
-    throw new Error('PDFDANCER_TOKEN not set and no token file found; set env or place jwt-token-*.txt in repo');
-  }
+    if (!token) {
+        throw new Error('PDFDANCER_TOKEN not set and no token file found; set env or place jwt-token-*.txt in repo');
+    }
 
-  // Look for PDF fixture file
-  const fixturesDir = path.resolve(__dirname, '../../../fixtures');
-  const pdfPath = path.join(fixturesDir, pdfFilename);
+    // Look for PDF fixture file
+    const fixturesDir = path.resolve(__dirname, '../../../fixtures');
+    const pdfPath = path.join(fixturesDir, pdfFilename);
 
-  if (!fs.existsSync(pdfPath)) {
-    throw new Error(`${pdfFilename} fixture not found at ${pdfPath}`);
-  }
+    if (!fs.existsSync(pdfPath)) {
+        throw new Error(`${pdfFilename} fixture not found at ${pdfPath}`);
+    }
 
-  const pdfData = fs.readFileSync(pdfPath);
-  return [baseUrl, token, new Uint8Array(pdfData)];
+    const pdfData = fs.readFileSync(pdfPath);
+    return [baseUrl, token, new Uint8Array(pdfData)];
 }
 
 /**
- * Helper to create temporary file path (for Node.js environment)
+ * Helper to open temporary file path (for Node.js environment)
  */
 export function createTempPath(filename: string): string {
-  const tmpDir = process.env.TMPDIR || '/tmp';
-  return path.join(tmpDir, filename);
+    const tmpDir = process.env.TMPDIR || '/tmp';
+    return path.join(tmpDir, filename);
 }
 
 /**
  * Helper to read image file for tests
  */
 export function readImageFixture(filename: string): Uint8Array {
-  const fixturesDir = path.resolve(__dirname, '../../../fixtures');
-  const imagePath = path.join(fixturesDir, filename);
+    const imagePath = getImagePath(filename);
+
+    if (!fs.existsSync(imagePath)) {
+        throw new Error(`Image fixture not found: ${filename}`);
+    }
 
-  if (!fs.existsSync(imagePath)) {
-    throw new Error(`Image fixture not found: ${filename}`);
-  }
+    const imageData = fs.readFileSync(imagePath);
+    return new Uint8Array(imageData);
+}
 
-  const imageData = fs.readFileSync(imagePath);
-  return new Uint8Array(imageData);
+export function getImagePath(filename: string): string {
+    const fixturesDir = path.resolve(__dirname, '../../../fixtures');
+    return path.join(fixturesDir, filename);
 }
 
 /**
  * Helper to read font file for tests
  */
 export function readFontFixture(filename: string): Uint8Array {
-  const fixturesDir = path.resolve(__dirname, '../../../fixtures');
-  const fontPath = path.join(fixturesDir, filename);
+    const fixturesDir = path.resolve(__dirname, '../../../fixtures');
+    const fontPath = path.join(fixturesDir, filename);
 
-  if (!fs.existsSync(fontPath)) {
-    throw new Error(`Font fixture not found: ${filename}`);
-  }
+    if (!fs.existsSync(fontPath)) {
+        throw new Error(`Font fixture not found: ${filename}`);
+    }
 
-  const fontData = fs.readFileSync(fontPath);
-  return new Uint8Array(fontData);
-}
+    const fontData = fs.readFileSync(fontPath);
+    return new Uint8Array(fontData);
+}