@syncfusion/ej2-pdf-export 25.2.3 → 26.1.35

package/dist/ts/implementation/pages/pdf-document-page-collection.d.ts

@@ -0,0 +1,86 @@
+import { PdfDocument } from './../document/pdf-document';
+import { PdfPage } from './pdf-page';
+import { PdfSection } from './pdf-section';
+import { PageAddedEventArgs } from './../pages/page-added-event-arguments';
+import { Dictionary } from './../collections/dictionary';
+/**
+ * Represents a virtual collection of all the pages in the document.
+ * @private
+ */
+export declare class PdfDocumentPageCollection {
+    /**
+     * Parent `document`.
+     * @private
+     */
+    private document;
+    /**
+     * It holds the page collection with the `index`.
+     * @private
+     */
+    private pdfPageCollectionIndex;
+    /**
+     * Internal variable for `page added event`.
+     * @private
+     */
+    pageAdded: PageAddedEventArgs;
+    /**
+     * Gets the total `number of the pages`.
+     * @private
+     */
+    readonly count: number;
+    /**
+     * Gets a `page index` from the document.
+     * @private
+     */
+    readonly pageCollectionIndex: Dictionary<PdfPage, number>;
+    /**
+     * Initializes a new instance of the `PdfPageCollection` class.
+     * @private
+     */
+    constructor(document: PdfDocument);
+    /**
+     * Creates a page and `adds` it to the last section in the document.
+     * @private
+     */
+    add(): PdfPage;
+    /**
+     * Creates a page and `adds` it to the last section in the document.
+     * @private
+     */
+    add(page: PdfPage): void;
+    /**
+     * Returns `last section` in the document.
+     * @private
+     */
+    private getLastSection;
+    /**
+     * Called when `new page has been added`.
+     * @private
+     */
+    onPageAdded(args: PageAddedEventArgs): void;
+    /**
+     * Gets the `total number of pages`.
+     * @private
+     */
+    private countPages;
+    /**
+     * Gets the `page object` from page index.
+     * @private
+     */
+    getPageByIndex(index: number): PdfPage;
+    /**
+     * Gets a page by its `index` in the document.
+     * @private
+     */
+    private getPage;
+    /**
+     * Gets the `index of` the page in the document.
+     * @private
+     */
+    indexOf(page: PdfPage): number;
+    /**
+     * `Removes` the specified page.
+     * @private
+     */
+    remove(page: PdfPage): PdfSection;
+}

package/dist/ts/implementation/pages/pdf-document-page-collection.ts

