pdfdancer-client-typescript 1.0.1

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

@@ -0,0 +1,134 @@
+/**
+ * E2E tests for text line operations
+ */
+
+import * as fs from 'fs';
+import { ClientV1, Position } from '../../index';
+import { requireEnvAndFixture, createTempPath } from './test-helpers';
+
+describe('Line E2E Tests', () => {
+  // Tests should fail properly if environment is not configured
+
+  test('find lines by position', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const lines = await client.findTextLines();
+    expect(lines).toHaveLength(340);
+
+    const first = lines[0];
+    expect(first.internalId).toBe('LINE_000001');
+    expect(first.position).toBeDefined();
+    expect(first.position.boundingRect?.x).toBeCloseTo(326, 1);
+    expect(first.position.boundingRect?.y).toBeCloseTo(706, 1);
+
+    const last = lines[lines.length - 1];
+    expect(last.internalId).toBe('LINE_000340');
+    expect(last.position).toBeDefined();
+    expect(last.position.boundingRect?.x).toBeCloseTo(548, 2);
+    expect(last.position.boundingRect?.y).toBeCloseTo(35, 2);
+  });
+
+  test('find lines by text', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const pos = Position.fromPageIndex(0);
+    pos.textStartsWith = 'the complete';
+    const lines = await client.findTextLines(pos);
+    expect(lines).toHaveLength(1);
+
+    const line = lines[0];
+    expect(line.internalId).toBe('LINE_000002');
+    expect(line.position).toBeDefined();
+    expect(line.position.boundingRect?.x).toBeCloseTo(54, 1);
+    expect(line.position.boundingRect?.y).toBeCloseTo(606, 2);
+  });
+
+  test('delete line', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const pos = Position.fromPageIndex(0);
+    pos.textStartsWith = 'The Complete';
+    const ref = (await client.findTextLines(pos))[0];
+    expect(await client.delete(ref)).toBe(true);
+
+    const pos2 = Position.fromPageIndex(0);
+    pos2.textStartsWith = 'The Complete';
+    expect(await client.findTextLines(pos2)).toHaveLength(0);
+
+    // Save PDF to verify operation (Node.js environment)
+    const outPath = createTempPath('deleteLine.pdf');
+    const outputPdfData = await client.getPdfFile();
+    fs.writeFileSync(outPath, outputPdfData);
+    expect(fs.existsSync(outPath)).toBe(true);
+    expect(fs.statSync(outPath).size).toBeGreaterThan(0);
+
+    // Cleanup
+    fs.unlinkSync(outPath);
+  });
+
+  test('move line', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const pos3 = Position.fromPageIndex(0);
+    pos3.textStartsWith = 'The Complete';
+    const ref = (await client.findTextLines(pos3))[0];
+    const newPos = ref.position.copy();
+    newPos.moveX(100);
+    expect(await client.move(ref, newPos)).toBe(true);
+
+    const ref2 = (await client.findParagraphs(newPos))[0];
+    expect(ref2).toBeDefined();
+
+    // Save PDF to verify operation
+    const outPath = createTempPath('moveLine.pdf');
+    const outputPdfData = await client.getPdfFile();
+    fs.writeFileSync(outPath, outputPdfData);
+    expect(fs.existsSync(outPath)).toBe(true);
+    expect(fs.statSync(outPath).size).toBeGreaterThan(0);
+
+    // Cleanup
+    fs.unlinkSync(outPath);
+  });
+
+  test('modify line', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const pos4 = Position.fromPageIndex(0);
+    pos4.textStartsWith = 'The Complete';
+    const ref = (await client.findTextLines(pos4))[0];
+    expect(await client.modifyTextLine(ref, ' replaced ')).toBe(true);
+
+    // Save PDF to verify operation
+    const outPath = createTempPath('modifyLine.pdf');
+    const outputPdfData = await client.getPdfFile();
+    fs.writeFileSync(outPath, outputPdfData);
+    expect(fs.existsSync(outPath)).toBe(true);
+    expect(fs.statSync(outPath).size).toBeGreaterThan(0);
+
+    // Verify the text was replaced
+    const pos5 = Position.fromPageIndex(0);
+    pos5.textStartsWith = 'The Complete';
+    expect(await client.findTextLines(pos5)).toHaveLength(0);
+
+    const pos6 = Position.fromPageIndex(0);
+    pos6.textStartsWith = ' replaced ';
+    expect(await client.findTextLines(pos6)).not.toHaveLength(0);
+
+    const pos7 = Position.fromPageIndex(0);
+    pos7.textStartsWith = ' replaced ';
+    expect(await client.findParagraphs(pos7)).not.toHaveLength(0);
+
+    // Cleanup
+    fs.unlinkSync(outPath);
+  });
+});

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

