@syncfusion/ej2-pdf-export 21.2.10 → 22.1.34

package/dist/ts/implementation/document/automatic-fields/pdf-numbers-convertor.ts

@@ -0,0 +1,157 @@
+/**
+ * PdfNumbersConvertor.ts class for EJ2-PDF
+ * @private
+ */
+import { PdfNumberStyle } from './../../pages/enum';
+/**
+ * `PdfNumbersConvertor` for convert page number into numbers, roman letters, etc.,
+ * @private
+ */
+export class PdfNumbersConvertor {
+    // Fields
+    /**
+     * numbers of letters in english [readonly].
+     * @default = 26.0
+     * @private
+     */
+    private static readonly letterLimit : number = 26.0;
+    /**
+     * Resturns `acsii start index` value.
+     * @default 64
+     * @private
+     */
+    private static readonly acsiiStartIndex : number = <number>(65 - 1);
+    // Static methods
+    /**
+     * Convert string value from page number with correct format.
+     * @private
+     */
+    public static convert(intArabic : number, numberStyle : PdfNumberStyle) : string {
+        let result : string = '';
+        switch (numberStyle) {
+            case PdfNumberStyle.None:
+                result = '';
+                break;
+            case PdfNumberStyle.Numeric:
+                result = intArabic.toString();
+                break;
+            case PdfNumberStyle.LowerLatin:
+                result = this.arabicToLetter(intArabic).toLowerCase();
+                break;
+            case PdfNumberStyle.LowerRoman:
+                result = this.arabicToRoman(intArabic).toLowerCase();
+                break;
+            case PdfNumberStyle.UpperLatin:
+                result = this.arabicToLetter(intArabic);
+                break;
+            case PdfNumberStyle.UpperRoman:
+                result = this.arabicToRoman(intArabic);
+                break;
+        }
+        return result;
+    }
+    /**
+     * Converts `arabic to roman` letters.
+     * @private
+     */
+    private static arabicToRoman(intArabic : number) : string {
+        let retval : string = '';
+        let retvalM : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 1000, 'M');
+        retval += retvalM.returnValue;
+        intArabic = retvalM.intArabic;
+        let retvalCM : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 900, 'CM');
+        retval += retvalCM.returnValue;
+        intArabic = retvalCM.intArabic;
+        let retvalD : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 500, 'D');
+        retval += retvalD.returnValue;
+        intArabic = retvalD.intArabic;
+        let retvalCD : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 400, 'CD');
+        retval += retvalCD.returnValue;
+        intArabic = retvalCD.intArabic;
+        let retvalC : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 100, 'C');
+        retval += retvalC.returnValue;
+        intArabic = retvalC.intArabic;
+        let retvalXC : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 90, 'XC');
+        retval += retvalXC.returnValue;
+        intArabic = retvalXC.intArabic;
+        let retvalL : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 50, 'L');
+        retval += retvalL.returnValue;
+        intArabic = retvalL.intArabic;
+        let retvalXL : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 40, 'XL');
+        retval += retvalXL.returnValue;
+        intArabic = retvalXL.intArabic;
+        let retvalX : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 10, 'X');
+        retval += retvalX.returnValue;
+        intArabic = retvalX.intArabic;
+        let retvalIX : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 9, 'IX');
+        retval += retvalIX.returnValue;
+        intArabic = retvalIX.intArabic;
+        let retvalV : {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 5, 'V');
+        retval += retvalV.returnValue;
+        intArabic = retvalV.intArabic;
+        let retvalIV: {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 4, 'IV');
+        retval += retvalIV.returnValue;
+        intArabic = retvalIV.intArabic;
+        let retvalI: {returnValue : string , intArabic : number } = this.generateNumber(intArabic, 1, 'I');
+        retval += retvalI.returnValue;
+        intArabic = retvalI.intArabic;
+
+        return retval.toString();
+    }
+    /**
+     * Converts `arabic to normal letters`.
+     * @private
+     */
+    private static arabicToLetter(arabic : number) : string {
+        let stack : number[] = this.convertToLetter(arabic);
+        let result : string = '';
+        while (stack.length > 0) {
+            let num : number = stack.pop();
+            result = this.appendChar(result, num);
+        }
+        return result.toString();
+    }
+    /**
+     * Generate a string value of an input number.
+     * @private
+     */
+    private static generateNumber(value : number, magnitude : number, letter : string) : { returnValue : string, intArabic : number } {
+        let numberstring : string = '';
+        while (value >= magnitude) {
+            value -= magnitude;
+            numberstring += letter;
+        }
+        return {returnValue : numberstring.toString(), intArabic : value };
+    }
+    /**
+     * Convert a input number into letters.
+     * @private
+     */
+    private static convertToLetter(arabic : number) : number[] {
+        if (arabic <= 0) {
+            throw Error('ArgumentOutOfRangeException-arabic, Value can not be less 0');
+        }
+        let stack : number[] = [];
+        while ((arabic as number) > this.letterLimit) {
+            let remainder : number = arabic % this.letterLimit;
+            if (remainder === 0.0) {
+                arabic = arabic / this.letterLimit - 1;
+                remainder = this.letterLimit;
+            } else {
+                arabic /= this.letterLimit;
+            }
+            stack.push(remainder as number);
+        }
+        stack.push(arabic as number);
+        return stack;
+    }
+    /**
+     * Convert number to actual string value.
+     * @private
+     */
+    private static appendChar(builder : string, value : number) : string {
+        let letter : string = String.fromCharCode(PdfNumbersConvertor.acsiiStartIndex + value);
+        builder += letter;
+        return builder;
+    }
+}

