pdfdancer-client-typescript 1.0.4 → 1.0.6

package/dist/pdfdancer_v1.js

@@ -0,0 +1,702 @@
+"use strict";
+/**
+ * PDFDancer TypeScript Client V1
+ *
+ * A TypeScript client that provides session-based PDF manipulation operations with strict validation.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PDFDancer = void 0;
+const exceptions_1 = require("./exceptions");
+const models_1 = require("./models");
+const paragraph_builder_1 = require("./paragraph-builder");
+const types_1 = require("./types");
+const image_builder_1 = require("./image-builder");
+const fs_1 = __importDefault(require("fs"));
+class PageClient {
+    constructor(client, pageIndex) {
+        this.type = models_1.ObjectType.PAGE;
+        this._client = client;
+        this._pageIndex = pageIndex;
+        this.internalId = `PAGE-${this._pageIndex}`;
+        this.position = models_1.Position.atPage(this._pageIndex);
+        // Cast to the internal interface to get access
+        this._internals = this._client;
+    }
+    async selectPathsAt(x, y) {
+        return this._internals.toPathObjects(await this._internals.findPaths(models_1.Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+    async selectImages() {
+        return this._internals.toImageObjects(await this._internals._findImages(models_1.Position.atPage(this._pageIndex)));
+    }
+    async selectImagesAt(x, y) {
+        return this._internals.toImageObjects(await this._internals._findImages(models_1.Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+    async delete() {
+        return this._internals.deletePage(this.ref());
+    }
+    ref() {
+        return new models_1.ObjectRef(this.internalId, this.position, this.type);
+    }
+    // noinspection JSUnusedGlobalSymbols
+    async selectForms() {
+        return this._internals.toFormXObjects(await this._internals.findFormXObjects(models_1.Position.atPage(this._pageIndex)));
+    }
+    async selectFormsAt(x, y) {
+        return this._internals.toFormXObjects(await this._internals.findFormXObjects(models_1.Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+    async selectFormFields() {
+        return this._internals.toFormFields(await this._internals.findFormFields(models_1.Position.atPage(this._pageIndex)));
+    }
+    async selectFormFieldsAt(x, y) {
+        return this._internals.toFormFields(await this._internals.findFormFields(models_1.Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+    // noinspection JSUnusedGlobalSymbols
+    async selectFormFieldsByName(fieldName) {
+        let pos = models_1.Position.atPage(this._pageIndex);
+        pos.name = fieldName;
+        return this._internals.toFormFields(await this._internals.findFormFields(pos));
+    }
+    async selectParagraphs() {
+        return this._internals.toParagraphObjects(await this._internals.findParagraphs(models_1.Position.atPage(this._pageIndex)));
+    }
+    async selectParagraphsStartingWith(text) {
+        let pos = models_1.Position.atPage(this._pageIndex);
+        pos.textStartsWith = text;
+        return this._internals.toParagraphObjects(await this._internals.findParagraphs(pos));
+    }
+    async selectParagraphsMatching(pattern) {
+        let pos = models_1.Position.atPage(this._pageIndex);
+        pos.textPattern = pattern;
+        return this._internals.toParagraphObjects(await this._internals.findParagraphs(pos));
+    }
+    async selectParagraphsAt(x, y) {
+        return this._internals.toParagraphObjects(await this._internals.findParagraphs(models_1.Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+    async selectTextLinesStartingWith(text) {
+        let pos = models_1.Position.atPage(this._pageIndex);
+        pos.textStartsWith = text;
+        return this._internals.toTextLineObjects(await this._internals.findTextLines(pos));
+    }
+    /**
+     * Creates a new ParagraphBuilder for fluent paragraph construction.
+     */
+    newParagraph() {
+        return new paragraph_builder_1.ParagraphBuilder(this._client, this.position.pageIndex);
+    }
+    async selectTextLines() {
+        return this._internals.toTextLineObjects(await this._internals.findTextLines(models_1.Position.atPage(this._pageIndex)));
+    }
+    // noinspection JSUnusedGlobalSymbols
+    async selectTextLinesMatching(pattern) {
+        let pos = models_1.Position.atPage(this._pageIndex);
+        pos.textPattern = pattern;
+        return this._internals.toTextLineObjects(await this._internals.findTextLines(pos));
+    }
+    // noinspection JSUnusedGlobalSymbols
+    async selectTextLinesAt(x, y) {
+        return this._internals.toTextLineObjects(await this._internals.findTextLines(models_1.Position.atPageCoordinates(this._pageIndex, x, y)));
+    }
+}
+// noinspection ExceptionCaughtLocallyJS,JSUnusedLocalSymbols
+/**
+ * REST API client for interacting with the PDFDancer PDF manipulation service.
+ * This client provides a convenient TypeScript interface for performing PDF operations
+ * including session management, object searching, manipulation, and retrieval.
+ * Handles authentication, session lifecycle, and HTTP communication transparently.
+ *
+ */
+class PDFDancer {
+    /**
+     * Creates a new client with PDF data.
+     * This constructor initializes the client, uploads the PDF data to open
+     * a new session, and prepares the client for PDF manipulation operations.
+     */
+    constructor(token, pdfData, baseUrl = "http://localhost:8080", readTimeout = 30000) {
+        if (!token || !token.trim()) {
+            throw new exceptions_1.ValidationException("Authentication token cannot be null or empty");
+        }
+        this._token = token.trim();
+        this._baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+        this._readTimeout = readTimeout;
+        // Process PDF data with validation
+        this._pdfBytes = this._processPdfData(pdfData);
+    }
+    /**
+     * Initialize the client by creating a session.
+     * Must be called after constructor before using the client.
+     */
+    async init() {
+        this._sessionId = await this._createSession();
+        return this;
+    }
+    static async open(pdfData, token, baseUrl, timeout) {
+        const resolvedToken = token ?? process.env.PDFDANCER_TOKEN;
+        const resolvedBaseUrl = baseUrl ??
+            process.env.PDFDANCER_BASE_URL ??
+            "https://api.pdfdancer.com";
+        const resolvedTimeout = timeout ?? 30000;
+        if (!resolvedToken) {
+            throw new Error("Missing PDFDancer token (pass it explicitly or set PDFDANCER_TOKEN in environment).");
+        }
+        const client = new PDFDancer(resolvedToken, pdfData, resolvedBaseUrl, resolvedTimeout);
+        return await client.init();
+    }
+    /**
+     * Process PDF data from various input types with strict validation.
+     */
+    _processPdfData(pdfData) {
+        if (!pdfData) {
+            throw new exceptions_1.ValidationException("PDF data cannot be null");
+        }
+        try {
+            if (pdfData instanceof Uint8Array) {
+                if (pdfData.length === 0) {
+                    throw new exceptions_1.ValidationException("PDF data cannot be empty");
+                }
+                return pdfData;
+            }
+            else if (pdfData instanceof ArrayBuffer) {
+                const uint8Array = new Uint8Array(pdfData);
+                if (uint8Array.length === 0) {
+                    throw new exceptions_1.ValidationException("PDF data cannot be empty");
+                }
+                return uint8Array;
+            }
+            else if (pdfData instanceof File) {
+                // Note: File reading will be handled asynchronously in the session creation
+                return new Uint8Array(); // Placeholder, will be replaced in _createSession
+            }
+            else {
+                throw new exceptions_1.ValidationException(`Unsupported PDF data type: ${typeof pdfData}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof exceptions_1.ValidationException) {
+                throw error;
+            }
+            throw new exceptions_1.PdfDancerException(`Failed to process PDF data: ${error}`, error);
+        }
+    }
+    /**
+     * Extract meaningful error messages from API response.
+     * Parses JSON error responses with _embedded.errors structure.
+     */
+    async _extractErrorMessage(response) {
+        if (!response) {
+            return "Unknown error";
+        }
+        try {
+            const errorData = await response.json();
+            // Check for embedded errors structure
+            if (errorData._embedded?.errors) {
+                const errors = errorData._embedded.errors;
+                if (Array.isArray(errors)) {
+                    const messages = errors
+                        .filter(error => error.message)
+                        .map(error => error.message);
+                    if (messages.length > 0) {
+                        return messages.join("; ");
+                    }
+                }
+            }
+            // Check for top-level message
+            if (errorData.message) {
+                return errorData.message;
+            }
+            // Fallback to response text or status
+            return await response.text() || `HTTP ${response.status}`;
+        }
+        catch {
+            // If JSON parsing fails, return response text or status
+            try {
+                return await response.text() || `HTTP ${response.status}`;
+            }
+            catch {
+                return `HTTP ${response.status}`;
+            }
+        }
+    }
+    /**
+     * Creates a new PDF processing session by uploading the PDF data.
+     */
+    async _createSession() {
+        try {
+            const formData = new FormData();
+            // Handle File objects by reading their content
+            if (this._pdfBytes instanceof File) {
+                formData.append('pdf', this._pdfBytes, 'document.pdf');
+            }
+            else {
+                const blob = new Blob([this._pdfBytes.buffer], { type: 'application/pdf' });
+                formData.append('pdf', blob, 'document.pdf');
+            }
+            const response = await fetch(`${this._baseUrl}/session/create`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this._token}`
+                },
+                body: formData,
+                signal: this._readTimeout > 0 ? AbortSignal.timeout(this._readTimeout) : undefined
+            });
+            if (!response.ok) {
+                const errorMessage = await this._extractErrorMessage(response);
+                throw new exceptions_1.HttpClientException(`Failed to create session: ${errorMessage}`, response);
+            }
+            const sessionId = (await response.text()).trim();
+            if (!sessionId) {
+                throw new exceptions_1.SessionException("Server returned empty session ID");
+            }
+            return sessionId;
+        }
+        catch (error) {
+            if (error instanceof exceptions_1.HttpClientException || error instanceof exceptions_1.SessionException) {
+                throw error;
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new exceptions_1.HttpClientException(`Failed to create session: ${errorMessage}`, undefined, error);
+        }
+    }
+    /**
+     * Make HTTP request with session headers and error handling.
+     */
+    async _makeRequest(method, path, data, params) {
+        const url = new URL(`${this._baseUrl}${path}`);
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                url.searchParams.append(key, value);
+            });
+        }
+        const headers = {
+            'Authorization': `Bearer ${this._token}`,
+            'X-Session-Id': this._sessionId,
+            'Content-Type': 'application/json'
+        };
+        try {
+            const response = await fetch(url.toString(), {
+                method,
+                headers,
+                body: data ? JSON.stringify(data) : undefined,
+                signal: this._readTimeout > 0 ? AbortSignal.timeout(this._readTimeout) : undefined
+            });
+            // Handle FontNotFoundException
+            if (response.status === 404) {
+                try {
+                    const errorData = await response.json();
+                    if (errorData.error === 'FontNotFoundException') {
+                        throw new exceptions_1.FontNotFoundException(errorData.message || 'Font not found');
+                    }
+                }
+                catch (e) {
+                    if (e instanceof exceptions_1.FontNotFoundException) {
+                        throw e;
+                    }
+                    // Continue with normal error handling if JSON parsing fails
+                }
+            }
+            if (!response.ok) {
+                const errorMessage = await this._extractErrorMessage(response);
+                throw new exceptions_1.HttpClientException(`API request failed: ${errorMessage}`, response);
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof exceptions_1.FontNotFoundException || error instanceof exceptions_1.HttpClientException) {
+                throw error;
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new exceptions_1.HttpClientException(`API request failed: ${errorMessage}`, undefined, error);
+        }
+    }
+    // Search Operations
+    /**
+     * Searches for PDF objects matching the specified criteria.
+     * This method provides flexible search capabilities across all PDF content,
+     * allowing filtering by object type and position constraints.
+     */
+    async find(objectType, position) {
+        const requestData = new models_1.FindRequest(objectType, position).toDict();
+        const response = await this._makeRequest('POST', '/pdf/find', requestData);
+        const objectsData = await response.json();
+        return objectsData.map((objData) => this._parseObjectRef(objData));
+    }
+    /**
+     * Searches for paragraph objects at the specified position.
+     */
+    async findParagraphs(position) {
+        return this.find(models_1.ObjectType.PARAGRAPH, position);
+    }
+    /**
+     * Searches for image objects at the specified position.
+     */
+    async _findImages(position) {
+        return this.find(models_1.ObjectType.IMAGE, position);
+    }
+    async selectImages() {
+        return this.toImageObjects(await this.find(models_1.ObjectType.IMAGE));
+    }
+    /**
+     * Searches for form X objects at the specified position.
+     */
+    async findFormXObjects(position) {
+        return this.find(models_1.ObjectType.FORM_X_OBJECT, position);
+    }
+    /**
+     * Searches for vector path objects at the specified position.
+     */
+    async findPaths(position) {
+        return this.find(models_1.ObjectType.PATH, position);
+    }
+    async selectPaths() {
+        return this.toPathObjects(await this.find(models_1.ObjectType.PATH));
+    }
+    async selectForms() {
+        return this.toFormXObjects(await this.find(models_1.ObjectType.FORM_X_OBJECT));
+    }
+    async selectFormFields() {
+        return this.toFormFields(await this.findFormFields());
+    }
+    async selectFieldsByName(fieldName) {
+        return this.toFormFields(await this.findFormFields(models_1.Position.byName(fieldName)));
+    }
+    /**
+     * Searches for text line objects at the specified position.
+     */
+    async findTextLines(position) {
+        return this.find(models_1.ObjectType.TEXT_LINE, position);
+    }
+    /**
+     * Searches for form fields at the specified position.
+     * Returns FormFieldRef objects with name and value properties.
+     */
+    async findFormFields(position) {
+        const requestData = new models_1.FindRequest(models_1.ObjectType.FORM_FIELD, position).toDict();
+        const response = await this._makeRequest('POST', '/pdf/find', requestData);
+        const objectsData = await response.json();
+        return objectsData.map((objData) => this._parseFormFieldRef(objData));
+    }
+    // Page Operations
+    /**
+     * Retrieves references to all pages in the PDF document.
+     */
+    async getPages() {
+        const response = await this._makeRequest('POST', '/pdf/page/find');
+        const pagesData = await response.json();
+        return pagesData.map((pageData) => this._parseObjectRef(pageData));
+    }
+    /**
+     * Retrieves a reference to a specific page by its page index.
+     */
+    async _getPage(pageIndex) {
+        if (pageIndex < 0) {
+            throw new exceptions_1.ValidationException(`Page index must be >= 0, got ${pageIndex}`);
+        }
+        const params = { pageIndex: pageIndex.toString() };
+        const response = await this._makeRequest('POST', '/pdf/page/find', undefined, params);
+        const pagesData = await response.json();
+        if (!pagesData || pagesData.length === 0) {
+            return null;
+        }
+        return this._parseObjectRef(pagesData[0]);
+    }
+    /**
+     * Deletes a page from the PDF document.
+     */
+    async deletePage(pageRef) {
+        if (!pageRef) {
+            throw new exceptions_1.ValidationException("Page reference cannot be null");
+        }
+        const requestData = pageRef.toDict();
+        const response = await this._makeRequest('DELETE', '/pdf/page/delete', requestData);
+        return await response.json();
+    }
+    // Manipulation Operations
+    /**
+     * Deletes the specified PDF object from the document.
+     */
+    async delete(objectRef) {
+        if (!objectRef) {
+            throw new exceptions_1.ValidationException("Object reference cannot be null");
+        }
+        const requestData = new models_1.DeleteRequest(objectRef).toDict();
+        const response = await this._makeRequest('DELETE', '/pdf/delete', requestData);
+        return await response.json();
+    }
+    /**
+     * Moves a PDF object to a new position within the document.
+     */
+    async move(objectRef, position) {
+        if (!objectRef) {
+            throw new exceptions_1.ValidationException("Object reference cannot be null");
+        }
+        if (!position) {
+            throw new exceptions_1.ValidationException("Position cannot be null");
+        }
+        const requestData = new models_1.MoveRequest(objectRef, position).toDict();
+        const response = await this._makeRequest('PUT', '/pdf/move', requestData);
+        return await response.json();
+    }
+    /**
+     * Changes the value of a form field.
+     */
+    async changeFormField(formFieldRef, newValue) {
+        if (!formFieldRef) {
+            throw new exceptions_1.ValidationException("Form field reference cannot be null");
+        }
+        const requestData = new models_1.ChangeFormFieldRequest(formFieldRef, newValue).toDict();
+        const response = await this._makeRequest('PUT', '/pdf/modify/formField', requestData);
+        return await response.json();
+    }
+    // Add Operations
+    /**
+     * Adds an image to the PDF document.
+     */
+    async addImage(image, position) {
+        if (!image) {
+            throw new exceptions_1.ValidationException("Image cannot be null");
+        }
+        if (position) {
+            image.setPosition(position);
+        }
+        if (!image.getPosition()) {
+            throw new exceptions_1.ValidationException("Image position is null");
+        }
+        return this._addObject(image);
+    }
+    /**
+     * Adds a paragraph to the PDF document.
+     */
+    async addParagraph(paragraph) {
+        if (!paragraph) {
+            throw new exceptions_1.ValidationException("Paragraph cannot be null");
+        }
+        if (!paragraph.getPosition()) {
+            throw new exceptions_1.ValidationException("Paragraph position is null");
+        }
+        if (paragraph.getPosition().pageIndex === undefined) {
+            throw new exceptions_1.ValidationException("Paragraph position page index is null");
+        }
+        if (paragraph.getPosition().pageIndex < 0) {
+            throw new exceptions_1.ValidationException("Paragraph position page index is less than 0");
+        }
+        return this._addObject(paragraph);
+    }
+    /**
+     * Internal method to add any PDF object.
+     */
+    async _addObject(pdfObject) {
+        const requestData = new models_1.AddRequest(pdfObject).toDict();
+        const response = await this._makeRequest('POST', '/pdf/add', requestData);
+        return await response.json();
+    }
+    // Modify Operations
+    /**
+     * Modifies a paragraph object or its text content.
+     */
+    async modifyParagraph(objectRef, newParagraph) {
+        if (!objectRef) {
+            throw new exceptions_1.ValidationException("Object reference cannot be null");
+        }
+        if (newParagraph === null || newParagraph === undefined) {
+            throw new exceptions_1.ValidationException("New paragraph cannot be null");
+        }
+        if (typeof newParagraph === 'string') {
+            // Text modification
+            const requestData = new models_1.ModifyTextRequest(objectRef, newParagraph).toDict();
+            const response = await this._makeRequest('PUT', '/pdf/text/paragraph', requestData);
+            return await response.json();
+        }
+        else {
+            // Object modification
+            const requestData = new models_1.ModifyRequest(objectRef, newParagraph).toDict();
+            const response = await this._makeRequest('PUT', '/pdf/modify', requestData);
+            return await response.json();
+        }
+    }
+    /**
+     * Modifies a text line object.
+     */
+    async modifyTextLine(objectRef, newText) {
+        if (!objectRef) {
+            throw new exceptions_1.ValidationException("Object reference cannot be null");
+        }
+        if (newText === null || newText === undefined) {
+            throw new exceptions_1.ValidationException("New text cannot be null");
+        }
+        const requestData = new models_1.ModifyTextRequest(objectRef, newText).toDict();
+        const response = await this._makeRequest('PUT', '/pdf/text/line', requestData);
+        return await response.json();
+    }
+    // Font Operations
+    /**
+     * Finds available fonts matching the specified name and size.
+     */
+    async findFonts(fontName, fontSize) {
+        if (!fontName || !fontName.trim()) {
+            throw new exceptions_1.ValidationException("Font name cannot be null or empty");
+        }
+        if (fontSize <= 0) {
+            throw new exceptions_1.ValidationException(`Font size must be positive, got ${fontSize}`);
+        }
+        const params = { fontName: fontName.trim() };
+        const response = await this._makeRequest('GET', '/font/find', undefined, params);
+        const fontNames = await response.json();
+        return fontNames.map((name) => new models_1.Font(name, fontSize));
+    }
+    /**
+     * Registers a custom font for use in PDF operations.
+     */
+    async registerFont(ttfFile) {
+        if (!ttfFile) {
+            throw new exceptions_1.ValidationException("TTF file cannot be null");
+        }
+        try {
+            let fontData;
+            let filename;
+            if (ttfFile instanceof Uint8Array) {
+                if (ttfFile.length === 0) {
+                    throw new exceptions_1.ValidationException("Font data cannot be empty");
+                }
+                fontData = ttfFile;
+                filename = 'font.ttf';
+            }
+            else if (ttfFile instanceof File) {
+                if (ttfFile.size === 0) {
+                    throw new exceptions_1.ValidationException("Font file is empty");
+                }
+                fontData = new Uint8Array(await ttfFile.arrayBuffer());
+                filename = ttfFile.name;
+            }
+            else {
+                throw new exceptions_1.ValidationException(`Unsupported font file type: ${typeof ttfFile}`);
+            }
+            // Upload font file
+            const formData = new FormData();
+            const blob = new Blob([fontData.buffer], { type: 'font/ttf' });
+            formData.append('ttfFile', blob, filename);
+            const response = await fetch(`${this._baseUrl}/font/register`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this._token}`,
+                    'X-Session-Id': this._sessionId
+                },
+                body: formData,
+                signal: AbortSignal.timeout(30000)
+            });
+            if (!response.ok) {
+                const errorMessage = await this._extractErrorMessage(response);
+                throw new exceptions_1.HttpClientException(`Font registration failed: ${errorMessage}`, response);
+            }
+            return (await response.text()).trim();
+        }
+        catch (error) {
+            if (error instanceof exceptions_1.ValidationException || error instanceof exceptions_1.HttpClientException) {
+                throw error;
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new exceptions_1.PdfDancerException(`Failed to read font file: ${errorMessage}`, error);
+        }
+    }
+    // Document Operations
+    /**
+     * Downloads the current state of the PDF document with all modifications applied.
+     */
+    async getPdfFile() {
+        const response = await this._makeRequest('GET', `/session/${this._sessionId}/pdf`);
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    /**
+     * Saves the current PDF to a file (browser environment).
+     * Downloads the PDF in the browser.
+     */
+    async save(filename) {
+        if (!filename) {
+            throw new exceptions_1.ValidationException("Filename cannot be null or empty");
+        }
+        try {
+            const pdfData = await this.getPdfFile();
+            fs_1.default.writeFileSync(filename, pdfData);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new exceptions_1.PdfDancerException(`Failed to save PDF file: ${errorMessage}`, error);
+        }
+    }
+    // Utility Methods
+    /**
+     * Parse JSON object data into ObjectRef instance.
+     */
+    _parseObjectRef(objData) {
+        const positionData = objData.position || {};
+        const position = positionData ? this._parsePosition(positionData) : new models_1.Position();
+        const objectType = objData.type;
+        return new models_1.ObjectRef(objData.internalId, position, objectType);
+    }
+    _parseFormFieldRef(objData) {
+        const positionData = objData.position || {};
+        const position = positionData ? this._parsePosition(positionData) : new models_1.Position();
+        const objectType = objData.type;
+        return new models_1.FormFieldRef(objData.internalId, position, objectType, objData.name || undefined, objData.value !== undefined ? objData.value : null);
+    }
+    /**
+     * Parse JSON position data into Position instance.
+     */
+    _parsePosition(posData) {
+        const position = new models_1.Position();
+        position.pageIndex = posData.pageIndex;
+        position.textStartsWith = posData.textStartsWith;
+        if (posData.shape) {
+            position.shape = models_1.ShapeType[posData.shape];
+        }
+        if (posData.mode) {
+            position.mode = models_1.PositionMode[posData.mode];
+        }
+        if (posData.boundingRect) {
+            const rectData = posData.boundingRect;
+            position.boundingRect = new models_1.BoundingRect(rectData.x, rectData.y, rectData.width, rectData.height);
+        }
+        return position;
+    }
+    // Builder Pattern Support
+    toPathObjects(objectRefs) {
+        return objectRefs.map(ref => types_1.PathObject.fromRef(this, ref));
+    }
+    toFormXObjects(objectRefs) {
+        return objectRefs.map(ref => types_1.FormXObject.fromRef(this, ref));
+    }
+    toImageObjects(objectRefs) {
+        return objectRefs.map(ref => types_1.ImageObject.fromRef(this, ref));
+    }
+    newImage() {
+        return new image_builder_1.ImageBuilder(this);
+    }
+    page(pageIndex) {
+        if (pageIndex < 0) {
+            throw new exceptions_1.ValidationException(`Page index must be >= 0, got ${pageIndex}`);
+        }
+        return new PageClient(this, pageIndex);
+    }
+    async pages() {
+        let pageRefs = await this.getPages();
+        return pageRefs.map((_, pageIndex) => new PageClient(this, pageIndex));
+    }
+    toFormFields(objectRefs) {
+        return objectRefs.map(ref => types_1.FormFieldObject.fromRef(this, ref));
+    }
+    async selectParagraphs() {
+        return this.toParagraphObjects(await this.findParagraphs());
+    }
+    toParagraphObjects(objectRefs) {
+        return objectRefs.map(ref => types_1.ParagraphObject.fromRef(this, ref));
+    }
+    toTextLineObjects(objectRefs) {
+        return objectRefs.map(ref => types_1.TextLineObject.fromRef(this, ref));
+    }
+    async selectLines() {
+        return this.toTextLineObjects(await this.findTextLines());
+    }
+}
+exports.PDFDancer = PDFDancer;
+//# sourceMappingURL=pdfdancer_v1.js.map