pdfdancer-client-typescript 1.0.12 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdfdancer-client-typescript",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "A TypeScript client library for the PDFDancer PDF manipulation API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -15,7 +15,7 @@ describe('AcroForm Fields E2E Tests (v2 API)', () => {
         const fields = await pdf.selectFormFields();
         expect(fields).toHaveLength(10);
         expect(fields[0].type).toBe('TEXT_FIELD');
-        expect(fields[4].type).toBe('CHECK_BOX');
+        expect(fields[4].type).toBe('CHECKBOX');
         expect(fields[6].type).toBe('RADIO_BUTTON');
 
         let allAtOrigin = true;
@@ -30,7 +30,7 @@ describe('AcroForm Fields E2E Tests (v2 API)', () => {
         const firstPageFields = await pdf.page(0).selectFormFields();
         expect(firstPageFields).toHaveLength(10);
 
-        const firstForm = await pdf.page(0).selectFormFieldsAt(290, 460);
+        const firstForm = await pdf.page(0).selectFormFieldsAt(280, 455, 1);
         expect(firstForm).toHaveLength(1);
         expect(firstForm[0].type).toBe('RADIO_BUTTON');
         expect(firstForm[0].internalId).toBe('FORM_FIELD_000008');
@@ -63,7 +63,7 @@ describe('AcroForm Fields E2E Tests (v2 API)', () => {
         const [baseUrl, token, pdfData] = await requireEnvAndFixture('mixed-form-types.pdf');
         const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
-        let fields = await pdf.page(0).selectFormFieldsAt(290, 460);
+        let fields = await pdf.page(0).selectFormFieldsAt(280, 455, 1);
         expect(fields).toHaveLength(1);
         const field = fields[0];
         expect(Math.abs((field.position.getX() ?? 0) - 280)).toBeLessThan(0.1);
@@ -71,10 +71,10 @@ describe('AcroForm Fields E2E Tests (v2 API)', () => {
 
         await field.moveTo(30, 40);
 
-        fields = await pdf.page(0).selectFormFieldsAt(290, 460);
+        fields = await pdf.page(0).selectFormFieldsAt(280, 455, 1);
         expect(fields).toHaveLength(0);
 
-        fields = await pdf.page(0).selectFormFieldsAt(30, 40);
+        fields = await pdf.page(0).selectFormFieldsAt(30, 40, 1);
         expect(fields).toHaveLength(1);
         expect(fields[0].internalId).toBe(field.internalId);
 

package/src/__tests__/e2e/context-manager-showcase.test.ts

@@ -0,0 +1,267 @@
+import {Color, PDFDancer, StandardFonts} from '../../index';
+import {requireEnvAndFixture} from './test-helpers';
+import {PDFAssertions} from './pdf-assertions';
+
+const SAMPLE_PARAGRAPH = 'This is regular Sans text showing alignment and styles.';
+
+describe('Paragraph Edit Session E2E Tests (Showcase)', () => {
+    test('basic usage', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const paragraphs = await pdf.selectParagraphs();
+        expect(paragraphs.length).toBe(24);
+    });
+
+    test('edit text only', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().replace('This is replaced\ntext on two lines').apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineExists('This is replaced', 0);
+        await assertions.assertTextlineExists('text on two lines', 0);
+        await assertions.assertTextlineDoesNotExist(SAMPLE_PARAGRAPH, 0);
+    });
+
+    test('edit font only', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().font('Helvetica', 28).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont(SAMPLE_PARAGRAPH, 'Helvetica', 28);
+        await assertions.assertTextlineHasColor(SAMPLE_PARAGRAPH, new Color(0, 0, 0));
+    });
+
+    test('edit text and font', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().replace('New Text\nHere').font('Helvetica', 16).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('New Text', 'Helvetica', 16);
+        await assertions.assertTextlineHasFont('Here', 'Helvetica', 16);
+        await assertions.assertTextlineDoesNotExist(SAMPLE_PARAGRAPH);
+    });
+
+    test('edit all properties', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit()
+            .replace('Fully\nModified')
+            .font('Helvetica', 18)
+            .color(new Color(255, 0, 0))
+            .lineSpacing(1.5)
+            .moveTo(100, 200)
+            .apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('Fully', 'Helvetica', 18);
+        await assertions.assertTextlineHasFont('Modified', 'Helvetica', 18);
+        await assertions.assertTextlineHasColor('Fully', new Color(255, 0, 0));
+        await assertions.assertTextlineHasColor('Modified', new Color(255, 0, 0));
+        await assertions.assertParagraphIsAt('Fully', 100, 200, 0);
+    });
+
+    test('edit color only', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().color(new Color(0, 255, 0)).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasColor(SAMPLE_PARAGRAPH, new Color(0, 255, 0));
+    });
+
+    test('edit line spacing only', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().lineSpacing(2.0).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineExists(SAMPLE_PARAGRAPH);
+    });
+
+    test('edit move only', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().moveTo(150, 300).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont(SAMPLE_PARAGRAPH, 'AAAZPH+Roboto-Regular', 12);
+        await assertions.assertParagraphIsAt(SAMPLE_PARAGRAPH, 150, 300, 0, 0.22);
+    });
+
+    test('multiple edits sequential', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [first] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await first.edit().replace('First Edit').apply();
+
+        const [second] = await pdf.page(0).selectParagraphsStartingWith('First Edit');
+        await second.edit().replace('Second Edit').font('Helvetica', 20).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('Second Edit', 'Helvetica', 20);
+        await assertions.assertTextlineDoesNotExist('First Edit');
+        await assertions.assertTextlineDoesNotExist(SAMPLE_PARAGRAPH);
+    });
+
+    test('edit multiple paragraphs', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const paragraphs = await pdf.page(0).selectParagraphs();
+        await paragraphs[0].edit().replace('Modified First').font('Helvetica', 14).apply();
+        await paragraphs[1].edit().replace('Modified Second').font('Helvetica', 14).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('Modified First', 'Helvetica', 14);
+        await assertions.assertTextlineHasFont('Modified Second', 'Helvetica', 14);
+    });
+
+    test('edit with exception does not apply', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        const editor = paragraph.edit();
+        editor.replace('Should Fail');
+
+        await expect(async () => {
+            throw new Error('boom');
+        }).rejects.toThrow('boom');
+
+        const remaining = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        expect(remaining.length).toBeGreaterThan(0);
+    });
+
+    test('nested PDF and edit sessions', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf1 = await PDFDancer.open(pdfData, token, baseUrl);
+        const pdf2 = await PDFDancer.new({initialPageCount: 1}, token, baseUrl);
+
+        await pdf2.page(0).newParagraph()
+            .text('Temporary Text')
+            .font(StandardFonts.HELVETICA, 12)
+            .at(50, 50)
+            .apply();
+
+        const [paragraph] = await pdf1.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().replace('Nested Edit').apply();
+
+        const assertions = await PDFAssertions.create(pdf1);
+        await assertions.assertTextlineExists('Nested Edit');
+    });
+
+    test('edit preserves position when not specified', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        const original = paragraph.position;
+        await paragraph.edit().replace('No Move').apply();
+
+        const [updated] = await pdf.page(0).selectParagraphsStartingWith('No Move');
+        expect(updated.position.getX()).toBeCloseTo(original.getX()!, 5);
+        expect(updated.position.getY()).toBeCloseTo(original.getY()!, 5);
+    });
+
+    test('edit chaining', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit()
+            .replace('Chained\nEdits')
+            .font('Helvetica', 15)
+            .color(new Color(128, 128, 128))
+            .lineSpacing(1.8)
+            .apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('Chained', 'Helvetica', 15);
+        await assertions.assertTextlineHasFont('Edits', 'Helvetica', 15);
+        await assertions.assertTextlineHasColor('Chained', new Color(128, 128, 128));
+    });
+
+    test('edit with standard fonts', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().replace('Times Roman').font(StandardFonts.TIMES_ROMAN, 18).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('Times Roman', StandardFonts.TIMES_ROMAN, 18);
+    });
+
+    test('edit with multiline text', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().replace('Line 1\nLine 2').font('Helvetica', 12).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineExists('Line 1');
+        await assertions.assertTextlineExists('Line 2');
+    });
+
+    test('edit with empty text', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().replace('').font('Helvetica', 12).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineDoesNotExist(SAMPLE_PARAGRAPH);
+    });
+
+    test('example from docs', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph] = await pdf.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph.edit().replace('Awesomely\nObvious!').font('Helvetica', 12).apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('Awesomely', 'Helvetica', 12);
+        await assertions.assertTextlineHasFont('Obvious!', 'Helvetica', 12);
+        await assertions.assertTextlineDoesNotExist(SAMPLE_PARAGRAPH);
+    });
+
+    test('vs manual apply', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf1 = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [paragraph1] = await pdf1.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph1.edit().replace('Test Text').font('Helvetica', 14).color(new Color(255, 0, 0)).apply();
+
+        const assertions1 = await PDFAssertions.create(pdf1);
+        await assertions1.assertTextlineHasFont('Test Text', 'Helvetica', 14);
+
+        const pdf2 = await PDFDancer.open(pdfData, token, baseUrl);
+        const [paragraph2] = await pdf2.page(0).selectParagraphsStartingWith(SAMPLE_PARAGRAPH);
+        await paragraph2.edit().replace('Test Text').font('Helvetica', 14).color(new Color(255, 0, 0)).apply();
+
+        const assertions2 = await PDFAssertions.create(pdf2);
+        await assertions2.assertTextlineHasFont('Test Text', 'Helvetica', 14);
+    });
+});

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