@@ -0,0 +1,180 @@
+import { PdfDocument } from './../document/pdf-document';
+import { PdfPage } from './pdf-page';
+import { PdfSection } from './pdf-section';
+import { PdfSectionCollection } from './pdf-section-collection';
+import { PageAddedEventArgs } from './../pages/page-added-event-arguments';
+import { Dictionary } from './../collections/dictionary';
+/**
+ * Represents a virtual collection of all the pages in the document.
+ * @private
+ */
+export class PdfDocumentPageCollection {
+    /**
+     * Parent `document`.
+     * @private
+     */
+    private document : PdfDocument;
+    /**
+     * It holds the page collection with the `index`.
+     * @private
+     */
+    private pdfPageCollectionIndex : Dictionary<PdfPage, number> = new Dictionary<PdfPage, number>();
+    /**
+     * Internal variable for `page added event`.
+     * @private
+     */
+    public pageAdded : PageAddedEventArgs; //event
+    //Property
+    /**
+     * Gets the total `number of the pages`.
+     * @private
+     */
+    public get count() : number {
+        return this.countPages();
+    }
+    /**
+     * Gets a `page index` from the document.
+     * @private
+     */
+    public get pageCollectionIndex() : Dictionary<PdfPage, number> {
+        return this.pdfPageCollectionIndex;
+    }
+    //constructor
+    /**
+     * Initializes a new instance of the `PdfPageCollection` class.
+     * @private
+     */
+    constructor(document : PdfDocument) {
+        this.document = document;
+    }
+    /**
+     * Creates a page and `adds` it to the last section in the document.
+     * @private
+     */
+    public add() : PdfPage
+    /**
+     * Creates a page and `adds` it to the last section in the document.
+     * @private
+     */
+    public add(page : PdfPage) : void
+    public add(page? : PdfPage) : PdfPage|void {
+        if (typeof page === 'undefined') {
+            let page : PdfPage = new PdfPage();
+            this.add(page);
+            return page;
+        } else {
+            let section : PdfSection = this.getLastSection();
+            section.add(page);
+        }
+    }
+    /**
+     * Returns `last section` in the document.
+     * @private
+     */
+    private getLastSection() : PdfSection {
+        let sc : PdfSectionCollection = this.document.sections;
+        if (sc.section.length === 0) {
+            sc.add();
+        }
+        let section : PdfSection = sc.section[sc.section.length - 1];
+        return section;
+    }
+    /**
+     * Called when `new page has been added`.
+     * @private
+     */
+    public onPageAdded(args : PageAddedEventArgs) : void {
+        // if (PageAdded !== null)
+        // {
+        //     PageAdded(this, args);
+        // }
+    }
+    /**
+     * Gets the `total number of pages`.
+     * @private
+     */
+    private countPages() : number {
+        let sc : PdfSectionCollection = this.document.sections;
+        let count : number = 0;
+        for (let index : number = 0; index < sc.section.length; index++) {
+            count += sc.section[index].count;
+        }
+        return count;
+    }
+    /**
+     * Gets the `page object` from page index.
+     * @private
+     */
+    public getPageByIndex(index : number) : PdfPage {
+        return this.getPage(index);
+    }
+    /**
+     * Gets a page by its `index` in the document.
+     * @private
+     */
+    private getPage(index : number) : PdfPage {
+        if ((index < 0) || (index >= this.count)) {
+            throw Error('ArgumentOutOfRangeException("index", "Value can not be less 0")');
+        }
+        let page : PdfPage = null;
+        let sectionStartIndex : number = 0;
+        let sectionCount : number = 0;
+        let pageIndex : number = 0;
+        let length : number = this.document.sections.count;
+        for (let i : number = 0; i < length; i++) {
+            let section : PdfSection = this.document.sections.section[i];
+            sectionCount = section.count;
+            pageIndex = index - sectionStartIndex;
+            // We found a section containing the page.
+            if ((index >= sectionStartIndex && pageIndex < sectionCount)) {
+                page = section.getPages()[pageIndex] as PdfPage;
+                break;
+            }
+            sectionStartIndex += sectionCount;
+        }
+        return page;
+    }
+    /**
+     * Gets the `index of` the page in the document.
+     * @private
+     */
+    public indexOf(page : PdfPage) : number {
+        let index : number = -1;
+        if (page == null) {
+            throw new Error('ArgumentNullException: page');
+        } else {
+            let numPages : number = 0;
+            for (let i : number = 0, len : number = this.document.sections.count; i < len; i++) {
+                let section : PdfSection = this.document.sections.pdfSectionCollection(i);
+                index = section.indexOf(page);
+                if (index >= 0) {
+                    index += numPages;
+                    break;
+                } else {
+                    index = -1;
+                }
+                numPages += section.count;
+            }
+        }
+        return index;
+    }
+    /**
+     * `Removes` the specified page.
+     * @private
+     */
+    public remove(page : PdfPage) : PdfSection {
+        if (page == null) {
+            throw Error('ArgumentNullException("page")');
+        }
+        let section : PdfSection = null;
+        let len : number;
+        for (let i : number = 0, len : number = this.document.sections.count; i < len; i++) {
+            section = this.document.sections.pdfSectionCollection(i);
+            if (section.pages.contains(page)) {
+                section.pages.remove(page);
+                break;
+            }
+        }
+        return section;
+    }
+}

package/dist/ts/implementation/pages/pdf-page-base.d.ts