package/dist/ts/implementation/document/automatic-fields/pdf-page-number-field.ts

@@ -0,0 +1,82 @@
+/**
+ * PdfPageNumberField.ts class for EJ2-PDF
+ */
+import { PdfFont } from './../../graphics/fonts/pdf-font';
+import { PdfBrush } from './../../graphics/brushes/pdf-brush';
+import { PdfPage } from './../../pages/pdf-page';
+import { PdfGraphics } from './../../graphics/pdf-graphics';
+import { PdfDocument } from './../pdf-document';
+import { RectangleF } from './../../drawing/pdf-drawing';
+import { PdfNumberStyle } from './../../pages/enum';
+import { PdfNumbersConvertor } from './pdf-numbers-convertor';
+import { PdfMultipleValueField } from './multiple-value-field';
+/**
+ * Represents PDF document `page number field`.
+ * @public
+ */
+export class PdfPageNumberField extends  PdfMultipleValueField {
+    // Constructors
+    /**
+     * Initialize a new instance for page number field.
+     * @public
+     */
+    public constructor(font : PdfFont)
+    /**
+     * Initialize a new instance for page number field.
+     * @public
+     */
+    public constructor(font : PdfFont, bounds : RectangleF)
+    /**
+     * Initialize a new instance for page number field.
+     * @public
+     */
+    public constructor(font : PdfFont, brush: PdfBrush)
+    public constructor(font : PdfFont, arg2 ?: RectangleF|PdfBrush) {
+        super();
+        if (typeof arg2 === 'undefined') {
+            this.font = font;
+        } else if ( arg2 instanceof PdfBrush) {
+            this.font = font;
+            this.brush = arg2;
+        } else {
+            this.font = font;
+            this.bounds = arg2;
+        }
+    }
+    // Fields
+    /**
+     * Stores the number style of the page number field.
+     * @private
+     */
+    private internalNumberStyle : PdfNumberStyle = PdfNumberStyle.Numeric;
+    // Properties
+    /**
+     * Gets and sets the number style of the page number field.
+     * @private
+     */
+    public get numberStyle() : PdfNumberStyle {
+        return this.internalNumberStyle;
+    }
+    public set numberStyle(value : PdfNumberStyle) {
+        this.internalNumberStyle = value;
+    }
+    /**
+     * Return the `string` value of page number field.
+     * @public
+     */
+    public getValue(graphics : PdfGraphics) : string {
+        let result : string = null;
+        let page : PdfPage = this.getPageFromGraphics(graphics);
+        result = this.internalGetValue(page);
+        return result;
+    }
+    /**
+     * Internal method to `get actual value of page number`.
+     * @private
+     */
+    protected internalGetValue(page : PdfPage) : string {
+        let document : PdfDocument = page.document;
+        let pageIndex : number = document.pages.indexOf(page) + 1;
+        return PdfNumbersConvertor.convert(pageIndex, this.numberStyle);
+    }
+}