@@ -48,7 +48,7 @@ describe('Form E2E Tests (v2 API)', () => {
         expect(forms).toHaveLength(0);
 
         // Page 0, position (321,601) — expect a form
-        forms = await pdf.page(0).selectFormsAt(321, 601);
+        forms = await pdf.page(0).selectFormsAt(321, 601, 1);
         expect(forms).toHaveLength(1);
         expect(forms[0].internalId).toBe('FORM_000005');
 

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

@@ -0,0 +1,133 @@
+import fs from 'fs';
+import {ObjectType, PDFDancer} from '../../index';
+import {getImagePath, requireEnvAndFixture} from './test-helpers';
+import {PDFAssertions} from './pdf-assertions';
+
+describe('Image E2E Tests (Showcase)', () => {
+    test('find images', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const images = await pdf.selectImages();
+        expect(images.length).toBe(12);
+        expect(images[0].type).toBe(ObjectType.IMAGE);
+
+        const pageImages = await pdf.page(0).selectImages();
+        expect(pageImages.length).toBe(2);
+    });
+
+    test('delete all images', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const images = await pdf.selectImages();
+        expect(images.length).toBe(12);
+        for (const image of images) {
+            await image.delete();
+        }
+
+        expect(await pdf.selectImages()).toHaveLength(0);
+
+        const assertions = await PDFAssertions.create(pdf);
+        for (const page of await pdf.pages()) {
+            await assertions.assertNumberOfImages(0, page.position.pageIndex ?? 0);
+        }
+    });
+
+    test('move image', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const images = await pdf.selectImages();
+        const image = images[10];
+        const position = image.position;
+        const originalX = position.getX()!;
+        const originalY = position.getY()!;
+        expect(position.pageIndex).toBe(5);
+
+        const newX = 500.1;
+        const newY = 600.1;
+        await image.moveTo(newX, newY);
+
+        const moved = (await pdf.page(5).selectImagesAt(newX, newY))[0];
+        expect(moved.position).toBeDefined();
+        expect(Math.abs(moved.position.getX()! - newX)).toBeLessThanOrEqual(0.05);
+        expect(Math.abs(moved.position.getY()! - newY)).toBeLessThanOrEqual(0.05);
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertImageAt(newX, newY, 5);
+        await assertions.assertNoImageAt(originalX, originalY, 5);
+    });
+
+    test('find image by position', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const none = await pdf.page(5).selectImagesAt(0, 0);
+        expect(none.length).toBe(0);
+
+        const found = await pdf.page(5).selectImagesAt(57, 55, 1);
+        expect(found.length).toBe(1);
+        expect(found[0].internalId).toBe('IMAGE_000011');
+    });
+
+    test('add image via document builder', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        expect(await pdf.selectImages()).toHaveLength(12);
+        expect(await pdf.page(6).selectImages()).toHaveLength(1);
+
+        const fixturePath = getImagePath('logo-80.png');
+        expect(fs.existsSync(fixturePath)).toBe(true);
+
+        await pdf.newImage()
+            .fromFile(fixturePath)
+            .at(6, 50.1, 98.0)
+            .add();
+
+        expect(await pdf.selectImages()).toHaveLength(13);
+        const pageImages = await pdf.page(6).selectImages();
+        expect(pageImages.length).toBe(2);
+
+        const added = pageImages[1];
+        expect(added.position.pageIndex).toBe(6);
+        expect(added.internalId).toBe('IMAGE_000013');
+        expect(Math.abs(added.position.getX()! - 50.1)).toBeLessThanOrEqual(0.05);
+        expect(Math.abs(added.position.getY()! - 98.0)).toBeLessThanOrEqual(0.05);
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertImageAt(50.1, 98, 6);
+        await assertions.assertNumberOfImages(2, 6);
+    });
+
+    test('add image via page builder', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        expect(await pdf.selectImages()).toHaveLength(12);
+        expect(await pdf.page(6).selectImages()).toHaveLength(1);
+
+        const fixturePath = getImagePath('logo-80.png');
+        expect(fs.existsSync(fixturePath)).toBe(true);
+
+        await pdf.page(6).newImage()
+            .fromFile(fixturePath)
+            .at(50.1, 98.0)
+            .add();
+
+        expect(await pdf.selectImages()).toHaveLength(13);
+        const pageImages = await pdf.page(6).selectImages();
+        expect(pageImages.length).toBe(2);
+
+        const added = pageImages[1];
+        expect(added.position.pageIndex).toBe(6);
+        expect(added.internalId).toBe('IMAGE_000013');
+        expect(Math.abs(added.position.getX()! - 50.1)).toBeLessThanOrEqual(0.05);
+        expect(Math.abs(added.position.getY()! - 98.0)).toBeLessThanOrEqual(0.05);
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertImageAt(50.1, 98, 6);
+        await assertions.assertNumberOfImages(2, 6);
+    });
+});

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

