@syncfusion/ej2-pdf 24.2.7 → 24.2.9

package/dist/es6/ej2-pdf.es2015.js

@@ -8906,6 +8906,13 @@ class PdfField {
         this._textAlignment = value;
         this._stringFormat = new PdfStringFormat(value, PdfVerticalAlignment.middle);
     }
+    _parseItems() {
+        const collection = [];
+        for (let i = 0; i < this.itemsCount; i++) {
+            collection.push(this.itemAt(i));
+        }
+        return collection;
+    }
 }
 /**
  * `PdfTextBoxField` class represents the text box field objects.
@@ -39361,18 +39368,24 @@ class _PdfCrossReference {
             }
         }
         let hasRoot = false;
+        let root;
         try {
-            const root = trailerDictionary.get('Root');
-            if (root) {
+            root = trailerDictionary.get('Root');
+        }
+        catch (e) {
+            throw new BaseException('Invalid cross reference', 'XRefParseException');
+        }
+        if (root) {
+            try {
                 const pagesEntry = root.get('Pages');
                 if (pagesEntry) {
                     this._root = root;
                     hasRoot = true;
                 }
             }
-        }
-        catch (ex) {
-            throw new BaseException('Invalid cross reference', 'InvalidXRef');
+            catch (ex) {
+                throw new BaseException('Invalid cross reference', 'InvalidXRef');
+            }
         }
         if (!hasRoot) {
             if (!recoveryMode) {
@@ -40696,7 +40709,7 @@ class PdfForm {
                         for (let i = 0; i < this._fieldCollection.length; i++) {
                             const field = this._fieldCollection[Number.parseInt(i.toString(), 10)];
                             if (field.page) {
-                                const index = _getPageIndex(document, field.page._pageDictionary);
+                                const index = _getPageIndex(document, this._sortItemByPageIndex(field, true)._pageDictionary);
                                 if (index >= 0) {
                                     if (fieldCollection.has(index)) {
                                         value = fieldCollection.get(index);
@@ -40720,16 +40733,18 @@ class PdfForm {
                         let fieldsCount = 0;
                         fieldCollection.forEach((value, key) => {
                             this._tabOrder = this._tabCollection.get(key);
-                            const fields = value;
-                            fields.sort((pdfField1, pdfField2) => {
-                                return this._compareFields(pdfField1, pdfField2);
-                            });
-                            for (let j = 0; j < fields.length; j++) {
-                                const fieldIndex = this._fieldCollection.indexOf(fields[Number.parseInt(j.toString(), 10)]);
-                                if (fieldIndex !== -1 && fieldIndex !== fieldsCount + j) {
-                                    const field = this._fieldCollection[Number.parseInt(fieldIndex.toString(), 10)];
-                                    this._fieldCollection.splice(fieldIndex, 1);
-                                    this._fieldCollection.splice(fieldsCount + j, 0, field);
+                            if (this._tabOrder !== PdfFormFieldsTabOrder.structure) {
+                                const fields = value;
+                                fields.sort((pdfField1, pdfField2) => {
+                                    return this._compareFields(pdfField1, pdfField2);
+                                });
+                                for (let j = 0; j < fields.length; j++) {
+                                    const fieldIndex = this._fieldCollection.indexOf(fields[Number.parseInt(j.toString(), 10)]);
+                                    if (fieldIndex !== -1 && fieldIndex !== fieldsCount + j) {
+                                        const field = this._fieldCollection[Number.parseInt(fieldIndex.toString(), 10)];
+                                        this._fieldCollection.splice(fieldIndex, 1);
+                                        this._fieldCollection.splice(fieldsCount + j, 0, field);
+                                    }
                                 }
                             }
                             fieldsCount += value.length;
@@ -40968,10 +40983,24 @@ class PdfForm {
         const page1 = field1.page;
         const page2 = field2.page;
         if (page1 && page1 instanceof PdfPage && page2 && page2 instanceof PdfPage) {
-            const page1Index = page1._pageIndex;
-            const page2Index = page2._pageIndex;
-            const rectangle1 = this._getRectangle(field1._dictionary);
-            const rectangle2 = this._getRectangle(field2._dictionary);
+            const page1Index = this._sortItemByPageIndex(field1, false)._pageIndex;
+            const page2Index = this._sortItemByPageIndex(field2, false)._pageIndex;
+            let rectangle1;
+            if (field1._dictionary.has('Kids')) {
+                rectangle1 = this._getItemRectangle(field1);
+            }
+            else {
+                rectangle1 = this._getRectangle(field1._dictionary);
+            }
+            let rectangle2;
+            if (field2._dictionary.has('Kids')) {
+                rectangle2 = this._getItemRectangle(field2);
+            }
+            else {
+                rectangle2 = this._getRectangle(field2._dictionary);
+            }
+            const firstHeight = rectangle1[3] - rectangle1[1];
+            const secondHeight = rectangle2[3] - rectangle2[1];
             if (rectangle1 && rectangle1.length >= 2 && rectangle2 && rectangle2.length >= 2) {
                 const x1 = rectangle1[0];
                 const y1 = rectangle1[1];
@@ -40982,6 +41011,13 @@ class PdfForm {
                     index = page1Index - page2Index;
                     if (this._tabOrder === PdfFormFieldsTabOrder.row) {
                         xdiff = this._compare(y2, y1);
+                        if (xdiff !== 0) {
+                            let isValid = xdiff === -1 && y1 > y2 && (y1 - firstHeight / 2) < y2;
+                            isValid = isValid || (xdiff === 1 && y2 > y1 && (y2 - secondHeight / 2) < y1);
+                            if (isValid) {
+                                xdiff = 0;
+                            }
+                        }
                         if (index !== 0) {
                             result = index;
                         }
@@ -41024,27 +41060,32 @@ class PdfForm {
         return result;
     }
     _getRectangle(dictionary) {
+        let rect;
         if (dictionary.has('Rect')) {
-            const rect = dictionary.get('Rect');
-            if (rect) {
-                return rect;
-            }
+            rect = dictionary.getArray('Rect');
         }
-        else {
-            if (dictionary.has('Kids')) {
-                const kidsArray = dictionary.get('Kids');
-                if (kidsArray) {
-                    if (kidsArray.length > 1) {
-                        kidsArray.sort((x, y) => {
-                            return this._compareKidsElement(x, y);
-                        });
+        return rect;
+    }
+    _getItemRectangle(field) {
+        let result;
+        const dictionary = field._dictionary;
+        if (dictionary.has('Kids')) {
+            const kids = dictionary.getArray('Kids');
+            if (kids && kids.length >= 1) {
+                if (kids.length === 1) {
+                    result = this._getRectangle(kids[0]);
+                }
+                else {
+                    if (field && field.itemsCount > 1) {
+                        result = this._getRectangle(field.itemAt(0)._dictionary);
+                    }
+                    else {
+                        result = this._getRectangle(kids[0]);
                     }
-                    const dictionary = this._crossReference._fetch(kidsArray[0]);
-                    return this._getRectangle(dictionary);
                 }
             }
         }
-        return null;
+        return result;
     }
     _compare(x, y) {
         if (x > y) {
@@ -41062,6 +41103,7 @@ class PdfForm {
         const yDictionary = this._crossReference._fetch(y);
         const xRect = this._getRectangle(xDictionary);
         const yRect = this._getRectangle(yDictionary);
+        let result;
         if (xRect && xRect.length >= 2 && yRect && yRect.length >= 2) {
             const x1 = xRect[0];
             const y1 = xRect[1];
@@ -41069,7 +41111,6 @@ class PdfForm {
             const y2 = yRect[1];
             if (typeof x1 === 'number' && typeof x2 === 'number' &&
                 typeof y1 === 'number' && typeof y2 === 'number') {
-                let result = 0;
                 let xdiff;
                 if (this._tabOrder === PdfFormFieldsTabOrder.row) {
                     xdiff = this._compare(y2, y1);
@@ -41089,10 +41130,89 @@ class PdfForm {
                         result = this._compare(y2, y1);
                     }
                 }
+                else {
+                    result = 0;
+                }
                 return result;
             }
         }
-        return null;
+        return result;
+    }
+    _sortItemByPageIndex(field, hasPageTabOrder) {
+        let page = field.page;
+        const tabOrder = this._tabOrder;
+        this._tabOrder = hasPageTabOrder ? field.page.tabOrder : tabOrder;
+        this._sortFieldItems(field);
+        if (field._isLoaded && field._kidsCount > 1) {
+            page = field.itemAt(0).page;
+        }
+        this._tabOrder = tabOrder;
+        if (typeof page === 'undefined') {
+            page = field.page;
+        }
+        return page;
+    }
+    _sortFieldItems(field) {
+        if (field._isLoaded && (field instanceof PdfTextBoxField ||
+            field instanceof PdfListBoxField ||
+            field instanceof PdfCheckBoxField ||
+            field instanceof PdfRadioButtonListField)) {
+            const collection = field._parseItems(); // eslint-disable-line
+            collection.sort((item1, item2) => {
+                return this._compareFieldItem(item1, item2);
+            });
+            field._parsedItems.clear();
+            for (let i = 0; i < collection.length; i++) {
+                field._parsedItems.set(i, collection[Number.parseInt(i.toString(), 10)]);
+            }
+        }
+    }
+    _compareFieldItem(item1, item2) {
+        let result = 0;
+        if (typeof item1 !== 'undefined' && typeof item2 !== 'undefined') {
+            const page1 = item1.page;
+            const page2 = item2.page;
+            const array1 = this._getRectangle(item1._dictionary);
+            const array2 = this._getRectangle(item2._dictionary);
+            if (array1 && array2) {
+                const x1 = array1[0];
+                const y1 = array1[1];
+                const x2 = array2[0];
+                const y2 = array2[1];
+                let xdiff;
+                if (this._tabOrder === PdfFormFieldsTabOrder.row) {
+                    xdiff = this._compare(page1._pageIndex, page2._pageIndex);
+                    if (xdiff !== 0) {
+                        result = xdiff;
+                    }
+                    else {
+                        xdiff = this._compare(y2, y1);
+                        if (xdiff !== 0) {
+                            result = xdiff;
+                        }
+                        else {
+                            result = this._compare(x1, x2);
+                        }
+                    }
+                }
+                else if (this._tabOrder === PdfFormFieldsTabOrder.column) {
+                    xdiff = this._compare(page1._pageIndex, page2._pageIndex);
+                    if (xdiff !== 0) {
+                        result = xdiff;
+                    }
+                    else {
+                        xdiff = this._compare(x1, x2);
+                        if (xdiff !== 0) {
+                            result = xdiff;
+                        }
+                        else {
+                            result = this._compare(y2, y1);
+                        }
+                    }
+                }
+            }
+        }
+        return result;
     }
     _clear() {
         this._fields = [];