package/dist/ts/implementation/document/automatic-fields/pdf-template-value-pair.ts

@@ -0,0 +1,60 @@
+/**
+ * PdfTemplateValuePair.ts class for EJ2-PDF
+ * @private
+ */
+import { PdfTemplate } from './../../graphics/figures/pdf-template';
+/**
+ * Represent class to store information about `template and value pairs`.
+ * @private
+ */
+export class PdfTemplateValuePair {
+    // Fields
+    /**
+     * Internal variable to store template.
+     * @default null
+     * @private
+     */
+    private pdfTemplate : PdfTemplate = null;
+    /**
+     * Intenal variable to store value.
+     * @private
+     */
+    private content : string = '';
+
+    // Constructors
+    /**
+     * Initializes a new instance of the 'PdfTemplateValuePair' class.
+     * @private
+     */
+    public constructor()
+    public constructor(template : PdfTemplate, value : string)
+    public constructor(template ?: PdfTemplate, value ?: string) {
+        if (typeof template === 'undefined') {
+            //
+        } else {
+            this.template = template;
+            this.value = value;
+        }
+    }
+    // Properties
+    /**
+     * Gets or sets the template.
+     * @private
+     */
+    public get template() : PdfTemplate {
+        return this.pdfTemplate;
+    }
+    public set template(value : PdfTemplate) {
+        this.pdfTemplate = value;
+    }
+    /**
+     * Gets or sets the value.
+     * @private
+     */
+    public get value() : string {
+        return this.content;
+    }
+    public set value(value : string) {
+        this.content = value;
+    }
+}

package/dist/ts/implementation/document/automatic-fields/single-value-field.ts

@@ -0,0 +1,48 @@
+/**
+ * PdfSingleValueField.ts class for EJ2-PDF
+ */
+import { PdfAutomaticField } from './automatic-field';
+import { PdfGraphics } from './../../graphics/pdf-graphics';
+import { TemporaryDictionary } from './../../collections/object-object-pair/dictionary';
+import { PdfTemplateValuePair } from './pdf-template-value-pair';
+import { PdfDocumentBase } from './../pdf-document-base';
+import { PdfDocument } from './../pdf-document';
+import { PdfPage } from './../../pages/pdf-page';
+import { PointF, SizeF} from './../../drawing/pdf-drawing';
+import { PdfTemplate } from './../../graphics/figures/pdf-template';
+/**
+ * Represents automatic field which has the same value in the whole document.
+ */
+export abstract class PdfSingleValueField extends PdfAutomaticField {
+    // Fields
+    /* tslint:disable */
+    private list : TemporaryDictionary<PdfDocumentBase, PdfTemplateValuePair> = new TemporaryDictionary<PdfDocumentBase, PdfTemplateValuePair>();
+    /* tslint:enable */
+    private painterGraphics : PdfGraphics[] = [];
+    // Constructors
+    public constructor() {
+        super();
+    }
+    public performDraw(graphics : PdfGraphics, location : PointF, scalingX : number, scalingY : number) : void {
+        super.performDrawHelper(graphics, location, scalingX, scalingY);
+        let page : PdfPage = this.getPageFromGraphics(graphics);
+        let document : PdfDocument = page.document;
+        let textValue : string = this.getValue(graphics);
+        /* tslint:disable */
+        if (this.list.containsKey(document)) {
+            let pair : PdfTemplateValuePair = this.list.getValue(document) as PdfTemplateValuePair;
+            let drawLocation : PointF = new PointF(location.x + this.location.x, location.y + this.location.y);
+            graphics.drawPdfTemplate(pair.template, drawLocation, new SizeF(pair.template.width * scalingX, pair.template.height * scalingY));
+            this.painterGraphics.push(graphics);
+        } else {
+            let size : SizeF = this.getSize();
+            let template : PdfTemplate = new PdfTemplate(size);
+            this.list.setValue(document, new PdfTemplateValuePair(template, textValue));
+            template.graphics.drawString(textValue, this.getFont(), this.pen, this.getBrush(), 0, 0, size.width, size.height, this.stringFormat);
+            let drawLocation : PointF = new PointF(location.x + this.location.x, location.y + this.location.y);
+            graphics.drawPdfTemplate(template, drawLocation, new SizeF(template.width * scalingX, template.height * scalingY));
+            this.painterGraphics.push(graphics);
+        }
+        /* tslint:enable */
+    }
+}

