pdfdancer-client-typescript 1.0.8 → 1.0.10

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

@@ -2,9 +2,10 @@
  * E2E tests for paragraph operations — new PDFDancer API
  */
 
-import {Color, PDFDancer, StandardFonts} from '../../index';
+import {Color, FontType, PDFDancer, StandardFonts} from '../../index';
 import {getFontPath, readFontFixture, requireEnvAndFixture} from './test-helpers';
 import {expectWithin} from '../assertions';
+import {PDFAssertions} from './pdf-assertions';
 
 describe('Paragraph E2E Tests (v2 API)', () => {
 
@@ -29,6 +30,11 @@ describe('Paragraph E2E Tests (v2 API)', () => {
         expect(last.position).toBeDefined();
         expectWithin(last.position.boundingRect?.x, 54, 1);
         expectWithin(last.position.boundingRect?.y, 496, 2);
+
+        expect(last.objectRef().status).toBeDefined();
+        expect(last.objectRef().status?.isEncodable()).toBe(true);
+        expect(last.objectRef().status?.getFontType()).toBe(FontType.EMBEDDED);
+        expect(last.objectRef().status?.isModified()).toBe(false);
     });
 
     test('find paragraphs by text', async () => {
@@ -101,6 +107,21 @@ describe('Paragraph E2E Tests (v2 API)', () => {
             .apply()
 
         await assertNewParagraphExists(pdf);
+
+        const movedParas = await pdf.page(0).selectParagraphsAt(300.1, 500);
+        expect(movedParas.length).toBeGreaterThan(0);
+        const moved = movedParas[0];
+        expect(moved.objectRef().status).toBeDefined();
+        expect(moved.objectRef().status?.isEncodable()).toBe(true);
+        expect(moved.objectRef().status?.getFontType()).toBe(FontType.STANDARD);
+        expect(moved.objectRef().status?.isModified()).toBe(true);
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('Awesomely', 'Helvetica', 12, 0);
+        await assertions.assertTextlineHasFont('Obvious!', 'Helvetica', 12, 0);
+        await assertions.assertTextlineHasColor('Awesomely', new Color(255, 255, 255), 0);
+        await assertions.assertTextlineHasColor('Obvious!', new Color(255, 255, 255), 0);
+        await assertions.assertParagraphIsAt('Awesomely', 300.1, 500, 0);
     });
 
     test('modify paragraph (simple)', async () => {
@@ -108,8 +129,28 @@ describe('Paragraph E2E Tests (v2 API)', () => {
         const pdf = await PDFDancer.open(pdfData, token, baseUrl);
 
         const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
-        await para.edit().replace('Awesomely\nObvious!').apply();
+        const result = await para.edit().replace('Awesomely\nObvious!').apply();
+
+        // This should issue a warning about an embedded font modification
+        expect(typeof result).toBe('object');
+        expect((result as any).warning).toBeDefined();
+        expect((result as any).warning).toContain('You are using an embedded font and modified the text.');
+
         await assertNewParagraphExists(pdf);
+
+        const modifiedParas = await pdf.page(0).selectParagraphsStartingWith('Awesomely');
+        expect(modifiedParas.length).toBeGreaterThan(0);
+        const modified = modifiedParas[0];
+        expect(modified.objectRef().status).toBeDefined();
+        expect(modified.objectRef().status?.isEncodable()).toBe(true);
+        expect(modified.objectRef().status?.getFontType()).toBe(FontType.EMBEDDED);
+        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.assertTextlineHasColor('Awesomely', new Color(255, 255, 255), 0);
+        await assertions.assertTextlineHasColor('Obvious!', new Color(255, 255, 255), 0);
     });
 
     test('add paragraph with missing font (expect error)', async () => {
@@ -399,8 +440,188 @@ describe('Paragraph E2E Tests (v2 API)', () => {
         expect(lines.length).toBe(4);
     });
 
+
+    test('modify paragraph with assertions', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+
+        await para.edit().replace('Awesomely\nObvious!')
+            .font("Helvetica", 12)
+            .lineSpacing(0.7)
+            .moveTo(300.1, 500)
+            .apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('Awesomely', 'Helvetica', 12, 0);
+        await assertions.assertTextlineHasFont('Obvious!', 'Helvetica', 12, 0);
+        await assertions.assertTextlineHasColor('Awesomely', new Color(255, 255, 255), 0);
+        await assertions.assertTextlineHasColor('Obvious!', new Color(255, 255, 255), 0);
+        await assertions.assertParagraphIsAt('Awesomely', 300.1, 500, 0);
+    });
+
+    test('modify paragraph without position', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+        let originalX = para.position.getX();
+        let originalY = para.position.getY();
+
+        await para.edit()
+            .replace('Awesomely\nObvious!')
+            .font('Helvetica', 12)
+            .lineSpacing(0.7)
+            .apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('Awesomely', 'Helvetica', 12, 0);
+        await assertions.assertTextlineHasFont('Obvious!', 'Helvetica', 12, 0);
+        await assertions.assertTextlineHasColor('Awesomely', new Color(255, 255, 255), 0);
+        await assertions.assertTextlineHasColor('Obvious!', new Color(255, 255, 255), 0);
+        await assertions.assertParagraphIsAt('Awesomely', originalX!, originalY!, 0);
+    });
+
+    test('modify paragraph without position and spacing', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+        let originalX = para.position.getX();
+        let originalY = para.position.getY();
+
+        await para.edit()
+            .replace('Awesomely\nObvious!')
+            .font('Helvetica', 12)
+            .apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('Awesomely', 'Helvetica', 12, 0);
+        await assertions.assertTextlineHasFont('Obvious!', 'Helvetica', 12, 0);
+        await assertions.assertTextlineHasColor('Awesomely', new Color(255, 255, 255), 0);
+        await assertions.assertTextlineHasColor('Obvious!', new Color(255, 255, 255), 0);
+        await assertions.assertParagraphIsAt('Awesomely', originalX!, originalY!, 0);
+    });
+
+    test('modify paragraph only font', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+
+        await para.edit()
+            .font('Helvetica', 28)
+            .apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFont('The Complete', 'Helvetica', 28, 0);
+        await assertions.assertTextlineHasColor('The Complete', new Color(255, 255, 255), 0);
+    });
+
+    test('modify paragraph only move', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+
+        await para.edit()
+            .moveTo(1, 1)
+            .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.assertTextlineHasColor('The Complete', new Color(255, 255, 255), 0);
+    });
+
+    test('modify paragraph simple', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        const [para] = await pdf.page(0).selectParagraphsStartingWith('The Complete');
+        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.assertTextlineHasColor('Awesomely', new Color(255, 255, 255), 0);
+        await assertions.assertTextlineHasColor('Obvious!', new Color(255, 255, 255), 0);
+    });
+
+    test('add paragraph with standard font Times Roman', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        await pdf.page(0).newParagraph()
+            .text('Times Roman Test')
+            .font(StandardFonts.TIMES_ROMAN, 14)
+            .at(150, 150)
+            .apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextHasFont('Times Roman Test', StandardFonts.TIMES_ROMAN, 14, 0);
+        await assertions.assertParagraphIsAt('Times Roman Test', 150, 150, 0);
+    });
+
+    test('add paragraph with standard font Courier Bold', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        await pdf.page(0).newParagraph()
+            .text('Courier Monospace\nCode Example')
+            .font(StandardFonts.COURIER_BOLD, 12)
+            .lineSpacing(1.5)
+            .at(200, 200)
+            .apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextHasFont('Courier Monospace', StandardFonts.COURIER_BOLD, 12, 0);
+        await assertions.assertParagraphIsAt('Courier Monospace', 200, 200, 0);
+    });
+
+    test('paragraph color reading', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('ObviouslyAwesome.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        await pdf.page(0).newParagraph()
+            .text('Red Color Test')
+            .font(StandardFonts.HELVETICA, 14)
+            .color(new Color(255, 0, 0))
+            .at(100, 100)
+            .apply();
+
+        await pdf.page(0).newParagraph()
+            .text('Blue Color Test')
+            .font(StandardFonts.HELVETICA, 14)
+            .color(new Color(0, 0, 255))
+            .at(100, 120)
+            .apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasColor('Blue Color Test', new Color(0, 0, 255), 0);
+        await assertions.assertTextlineHasColor('Red Color Test', new Color(255, 0, 0), 0);
+    });
+
+    test('add paragraph to new page', async () => {
+        const [baseUrl, token, pdfData] = await requireEnvAndFixture('Empty.pdf');
+        const pdf = await PDFDancer.open(pdfData, token, baseUrl);
+
+        await pdf.page(0).newParagraph()
+            .text('Awesome')
+            .font('Roboto-Regular', 14)
+            .at(50, 100)
+            .apply();
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertTextlineHasFontMatching('Awesome', 'Roboto-Regular', 14, 0);
+        await assertions.assertTextlineHasColor('Awesome', new Color(0, 0, 0), 0);
+        await assertions.assertParagraphIsAt('Awesome', 50, 100, 0);
+    });
+
     test('Symbol and ZapfDingbats fonts are available as standard fonts', () => {
         expect(StandardFonts.SYMBOL).toBe('Symbol');
         expect(StandardFonts.ZAPF_DINGBATS).toBe('ZapfDingbats');
     });