@@ -0,0 +1,121 @@
+import { PdfDictionary } from './../primitives/pdf-dictionary';
+import { IPdfWrapper } from './../../interfaces/i-pdf-wrapper';
+import { IPdfPrimitive } from './../../interfaces/i-pdf-primitives';
+import { PdfArray } from './../primitives/pdf-array';
+import { PointF, SizeF } from './../drawing/pdf-drawing';
+import { PdfPageLayerCollection } from './pdf-page-layer-collection';
+import { PdfPageLayer } from './pdf-page-layer';
+import { DictionaryProperties } from './../input-output/pdf-dictionary-properties';
+import { PdfResources } from './../graphics/pdf-resources';
+import { PdfSection } from './pdf-section';
+/**
+ * The abstract base class for all pages,
+ * `PdfPageBase` class provides methods and properties to create PDF pages and its elements.
+ * @private
+ */
+export declare abstract class PdfPageBase implements IPdfWrapper {
+    /**
+     * Collection of the `layers` of the page.
+     * @private
+     */
+    private layerCollection;
+    /**
+     * Stores the instance of `PdfDictionary` class.
+     * @private
+     */
+    private pageDictionary;
+    /**
+     * `Index` of the default layer.
+     * @default -1.
+     * @private
+     */
+    private defLayerIndex;
+    /**
+     * Local variable to store if page `updated`.
+     * @default false.
+     * @private
+     */
+    private modified;
+    /**
+     * Stores the instance of `PdfResources`.
+     * @hidden
+     * @private
+     */
+    private resources;
+    /**
+     * Instance of `DictionaryProperties` class.
+     * @hidden
+     * @private
+     */
+    protected dictionaryProperties: DictionaryProperties;
+    /**
+     * Specifies the current `section`.
+     * @hidden
+     * @private
+     */
+    private pdfSection;
+    /**
+     * Gets the `section` of a page.
+     * @private
+     */
+    section: PdfSection;
+    /**
+     * Gets the page `dictionary`.
+     * @private
+     */
+    readonly dictionary: PdfDictionary;
+    /**
+     * Gets the wrapped `element`.
+     * @private
+     */
+    readonly element: IPdfPrimitive;
+    /**
+     * Gets the `default layer` of the page (Read only).
+     * @private
+     */
+    readonly defaultLayer: PdfPageLayer;
+    /**
+     * Gets or sets `index of the default layer`.
+     * @private
+     */
+    /**
+    * Gets or sets` index of the default layer`.
+    * @private
+    */
+    defaultLayerIndex: number;
+    /**
+     * Gets the collection of the page's `layers` (Read only).
+     * @private
+     */
+    readonly layers: PdfPageLayerCollection;
+    /**
+     * Return an instance of `PdfResources` class.
+     * @private
+     */
+    getResources(): PdfResources;
+    /**
+     * Gets `array of page's content`.
+     * @private
+     */
+    readonly contents: PdfArray;
+    /**
+     * Sets the `resources`.
+     * @private
+     */
+    setResources(res: PdfResources): void;
+    /**
+     * Gets the `size of the page` (Read only).
+     * @private
+     */
+    abstract readonly size: SizeF;
+    /**
+     * Gets the `origin of the page`.
+     * @private
+     */
+    abstract readonly origin: PointF;
+    /**
+     * Initializes a new instance of the `PdfPageBase` class.
+     * @private
+     */
+    constructor(dictionary: PdfDictionary);
+}

package/dist/ts/implementation/pages/pdf-page-base.ts