package/dist/ts/implementation/document/pdf-catalog.ts

@@ -0,0 +1,52 @@
+/**
+ * PdfCatalog.ts class for EJ2-PDF
+ */
+import { PdfDictionary } from './../primitives/pdf-dictionary';
+import { PdfSectionCollection } from './../pages/pdf-section-collection';
+import { DictionaryProperties } from './../input-output/pdf-dictionary-properties';
+import { PdfName } from './../primitives/pdf-name';
+import { PdfReferenceHolder } from './../primitives/pdf-reference';
+/**
+ * `PdfCatalog` class represents internal catalog of the Pdf document.
+ * @private
+ */
+export class PdfCatalog extends PdfDictionary {
+    //fields
+    /**
+     * Internal variable to store collection of `sections`.
+     * @default null
+     * @private
+     */
+    private sections : PdfSectionCollection = null;
+    /**
+     * Internal variable for accessing fields from `DictionryProperties` class.
+     * @private
+     */
+    private tempDictionaryProperties : DictionaryProperties = new DictionaryProperties();
+    //constructor
+    /**
+     * Initializes a new instance of the `PdfCatalog` class.
+     * @private
+     */
+    public constructor() {
+        super();
+        this.items.setValue(new DictionaryProperties().type, new PdfName('Catalog'));
+    }
+    //Properties
+    /**
+     * Gets or sets the sections, which contain `pages`.
+     * @private
+     */
+    public get pages() : PdfSectionCollection {
+        return this.sections;
+    }
+    public set pages(value : PdfSectionCollection) {
+        let dictionary : PdfDictionary = value.element as PdfDictionary;
+        // if (this.sections !== value) {
+        //     this.sections = value;
+        //     this.Items.setValue(this.tempDictionaryProperties.pages, new PdfReferenceHolder(value));
+        // }
+        this.sections = value;
+        this.items.setValue(this.tempDictionaryProperties.pages, new PdfReferenceHolder(value));
+    }
+}

package/dist/ts/implementation/document/pdf-document-base.ts

