pdfdancer-client-typescript 1.0.12 → 1.0.13

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

@@ -85,7 +85,7 @@ describe('Paragraph E2E Tests (v2 API)', () => {
         const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
         await para.moveTo(0.1, 300);
 
-        const moved = await pdf.page(0).selectParagraphsAt(0.1, 300);
+        const moved = await pdf.page(0).selectParagraphsAt(0.1, 300, 1);
         expect(moved.length).toBeGreaterThan(0);
     });
 
@@ -147,8 +147,8 @@ describe('Paragraph E2E Tests (v2 API)', () => {
         expect(modified.objectRef().status?.isModified()).toBe(true);
 
         const assertions = await PDFAssertions.create(pdf);
-        await assertions.assertTextlineHasFont('Awesomely', 'IXKSWR+Poppins-Bold', 1, 0);
-        await assertions.assertTextlineHasFont('Obvious!', 'IXKSWR+Poppins-Bold', 1, 0);
+        await assertions.assertTextlineHasFont('Awesomely', 'IXKSWR+Poppins-Bold', 45, 0);
+        await assertions.assertTextlineHasFont('Obvious!', 'IXKSWR+Poppins-Bold', 45, 0);
         await assertions.assertTextlineHasColor('Awesomely', new Color(255, 255, 255), 0);
         await assertions.assertTextlineHasColor('Obvious!', new Color(255, 255, 255), 0);
     });
@@ -526,12 +526,12 @@ describe('Paragraph E2E Tests (v2 API)', () => {
         const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
 
         await para.edit()
-            .moveTo(1, 1)
+            .moveTo(40, 40)
             .apply();
 
         const assertions = await PDFAssertions.create(pdf);
-        await assertions.assertTextlineHasFont('The Complete', 'IXKSWR+Poppins-Bold', 1, 0);
-        await assertions.assertTextlineIsAt('The Complete', 1, 1, 0, 0.22);
+        await assertions.assertTextlineHasFont('The Complete', 'IXKSWR+Poppins-Bold', 45, 0);
+        await assertions.assertParagraphIsAt('The Complete', 40, 40, 0, 0.22);
         await assertions.assertTextlineHasColor('The Complete', new Color(255, 255, 255), 0);
     });
 
@@ -543,8 +543,8 @@ describe('Paragraph E2E Tests (v2 API)', () => {
         await para.edit().replace('Awesomely\nObvious!').apply();
 
         const assertions = await PDFAssertions.create(pdf);
-        await assertions.assertTextlineHasFont('Awesomely', 'IXKSWR+Poppins-Bold', 1, 0);
-        await assertions.assertTextlineHasFont('Obvious!', 'IXKSWR+Poppins-Bold', 1, 0);
+        await assertions.assertTextlineHasFont('Awesomely', 'IXKSWR+Poppins-Bold', 45, 0);
+        await assertions.assertTextlineHasFont('Obvious!', 'IXKSWR+Poppins-Bold', 45, 0);
         await assertions.assertTextlineHasColor('Awesomely', new Color(255, 255, 255), 0);
         await assertions.assertTextlineHasColor('Obvious!', new Color(255, 255, 255), 0);
     });

package/src/__tests__/e2e/pdf-assertions.ts