@@ -0,0 +1,181 @@
+import { PdfDictionary } from './../primitives/pdf-dictionary';
+import { IPdfWrapper } from './../../interfaces/i-pdf-wrapper';
+import { IPdfPrimitive } from './../../interfaces/i-pdf-primitives';
+import { PdfArray } from './../primitives/pdf-array';
+import { PointF, SizeF } from './../drawing/pdf-drawing';
+import { PdfPageLayerCollection } from './pdf-page-layer-collection';
+import { PdfPageLayer } from './pdf-page-layer';
+import { DictionaryProperties } from './../input-output/pdf-dictionary-properties';
+import { PdfReferenceHolder } from './../primitives/pdf-reference';
+import { PdfResources } from './../graphics/pdf-resources';
+import { PdfSection } from './pdf-section';
+/**
+ * The abstract base class for all pages,
+ * `PdfPageBase` class provides methods and properties to create PDF pages and its elements.
+ * @private
+ */
+export abstract class PdfPageBase implements IPdfWrapper {
+    /**
+     * Collection of the `layers` of the page.
+     * @private
+     */
+    private layerCollection : PdfPageLayerCollection;
+    /**
+     * Stores the instance of `PdfDictionary` class.
+     * @private
+     */
+    private pageDictionary : PdfDictionary;
+    /**
+     * `Index` of the default layer.
+     * @default -1.
+     * @private
+     */
+    private defLayerIndex : number = -1;
+    /**
+     * Local variable to store if page `updated`.
+     * @default false.
+     * @private
+     */
+    private modified : boolean = false;
+    /**
+     * Stores the instance of `PdfResources`.
+     * @hidden
+     * @private
+     */
+    private resources : PdfResources;
+    /**
+     * Instance of `DictionaryProperties` class.
+     * @hidden
+     * @private
+     */
+    protected dictionaryProperties : DictionaryProperties = new DictionaryProperties();
+    /**
+     * Specifies the current `section`.
+     * @hidden
+     * @private
+     */
+    private pdfSection : PdfSection;
+    //Properties
+    /**
+     * Gets the `section` of a page.
+     * @private
+     */
+    public get section() : PdfSection {
+        // if (this.pdfSection === null) {
+        //     throw new Error('PdfException : Page must be added to some section before using.');
+        // }
+        return this.pdfSection;
+    }
+    public set section(value : PdfSection) {
+        this.pdfSection = value;
+    }
+    /**
+     * Gets the page `dictionary`.
+     * @private
+     */
+    public get dictionary() : PdfDictionary {
+        return this.pageDictionary;
+    }
+    /**
+     * Gets the wrapped `element`.
+     * @private
+     */
+    public get element() : IPdfPrimitive {
+        return this.pageDictionary;
+    }
+    /**
+     * Gets the `default layer` of the page (Read only).
+     * @private
+     */
+    public get defaultLayer() : PdfPageLayer {
+        let layer : PdfPageLayerCollection = this.layers;
+        let index : number = this.defaultLayerIndex;
+        let returnlayer : PdfPageLayer = layer.items(index) as PdfPageLayer;
+        return returnlayer;
+    }
+    /**
+     * Gets or sets `index of the default layer`.
+     * @private
+     */
+    public get defaultLayerIndex() : number {
+        if (this.layerCollection.count === 0 || this.defLayerIndex === -1) {
+            let layer : PdfPageLayer = this.layerCollection.add();
+            this.defLayerIndex = this.layerCollection.indexOf(layer);
+        }
+        return this.defLayerIndex;
+    }
+    /**
+     * Gets the collection of the page's `layers` (Read only).
+     * @private
+     */
+    public get layers() : PdfPageLayerCollection {
+        if (this.layerCollection == null || typeof this.layerCollection === 'undefined') {
+            this.layerCollection = new PdfPageLayerCollection(this);
+        }
+        return this.layerCollection;
+    }
+    /**
+     * Return an instance of `PdfResources` class.
+     * @private
+     */
+    public getResources() : PdfResources {
+        if (this.resources == null) {
+            this.resources = new PdfResources();
+            this.dictionary.items.setValue(this.dictionaryProperties.resources, this.resources);
+        }
+        return this.resources;
+    }
+    /**
+     * Gets `array of page's content`.
+     * @private
+     */
+    public get contents(): PdfArray {
+        let obj : IPdfPrimitive = this.pageDictionary.items.getValue(this.dictionaryProperties.contents);
+        let contents : PdfArray = obj as PdfArray;
+        let rh : PdfReferenceHolder = obj as PdfReferenceHolder;
+        if (contents == null) {
+            contents = new PdfArray();
+            this.pageDictionary.items.setValue(this.dictionaryProperties.contents, contents);
+        }
+        return contents;
+    }
+    /**
+     * Gets or sets` index of the default layer`.
+     * @private
+     */
+    public set defaultLayerIndex(value : number) {
+        if (value < 0 || value > this.layers.count - 1) {
+            throw new Error('ArgumentOutOfRangeException : value, Index can not be less 0 and greater Layers.Count - 1');
+        } else {
+            this.defLayerIndex = value;
+            this.modified = true;
+        }
+    }
+    /**
+     * Sets the `resources`.
+     * @private
+     */
+    public setResources(res : PdfResources) : void {
+        this.resources = res;
+        this.dictionary.items.setValue(this.dictionaryProperties.resources, this.resources);
+        this.modified = true;
+    }
+    /**
+     * Gets the `size of the page` (Read only).
+     * @private
+     */
+    public abstract get size() : SizeF;
+    /**
+     * Gets the `origin of the page`.
+     * @private
+     */
+    public abstract get origin() : PointF;
+    //constructors
+    /**
+     * Initializes a new instance of the `PdfPageBase` class.
+     * @private
+     */
+    constructor(dictionary : PdfDictionary) {
+        this.pageDictionary = dictionary;
+    }
+}

