pdfdancer-client-typescript 1.0.4 → 1.0.6

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

@@ -1,104 +1,101 @@
 /**
- * E2E tests for image operations
+ * E2E tests for image operations — new PDFDancer API
  */
 
 import * as fs from 'fs';
-import {ClientV1, Image, ObjectType, Position} from '../../index';
-import {createTempPath, readImageFixture, requireEnvAndFixture} from './test-helpers';
-import {expectWithin} from "../assertions";
+import {PDFDancer} from '../../index';
+import {createTempPath, getImagePath, requireEnvAndFixture} from './test-helpers';
+import {expectWithin} from '../assertions';
 
-describe('Image E2E Tests', () => {
-    // Tests should fail properly if environment is not configured
+describe('Image E2E Tests (v2 API)', () => {
 
     test('find images', 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, 30000);
 
-        const images = await client.findImages();
+        const images = await pdf.selectImages();
         expect(images).toHaveLength(3);
-        expect(images[0].type).toBe(ObjectType.IMAGE);
+        expect(images[0].type).toBe('IMAGE');
 
-        const imagesPage0 = await client.findImages(Position.atPage(0));
-        expect(imagesPage0).toHaveLength(2);
+        const imagesOnPage0 = await pdf.page(0).selectImages();
+        expect(imagesOnPage0).toHaveLength(2);
     });
 
     test('delete images', 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, 30000);
 
-        const images = await client.findImages();
-        for (const obj of images) {
-            expect(await client.delete(obj)).toBe(true);
+        const images = await pdf.selectImages();
+        for (const img of images) {
+            await img.delete();
         }
-        expect(await client.findImages()).toHaveLength(0);
 
-        // Save PDF to verify operation
+        const remaining = await pdf.selectImages();
+        expect(remaining).toHaveLength(0);
+
         const outPath = createTempPath('deleteImage.pdf');
-        const outputPdfData = await client.getPdfFile();
-        fs.writeFileSync(outPath, outputPdfData);
+        const outData = await pdf.getPdfFile();
+        fs.writeFileSync(outPath, outData);
+
         expect(fs.existsSync(outPath)).toBe(true);
         expect(fs.statSync(outPath).size).toBeGreaterThan(0);
 
-        // Cleanup
         fs.unlinkSync(outPath);
     });
 
     test('move image', 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, 30000);
 
-        let images = await client.findImages();
-        const imageRef = images[2];
-        const position = imageRef.position;
-        expectWithin(position.boundingRect?.x, 54, 0.5);
-        expectWithin(position.boundingRect?.y, 300, 1);
+        const images = await pdf.selectImages();
+        const image = images[2];
 
-        expect(await client.move(imageRef, Position.atPageCoordinates(11, 50.1, 100.0))).toBe(true);
+        expectWithin(image.position.boundingRect?.x, 54, 0.5);
+        expectWithin(image.position.boundingRect?.y, 300, 1);
 
-        images = await client.findImages();
-        const movedImageRef = images[2];
-        const newPosition = movedImageRef.position;
-        expectWithin(newPosition.boundingRect?.x, 50.1, 0.05);
-        expectWithin(newPosition.boundingRect?.y, 100.0, 0.05);
+        await image.moveTo(50.1, 100);
+
+        const moved = (await pdf.selectImages())[2];
+        expectWithin(moved.position.boundingRect?.x, 50.1, 0.05);
+        expectWithin(moved.position.boundingRect?.y, 100, 0.05);
     });
 
     test('find image 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, 30000);
 
-        let images = await client.findImages(Position.atPageCoordinates(11, 0, 0));
-        expect(images).toHaveLength(0);
+        const none = await pdf.page(11).selectImagesAt(0, 0);
+        expect(none).toHaveLength(0);
 
-        images = await client.findImages(Position.atPageCoordinates(11, 55, 310));
-        expect(images).toHaveLength(1);
-        expect(images[0].internalId).toBe('IMAGE_000003');
+        const found = await pdf.page(11).selectImagesAt(55, 310);
+        expect(found).toHaveLength(1);
+        expect(found[0].internalId).toBe('IMAGE_000003');
     });
 
     test('add image', 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, 30000);
 