@@ -27,6 +27,7 @@ export class PDFAssertions {
 
         // Reopen the PDF with the same token and baseUrl
         const pdfData = fs.readFileSync(tempFile);
+        console.log(`PDF file saved to ${tempFile}`);
         const pdf = await PDFDancer.open(new Uint8Array(pdfData), token, baseUrl);
 
         return new PDFAssertions(pdf);
@@ -66,6 +67,12 @@ export class PDFAssertions {
         return this;
     }
 
+    async assertNumberOfPages(expected: number): Promise<this> {
+        const pages = await this.pdf.pages();
+        expect(pages.length).toBe(expected);
+        return this;
+    }
+
     async assertPageCount(expected: number): Promise<this> {
         const pages = await this.pdf.pages();
         expect(pages.length).toBe(expected);
@@ -91,7 +98,7 @@ export class PDFAssertions {
         expectWithin(reference.position.getX()!, x, epsilon);
         expectWithin(reference.position.getY()!, y, epsilon);
 
-        const byPosition = await this.pdf.page(page).selectParagraphsAt(x, y);
+        const byPosition = await this.pdf.page(page).selectParagraphsAt(x, y, epsilon);
         expect(byPosition.length).toBeGreaterThan(0);
         return this;
     }
@@ -151,7 +158,7 @@ export class PDFAssertions {
         const reference = lines[0].objectRef();
         expectWithin(reference.position.getX()!, x, epsilon);
         expectWithin(reference.position.getY()!, y, epsilon);
-        const byPosition = await this.pdf.page(page).selectTextLinesAt(x, y);
+        const byPosition = await this.pdf.page(page).selectTextLinesAt(x, y, epsilon);
         expect(byPosition.length).toBeGreaterThan(0);
         return this;
     }
@@ -185,7 +192,7 @@ export class PDFAssertions {
     }
 
     async assertImageAt(x: number, y: number, page = 0): Promise<this> {
-        const images = await this.pdf.page(page).selectImagesAt(x, y);
+        const images = await this.pdf.page(page).selectImagesAt(x, y, 0.1);
         expect(images.length).toBe(1);
         return this;
     }

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

@@ -0,0 +1,40 @@
+import {PDFDancer, ValidationException} from '../../index';
+import {readToken, requireEnvAndFixture} from './test-helpers';
+
+describe('PDFDancer Environment Tests (Showcase)', () => {
+    test.skip('environment variable handling matches python client', async () => {
+        const [baseUrl, , pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const originalBaseUrl = process.env.PDFDANCER_BASE_URL;
+        const originalToken = process.env.PDFDANCER_TOKEN;
+
+        try {
+            delete process.env.PDFDANCER_TOKEN;
+
+            // TypeScript client currently requires an explicit token; when parity is implemented,
+            // this assertion should be updated to match the Python client's anonymous token fallback.
+            await expect(PDFDancer.open(pdfData, undefined, baseUrl)).rejects.toThrow(ValidationException);
+
+            process.env.PDFDANCER_TOKEN = readToken() ?? '';
+            await expect(PDFDancer.open(pdfData, undefined, baseUrl)).resolves.toBeDefined();
+
+            process.env.PDFDANCER_BASE_URL = 'https://www.google.com';
+            await expect(PDFDancer.open(pdfData)).rejects.toThrow();
+
+            process.env.PDFDANCER_BASE_URL = 'https://api.pdfdancer.com';
+            delete process.env.PDFDANCER_TOKEN;
+            await expect(PDFDancer.open(pdfData)).rejects.toThrow();
+        } finally {
+            if (originalBaseUrl === undefined) {
+                delete process.env.PDFDANCER_BASE_URL;
+            } else {
+                process.env.PDFDANCER_BASE_URL = originalBaseUrl;
+            }
+
+            if (originalToken === undefined) {
+                delete process.env.PDFDANCER_TOKEN;
+            } else {
+                process.env.PDFDANCER_TOKEN = originalToken;
+            }
+        }
+    });
+});

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

@@ -0,0 +1,158 @@
+import {ObjectType, PDFDancer} from '../../index';
+import {requireEnvAndFixture} from './test-helpers';
+
+describe('Snapshot E2E Tests (Showcase)', () => {
+    test('page snapshot matches select paragraphs', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await pdf.getPageSnapshot(0);
+        const snapshotParagraphs = snapshot.elements.filter(e => e.type === ObjectType.PARAGRAPH);
+        const selected = await pdf.page(0).selectParagraphs();
+
+        expect(selected.length).toBe(snapshotParagraphs.length);
+        const snapshotIds = new Set(snapshotParagraphs.map(e => e.internalId));
+        const selectedIds = new Set(selected.map(p => p.internalId));
+        expect(selectedIds).toEqual(snapshotIds);
+    });
+
+    test('page snapshot matches select images', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await pdf.getPageSnapshot(0);
+        const snapshotImages = snapshot.elements.filter(e => e.type === ObjectType.IMAGE);
+        const selected = await pdf.page(0).selectImages();
+
+        expect(selected.length).toBe(snapshotImages.length);
+        if (selected.length > 0) {
+            const snapshotIds = new Set(snapshotImages.map(e => e.internalId));
+            const selectedIds = new Set(selected.map(img => img.internalId));
+            expect(selectedIds).toEqual(snapshotIds);
+        }
+    });
+
+    test('page snapshot matches select forms', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await pdf.getPageSnapshot(0);
+        const snapshotForms = snapshot.elements.filter(e => e.type === ObjectType.FORM_X_OBJECT);
+        const selected = await pdf.page(0).selectForms();
+
+        expect(selected.length).toBe(snapshotForms.length);
+        if (selected.length > 0) {
+            const snapshotIds = new Set(snapshotForms.map(e => e.internalId));
+            const selectedIds = new Set(selected.map(form => form.internalId));
+            expect(selectedIds).toEqual(snapshotIds);
+        }
+    });
+
+    test('page snapshot matches select form fields', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await pdf.getPageSnapshot(0);
+        const snapshotFields = snapshot.elements.filter(e => [
+            ObjectType.FORM_FIELD,
+            ObjectType.TEXT_FIELD,
+            ObjectType.CHECKBOX,
+            ObjectType.RADIO_BUTTON
+        ].includes(e.type));
+        const selected = await pdf.page(0).selectFormFields();
+
+        expect(selected.length).toBe(snapshotFields.length);
+        if (selected.length > 0) {
+            const snapshotIds = new Set(snapshotFields.map(e => e.internalId));
+            const selectedIds = new Set(selected.map(field => field.internalId));
+            expect(selectedIds).toEqual(snapshotIds);
+        }
+    });
+
+    test('page snapshot contains all element types', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await pdf.getPageSnapshot(0);
+        const paragraphCount = snapshot.elements.filter(e => e.type === ObjectType.PARAGRAPH).length;
+        const textLineCount = snapshot.elements.filter(e => e.type === ObjectType.TEXT_LINE).length;
+
+        expect(paragraphCount > 0 || textLineCount > 0).toBe(true);
+        for (const element of snapshot.elements) {
+            expect(element.type).toBeDefined();
+            expect(element.internalId).toBeDefined();
+            expect(element.position).toBeDefined();
+        }
+    });
+
+    test('document snapshot matches all pages', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const docSnapshot = await pdf.getDocumentSnapshot();
+        for (let i = 0; i < docSnapshot.pageCount; i++) {
+            const docPage = docSnapshot.pages[i];
+            const pageSnapshot = await pdf.getPageSnapshot(i);
+            expect(pageSnapshot.elements.length).toBe(docPage.elements.length);
+
+            const docIds = new Set(docPage.elements.map(e => e.internalId));
+            const pageIds = new Set(pageSnapshot.elements.map(e => e.internalId));
+            expect(pageIds).toEqual(docIds);
+        }
+    });
+
+    test('type filter matches select method', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await pdf.getPageSnapshot(0, [ObjectType.PARAGRAPH]);
+        const selected = await pdf.page(0).selectParagraphs();
+
+        expect(snapshot.elements.length).toBe(selected.length);
+        expect(snapshot.elements.every(e => e.type === ObjectType.PARAGRAPH)).toBe(true);
+
+        const snapshotIds = new Set(snapshot.elements.map(e => e.internalId));
+        const selectedIds = new Set(selected.map(p => p.internalId));
+        expect(selectedIds).toEqual(snapshotIds);
+    });
+
+    test('multiple type filters combined', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await pdf.getPageSnapshot(0, [ObjectType.PARAGRAPH, ObjectType.TEXT_LINE]);
+        expect(snapshot.elements.every(e => e.type === ObjectType.PARAGRAPH || e.type === ObjectType.TEXT_LINE)).toBe(true);
+
+        const full = await pdf.getPageSnapshot(0);
+        const expectedCount = full.elements.filter(e => e.type === ObjectType.PARAGRAPH || e.type === ObjectType.TEXT_LINE).length;
+        expect(snapshot.elements.length).toBe(expectedCount);
+    });
+
+    test('total element count matches expected', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const elements = await pdf.selectElements();
+        expect(elements.length).toBe(99);
+
+        const docSnapshot = await pdf.getDocumentSnapshot();
+        const snapshotTotal = docSnapshot.pages.reduce((count, page) => count + page.elements.length, 0);
+        expect(snapshotTotal).toBe(elements.length);
+        expect((await pdf.pages()).length).toBe(7);
+    });
+
+    test('snapshot consistency across multiple pages', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Showcase.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const docSnapshot = await pdf.getDocumentSnapshot();
+        expect(docSnapshot.pageCount).toBeGreaterThan(1);
+
+        const limit = Math.min(3, docSnapshot.pageCount);
+        for (let i = 0; i < limit; i++) {
+            const pageSnapshot = await pdf.getPageSnapshot(i);
+            expect(pageSnapshot).toBeDefined();
+            expect(pageSnapshot.pageRef.position.pageIndex).toBe(i);
+        }
+    });
+});

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