+
 });

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

@@ -4,6 +4,7 @@
 
 import {requireEnvAndFixture} from './test-helpers';
 import {PDFDancer} from "../../pdfdancer_v1";
+import {PDFAssertions} from './pdf-assertions';
 
 describe('Path E2E Tests (New API)', () => {
 
@@ -47,6 +48,10 @@ describe('Path E2E Tests (New API)', () => {
 
         const allPaths = await pdf.selectPaths();
         expect(allPaths).toHaveLength(8);
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertNoPathAt(80, 720);
+        await assertions.assertNumberOfPaths(8);
     });
 
     test('move path', async () => {
@@ -67,5 +72,8 @@ describe('Path E2E Tests (New API)', () => {
         const movedPos = moved[0].position;
         expect(movedPos.getX()).toBeCloseTo(50.1, 1);
         expect(movedPos.getY()).toBeCloseTo(100, 1);
+
+        const assertions = await PDFAssertions.create(pdf);
+        await assertions.assertPathIsAt('PATH_000001', 50.1, 100);
     });
 });

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

@@ -0,0 +1,241 @@
+/**
+ * PDF Assertions helper for e2e tests
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import {Color, Orientation, PDFDancer} from '../../index';
+import {expectWithin} from '../assertions';
+
+export class PDFAssertions {
+    private pdf: PDFDancer;
+
+    private constructor(pdf: PDFDancer) {
+        this.pdf = pdf;
+    }
+
+    static async create(sourcePdf: PDFDancer): Promise<PDFAssertions> {
+        // Save and reload the PDF to ensure all changes are persisted
+        // This matches the Python implementation
+        const token = (sourcePdf as any)._token;
+        const baseUrl = (sourcePdf as any)._baseUrl;
+
+        // Create a temporary file
+        const tempFile = path.join(os.tmpdir(), `test-${Date.now()}.pdf`);
+        await sourcePdf.save(tempFile);
+
+        // Reopen the PDF with the same token and baseUrl
+        const pdfData = fs.readFileSync(tempFile);
+        const pdf = await PDFDancer.open(new Uint8Array(pdfData), token, baseUrl);
+
+        return new PDFAssertions(pdf);
+    }
+
+    private async aggregateCounts(pageIndex?: number) {
+        const [paragraphs, textLines, images, paths, forms, fields] = await Promise.all([
+            this.pdf.selectParagraphs(),
+            this.pdf.selectLines(),
+            this.pdf.selectImages(),
+            this.pdf.selectPaths(),
+            this.pdf.selectForms(),
+            this.pdf.selectFormFields()
+        ]);
+
+        const filter = <T extends { position: { pageIndex?: number } }>(items: T[]): T[] => {
+            if (pageIndex === undefined) {
+                return items;
+            }
+            return items.filter(item => item.position.pageIndex === pageIndex);
+        };
+
+        return {
+            paragraphs: filter(paragraphs).length,
+            textLines: filter(textLines).length,
+            images: filter(images).length,
+            paths: filter(paths).length,
+            forms: filter(forms).length,
+            fields: filter(fields).length
+        };
+    }
+
+    async assertTotalNumberOfElements(expected: number, pageIndex?: number): Promise<this> {
+        const totals = await this.aggregateCounts(pageIndex);
+        const actual = Object.values(totals).reduce((acc, count) => acc + count, 0);
+        expect(actual).toBe(expected);
+        return this;
+    }
+
+    async assertPageCount(expected: number): Promise<this> {
+        const pages = await this.pdf.pages();
+        expect(pages.length).toBe(expected);
+        return this;
+    }
+
+    async assertPageDimension(width: number, height: number, orientation?: Orientation, pageIndex = 0): Promise<this> {
+        const pages = await this.pdf.pages();
+        expect(pageIndex).toBeLessThan(pages.length);
+        const page = pages[pageIndex];
+        expect(page.pageSize?.width).toBeCloseTo(width, 6);
+        expect(page.pageSize?.height).toBeCloseTo(height, 6);
+        if (orientation) {
+            expect(page.orientation).toBe(orientation);
+        }
+        return this;
+    }
+
+    async assertParagraphIsAt(text: string, x: number, y: number, page = 0, epsilon = 1e-4): Promise<this> {
+        const paragraphs = await this.pdf.page(page).selectParagraphsMatching(`.*${text}.*`);
+        expect(paragraphs.length).toBeGreaterThan(0);
+        const reference = paragraphs[0].objectRef();
+        expectWithin(reference.position.getX()!, x, epsilon);
+        expectWithin(reference.position.getY()!, y, epsilon);
+
+        const byPosition = await this.pdf.page(page).selectParagraphsAt(x, y);
+        expect(byPosition.length).toBeGreaterThan(0);
+        return this;
+    }
+
+    async assertTextHasFont(text: string, fontName: string, fontSize: number, page = 0): Promise<this> {
+        await this.assertTextlineHasFont(text, fontName, fontSize, page);
+
+        const paragraphs = await this.pdf.page(page).selectParagraphsMatching(`.*${text}.*`);
+        expect(paragraphs.length).toBeGreaterThan(0);
+        const reference = paragraphs[0].objectRef();
+        expect(reference.fontName).toBe(fontName);
+        expectWithin(reference.fontSize!, fontSize, 1e-6);
+        return this;
+    }
+
+    async assertTextHasFontMatching(text: string, fontName: string, fontSize: number, page = 0): Promise<this> {
+        await this.assertTextlineHasFontMatching(text, fontName, fontSize, page);
+        return this;
+    }
+
+    async assertTextHasColor(text: string, color: Color, page = 0): Promise<this> {
+        await this.assertTextlineHasColor(text, color, page);
+        return this;
+    }
+
+    async assertTextlineHasColor(text: string, color: Color, page = 0): Promise<this> {
+        const lines = await this.pdf.page(page).selectTextLinesMatching(text);
+        expect(lines.length).toBe(1);
+        const reference = lines[0].objectRef();
+        const refColor = reference.color;
+        expect(refColor).toEqual(color);
+        expect(reference.text).toContain(text);
+        return this;
+    }
+
+    async assertTextlineHasFont(text: string, fontName: string, fontSize: number, page = 0): Promise<this> {
+        const lines = await this.pdf.page(page).selectTextLinesStartingWith(text);
+        expect(lines.length).toBe(1);
+        const reference = lines[0].objectRef();
+        expect(reference.fontName).toBe(fontName);
+        expectWithin(reference.fontSize!, fontSize, 1e-6);
+        return this;
+    }
+
+    async assertTextlineHasFontMatching(text: string, fontName: string, fontSize: number, page = 0): Promise<this> {
+        const lines = await this.pdf.page(page).selectTextLinesStartingWith(text);
+        expect(lines.length).toBe(1);
+        const reference = lines[0].objectRef();
+        expect((reference.fontName ?? '').includes(fontName)).toBe(true);
+        expectWithin(reference.fontSize!, fontSize, 1e-6);
+        return this;
+    }
+
+    async assertTextlineIsAt(text: string, x: number, y: number, page = 0, epsilon = 1e-4): Promise<this> {
+        const lines = await this.pdf.page(page).selectTextLinesStartingWith(text);
+        expect(lines.length).toBe(1);
+        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);
+        expect(byPosition.length).toBeGreaterThan(0);
+        return this;
+    }
+
+    async assertPathIsAt(internalId: string, x: number, y: number, page = 0, epsilon = 1e-4): Promise<this> {
+        const paths = await this.pdf.page(page).selectPathsAt(x, y);
+        expect(paths.length).toBe(1);
+        const reference = paths[0];
+        expect(reference.internalId).toBe(internalId);
+        expectWithin(reference.position.getX()!, x, epsilon);
+        expectWithin(reference.position.getY()!, y, epsilon);
+        return this;
+    }
+
+    async assertNoPathAt(x: number, y: number, page = 0): Promise<this> {
+        const paths = await this.pdf.page(page).selectPathsAt(x, y);
+        expect(paths.length).toBe(0);
+        return this;
+    }
+
+    async assertNumberOfPaths(expected: number, page?: number): Promise<this> {
+        const paths = page === undefined ? await this.pdf.selectPaths() : await this.pdf.page(page).selectPaths();
+        expect(paths.length).toBe(expected);
+        return this;
+    }
+
+    async assertNumberOfImages(expected: number, page?: number): Promise<this> {
+        const images = page === undefined ? await this.pdf.selectImages() : await this.pdf.page(page).selectImages();
+        expect(images.length).toBe(expected);
+        return this;
+    }
+
+    async assertImageAt(x: number, y: number, page = 0): Promise<this> {
+        const images = await this.pdf.page(page).selectImagesAt(x, y);
+        expect(images.length).toBe(1);
+        return this;
+    }
+
+    async assertNoImageAt(x: number, y: number, page = 0): Promise<this> {
+        const images = await this.pdf.page(page).selectImagesAt(x, y);
+        expect(images.length).toBe(0);
+        return this;
+    }
+
+    async assertImageWithIdAt(internalId: string, x: number, y: number, page = 0): Promise<this> {
+        const images = await this.pdf.page(page).selectImagesAt(x, y);
+        expect(images.length).toBe(1);
+        expect(images[0].internalId).toBe(internalId);
+        return this;
+    }
+
+    async assertNumberOfFormXObjects(expected: number, page?: number): Promise<this> {
+        const forms = page === undefined ? await this.pdf.selectForms() : await this.pdf.page(page).selectForms();
+        expect(forms.length).toBe(expected);
+        return this;
+    }
+
+    async assertNumberOfFormFields(expected: number, page?: number): Promise<this> {
+        const fields = page === undefined ? await this.pdf.selectFormFields() : await this.pdf.page(page).selectFormFields();
+        expect(fields.length).toBe(expected);
+        return this;
+    }
+
+    async assertParagraphExists(text: string, page = 0): Promise<this> {
+        const paragraphs = await this.pdf.page(page).selectParagraphsStartingWith(text);
+        expect(paragraphs.length).toBeGreaterThan(0);
+        return this;
+    }
+
+    async assertParagraphDoesNotExist(text: string, page = 0): Promise<this> {
+        const paragraphs = await this.pdf.page(page).selectParagraphsStartingWith(text);
+        expect(paragraphs.length).toBe(0);
+        return this;
+    }
+
+    async assertTextlineExists(text: string, page = 0): Promise<this> {
+        const lines = await this.pdf.page(page).selectTextLinesStartingWith(text);
+        expect(lines.length).toBeGreaterThan(0);
+        return this;
+    }
+
+    async assertTextlineDoesNotExist(text: string, page = 0): Promise<this> {
+        const lines = await this.pdf.page(page).selectTextLinesStartingWith(text);
+        expect(lines.length).toBe(0);
+        return this;
+    }
+}

package/src/__tests__/url-builder.test.ts

@@ -0,0 +1,44 @@
+/**
+ * Unit tests for URL building helper
+ */
+
+describe('URL Building', () => {
+    // Helper function to simulate the _buildUrl logic
+    function buildUrl(baseUrl: string, path: string): string {
+        const base = baseUrl.replace(/\/+$/, '');
+        const endpoint = path.replace(/^\/+/, '');
+        return `${base}/${endpoint}`;
+    }
+
+    test('handles base URL with trailing slash', () => {
+        expect(buildUrl('http://localhost:8080/', '/session/create')).toBe('http://localhost:8080/session/create');
+    });
+
+    test('handles base URL without trailing slash', () => {
+        expect(buildUrl('http://localhost:8080', '/session/create')).toBe('http://localhost:8080/session/create');
+    });
+
+    test('handles path without leading slash', () => {
+        expect(buildUrl('http://localhost:8080', 'session/create')).toBe('http://localhost:8080/session/create');
+    });
+
+    test('handles both with slashes', () => {
+        expect(buildUrl('http://localhost:8080/', '/session/create')).toBe('http://localhost:8080/session/create');
+    });
+
+    test('handles neither with slashes', () => {
+        expect(buildUrl('http://localhost:8080', 'session/create')).toBe('http://localhost:8080/session/create');
+    });
+
+    test('handles multiple trailing slashes', () => {
+        expect(buildUrl('http://localhost:8080///', '///session/create')).toBe('http://localhost:8080/session/create');
+    });
+
+    test('handles production URL', () => {
+        expect(buildUrl('https://api.pdfdancer.com/', '/pdf/find')).toBe('https://api.pdfdancer.com/pdf/find');
+    });
+
+    test('handles base URL with path', () => {
+        expect(buildUrl('http://localhost:8080/api/', '/session/create')).toBe('http://localhost:8080/api/session/create');
+    });
+});

package/src/index.ts

@@ -18,6 +18,8 @@ export {
 export {
   ObjectRef,
   FormFieldRef,
+  PageRef,
+  PageSize,
   TextObjectRef,
   Position,
   ObjectType,
@@ -29,7 +31,12 @@ export {
   PositionMode,
   ShapeType,
   Point,
-  StandardFonts
+  StandardFonts,
+  Orientation,
+  CommandResult,
+  TextStatus,
+  FontRecommendation,
+  FontType
 } from './models';
 
 export const VERSION = "1.0.0";