@syncfusion/ej2-pdf 1.0.23 → 23.1.38

package/src/pdf/core/import-export/xml-document.d.ts

@@ -0,0 +1,14 @@
+import { PdfDocument } from './../pdf-document';
+import { _XmlWriter } from './xml-writer';
+import { _ExportHelper } from './xfdf-document';
+export declare class _XmlDocument extends _ExportHelper {
+    constructor(fileName?: string);
+    _exportAnnotations(): Uint8Array;
+    _exportFormFields(document: PdfDocument): Uint8Array;
+    _save(): Uint8Array;
+    _writeFormFieldData(writer: _XmlWriter, isAcrobat?: boolean): void;
+    _importFormData(document: PdfDocument, data: Uint8Array): void;
+    _parseFormData(root: HTMLElement): void;
+    _importField(): void;
+    _checkXml(xmlDocument: Document): void;
+}

package/src/pdf/core/import-export/xml-document.js

@@ -0,0 +1,166 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { _XmlWriter } from './xml-writer';
+import { _bytesToString, _getNewGuidString } from './../utils';
+import { _ExportHelper } from './xfdf-document';
+var _XmlDocument = /** @class */ (function (_super) {
+    __extends(_XmlDocument, _super);
+    function _XmlDocument(fileName) {
+        var _this = _super.call(this) || this;
+        if (fileName !== null && typeof fileName !== 'undefined') {
+            _this._fileName = fileName;
+        }
+        return _this;
+    }
+    _XmlDocument.prototype._exportAnnotations = function () {
+        throw new Error('Method not implemented.');
+    };
+    _XmlDocument.prototype._exportFormFields = function (document) {
+        this._document = document;
+        this._crossReference = document._crossReference;
+        this._isAnnotationExport = false;
+        this._format = 'XML';
+        this._key = _getNewGuidString();
+        return this._save();
+    };
+    _XmlDocument.prototype._save = function () {
+        var writer = new _XmlWriter();
+        writer._writeStartDocument();
+        if (this._asPerSpecification) {
+            writer._writeStartElement('fields');
+            writer._writeAttributeString('xfdf', 'http://ns.adobe.com/xfdf-transition/', 'xmlns', null);
+        }
+        else {
+            writer._writeStartElement('Fields');
+        }
+        var form = this._document.form;
+        if (form !== null && typeof form !== 'undefined') {
+            this._exportEmptyFields = form.exportEmptyFields;
+            var count = this._document.form.count;
+            for (var i = 0; i < count; i++) {
+                var field = this._document.form.fieldAt(i);
+                if (field !== null && typeof field !== 'undefined' && field.export) {
+                    this._exportFormFieldData(field);
+                }
+            }
+            this._writeFormFieldData(writer, this._asPerSpecification);
+        }
+        var result = writer._save();
+        writer._destroy();
+        return result;
+    };
+    _XmlDocument.prototype._writeFormFieldData = function (writer, isAcrobat) {
+        if (isAcrobat === void 0) { isAcrobat = false; }
+        if (isAcrobat) {
+            this._table.forEach(function (value, key) {
+                if (key.includes(' ')) {
+                    var text = key.replace(/ /g, '');
+                    writer._writeStartElement(text.toString());
+                    writer._writeAttributeString('original', key.toString(), 'xfdf', null);
+                }
+                else {
+                    writer._writeStartElement(key.toString());
+                }
+                writer._writeString(value.toString());
+                writer._writeEndElement();
+            });
+        }
+        else {
+            this._table.forEach(function (value, key) {
+                if (key.includes(' ')) {
+                    key = key.replace(/ /g, '_x0020_');
+                }
+                writer._writeStartElement(key.toString());
+                writer._writeString(value.toString());
+                writer._writeEndElement();
+            });
+        }
+        writer._writeEndElement();
+    };
+    _XmlDocument.prototype._importFormData = function (document, data) {
+        this._document = document;
+        this._crossReference = document._crossReference;
+        this._isAnnotationExport = false;
+        var value = _bytesToString(data);
+        value = value.replace(/(\r\n|\n|\r)/gm, '');
+        value = value.replace(/[^\x20-\x7E]/g, '');
+        this._xmlDocument = (new DOMParser()).parseFromString(value, 'text/xml');
+        this._checkXml(this._xmlDocument);
+        this._xmlImport = true;
+        this._parseFormData(this._xmlDocument.documentElement);
+        this._xmlImport = false;
+    };
+    _XmlDocument.prototype._parseFormData = function (root) {
+        var child = root.childNodes;
+        if (child !== null && typeof child !== 'undefined' && child.length > 0) {
+            for (var i = 0; i < child.length; i++) {
+                var childNode = child.item(i);
+                if (childNode !== null && typeof childNode !== 'undefined' && childNode.nodeType === 1) {
+                    var element = childNode;
+                    var text = '';
+                    if (element.attributes !== null && typeof element.attributes !== 'undefined' && element.attributes.length > 0) {
+                        var attribute = element.attributes.item(0); // eslint-disable-line
+                        if (attribute !== null && typeof attribute !== 'undefined' && attribute.name === 'xfdf:original') {
+                            text = attribute.value;
+                        }
+                    }
+                    else {
+                        text = element.tagName;
+                    }
+                    var v = element.textContent;
+                    if (text !== null && text !== undefined && text.length > 0) {
+                        this._table.set(text, v);
+                    }
+                }
+            }
+        }
+        this._importField();
+    };
+    _XmlDocument.prototype._importField = function () {
+        var _this = this;
+        var form = this._document.form;
+        var count = form.count;
+        if (count) {
+            this._table.forEach(function (value, key) {
+                var textValue;
+                if (_this._table.size > 0 && _this._table.has(key)) {
+                    textValue = _this._table.get(key);
+                }
+                var text = key.toString();
+                if (text.indexOf('_x0020_') !== -1) {
+                    text = text.replace(/_x0020_/g, ' ');
+                }
+                var index = form._getFieldIndex(text);
+                if (index !== -1 && index < count) {
+                    var field = form.fieldAt(index);
+                    if (field && field !== null && typeof field !== 'undefined') {
+                        if (textValue && textValue !== '') {
+                            field._dictionary.update('RV', textValue);
+                        }
+                        var param = [];
+                        param.push(value);
+                        _this._importFieldData(field, param);
+                    }
+                }
+            });
+        }
+    };
+    _XmlDocument.prototype._checkXml = function (xmlDocument) {
+        if (xmlDocument.getElementsByTagName('parsererror').length > 0) {
+            throw new Error('Invalid XML file.');
+        }
+    };
+    return _XmlDocument;
+}(_ExportHelper));
+export { _XmlDocument };