package/dist/ts/implementation/pages/pdf-page-layer-collection.d.ts

@@ -0,0 +1,99 @@
+/**
+ * PdfPageLayerCollection.ts class for EJ2-PDF
+ */
+import { PdfPageBase } from './pdf-page-base';
+import { PdfDictionary } from './../primitives/pdf-dictionary';
+import { PdfPageLayer } from './pdf-page-layer';
+import { PdfCollection } from './../general/pdf-collection';
+/**
+ * The class provides methods and properties to handle the collections of `PdfPageLayer`.
+ */
+export declare class PdfPageLayerCollection extends PdfCollection {
+    /**
+     * Parent `page`.
+     * @private
+     */
+    private page;
+    /**
+     * Stores the `number of first level layers` in the document.
+     * @default 0
+     * @private
+     */
+    private parentLayerCount;
+    /**
+     * Indicates if `Sublayer` is present.
+     * @default false
+     * @private
+     */
+    sublayer: boolean;
+    /**
+     * Stores the `optional content dictionary`.
+     * @private
+     */
+    optionalContent: PdfDictionary;
+    /**
+     * Return the `PdfLayer` from the layer collection by index.
+     * @private
+     */
+    items(index: number): PdfPageLayer;
+    /**
+     * Stores the `layer` into layer collection with specified index.
+     * @private
+     */
+    items(index: number, value: PdfPageLayer): void;
+    /**
+     * Initializes a new instance of the `PdfPageLayerCollection` class
+     * @private
+     */
+    constructor();
+    /**
+     * Initializes a new instance of the `PdfPageLayerCollection` class
+     * @private
+     */
+    constructor(page: PdfPageBase);
+    /**
+     * Creates a new `PdfPageLayer` and adds it to the end of the collection.
+     * @private
+     */
+    add(): PdfPageLayer;
+    /**
+     * Creates a new `PdfPageLayer` and adds it to the end of the collection.
+     * @private
+     */
+    add(layerName: string, visible: boolean): PdfPageLayer;
+    /**
+     * Creates a new `PdfPageLayer` and adds it to the end of the collection.
+     * @private
+     */
+    add(layerName: string): PdfPageLayer;
+    /**
+     * Creates a new `PdfPageLayer` and adds it to the end of the collection.
+     * @private
+     */
+    add(layer: PdfPageLayer): number;
+    /**
+     * Registers `layer` at the page.
+     * @private
+     */
+    private addLayer;
+    /**
+     * Inserts `PdfPageLayer` into the collection at specified index.
+     * @private
+     */
+    insert(index: number, layer: PdfPageLayer): void;
+    /**
+     * Registers layer at the page.
+     * @private
+     */
+    private insertLayer;
+    /**
+     * `Parses the layers`.
+     * @private
+     */
+    private parseLayers;
+    /**
+     * Returns `index of` the `PdfPageLayer` in the collection if exists, -1 otherwise.
+     * @private
+     */
+    indexOf(layer: PdfPageLayer): number;
+}