@@ -0,0 +1,45 @@
+/**
+ * E2E tests for page operations
+ */
+
+import { ClientV1, ObjectType } from '../../index';
+import { requireEnvAndFixture } from './test-helpers';
+
+describe('Page E2E Tests', () => {
+  // Tests should fail properly if environment is not configured
+
+  test('get pages', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const pages = await client.getPages();
+    expect(pages).toBeDefined();
+    expect(pages[0].type).toBe(ObjectType.PAGE);
+    expect(pages).toHaveLength(12);
+  });
+
+  test('get page', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const page = await client.getPage(2);
+    expect(page).toBeDefined();
+    expect(page!.position.pageIndex).toBe(2);
+    expect(page!.internalId).toBeDefined();
+  });
+
+  test('delete page', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const page3 = await client.getPage(3);
+    expect(page3).toBeDefined();
+    expect(await client.deletePage(page3!)).toBe(true);
+
+    const newPages = await client.getPages();
+    expect(newPages).toHaveLength(11);
+  });
+});

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

@@ -0,0 +1,210 @@
+/**
+ * E2E tests for paragraph operations
+ */
+
+import { ClientV1, Position, Font, Color, FontNotFoundException } from '../../index';
+import { requireEnvAndFixture, readFontFixture } from './test-helpers';
+
+describe('Paragraph E2E Tests', () => {
+  // Tests should fail properly if environment is not configured
+
+  test('find paragraphs by position', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const paras = await client.findParagraphs();
+    expect(paras).toHaveLength(172);
+
+    const parasPage0 = await client.findParagraphs(Position.fromPageIndex(0));
+    expect(parasPage0).toHaveLength(2);
+
+    const first = parasPage0[0];
+    expect(first.internalId).toBe('PARAGRAPH_000003');
+    expect(first.position).toBeDefined();
+    expect(first.position.boundingRect?.x).toBeCloseTo(326, 1);
+    expect(first.position.boundingRect?.y).toBeCloseTo(706, 1);
+
+    const last = parasPage0[parasPage0.length - 1];
+    expect(last.internalId).toBe('PARAGRAPH_000004');
+    expect(last.position).toBeDefined();
+    expect(last.position.boundingRect?.x).toBeCloseTo(54, 1);
+    expect(last.position.boundingRect?.y).toBeCloseTo(496, 2);
+  });
+
+  test('find paragraphs by text', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const pos = Position.fromPageIndex(0);
+    pos.textStartsWith = 'The Complete';
+    const paras = await client.findParagraphs(pos);
+    expect(paras).toHaveLength(1);
+
+    const p = paras[0];
+    expect(p.internalId).toBe('PARAGRAPH_000004');
+    expect(p.position).toBeDefined();
+    expect(p.position.boundingRect?.x).toBeCloseTo(54, 1);
+    expect(p.position.boundingRect?.y).toBeCloseTo(496, 2);
+  });
+
+  test('delete paragraph', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const posDel = Position.fromPageIndex(0);
+    posDel.textStartsWith = 'The Complete';
+    const ref = (await client.findParagraphs(posDel))[0];
+    expect(await client.delete(ref)).toBe(true);
+
+    const posDel2 = Position.fromPageIndex(0);
+    posDel2.textStartsWith = 'The Complete';
+    expect(await client.findParagraphs(posDel2)).toHaveLength(0);
+  });
+
+  test('move paragraph', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const posMove = Position.fromPageIndex(0);
+    posMove.textStartsWith = 'The Complete';
+    const ref = (await client.findParagraphs(posMove))[0];
+    const newPos = Position.onPageCoordinates(0, 0.1, 300);
+    expect(await client.move(ref, newPos)).toBe(true);
+
+    const ref2 = (await client.findParagraphs(newPos))[0];
+    expect(ref2).toBeDefined();
+  });
+
+  async function assertNewParagraphExists(client: ClientV1): Promise<void> {
+    // Validate via find_text_lines for text starting with 'Awesomely'
+    const pos = Position.fromPageIndex(0);
+    pos.textStartsWith = 'Awesomely';
+    const lines = await client.findTextLines(pos);
+    expect(lines.length).toBeGreaterThanOrEqual(1);
+  }
+
+  test('modify paragraph', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const posMod = Position.fromPageIndex(0);
+    posMod.textStartsWith = 'The Complete';
+    const ref = (await client.findParagraphs(posMod))[0];
+
+    const newParagraph = client.paragraphBuilder()
+      .fromString('Awesomely\\nObvious!')
+      .withFont(new Font('Helvetica', 14))
+      .withLineSpacing(0.7)
+      .withPosition(Position.onPageCoordinates(0, 300.1, 500))
+      .build();
+
+    expect(await client.modifyParagraph(ref, newParagraph)).toBe(true);
+    await assertNewParagraphExists(client);
+  });
+
+  test('modify paragraph simple', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const posMod2 = Position.fromPageIndex(0);
+    posMod2.textStartsWith = 'The Complete';
+    const ref = (await client.findParagraphs(posMod2))[0];
+    expect(await client.modifyParagraph(ref, 'Awesomely\\nObvious!')).toBe(true);
+    await assertNewParagraphExists(client);
+  });
+
+  test('add paragraph with custom font - expect not found', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const pb = client.paragraphBuilder()
+      .fromString('Awesomely\\nObvious!')
+      .withFont(new Font('Roboto', 14))
+      .withLineSpacing(0.7)
+      .withPosition(Position.onPageCoordinates(0, 300.1, 500));
+
+    await expect(client.addParagraph(pb.build())).rejects.toThrow('Font not found');
+  });
+
+  test('add paragraph with custom font - Roboto-Regular', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const pb = client.paragraphBuilder()
+      .fromString('Awesomely\\nObvious!')
+      .withFont(new Font('Roboto-Regular', 14))
+      .withLineSpacing(0.7)
+      .withPosition(Position.onPageCoordinates(0, 300.1, 500));
+
+    expect(await client.addParagraph(pb.build())).toBe(true);
+    await assertNewParagraphExists(client);
+  });
+
+  test('add paragraph with found font', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const fonts = await client.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.onPageCoordinates(0, 300.1, 500));
+
+    expect(await client.addParagraph(pb.build())).toBe(true);
+    await assertNewParagraphExists(client);
+  });
+
+  test('add paragraph with Asimovian font', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const fonts = await client.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.onPageCoordinates(0, 300.1, 500));
+
+    expect(await client.addParagraph(pb.build())).toBe(true);
+    await assertNewParagraphExists(client);
+  });
+
+  test('add paragraph with custom TTF font', async () => {
+    const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+    const client = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    // Use DancingScript-Regular.ttf from fixtures directory
+    const ttfData = readFontFixture('DancingScript-Regular.ttf');
+
+    const pb = client.paragraphBuilder()
+      .fromString('Awesomely\\nObvious!')
+      .withLineSpacing(1.8)
+      .withColor(new Color(0, 0, 255))
+      .withPosition(Position.onPageCoordinates(0, 300.1, 500));
+
+    await pb.withFontFile(ttfData, 24);
+
+    expect(await client.addParagraph(pb.build())).toBe(true);
+    await assertNewParagraphExists(client);
+  });
+});

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