@@ -0,0 +1,296 @@
+/**
+ * E2E tests for snapshot operations
+ */
+
+import {ObjectType, PDFDancer, DocumentSnapshot, PageSnapshot} from '../../index';
+import {requireEnvAndFixture} from './test-helpers';
+
+describe('Snapshot E2E Tests', () => {
+    
+    test('get document snapshot', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await client.getDocumentSnapshot();
+        
+        // Verify snapshot structure
+        expect(snapshot).toBeDefined();
+        expect(snapshot).toBeInstanceOf(DocumentSnapshot);
+        
+        // Verify page count
+        expect(snapshot.pageCount).toBe(12);
+        
+        // Verify fonts array exists
+        expect(snapshot.fonts).toBeDefined();
+        expect(Array.isArray(snapshot.fonts)).toBe(true);
+        
+        // Verify pages array
+        expect(snapshot.pages).toBeDefined();
+        expect(Array.isArray(snapshot.pages)).toBe(true);
+        expect(snapshot.pages.length).toBe(12);
+        
+        // Verify each page snapshot
+        for (let i = 0; i < snapshot.pages.length; i++) {
+            const pageSnapshot = snapshot.pages[i];
+            expect(pageSnapshot).toBeInstanceOf(PageSnapshot);
+            expect(pageSnapshot.pageRef).toBeDefined();
+            expect(pageSnapshot.pageRef.position.pageIndex).toBe(i);
+            expect(pageSnapshot.elements).toBeDefined();
+            expect(Array.isArray(pageSnapshot.elements)).toBe(true);
+        }
+    });
+
+    test('get document snapshot with type filter', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        // Get snapshot filtered by paragraphs only
+        const snapshot = await client.getDocumentSnapshot([ObjectType.PARAGRAPH]);
+        
+        expect(snapshot).toBeDefined();
+        expect(snapshot.pageCount).toBe(12);
+        
+        // Verify all elements are paragraphs
+        const allElements = snapshot.getAllElements();
+        for (const element of allElements) {
+            expect(element.type).toBe(ObjectType.PARAGRAPH);
+        }
+    });
+
+    test('get document snapshot with multiple type filters', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        // Get snapshot filtered by paragraphs and images
+        const snapshot = await client.getDocumentSnapshot([ObjectType.PARAGRAPH, ObjectType.IMAGE]);
+        
+        expect(snapshot).toBeDefined();
+        
+        // Verify all elements are either paragraphs or images
+        const allElements = snapshot.getAllElements();
+        for (const element of allElements) {
+            expect([ObjectType.PARAGRAPH, ObjectType.IMAGE]).toContain(element.type);
+        }
+    });
+
+    test('get page snapshot', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const pageSnapshot = await client.getPageSnapshot(0);
+        
+        // Verify snapshot structure
+        expect(pageSnapshot).toBeDefined();
+        expect(pageSnapshot).toBeInstanceOf(PageSnapshot);
+        
+        // Verify page reference
+        expect(pageSnapshot.pageRef).toBeDefined();
+        expect(pageSnapshot.pageRef.position.pageIndex).toBe(0);
+        expect(pageSnapshot.pageRef.type).toBe(ObjectType.PAGE);
+        
+        // Verify elements
+        expect(pageSnapshot.elements).toBeDefined();
+        expect(Array.isArray(pageSnapshot.elements)).toBe(true);
+        expect(pageSnapshot.elements.length).toBeGreaterThan(0);
+        
+        // Verify each element has required properties
+        for (const element of pageSnapshot.elements) {
+            expect(element.internalId).toBeDefined();
+            expect(element.type).toBeDefined();
+            expect(element.position).toBeDefined();
+        }
+    });
+
+    test('get page snapshot with type filter', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        // Get page snapshot filtered by images only
+        const pageSnapshot = await client.getPageSnapshot(0, [ObjectType.IMAGE]);
+        
+        expect(pageSnapshot).toBeDefined();
+        
+        // Verify all elements are images
+        for (const element of pageSnapshot.elements) {
+            expect(element.type).toBe(ObjectType.IMAGE);
+        }
+    });
+
+    test('get page snapshot via PageClient', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const page = client.page(1);
+        const pageSnapshot = await page.getSnapshot();
+        
+        // Verify snapshot structure
+        expect(pageSnapshot).toBeDefined();
+        expect(pageSnapshot).toBeInstanceOf(PageSnapshot);
+        expect(pageSnapshot.pageRef.position.pageIndex).toBe(1);
+        expect(pageSnapshot.elements.length).toBeGreaterThan(0);
+    });
+
+    test('get page snapshot via PageClient with type filter', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const page = client.page(0);
+        const pageSnapshot = await page.getSnapshot([ObjectType.PARAGRAPH]);
+        
+        expect(pageSnapshot).toBeDefined();
+        
+        // Verify all elements are paragraphs
+        for (const element of pageSnapshot.elements) {
+            expect(element.type).toBe(ObjectType.PARAGRAPH);
+        }
+    });
+
+    test('DocumentSnapshot helper methods', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await client.getDocumentSnapshot();
+        
+        // Test getPageSnapshot
+        const page0 = snapshot.getPageSnapshot(0);
+        expect(page0).toBeDefined();
+        expect(page0!.getPageIndex()).toBe(0);
+        
+        const page5 = snapshot.getPageSnapshot(5);
+        expect(page5).toBeDefined();
+        expect(page5!.getPageIndex()).toBe(5);
+        
+        // Test getAllElements
+        const allElements = snapshot.getAllElements();
+        expect(allElements.length).toBeGreaterThan(0);
+        
+        // Test getTotalElementCount
+        const totalCount = snapshot.getTotalElementCount();
+        expect(totalCount).toBe(allElements.length);
+        expect(totalCount).toBeGreaterThan(0);
+        
+        // Test getElementsByType
+        const paragraphs = snapshot.getElementsByType(ObjectType.PARAGRAPH);
+        expect(paragraphs.length).toBeGreaterThan(0);
+        for (const para of paragraphs) {
+            expect(para.type).toBe(ObjectType.PARAGRAPH);
+        }
+    });
+
+    test('PageSnapshot helper methods', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const pageSnapshot = await client.getPageSnapshot(0);
+        
+        // Test getPageIndex
+        expect(pageSnapshot.getPageIndex()).toBe(0);
+        
+        // Test getElementCount
+        const elementCount = pageSnapshot.getElementCount();
+        expect(elementCount).toBe(pageSnapshot.elements.length);
+        expect(elementCount).toBeGreaterThan(0);
+        
+        // Test getElementsByType
+        const paragraphs = pageSnapshot.getElementsByType(ObjectType.PARAGRAPH);
+        for (const para of paragraphs) {
+            expect(para.type).toBe(ObjectType.PARAGRAPH);
+        }
+    });
+
+    test('snapshot with form fields', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('mixed-form-types.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        // Form fields can be TEXT_FIELD, CHECKBOX, or RADIO_BUTTON
+        const snapshot = await client.getDocumentSnapshot([
+            ObjectType.TEXT_FIELD,
+            ObjectType.CHECKBOX,
+            ObjectType.RADIO_BUTTON
+        ]);
+
+        expect(snapshot).toBeDefined();
+
+        // Get all form field types
+        const allFormFields = snapshot.getAllElements();
+        expect(allFormFields.length).toBeGreaterThan(0);
+
+        // Verify they are all form field types
+        const formFieldTypes = [ObjectType.TEXT_FIELD, ObjectType.CHECKBOX, ObjectType.RADIO_BUTTON];
+        for (const field of allFormFields) {
+            expect(formFieldTypes).toContain(field.type);
+        }
+    });
+
+    test('snapshot with paths', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('basic-paths.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await client.getDocumentSnapshot([ObjectType.PATH]);
+        
+        expect(snapshot).toBeDefined();
+        
+        // Get all paths
+        const paths = snapshot.getElementsByType(ObjectType.PATH);
+        expect(paths.length).toBeGreaterThan(0);
+        
+        // Verify they are all paths
+        for (const path of paths) {
+            expect(path.type).toBe(ObjectType.PATH);
+        }
+    });
+
+    test('compare snapshot with individual find operations', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        // Get snapshot
+        const snapshot = await client.getPageSnapshot(0);
+        const snapshotParagraphs = snapshot.getElementsByType(ObjectType.PARAGRAPH);
+        
+        // Get paragraphs via page client
+        const page = client.page(0);
+        const paragraphs = await page.selectParagraphs();
+        
+        // Should have same count
+        expect(snapshotParagraphs.length).toBe(paragraphs.length);
+    });
+
+    test('snapshot fonts information', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await client.getDocumentSnapshot();
+        
+        // Verify fonts array
+        expect(snapshot.fonts).toBeDefined();
+        expect(Array.isArray(snapshot.fonts)).toBe(true);
+        
+        // If there are fonts, verify their structure
+        if (snapshot.fonts.length > 0) {
+            for (const font of snapshot.fonts) {
+                expect(font.fontName).toBeDefined();
+                expect(font.fontType).toBeDefined();
+                expect(typeof font.similarityScore).toBe('number');
+            }
+        }
+    });
+
+    test('snapshot on empty page', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Empty.pdf');
+        const client = await PDFDancer.open(pdfData, token, baseUrl, 30000);
+
+        const snapshot = await client.getDocumentSnapshot();
+        
+        expect(snapshot).toBeDefined();
+        expect(snapshot.pageCount).toBeGreaterThan(0);
+        expect(snapshot.pages.length).toBeGreaterThan(0);
+        
+        // Empty pages might have no elements
+        const page0Snapshot = snapshot.getPageSnapshot(0);
+        expect(page0Snapshot).toBeDefined();
+        expect(page0Snapshot!.elements).toBeDefined();
+        expect(Array.isArray(page0Snapshot!.elements)).toBe(true);
+    });
+});
+