@@ -84,7 +84,7 @@ describe('Image E2E Tests (v2 API)', () => {
         const none = await pdf.page(11).selectImagesAt(0, 0);
         expect(none).toHaveLength(0);
 
-        const found = await pdf.page(11).selectImagesAt(55, 310);
+        const found = await pdf.page(11).selectImagesAt(54, 300, 1);
         expect(found).toHaveLength(1);
         expect(found[0].internalId).toBe('IMAGE_000003');
     });

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

@@ -0,0 +1,118 @@
+import {FontType, PDFDancer} from '../../index';
+import {requireEnvAndFixture} from './test-helpers';
+import {PDFAssertions} from './pdf-assertions';
+
+const SAMPLE_PARAGRAPH = 'This is regular Sans text showing alignment and styles.';
+
+describe('Text Line E2E Tests (Showcase)', () => {
+    test('find lines by position multi', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        for (let i = 0; i < 10; i++) {
+            const lines = await pdf.selectTextLines();
+            for (const line of lines) {
+                const status = line.objectRef().status;
+                expect(status).toBeDefined();
+                expect(status?.isModified()).toBe(false);
+                expect(status?.isEncodable()).toBe(true);
+            }
+        }
+    });
+
+    test('find lines by position', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const lines = await pdf.selectTextLines();
+        expect(lines.length).toBe(36);
+
+        const first = lines[0];
+        expect(first.internalId).toBe('TEXTLINE_000001');
+        expect(first.position).toBeDefined();
+        expect(Math.abs(first.position.getX()! - 180)).toBeLessThanOrEqual(1);
+        expect(Math.abs(first.position.getY()! - 750)).toBeLessThanOrEqual(1);
+        expect(first.objectRef().status?.isModified()).toBe(false);
+        expect(first.objectRef().status?.isEncodable()).toBe(true);
+
+        const last = lines[lines.length - 1];
+        expect(last.internalId).toBe('TEXTLINE_000036');
+        expect(Math.abs(last.position.getX()! - 69.3)).toBeLessThanOrEqual(2);
+        expect(Math.abs(last.position.getY()! - 45)).toBeLessThanOrEqual(2);
+        expect(last.objectRef().status?.isModified()).toBe(false);
+        expect(last.objectRef().status?.isEncodable()).toBe(true);
+    });
+
+    test('find lines by text', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const lines = await pdf.page(0).selectTextLinesStartingWith(SAMPLE_PARAGRAPH);
+        expect(lines.length).toBe(1);
+
+        const line = lines[0];
+        expect(line.internalId).toBe('TEXTLINE_000002');
+        expect(Math.abs(line.position.getX()! - 65)).toBeLessThanOrEqual(1);
+        expect(Math.abs(line.position.getY()! - 706.8)).toBeLessThanOrEqual(2);
+    });
+
+    test('delete line', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const [line] = await pdf.page(0).selectTextLinesStartingWith(SAMPLE_PARAGRAPH);
+        await line.delete();
+
+        const remaining = await pdf.page(0).selectTextLinesStartingWith(SAMPLE_PARAGRAPH);
+        expect(remaining.length).toBe(0);
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineDoesNotExist(SAMPLE_PARAGRAPH);
+    });
+
+    test('move line', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const [line] = await pdf.page(0).selectTextLinesStartingWith(SAMPLE_PARAGRAPH);
+        const pos = line.position;
+        const newX = pos.getX()! + 100;
+        const newY = pos.getY()! + 18;
+
+        await line.moveTo(newX, newY);
+
+        const moved = (await pdf.page(0).selectTextLinesAt(newX, newY, 1))[0];
+        const status = moved.objectRef().status;
+        expect(status).toBeDefined();
+        expect(status?.isEncodable()).toBe(true);
+        expect(status?.getFontType()).toBe(FontType.EMBEDDED);
+        expect(status?.isModified()).toBe(false);
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineIsAt(SAMPLE_PARAGRAPH, newX, newY);
+    });
+
+    test('modify line', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const [line] = await pdf.page(0).selectTextLinesStartingWith(SAMPLE_PARAGRAPH);
+        await line.edit().text(' replaced ').apply();
+
+        expect(await pdf.page(0).selectTextLinesStartingWith(SAMPLE_PARAGRAPH)).toHaveLength(0);
+        expect(await pdf.page(0).selectParagraphsStartingWith(' replaced ')).not.toHaveLength(0);
+
+        const lines = await pdf.page(0).selectTextLinesStartingWith(' replaced ');
+        expect(lines.length).toBeGreaterThan(0);
+        const status = lines[0].objectRef().status;
+        expect(status).toBeDefined();
+        expect(status?.isEncodable()).toBe(true);
+        expect(status?.getFontType()).toBe(FontType.EMBEDDED);
+        expect(status?.isModified()).toBe(true);
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineDoesNotExist(SAMPLE_PARAGRAPH);
+        await assertions.assertTextlineExists(' replaced ');
+        await assertions.assertParagraphExists(' replaced ');
+    });
+});

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