@@ -0,0 +1,72 @@
+/**
+ * E2E tests for path operations
+ */
+
+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 = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    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 = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    const paths = await client.findPaths(Position.onPageCoordinates(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 = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    let paths = await client.findPaths(Position.onPageCoordinates(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.onPageCoordinates(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 = new ClientV1(token, pdfData, baseUrl, 30000);
+    await client.init();
+
+    let paths = await client.findPaths(Position.onPageCoordinates(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.onPageCoordinates(0, 50.1, 100))).toBe(true);
+
+    expect(await client.findPaths(Position.onPageCoordinates(0, 80, 720))).toHaveLength(0);
+
+    paths = await client.findPaths(Position.onPageCoordinates(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);
+  });
+});

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

@@ -0,0 +1,132 @@
+/**
+ * Helper functions for e2e tests
+ */
+
+import * as fs from 'fs';
+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';
+}
+
+/**
+ * Read authentication token from environment or token files
+ */
+export function readToken(): string | null {
+  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');
+
+  for (const file of candidates) {
+    try {
+      return fs.readFileSync(file, 'utf-8').trim();
+    } catch {
+      continue;
+    }
+  }
+
+  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;
+  }
+}
+
+/**
+ * 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 [];
+  }
+}
+
+/**
+ * Require environment variables and PDF fixture for testing
+ */
+export async function requireEnvAndFixture(pdfFilename: string): Promise<[string, string, Uint8Array]> {
+  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 (!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);
+
+  if (!fs.existsSync(pdfPath)) {
+    throw new Error(`${pdfFilename} fixture not found at ${pdfPath}`);
+  }
+
+  const pdfData = fs.readFileSync(pdfPath);
+  return [baseUrl, token, new Uint8Array(pdfData)];
+}
+
+/**
+ * Helper to create temporary file path (for Node.js environment)
+ */
+export function createTempPath(filename: string): string {
+  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);
+
+  if (!fs.existsSync(imagePath)) {
+    throw new Error(`Image fixture not found: ${filename}`);
+  }
+
+  const imageData = fs.readFileSync(imagePath);
+  return new Uint8Array(imageData);
+}
+
+/**
+ * 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);
+
+  if (!fs.existsSync(fontPath)) {
+    throw new Error(`Font fixture not found: ${filename}`);
+  }
+
+  const fontData = fs.readFileSync(fontPath);
+  return new Uint8Array(fontData);
+}