package/src/__tests__/fingerprint.test.ts

@@ -0,0 +1,36 @@
+/**
+ * Tests for fingerprint generation
+ */
+
+import {generateFingerprint} from '../fingerprint';
+
+describe('Fingerprint', () => {
+    it('should generate a valid SHA256 fingerprint', async () => {
+        const fingerprint = await generateFingerprint();
+
+        // SHA256 produces 64 hex characters
+        expect(fingerprint).toHaveLength(64);
+        expect(fingerprint).toMatch(/^[a-f0-9]{64}$/);
+    });
+
+    it('should generate different fingerprints for different user IDs', async () => {
+        const fingerprint1 = await generateFingerprint('user1');
+        const fingerprint2 = await generateFingerprint('user2');
+
+        expect(fingerprint1).not.toBe(fingerprint2);
+        expect(fingerprint1).toHaveLength(64);
+        expect(fingerprint2).toHaveLength(64);
+    });
+
+    it('should generate consistent fingerprints for same user ID', async () => {
+        const fingerprint1 = await generateFingerprint('user123');
+        const fingerprint2 = await generateFingerprint('user123');
+
+        // Note: These might differ due to install salt randomness in test environment
+        // but they should both be valid SHA256 hashes
+        expect(fingerprint1).toHaveLength(64);
+        expect(fingerprint2).toHaveLength(64);
+        expect(fingerprint1).toMatch(/^[a-f0-9]{64}$/);
+        expect(fingerprint2).toMatch(/^[a-f0-9]{64}$/);
+    });
+});