@@ -0,0 +1,166 @@
+/**
+ * PdfDocumentBase.ts class for EJ2-PDF
+ */
+import { PdfMainObjectCollection } from './../input-output/pdf-main-object-collection';
+import { PdfCrossTable } from './../input-output/pdf-cross-table';
+import { PdfCatalog } from './pdf-catalog';
+import { StreamWriter } from '@syncfusion/ej2-file-utils';
+import { Encoding } from '@syncfusion/ej2-file-utils';
+import { PdfDocument } from './pdf-document';
+import { PdfReference } from './../primitives/pdf-reference';
+/**
+ * `PdfDocumentBase` class represent common properties of PdfDocument classes.
+ * @private
+ */
+export class PdfDocumentBase {
+    //Fields
+    /**
+     * Collection of the main `objects`.
+     * @private
+     */
+    private objects : PdfMainObjectCollection;
+    /**
+     * The `cross table`.
+     * @private
+     */
+    private pdfCrossTable : PdfCrossTable;
+    /**
+     * `Object` that is saving currently.
+     * @private
+     */
+    private currentSavingObject : PdfReference;
+    /**
+     * Document `catlog`.
+     * @private
+     */
+    private pdfCatalog : PdfCatalog;
+    /**
+     * If the stream is copied,  then it specifies true.
+     * @private
+     */
+    public isStreamCopied : boolean = false;
+    /**
+     * Instance of parent `document`.
+     * @private
+     */
+    public document : PdfDocument;
+    //constructor
+    /**
+     * Initializes a new instance of the `PdfDocumentBase` class.
+     * @private
+     */
+    public constructor()
+    /**
+     * Initializes a new instance of the `PdfDocumentBase` class with instance of PdfDocument as argument.
+     * @private
+     */
+    public constructor(document : PdfDocument)
+    public constructor(document? : PdfDocument) {
+        if (document instanceof PdfDocument) {
+            this.document = document;
+        }
+    }
+    //Prpperties
+    /**
+     * Gets the `PDF objects` collection, which stores all objects and references to it..
+     * @private
+     */
+    public get pdfObjects() : PdfMainObjectCollection {
+        return this.objects;
+    }
+    /**
+     * Gets the `cross-reference` table.
+     * @private
+     */
+    public get crossTable() : PdfCrossTable {
+        return this.pdfCrossTable;
+    }
+    /**
+     * Gets or sets the current saving `object number`.
+     * @private
+     */
+    public get currentSavingObj() : PdfReference {
+        return this.currentSavingObject;
+    }
+    public set currentSavingObj(value : PdfReference) {
+        this.currentSavingObject = value;
+    }
+    /**
+     * Gets the PDF document `catalog`.
+     * @private
+     */
+    public get catalog() : PdfCatalog {
+        return this.pdfCatalog;
+    }
+    public set catalog(value : PdfCatalog) {
+        this.pdfCatalog = value;
+    }
+    //Public methods
+    /**
+     * Sets the `main object collection`.
+     * @private
+     */
+    public setMainObjectCollection(mainObjectCollection : PdfMainObjectCollection) : void {
+        this.objects = mainObjectCollection;
+    }
+    /**
+     * Sets the `cross table`.
+     * @private
+     */
+    public setCrossTable(cTable : PdfCrossTable) : void {
+        this.pdfCrossTable = cTable;
+    }
+    /**
+     * Sets the `catalog`.
+     * @private
+     */
+    public setCatalog(catalog : PdfCatalog) : void {
+        this.pdfCatalog = catalog;
+    }
+    /**
+     * `Saves` the document to the specified filename.
+     * @private
+     */
+    public save(): Promise<{blobData: Blob}>
+    /**
+     * `Saves` the document to the specified filename.
+     * @public
+     * ```typescript
+     * // create a new PDF document
+     * let document : PdfDocument = new PdfDocument();
+     * // add a pages to the document
+     * let page1 : PdfPage = document.pages.add();
+     * //
+     * // save the document
+     * document.save('output.pdf');
+     * //
+     * // destroy the document
+     * document.destroy();
+     * ```
+     * @param filename Specifies the file name to save the output pdf document.
+     */
+    public save(filename : string) : void
+    public save(filename ?: string) : Promise<{blobData: Blob}> | void {
+        let encoding: Encoding = new Encoding(true);
+        let SW : StreamWriter = new StreamWriter(encoding);
+        if (typeof filename === 'undefined') {
+            let encoding: Encoding = new Encoding(true);
+            let SW: StreamWriter = new StreamWriter(encoding);
+            return new Promise((resolve: Function, reject: Function) => {
+                /* tslint:disable-next-line:no-any */
+                let obj: any = {};
+                obj.blobData = new Blob([this.document.docSave(SW, true)], {type : 'application/pdf'});
+                resolve(obj);
+            });
+        } else {
+            this.document.docSave(SW, filename, true);
+        }
+    }
+    /**
+     * `Clone` of parent object - PdfDocument.
+     * @private
+     */
+    public clone() : PdfDocument {
+        return this.document;
+    }
+}