-        let images = await client.findImages();
-        expect(images).toHaveLength(3);
+        const before = await pdf.selectImages();
+        expect(before).toHaveLength(3);
 
-        // Prepare image data
-        const imageData = readImageFixture('logo-80.png');
-        const image = new Image();
-        image.data = imageData;
-        const pos = Position.atPageCoordinates(6, 50.1, 98.0);
+        const result = await pdf.newImage()
+            .fromFile(getImagePath('logo-80.png'))
+            .at(6, 50.1, 98.0)
+            .add();
 
-        expect(await client.addImage(image, pos)).toBe(true);
+        expect(result).toBeTruthy();
 
-        images = await client.findImages();
-        expect(images).toHaveLength(4);
+        const after = await pdf.selectImages();
+        expect(after).toHaveLength(4);
 
-        const imagesPage6 = await client.findImages(Position.atPage(6));
-        expect(imagesPage6).toHaveLength(1);
+        const page6Images = await pdf.page(6).selectImages();
+        expect(page6Images).toHaveLength(1);
 
-        const newImage = imagesPage6[0];
-        expect(newImage.position.pageIndex).toBe(6);
-        expect(newImage.internalId).toBe('IMAGE_000004');
-        expectWithin(newImage.position.boundingRect?.x, 50.1, 0.05);
-        expectWithin(newImage.position.boundingRect?.y, 98.0, 0.05);
+        const added = page6Images[0];
+        expect(added.position.pageIndex).toBe(6);
+        expect(added.internalId).toBe('IMAGE_000004');
+        expectWithin(added.position.boundingRect?.x, 50.1, 0.05);
+        expectWithin(added.position.boundingRect?.y, 98.0, 0.05);
     });
 });

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

@@ -1,26 +1,25 @@
 /**
- * E2E tests for text line operations
+ * E2E tests for text line operations — new PDFDancer API
  */
 
 import * as fs from 'fs';
-import {ClientV1, Position} from '../../index';
+import {PDFDancer} from '../../index';
 import {createTempPath, requireEnvAndFixture} from './test-helpers';
-import {expectWithin} from "../assertions";
+import {expectWithin} from '../assertions';
 
