pdfdancer-client-typescript 1.0.12 → 1.0.13

package/dist/paragraph-builder.js

@@ -6,36 +6,111 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParagraphBuilder = void 0;
 const exceptions_1 = require("./exceptions");
 const models_1 = require("./models");
+const DEFAULT_LINE_SPACING_FACTOR = 1.2;
+const DEFAULT_BASE_FONT_SIZE = 12;
+const cloneColor = (color) => {
+    if (!color) {
+        return undefined;
+    }
+    return new models_1.Color(color.r, color.g, color.b, color.a);
+};
+const clonePosition = (position) => {
+    return position ? position.copy() : undefined;
+};
+const defaultTextColor = () => new models_1.Color(0, 0, 0);
 /**
  * Builder class for constructing Paragraph objects with fluent interface.
+ * Aligns with the Python client's ParagraphBuilder behaviour.
  */
 class ParagraphBuilder {
     constructor(_client, objectRefOrPageIndex) {
         this._client = _client;
-        this.objectRefOrPageIndex = objectRefOrPageIndex;
+        this._fontExplicitlyChanged = false;
+        this._positionChanged = false;
         this._pending = [];
         this._registeringFont = false;
         if (!_client) {
             throw new exceptions_1.ValidationException("Client cannot be null");
         }
-        this._pageIndex = objectRefOrPageIndex instanceof models_1.ObjectRef ? objectRefOrPageIndex.position.pageIndex : objectRefOrPageIndex;
         this._paragraph = new models_1.Paragraph();
-        // Cast to the internal interface to get access
         this._internals = this._client;
+        if (objectRefOrPageIndex instanceof models_1.TextObjectRef) {
+            this.target(objectRefOrPageIndex);
+        }
+        else if (typeof objectRefOrPageIndex === 'number') {
+            this._pageIndex = objectRefOrPageIndex;
+        }
+    }
+    static fromObjectRef(client, objectRef) {
+        if (!objectRef) {
+            throw new exceptions_1.ValidationException("Object reference cannot be null");
+        }
+        const builder = new ParagraphBuilder(client, objectRef);
+        builder.target(objectRef);
+        builder.setOriginalParagraphPosition(objectRef.position);
+        if (objectRef.lineSpacings) {
+            builder._paragraph.setLineSpacings(objectRef.lineSpacings);
+            const [firstSpacing] = objectRef.lineSpacings;
+            if (firstSpacing !== undefined) {
+                builder._paragraph.lineSpacing = firstSpacing;
+            }
+        }
+        if (objectRef.fontName && objectRef.fontSize) {
+            builder._originalFont = new models_1.Font(objectRef.fontName, objectRef.fontSize);
+        }
+        if (objectRef.color) {
+            builder._originalColor = cloneColor(objectRef.color);
+        }
+        if (objectRef.children && objectRef.children.length > 0) {
+            objectRef.children.forEach(child => builder.addTextLine(child));
+        }
+        else if (objectRef.text) {
+            builder._splitText(objectRef.text).forEach(segment => builder.addTextLine(segment));
+        }
+        return builder;
+    }
+    setFontExplicitlyChanged(changed) {
+        this._fontExplicitlyChanged = !!changed;
+    }
+    setOriginalParagraphPosition(position) {
+        this._originalParagraphPosition = clonePosition(position);
+        if (position && !this._paragraph.getPosition()) {
+            this._paragraph.setPosition(clonePosition(position));
+        }
+        if (position?.pageIndex !== undefined) {
+            this._pageIndex = position.pageIndex;
+        }
+    }
+    target(objectRef) {
+        if (!objectRef) {
+            throw new exceptions_1.ValidationException("Object reference cannot be null");
+        }
+        this._targetObjectRef = objectRef;
+        if (objectRef.position) {
+            this.setOriginalParagraphPosition(objectRef.position);
+        }
+        if (objectRef.position?.pageIndex !== undefined) {
+            this._pageIndex = objectRef.position.pageIndex;
+        }
+        return this;
+    }
+    onlyTextChanged() {
+        return (this._text !== undefined &&
+            this._textColor === undefined &&
+            this._ttfSource === undefined &&
+            (this._font === undefined || !this._fontExplicitlyChanged) &&
+            this._lineSpacingFactor === undefined);
     }
-    /**
-     * Set the text content for the paragraph.
-     */
     replace(text, color) {
+        return this.text(text, color);
+    }
+    text(text, color) {
         if (text === null || text === undefined) {
             throw new exceptions_1.ValidationException("Text cannot be null");
         }
-        if (!text.trim()) {
-            throw new exceptions_1.ValidationException("Text cannot be empty");
-        }
         this._text = text;
         if (color) {
-            this._textColor = color;
+            this.color(color);
         }
         return this;
     }
@@ -52,37 +127,36 @@ class ParagraphBuilder {
             }
             this._font = new models_1.Font(fontOrName, fontSize);
         }