@@ -94,16 +94,8 @@ describe('Text Line E2E Tests (v2 API)', () => {
         let newY = line.position!.getY()!;
         await line.moveTo(newX, newY);
 
-        const movedPara = await pdf.page(0).selectParagraphsAt(newX, newY);
+        const movedPara = await pdf.page(0).selectTextLinesAt(newX, newY);
         expect(movedPara.length).toBeGreaterThan(0);
-
-        const outPath = createTempPath('moveLine.pdf');
-        await pdf.save(outPath);
-        expect(fs.existsSync(outPath)).toBe(true);
-        expect(fs.statSync(outPath).size).toBeGreaterThan(0);
-
-        fs.unlinkSync(outPath);
-
         const assertions = await PDFAssertions.create(pdf);
         await assertions.assertTextlineIsAt('The Complete', newX, newY, 0, 0.25);
     });
@@ -119,11 +111,6 @@ describe('Text Line E2E Tests (v2 API)', () => {
         expect(result.warning).toBeDefined();
         expect(result.warning).toContain('You are using an embedded font and modified the text.');
 
-        const outPath = createTempPath('modifyLine.pdf');
-        await pdf.save(outPath);
-        expect(fs.existsSync(outPath)).toBe(true);
-        expect(fs.statSync(outPath).size).toBeGreaterThan(0);
-
         const stillOld = await pdf.page(0).selectParagraphsStartingWith('The Complete');
         expect(stillOld).toHaveLength(0);
 
@@ -140,8 +127,6 @@ describe('Text Line E2E Tests (v2 API)', () => {
         const containingParas = await pdf.page(0).selectParagraphsStartingWith(' replaced ');
         expect(containingParas.length).toBeGreaterThan(0);
 
-        fs.unlinkSync(outPath);
-
         const assertions = await PDFAssertions.create(pdf);
         await assertions.assertTextlineExists(' replaced ');
     });