-describe('Line E2E Tests', () => {
-    // Tests should fail properly if environment is not configured
+describe('Text Line E2E Tests (v2 API)', () => {
 
     test('find lines 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 lines = await client.findTextLines();
+        const lines = await pdf.selectLines();
         expect(lines).toHaveLength(340);
 
         const first = lines[0];
         expect(first.internalId).toBe('LINE_000001');
         expect(first.position).toBeDefined();
-        expectWithin(first.position.boundingRect?.x, 326, 1.0);
+        expectWithin(first.position.boundingRect?.x, 326, 1);
         expectWithin(first.position.boundingRect?.y, 706, 1);
 
         const last = lines[lines.length - 1];
@@ -30,12 +29,23 @@ describe('Line E2E Tests', () => {
         expectWithin(last.position.boundingRect?.y, 35, 1);
     });
 
+    test('find lines on page', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const lines = await pdf.page(1).selectTextLines();
+        expect(lines).toHaveLength(26);
+
+        const line = lines[0];
+        expect(line.internalId).toBe('LINE_000005');
+        expect(line.position).toBeDefined();
+    });
+
     test('find lines 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 lines = await client.findTextLines(pos);
+        const lines = await pdf.page(0).selectTextLinesStartingWith('the complete');
         expect(lines).toHaveLength(1);
 
         const line = lines[0];
@@ -47,76 +57,65 @@ describe('Line E2E Tests', () => {
 
     test('delete line', 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 ref = (await client.findTextLines(pos))[0];
-        expect(await client.delete(ref)).toBe(true);
+        const [line] = await pdf.page(0).selectTextLinesStartingWith('The Complete');
+        await line.delete();
 
-        const pos2 = Position.atPage(0).withTextStarts('The Complete');
-        expect(await client.findTextLines(pos2)).toHaveLength(0);
+        const remaining = await pdf.page(0).selectTextLinesStartingWith('The Complete');
+        expect(remaining).toHaveLength(0);
 
-        // Save PDF to verify operation (Node.js environment)
+        // Save PDF to verify operation
         const outPath = createTempPath('deleteLine.pdf');
-        const outputPdfData = await client.getPdfFile();
-        fs.writeFileSync(outPath, outputPdfData);
+        const data = await pdf.getPdfFile();
+        fs.writeFileSync(outPath, data);
         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 = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const pos3 = Position.atPage(0).withTextStarts('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 [line] = await pdf.page(0).selectTextLinesStartingWith('The Complete');
+        let newX = line.position!.getX()! + 100;
+        let newY = line.position!.getY()!;
+        await line.moveTo(newX, newY);
 
-        const ref2 = (await client.findParagraphs(newPos))[0];
-        expect(ref2).toBeDefined();
+        const movedPara = await pdf.page(0).selectParagraphsAt(newX, newY);
+        expect(movedPara.length).toBeGreaterThan(0);
 
-        // Save PDF to verify operation
         const outPath = createTempPath('moveLine.pdf');
-        const outputPdfData = await client.getPdfFile();
-        fs.writeFileSync(outPath, outputPdfData);
+        await pdf.save(outPath);
         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 = await ClientV1.create(token, pdfData, baseUrl, 30000);
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        const pos4 = Position.atPage(0).withTextStarts('The Complete');
-        const ref = (await client.findTextLines(pos4))[0];
-        expect(await client.modifyTextLine(ref, ' replaced ')).toBe(true);
+        const [line] = await pdf.page(0).selectTextLinesStartingWith('The Complete');
+        await line.edit().text(' replaced ').apply();
 
-        // Save PDF to verify operation
         const outPath = createTempPath('modifyLine.pdf');
-        const outputPdfData = await client.getPdfFile();
-        fs.writeFileSync(outPath, outputPdfData);
+        await pdf.save(outPath);
         expect(fs.existsSync(outPath)).toBe(true);
         expect(fs.statSync(outPath).size).toBeGreaterThan(0);
 
-        // Verify the text was replaced
-        const pos5 = Position.atPage(0).withTextStarts('The Complete');
-        expect(await client.findTextLines(pos5)).toHaveLength(0);
+        const stillOld = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+        expect(stillOld).toHaveLength(0);
 
-        const pos6 = Position.atPage(0).withTextStarts(' replaced ');
-        expect(await client.findTextLines(pos6)).not.toHaveLength(0);
+        const replaced = await pdf.page(0).selectParagraphsStartingWith(' replaced ');
+        expect(replaced.length).toBeGreaterThan(0);
 
-        const pos7 = Position.atPage(0).withTextStarts(' replaced ');
-        expect(await client.findParagraphs(pos7)).not.toHaveLength(0);
+        const containingParas = await pdf.page(0).selectParagraphsStartingWith(' replaced ');
+        expect(containingParas.length).toBeGreaterThan(0);
 
-        // Cleanup
         fs.unlinkSync(outPath);
     });
 });

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

@@ -2,41 +2,42 @@
  * E2E tests for page operations
  */
 
-import { ClientV1, ObjectType } from '../../index';
-import { requireEnvAndFixture } from './test-helpers';
+import {ObjectType, PDFDancer} 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 = await ClientV1.create(token, pdfData, baseUrl, 30000);
-
-    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 = await ClientV1.create(token, pdfData, baseUrl, 30000);
-
-    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 = await ClientV1.create(token, pdfData, baseUrl, 30000);
-
-    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);
-  });
-});
+    // Tests should fail properly if environment is not configured
+
+    test('get pages', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const pages = await client.pages();
+        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 = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const page = await client.page(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 = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        expect(await client.pages()).toHaveLength(12);
+        const page3 = client.page(3);
+        expect(page3).toBeDefined();
+        expect(await page3.delete()).toBe(true);
+
+        const newPages = await client.pages();
+        expect(newPages).toHaveLength(11);
+    });
+});