+        this._fontExplicitlyChanged = true;
         return this;
     }
-    /**
-     * Set the font for the paragraph using a TTF file.
-     */
     fontFile(ttfFile, fontSize) {
-        if (!ttfFile)
+        if (!ttfFile) {
             throw new exceptions_1.ValidationException("TTF file cannot be null");
+        }
         if (fontSize <= 0) {
             throw new exceptions_1.ValidationException(`Font size must be positive, got ${fontSize}`);
         }
+        this._ttfSource = ttfFile;
         this._registeringFont = true;
-        const job = this._registerTtf(ttfFile, fontSize).then(font => {
+        const job = this._registerTtf(ttfFile, fontSize)
+            .then(font => {
             this._font = font;
+            this._fontExplicitlyChanged = true;
+        })
+            .finally(() => {
+            this._registeringFont = false;
         });
         this._pending.push(job);
         return this;
     }
-    /**
-     * Set the line spacing for the paragraph.
-     */
     lineSpacing(spacing) {
         if (spacing <= 0) {
             throw new exceptions_1.ValidationException(`Line spacing must be positive, got ${spacing}`);
         }
-        this._lineSpacing = spacing;
+        this._lineSpacingFactor = spacing;
         return this;
     }
-    /**
-     * Set the text color for the paragraph.
-     */
     color(color) {
         if (!color) {
             throw new exceptions_1.ValidationException("Color cannot be null");
@@ -90,154 +164,353 @@ class ParagraphBuilder {
         this._textColor = color;
         return this;
     }
-    /**
-     * Set the position for the paragraph.
-     */
     moveTo(x, y) {
         if (x === null || x === undefined || y === null || y === undefined) {
             throw new exceptions_1.ValidationException("Coordinates cannot be null or undefined");
         }
-        this._position = models_1.Position.atPageCoordinates(this._pageIndex, x, y);
-        this._paragraph.setPosition(this._position);
+        let position = this._paragraph.getPosition();
+        if (!position && this._targetObjectRef?.position) {
+            position = clonePosition(this._targetObjectRef.position);
+        }
+        const pageIndex = position?.pageIndex ?? this._pageIndex;
+        if (pageIndex === undefined) {
+            throw new exceptions_1.ValidationException("Paragraph position must include a page index to move");
+        }
+        this._paragraph.setPosition(models_1.Position.atPageCoordinates(pageIndex, x, y));
+        this._positionChanged = true;
         return this;
     }
-    /**
-     * Build and return the final Paragraph object.
-     */
-    build() {
-        // Validate required fields
-        if (!this._text) {
-            throw new exceptions_1.ValidationException("Text must be set before building paragraph");
-        }
-        // Set paragraph properties
-        this._paragraph.font = this._font;
-        this._paragraph.color = this._textColor ?? new models_1.Color(0, 0, 0);
-        this._paragraph.lineSpacing = this._lineSpacing ?? 1.2; // Default 1.2 like Python
-        // Process text into lines
-        this._paragraph.textLines = this._processTextLines(this._text);
-        return this._paragraph;
+    atPosition(position) {
+        if (!position) {
+            throw new exceptions_1.ValidationException("Position cannot be null");
+        }
+        this._paragraph.setPosition(clonePosition(position));
+        this._positionChanged = true;
+        if (position.pageIndex !== undefined) {
+            this._pageIndex = position.pageIndex;
+        }
+        return this;
+    }
+    at(pageIndexOrX, xOrY, maybeY) {
+        if (maybeY === undefined) {
+            const pageIndex = this._pageIndex ?? this._paragraph.getPosition()?.pageIndex;
+            if (pageIndex === undefined) {
+                throw new exceptions_1.ValidationException("Page index must be provided before calling at(x, y)");
+            }
+            return this._setPosition(pageIndex, pageIndexOrX, xOrY);
+        }
+        return this._setPosition(pageIndexOrX, xOrY, maybeY);
+    }
+    _setPosition(pageIndex, x, y) {
+        this._pageIndex = pageIndex;
+        return this.atPosition(models_1.Position.atPageCoordinates(pageIndex, x, y));
+    }
+    addTextLine(textLine) {
+        this._paragraph.addLine(this._coerceTextLine(textLine));
+        return this;
+    }
+    getText() {
+        return this._text;
     }
-    // Python-style getter methods that preserve original values if not explicitly set
-    _getLineSpacing(originalRef) {
-        if (this._lineSpacing !== undefined) {
-            return this._lineSpacing;
+    async add() {
+        await this._prepareAsync();
+        if (this._targetObjectRef) {
+            throw new exceptions_1.ValidationException("Target object reference provided; use modify() for updates");
         }
-        else if (originalRef.lineSpacings && originalRef.lineSpacings.length > 0) {
-            // Calculate average like Python does
-            const sum = originalRef.lineSpacings.reduce((a, b) => a + b, 0);
-            return sum / originalRef.lineSpacings.length;
+        const paragraph = this._finalizeParagraph();
+        return this._internals.addParagraph(paragraph);
+    }
+    async modify(objectRef) {
+        await this._prepareAsync();
+        const target = objectRef ?? this._targetObjectRef;
+        if (!target) {
+            throw new exceptions_1.ValidationException("Object reference must be provided to modify a paragraph");
         }
-        else {
-            return 1.2; // DEFAULT_LINE_SPACING
+        if (this.onlyTextChanged()) {
+            const result = await this._internals.modifyParagraph(target, this._text ?? '');
+            return this._withWarning(result);
         }
+        const paragraph = this._finalizeParagraph();
+        const result = await this._internals.modifyParagraph(target, paragraph);
+        return this._withWarning(result);
     }
-    _getFont(originalRef) {
-        if (this._font) {
-            return this._font;
+    async apply() {
+        await this._prepareAsync();
+        if (this._targetObjectRef) {
+            return this.modify(this._targetObjectRef);
+        }
+        return this.add();
+    }
+    async _prepareAsync() {
+        if (this._pending.length) {
+            await Promise.all(this._pending);
+            this._pending = [];
         }
-        else if (originalRef.fontName && originalRef.fontSize) {
-            return new models_1.Font(originalRef.fontName, originalRef.fontSize);
+        if (this._registeringFont) {
+            throw new exceptions_1.ValidationException("Font registration is not complete");
         }
-        else {
-            throw new exceptions_1.ValidationException("Font is required");
+    }
+    _withWarning(result) {
+        if (result && result.warning) {
+            process.stderr.write(`WARNING: ${result.warning}\n`);
         }
+        return result;
     }
-    _getColor(originalRef) {
+    _finalizeParagraph() {
+        const position = this._paragraph.getPosition();
+        if (!position) {
+            throw new exceptions_1.ValidationException("Paragraph position is null, you need to specify a position for the new paragraph, using .at(x,y)");
+        }
+        if (!this._targetObjectRef && !this._font && !this._paragraph.font) {
+            throw new exceptions_1.ValidationException("Font must be set before building paragraph");
+        }
+        if (this._text !== undefined) {
+            this._finalizeLinesFromText();
+        }
+        else if (!this._paragraph.textLines || this._paragraph.textLines.length === 0) {
+            throw new exceptions_1.ValidationException("Either text must be provided or existing lines supplied");
+        }
+        else {
+            this._finalizeExistingLines();
+        }
+        this._repositionLines();
+        const shouldSkipLines = (this._positionChanged &&
+            this._text === undefined &&
+            this._textColor === undefined &&
+            (this._font === undefined || !this._fontExplicitlyChanged) &&
+            this._lineSpacingFactor === undefined);
+        if (shouldSkipLines) {
+            this._paragraph.textLines = undefined;
+            this._paragraph.setLineSpacings(null);
+        }
+        let finalFont = this._font ?? this._paragraph.font ?? this._originalFont;
+        if (!finalFont) {
+            finalFont = new models_1.Font(models_1.StandardFonts.HELVETICA, DEFAULT_BASE_FONT_SIZE);
+        }
+        this._paragraph.font = finalFont;
+        let finalColor;
         if (this._textColor) {
-            return this._textColor;
+            finalColor = cloneColor(this._textColor);
         }
-        else if (originalRef.color) {
-            return originalRef.color;
+        else if (this._text !== undefined) {
+            finalColor = cloneColor(this._originalColor) ?? defaultTextColor();
         }
         else {
-            return new models_1.Color(0, 0, 0); // DEFAULT_COLOR
+            finalColor = cloneColor(this._originalColor);
         }
+        this._paragraph.color = finalColor;
+        return this._paragraph;
     }
-    /**
-     * Register a TTF font with the client and return a Font object.
-     */
-    async _registerTtf(ttfFile, fontSize) {
-        try {
-            const fontName = await this._client.registerFont(ttfFile);
-            return new models_1.Font(fontName, fontSize);
+    _finalizeLinesFromText() {
+        const baseFont = this._font ?? this._originalFont;
+        const baseColor = this._textColor ?? cloneColor(this._originalColor) ?? defaultTextColor();
+        let spacing;
+        if (this._lineSpacingFactor !== undefined) {
+            spacing = this._lineSpacingFactor;
         }
-        catch (error) {
-            throw new exceptions_1.ValidationException(`Failed to register font file: ${error}`);
+        else {
+            const existingSpacings = this._paragraph.getLineSpacings();
+            if (existingSpacings && existingSpacings.length > 0) {
+                spacing = existingSpacings[0];
+            }
+            else if (this._paragraph.lineSpacing !== undefined && this._paragraph.lineSpacing !== null) {
+                spacing = this._paragraph.lineSpacing;
+            }
+            else {
+                spacing = DEFAULT_LINE_SPACING_FACTOR;
+            }
         }
+        this._paragraph.clearLines();
+        const lines = [];
+        this._splitText(this._text ?? '').forEach((lineText, index) => {
+            const linePosition = this._calculateLinePosition(index, spacing);
+            lines.push(new models_1.TextLine(linePosition, baseFont, cloneColor(baseColor), spacing, lineText));
+        });
+        this._paragraph.setLines(lines);
+        if (lines.length > 1) {
+            this._paragraph.setLineSpacings(Array(lines.length - 1).fill(spacing));
+        }
+        else {
+            this._paragraph.setLineSpacings(null);
+        }
+        this._paragraph.lineSpacing = spacing;
     }
-    /**
-     * Process text into lines for the paragraph.
-     * This is a simplified version - the full implementation would handle
-     * word wrapping, line breaks, and other text formatting based on the font
-     * and paragraph width.
-     */
-    _processTextLines(text) {
-        // Handle escaped newlines (\\n) as actual newlines
-        const processedText = text.replace(/\\\\n/g, '\n');
-        // Simple implementation - split on newlines
-        // In the full version, this would implement proper text layout
-        let lines = processedText.split('\n');
-        // Remove empty lines at the end but preserve intentional line breaks
-        while (lines.length > 0 && !lines[lines.length - 1].trim()) {
-            lines.pop();
-        }
-        // Ensure at least one line
-        if (lines.length === 0) {
-            lines = [''];
-        }
-        return lines;
-    }
-    async apply() {
-        // Wait for all deferred operations (e.g., fontFile, images, etc.)
-        if (this._pending.length) {
-            await Promise.all(this._pending);
-            this._pending = []; // reset if builder is reusable
+    _finalizeExistingLines() {
+        const lines = this._paragraph.getLines();
+        const spacingOverride = this._lineSpacingFactor;
+        let spacingForCalc = spacingOverride;
+        if (spacingForCalc === undefined) {
+            const existingSpacings = this._paragraph.getLineSpacings();
+            if (existingSpacings && existingSpacings.length > 0) {
+                spacingForCalc = existingSpacings[0];
+            }
         }
-        if (this._registeringFont && !this._font) {
-            throw new exceptions_1.ValidationException("Font registration is not complete");
+        if (spacingForCalc === undefined) {
+            spacingForCalc = this._paragraph.lineSpacing ?? DEFAULT_LINE_SPACING_FACTOR;
         }
-        if (this.objectRefOrPageIndex instanceof models_1.TextObjectRef) {
-            // Modifying existing paragraph - match Python's ParagraphEdit.apply() logic
-            const originalRef = this.objectRefOrPageIndex;
-            // Python logic: if ONLY text is being changed (all other properties are None), use simple text modification
-            if (this._position === undefined &&
-                this._lineSpacing === undefined &&
-                this._font === undefined &&
-                this._textColor === undefined) {
-                // Simple text-only modification
-                const result = await this._internals.modifyParagraph(originalRef, this._text);
-                if (result.warning) {
-                    process.stderr.write(`WARNING: ${result.warning}\n`);
+        const updatedLines = [];
+        lines.forEach((line, index) => {
+            if (line instanceof models_1.TextLine) {
+                if (spacingOverride !== undefined) {
+                    line.lineSpacing = spacingOverride;
+                }
+                if (this._textColor) {
+                    line.color = cloneColor(this._textColor);
                 }
-                return result;
+                if (this._font && this._fontExplicitlyChanged) {
+                    line.font = this._font;
+                }
+                updatedLines.push(line);
+            }
+            else {
+                const linePosition = this._calculateLinePosition(index, spacingForCalc);
+                updatedLines.push(new models_1.TextLine(linePosition, this._font ?? this._originalFont, this._textColor ?? cloneColor(this._originalColor) ?? defaultTextColor(), spacingOverride ?? spacingForCalc, String(line)));
+            }
+        });
+        this._paragraph.setLines(updatedLines);
+        if (spacingOverride !== undefined) {
+            if (updatedLines.length > 1) {
+                this._paragraph.setLineSpacings(Array(updatedLines.length - 1).fill(spacingOverride));
             }
             else {
-                // Full paragraph modification - build new paragraph using getter methods to preserve original values
-                const newParagraph = new models_1.Paragraph();
-                newParagraph.position = this._position ?? originalRef.position;
-                newParagraph.lineSpacing = this._getLineSpacing(originalRef);
-                newParagraph.font = this._getFont(originalRef);
-                newParagraph.textLines = this._text ? this._processTextLines(this._text) : this._processTextLines(originalRef.text);
-                newParagraph.color = this._getColor(originalRef);
-                const result = await this._internals.modifyParagraph(originalRef, newParagraph);
-                if (result.warning) {
-                    process.stderr.write(`WARNING: ${result.warning}\n`);
+                this._paragraph.setLineSpacings(null);
+            }
+            this._paragraph.lineSpacing = spacingOverride;
+        }
+    }
+    _repositionLines() {
+        if (this._text !== undefined) {
+            return;
+        }
+        const paragraphPos = this._paragraph.getPosition();
+        const lines = this._paragraph.textLines;
+        if (!paragraphPos || !lines || lines.length === 0) {
+            return;
+        }
+        let basePosition = this._originalParagraphPosition;
+        if (!basePosition) {
+            for (const line of lines) {
+                if (line instanceof models_1.TextLine && line.position) {
+                    basePosition = line.position;
+                    break;
                 }
-                return result;
             }
         }
-        else {
-            // Adding new paragraph
-            let paragraph = this.build();
-            return await this._internals.addParagraph(paragraph);
+        if (!basePosition) {
+            return;
+        }
+        const targetX = paragraphPos.getX();
+        const targetY = paragraphPos.getY();
+        const baseX = basePosition.getX();
+        const baseY = basePosition.getY();
+        if (targetX === undefined || targetY === undefined || baseX === undefined || baseY === undefined) {
+            return;
+        }
+        const dx = targetX - baseX;
+        const dy = targetY - baseY;
+        if (dx === 0 && dy === 0) {
+            return;
+        }
+        lines.forEach(line => {
+            if (line instanceof models_1.TextLine && line.position) {
+                const currentX = line.position.getX();
+                const currentY = line.position.getY();
+                if (currentX === undefined || currentY === undefined) {
+                    return;
+                }
+                const updatedPosition = line.position.copy();
+                updatedPosition.atCoordinates({ x: currentX + dx, y: currentY + dy });
+                line.setPosition(updatedPosition);
+            }
+        });
+    }
+    _coerceTextLine(source) {
+        if (source instanceof models_1.TextLine) {
+            return source;
+        }
+        if (source instanceof models_1.TextObjectRef) {
+            let font;
+            if (source.fontName && source.fontSize) {
+                font = new models_1.Font(source.fontName, source.fontSize);
+            }
+            else if (source.children) {
+                for (const child of source.children) {
+                    if (child.fontName && child.fontSize) {
+                        font = new models_1.Font(child.fontName, child.fontSize);
+                        break;
+                    }
+                }
+            }
+            if (!font) {
+                font = this._originalFont;
+            }
+            let spacing = this._lineSpacingFactor;
+            if (spacing === undefined && source.lineSpacings && source.lineSpacings.length > 0) {
+                spacing = source.lineSpacings[0];
+            }
+            if (spacing === undefined) {
+                spacing = this._paragraph.lineSpacing ?? DEFAULT_LINE_SPACING_FACTOR;
+            }
+            const color = source.color ?? this._originalColor;
+            if (!this._originalFont && font) {
+                this._originalFont = font;
+            }
+            if (!this._originalColor && color) {
+                this._originalColor = color;
+            }
+            return new models_1.TextLine(clonePosition(source.position), font, cloneColor(color), spacing, source.text ?? '');
         }
+        const currentIndex = this._paragraph.getLines().length;
+        const spacing = this._lineSpacingFactor ?? this._paragraph.lineSpacing ?? DEFAULT_LINE_SPACING_FACTOR;
+        const linePosition = this._calculateLinePosition(currentIndex, spacing);
+        return new models_1.TextLine(linePosition, this._font ?? this._originalFont, this._textColor ?? cloneColor(this._originalColor) ?? defaultTextColor(), spacing, source);
     }
-    text(text) {
-        this._text = text;
-        return this;
+    _splitText(text) {
+        const processed = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\\n/g, '\n');
+        const parts = processed.split('\n');
+        while (parts.length > 0 && parts[parts.length - 1] === '') {
+            parts.pop();
+        }
+        if (parts.length === 0) {
+            parts.push('');
+        }
+        return parts;
     }
-    at(x, y) {
-        return this.moveTo(x, y);
+    _calculateLinePosition(lineIndex, spacingFactor) {
+        const paragraphPosition = this._paragraph.getPosition();
+        if (!paragraphPosition) {
+            return undefined;
+        }
+        const pageIndex = paragraphPosition.pageIndex;
+        const baseX = paragraphPosition.getX();
+        const baseY = paragraphPosition.getY();
+        if (pageIndex === undefined || baseX === undefined || baseY === undefined) {
+            return undefined;
+        }
+        const offset = lineIndex * this._calculateBaselineDistance(spacingFactor);
+        return models_1.Position.atPageCoordinates(pageIndex, baseX, baseY + offset);
+    }
+    _calculateBaselineDistance(spacingFactor) {
+        const factor = spacingFactor > 0 ? spacingFactor : DEFAULT_LINE_SPACING_FACTOR;
+        return this._baselineFontSize() * factor;
+    }
+    _baselineFontSize() {
+        if (this._font?.size) {
+            return this._font.size;
+        }
+        if (this._originalFont?.size) {
+            return this._originalFont.size;
+        }
+        return DEFAULT_BASE_FONT_SIZE;
+    }
+    async _registerTtf(ttfFile, fontSize) {
+        try {
+            const fontName = await this._client.registerFont(ttfFile);
+            return new models_1.Font(fontName, fontSize);
+        }
+        catch (error) {
+            throw new exceptions_1.ValidationException(`Failed to register font file: ${error}`);
+        }
     }
 }
 exports.ParagraphBuilder = ParagraphBuilder;