package/src/pdf/core/import-export/xml-writer.d.ts

@@ -0,0 +1,69 @@
+export declare type _XmlWriteState = 'Initial' | 'StartDocument' | 'EndDocument' | 'StartElement' | 'EndElement' | 'ElementContent';
+export declare type _NamespaceKind = 'Written' | 'NeedToWrite' | 'Implied' | 'Special';
+export declare class _XmlWriter {
+    _bufferText: string;
+    _buffer: Uint8Array;
+    _currentState: _XmlWriteState;
+    _namespaceStack: _Namespace[];
+    _elementStack: _XmlElement[];
+    _position: number;
+    _attributeStack: _XmlAttribute[];
+    _skipNamespace: boolean;
+    readonly buffer: Uint8Array;
+    constructor(isAppearance?: boolean);
+    _writeStartDocument(standalone?: boolean): void;
+    _writeStartElement(localName: string, prefix?: string, namespace?: string): void;
+    _writeEndElement(): void;
+    _writeElementString(localName: string, value: string, prefix?: string, namespace?: string): void;
+    _writeAttributeString(localName: string, value: string, prefix?: string, namespace?: string): void;
+    _writeString(text: string): void;
+    _writeRaw(text: string): void;
+    _writeInternal(text: string, isRawString: boolean): void;
+    _save(): Uint8Array;
+    _destroy(): void;
+    _flush(): void;
+    _writeStartAttribute(localName: string, value: string, prefix: string, namespace: string): void;
+    _writeStartAttributePrefixAndNameSpace(localName: string, value: string, prefix?: string, namespace?: string): void;
+    _writeStartAttributeSpecialAttribute(prefix: string, localName: string, namespace: string, value: string): void;
+    _writeEndAttribute(): void;
+    _writeStartElementInternal(prefix: string, localName: string, namespace: string): void;
+    _writeEndElementInternal(prefix: string, localName: string): void;
+    _writeStartAttributeInternal(prefix: string, localName: string): void;
+    _writeNamespaceDeclaration(prefix: string, namespaceUri: string): void;
+    _writeStartNamespaceDeclaration(prefix: string): void;
+    _writeStringInternal(text: string, inAttributeValue: boolean): void;
+    _startElementContent(): void;
+    _rawText(text: string): void;
+    _addNamespace(prefix: string, ns: string, kind: _NamespaceKind): void;
+    _lookupPrefix(namespace: string): string;
+    _lookupNamespace(prefix: string): string;
+    _lookupNamespaceIndex(prefix: string): number;
+    _pushNamespaceImplicit(prefix: string, ns: string): void;
+    _pushNamespaceExplicit(prefix: string, ns: string): void;
+    _addAttribute(prefix: string, localName: string, namespaceName: string): void;
+    _skipPushAndWrite(prefix: string, localName: string, namespace: string): void;
+    _checkName(text: string): void;
+}
+export declare class _Namespace {
+    _prefix: string;
+    _namespaceUri: string;
+    _kind: _NamespaceKind;
+    _set(prefix: string, namespaceUri: string, kind: _NamespaceKind): void;
+    _destroy(): void;
+}
+export declare class _XmlElement {
+    _previousTop: number;
+    _prefix: string;
+    _localName: string;
+    _namespaceUri: string;
+    _set(prefix: string, localName: string, namespaceUri: string, previousTop: number): void;
+    _destroy(): void;
+}
+export declare class _XmlAttribute {
+    _prefix: string;
+    _namespaceUri: string;
+    _localName: string;
+    _set(prefix: string, localName: string, namespaceUri: string): void;
+    _isDuplicate(prefix: string, localName: string, namespaceUri: string): boolean;
+    _destroy(): void;
+}