@syncfusion/ej2-pdf-export 23.2.6 → 24.1.41

package/dist/ts/implementation/graphics/images/byte-array.ts

@@ -0,0 +1,137 @@
+/**
+ * ByteArray class
+ * Used to keep information about image stream as byte array.
+ * @private
+ */
+export class ByteArray {
+    /**
+     * Current stream `position`.
+     * @default 0
+     * @private
+     */
+    private mPosition: number = 0;
+    /**
+     * Uint8Array for returing `buffer`.
+     * @hidden
+     * @private
+     */
+    private buffer: Uint8Array;
+    /**
+     * Specifies the `data view`.
+     * @hidden
+     * @private
+     */
+    private dataView: DataView;
+    /**
+     * Initialize the new instance for `byte-array` class
+     * @hidden
+     * @private
+     */
+    constructor(length: number) {
+        this.buffer = new Uint8Array(length);
+        this.dataView = new DataView(this.buffer.buffer);
+    }
+    /**
+     * Gets and Sets a current `position` of byte array.
+     * @hidden
+     * @private
+     */
+    public get position(): number {
+        return this.mPosition;
+    }
+    public set position(value: number) {
+        this.mPosition = value;
+    }
+    /**
+     * `Read` from current stream position.
+     * @default 0
+     * @hidden
+     * @private
+     */
+    public read(buffer: ByteArray, offset: number, count: number): void {
+        for (let index: number = offset; index < count; index++) {
+            let position: number = this.position;
+            buffer.buffer[index] = this.readByte(position);
+            this.position++;
+        }
+    }
+    /**
+     * @hidden
+     */
+    public getBuffer(index: number): number {
+        return this.buffer[index];
+    }
+    /**
+     * @hidden
+     */
+    public writeFromBase64String(base64: string): void {
+        let arr: Uint8Array = this.encodedString(base64);
+        this.buffer = arr;
+    }
+    /**
+     * @hidden
+     */
+    public encodedString(input: string): Uint8Array {
+        let keyStr: string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        let chr1: number;
+        let chr2: number;
+        let chr3: number;
+        let enc1: number;
+        let enc2: number;
+        let enc3: number;
+        let enc4: number;
+        let i: number = 0;
+        let resultIndex: number = 0;
+        let dataUrlPrefix: string = 'data:';
+        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
+        let totalLength: number = input.length * 3 / 4;
+        if (input.charAt(input.length - 1) === keyStr.charAt(64)) {
+            totalLength--;
+        }
+        let output: Uint8Array = new Uint8Array(totalLength | 0);
+        while (i < input.length) {
+            enc1 = keyStr.indexOf(input.charAt(i++));
+            enc2 = keyStr.indexOf(input.charAt(i++));
+            enc3 = keyStr.indexOf(input.charAt(i++));
+            enc4 = keyStr.indexOf(input.charAt(i++));
+            chr1 = (enc1 << 2) | (enc2 >> 4);
+            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+            chr3 = ((enc3 & 3) << 6) | enc4;
+            output[resultIndex++] = chr1;
+            output[resultIndex++] = chr2;
+            output[resultIndex++] = chr3;
+        }
+        return output;
+    }
+    /**
+     * @hidden
+     */
+    public readByte(offset: number): number {
+        return (this.buffer[offset]);
+    }
+    /**
+     * @hidden
+     */
+    public get internalBuffer(): Uint8Array {
+        return this.buffer;
+    }
+    /**
+     * @hidden
+     */
+    public get count(): number {
+        return this.buffer.byteLength;
+    }
+    /**
+     * 'readNextTwoBytes' stream 
+     * @hidden
+     * @private
+     */
+    public readNextTwoBytes(stream: ByteArray): number {
+        let data : number = stream.readByte(this.position);
+        this.position++;
+        data <<= 8;
+        data |= stream.readByte(this.position);
+        this.position++;
+        return data;
+    }
+}

package/dist/ts/implementation/graphics/images/image-decoder.ts

@@ -0,0 +1,439 @@
+/**
+ * ImageDecoder class
+ */
+import { ByteArray } from './byte-array';
+import { PdfStream } from './../../primitives/pdf-stream';
+import { DictionaryProperties } from './../../input-output/pdf-dictionary-properties';
+import { PdfName } from './../../primitives/pdf-name';
+import { PdfNumber } from './../../primitives/pdf-number';
+import { PdfBoolean } from './../../primitives/pdf-boolean';
+import { PdfDictionary } from './../../primitives/pdf-dictionary';
+/**
+ * Specifies the image `format`.
+ * @private
+ */
+export enum ImageFormat {
+    /**
+     * Specifies the type of `Unknown`.
+     * @hidden
+     * @private
+     */
+    Unknown,
+    /**
+     * Specifies the type of `Bmp`.
+     * @hidden
+     * @private
+     */
+    Bmp,
+    /**
+     * Specifies the type of `Emf`.
+     * @hidden
+     * @private
+     */
+    Emf,
+    /**
+     * Specifies the type of `Gif`.
+     * @hidden
+     * @private
+     */
+    Gif,
+    /**
+     * Specifies the type of `Jpeg`.
+     * @hidden
+     * @private
+     */
+    Jpeg,
+    /**
+     * Specifies the type of `Png`.
+     * @hidden
+     * @private
+     */
+    Png,
+    /**
+     * Specifies the type of `Wmf`.
+     * @hidden
+     * @private
+     */
+    Wmf,
+    /**
+     * Specifies the type of `Icon`.
+     * @hidden
+     * @private
+     */
+    Icon
+}
+/**
+ * `Decode the image stream`.
+ * @private
+ */
+export class ImageDecoder {
+    /**
+     * Start of file markers.
+     * @hidden
+     * @private
+     */
+    private sof1Marker : number = 0x00C1;
+    private sof2Marker : number = 0x00C2;
+    private sof3Marker : number = 0x00C3;
+    private sof5Marker : number = 0x00C5;
+    private sof6Marker : number = 0x00C6;
+    private sof7Marker : number = 0x00C7;
+    private sof9Marker : number = 0x00C9;
+    private sof10Marker : number = 0x00CA;
+    private sof11Marker : number = 0x00CB;
+    private sof13Marker : number = 0x00CD;
+    private sof14Marker : number = 0x00CE;
+    private sof15Marker : number = 0x00CF;
+    /**
+     * Number array for `png header`.
+     * @hidden
+     * @private
+     */
+    private static mPngHeader: number[] = [137, 80, 78, 71, 13, 10, 26, 10];
+    /**
+     * Number Array for `jpeg header`.
+     * @hidden
+     * @private
+     */
+    private static mJpegHeader: number[] = [255, 216];
+    /**
+     * Number array for `gif header`.
+     * @hidden
+     * @private
+     */
+    private static GIF_HEADER: string = 'G,I,F,8';
+    /**
+     * Number array for `bmp header.`
+     * @hidden
+     * @private
+     */
+    private static BMP_HEADER: string = 'B,M';
+    /**
+     * `memory stream` to store image data.
+     * @hidden
+     * @private
+     */
+    private mStream: ByteArray;
+    /**
+     * Specifies `format` of image.
+     * @hidden
+     * @private
+     */
+    private mFormat: ImageFormat = ImageFormat.Unknown;
+    /**
+     * `height` of image.
+     * @hidden
+     * @private
+     */
+    private mHeight: number;
+    /**
+     * `width` of image.
+     * @hidden
+     * @private
+     */
+    private mWidth: number;
+    /**
+     * `Bits per component`.
+     * @default 8
+     * @hidden
+     * @private
+     */
+    private mbitsPerComponent : number = 8;
+    /**
+     * ByteArray to store `image data`.
+     * @hidden
+     * @private
+     */
+    private mImageData: ByteArray;
+    /**
+     * Store an instance of `PdfStream` for an image.
+     * @hidden
+     * @private
+     */
+    private imageStream : PdfStream;
+    /**
+     * 'offset' of image.
+     * @hidden
+     * @private
+     */
+    private offset : number;
+    /**
+     * Internal variable for accessing fields from `DictionryProperties` class.
+     * @hidden
+     * @private
+     */
+    private dictionaryProperties : DictionaryProperties = new DictionaryProperties();
+    /**
+     * Initialize the new instance for `image-decoder` class.
+     * @private
+     */
+    public constructor(stream: ByteArray) {
+        this.mStream = stream;
+        this.initialize();
+    }
+    /**
+     * Gets the `height` of image.
+     * @hidden
+     * @private
+     */
+    public get height(): number {
+        return this.mHeight;
+    }
+    /**
+     * Gets the `width` of image.
+     * @hidden
+     * @private
+     */
+    public get width(): number {
+        return this.mWidth;
+    }
+    /**
+     * Gets `bits per component`.
+     * @hidden
+     * @private
+     */
+    public get bitsPerComponent() : number {
+        return this.mbitsPerComponent;
+    }
+    /**
+     * Gets the `size` of an image data.
+     * @hidden
+     * @private
+     */
+    public get size(): number {
+        return this.mImageData.count;
+    }
+    /**
+     * Gets the value of an `image data`.
+     * @hidden
+     * @private
+     */
+    public get imageData(): ByteArray {
+        return this.mImageData;
+    }
+    /**
+     * Gets the value of an `image data as number array`.
+     * @hidden
+     * @private
+     */
+    public get imageDataAsNumberArray() : ArrayBuffer {
+        return this.mImageData.internalBuffer.buffer;
+    }
+    /**
+     * `Initialize` image data and image stream.
+     * @hidden
+     * @private
+     */
+    private initialize(): void {
+        if (this.mFormat === ImageFormat.Unknown && this.checkIfJpeg()) {
+            this.mFormat = ImageFormat.Jpeg;
+            this.parseJpegImage();
+        } else {
+            throw new TypeError('Only the JPEG format is supported');
+        }
+        this.reset();
+        this.mImageData = new ByteArray(this.mStream.count);
+        this.mStream.read(this.mImageData, 0, this.mImageData.count);
+    }
+    /**
+     * `Reset` stream position into 0.
+     * @hidden
+     * @private
+     */
+    private reset(): void {
+        this.mStream.position = 0;
+    }
+    /**
+     * `Parse` Jpeg image.
+     * @hidden
+     * @private
+     */
+    private parseJpegImage(): void {
+        this.reset();
+        let imgData: ByteArray = new ByteArray(this.mStream.count);
+        this.mStream.read(imgData, 0, imgData.count);
+        let i: number = 4;
+        let isLengthExceed : boolean = false;
+        /* tslint:disable */
+        let length: number = imgData.getBuffer(i) * 256 + imgData.getBuffer(i + 1);
+        while (i < imgData.count) {
+            i += length;
+            if (i < imgData.count) {
+                if (imgData.getBuffer(i + 1) === 192) {
+                    this.mHeight = imgData.getBuffer(i + 5) * 256 + imgData.getBuffer(i + 6);
+                    this.mWidth = imgData.getBuffer(i + 7) * 256 + imgData.getBuffer(i + 8);
+                    return;
+                } else {
+                    i += 2;
+                    length = imgData.getBuffer(i) * 256 + imgData.getBuffer(i + 1);
+                }
+            } else {
+                isLengthExceed = true;
+                break;
+            }
+        }
+        if (isLengthExceed) {
+            this.mStream.position = 0;
+            this.skip(this.mStream, 2);
+            this.readExceededJPGImage(this.mStream);
+        }
+        /* tslint:enable */
+    }
+    /**
+     * Gets the image `format`.
+     * @private
+     * @hidden
+     */
+    public get format(): ImageFormat {
+        return this.mFormat;
+    }
+    /**
+     * `Checks if JPG`.
+     * @private
+     * @hidden
+     */
+    private checkIfJpeg(): boolean {
+        this.reset();
+        for (let i: number = 0; i < ImageDecoder.mJpegHeader.length; i++) {
+            if (ImageDecoder.mJpegHeader[i] !== this.mStream.readByte(i)) {
+                return false;
+            }
+            this.mStream.position++;
+        }
+        return true;
+    }
+    /**
+     * Return image `dictionary`.
+     * @hidden
+     * @private
+     */
+    public getImageDictionary() : PdfStream {
+        if (this.mFormat === ImageFormat.Jpeg) {
+            let tempArrayBuffer : number = this.imageData.internalBuffer.length;
+            this.imageStream = new PdfStream();
+            this.imageStream.isResource = true;
+            let tempString : string = '';
+            let decodedString : string = '';
+            for (let i : number = 0; i < this.imageDataAsNumberArray.byteLength; i++ ) {
+                tempString += String.fromCharCode(null, this.mStream.readByte(i));
+            }
+            for (let i : number = 0; i < tempString.length; i++) {
+                if (i % 2 !== 0) {
+                    decodedString += tempString[i];
+                }
+            }
+            this.imageStream.data = [decodedString];
+            this.imageStream.compress = false;
+            this.imageStream.items.setValue(this.dictionaryProperties.type, new PdfName(this.dictionaryProperties.xObject));
+            this.imageStream.items.setValue(this.dictionaryProperties.subtype, new PdfName(this.dictionaryProperties.image));
+            this.imageStream.items.setValue(this.dictionaryProperties.width, new PdfNumber(this.width));
+            this.imageStream.items.setValue(this.dictionaryProperties.height, new PdfNumber(this.height));
+            this.imageStream.items.setValue(this.dictionaryProperties.bitsPerComponent, new PdfNumber(this.bitsPerComponent));
+            this.imageStream.items.setValue(this.dictionaryProperties.filter, new PdfName(this.dictionaryProperties.dctdecode));
+            this.imageStream.items.setValue(this.dictionaryProperties.colorSpace, new PdfName(this.getColorSpace() as string));
+            this.imageStream.items.setValue(this.dictionaryProperties.decodeParms, this.getDecodeParams());
+            return this.imageStream;
+        } else {
+            return this.imageStream;
+        }
+    }
+    /**
+     * Return `colorSpace` of an image.
+     * @hidden
+     * @private
+     */
+    private getColorSpace() : string {
+        return this.dictionaryProperties.deviceRgb;
+    }
+    /**
+     * Return `decode parameters` of an image.
+     * @hidden
+     * @private
+     */
+    private getDecodeParams() : PdfDictionary {
+        let decodeParams : PdfDictionary = new PdfDictionary();
+        decodeParams.items.setValue(this.dictionaryProperties.columns, new PdfNumber(this.width));
+        decodeParams.items.setValue(this.dictionaryProperties.blackIs1, new PdfBoolean(true));
+        decodeParams.items.setValue(this.dictionaryProperties.k, new PdfNumber(-1));
+        decodeParams.items.setValue(this.dictionaryProperties.predictor, new PdfNumber(15));
+        decodeParams.items.setValue(this.dictionaryProperties.bitsPerComponent, new PdfNumber(this.bitsPerComponent));
+        return decodeParams;
+    }
+
+    /**
+     * 'readExceededJPGImage' stream 
+     * @hidden
+     * @private
+     */
+    private readExceededJPGImage(stream: ByteArray): void {
+        this.mStream = stream;
+        let isContinueReading : boolean = true;
+        while (isContinueReading) {
+            let marker : number =  this.getMarker(stream);
+            switch (marker) {
+                case this.sof1Marker:
+                case this.sof2Marker:
+                case this.sof3Marker:
+                case this.sof5Marker:
+                case this.sof6Marker:
+                case this.sof7Marker:
+                case this.sof9Marker:
+                case this.sof10Marker:
+                case this.sof11Marker:
+                case this.sof13Marker:
+                case this.sof14Marker:
+                case this.sof15Marker:
+                    stream.position += 3;
+                    this.mHeight = this.mStream.readNextTwoBytes(stream);
+                    this.mWidth = this.mStream.readNextTwoBytes(stream);
+                    isContinueReading = false;
+                    break;
+                default:
+                this.skipStream(stream);
+                    break;
+            }
+        }
+    }
+    /**
+     * 'skip' stream 
+     * @hidden
+     * @private
+     */
+    private skip(stream: ByteArray, noOfBytes: number): void {
+        this.mStream = stream;
+        let temp : ByteArray =  new ByteArray(noOfBytes);
+        this.mStream.read(temp, 0, temp.count);
+    }
+    /**
+     * 'getMarker' stream 
+     * @hidden
+     * @private
+     */
+    private getMarker(stream: ByteArray): number {
+        let skippedByte :  number = 0;
+        let marker : number = 32;
+        marker = stream.readByte(this.mStream.position);
+        stream.position++;
+        while (marker !== 255) {
+            skippedByte++;
+            marker = stream.readByte(this.mStream.position); stream.position++;
+        }
+        do {
+            marker = stream.readByte(this.mStream.position);
+            stream.position++;
+        }
+        while (marker === 255);
+        return marker;
+    }
+    /**
+     * 'skipStream' stream 
+     * @hidden
+     * @private
+     */
+    private skipStream(stream: ByteArray): void {
+        let markerLength : number = this.mStream.readNextTwoBytes(stream) - 2;
+        if (markerLength > 0) {
+            stream.position += markerLength;
+        }
+    }
+}

package/dist/ts/implementation/graphics/images/pdf-bitmap.ts

@@ -0,0 +1,110 @@
+/**
+ * PdfBitmap.ts class for EJ2-PDF
+ */
+import { ImageDecoder } from './../../graphics/images/image-decoder';
+import { ByteArray } from './../../graphics/images/byte-array';
+import { DictionaryProperties } from './../../input-output/pdf-dictionary-properties';
+import { PdfImage } from './pdf-image';
+/**
+ * The 'PdfBitmap' contains methods and properties to handle the Bitmap images.
+ * ```typescript
+ * // create a new PDF document.
+ * let document : PdfDocument = new PdfDocument();
+ * // add a page to the document.
+ * let page1 : PdfPage = document.pages.add();
+ * // base64 string of an image
+ * let imageString : string = '/9j/3+2w7em7HzY/KiijFw … 1OEYRUYrQ45yc5OUtz/9k=';
+ * // load the image from the base64 string of original image.
+ * let image : PdfBitmap = new PdfBitmap(imageString);
+ * // draw the image
+ * page1.graphics.drawImage(image, new RectangleF({x : 10, y : 10}, {width : 200, height : 200}));
+ * // save the document.
+ * document.save('output.pdf');
+ * // destroy the document
+ * document.destroy();
+ * ```
+ */
+export class PdfBitmap extends PdfImage {
+    //Fields
+    /**
+     * Specifies the `status` of an image.
+     * @default true.
+     * @hidden
+     * @private
+     */
+    private imageStatus : boolean = true;
+    /**
+     * Internal variable for accessing fields from `DictionryProperties` class.
+     * @hidden
+     * @private
+     */
+    private dictionaryProperties : DictionaryProperties = new DictionaryProperties();
+    /**
+     * `Type` of an image.
+     * @hidden
+     * @private
+     */
+    public checkImageType : number;
+    //Properties
+    /**
+     * Object to store `decoder` of an image.
+     * @hidden
+     * @private
+     */
+    public decoder : ImageDecoder;
+    /**
+     * `Load image`.
+     * @hidden
+     * @private
+     */
+    private loadImage(encodedString : string) : void {
+        let task : void = this.initializeAsync(encodedString);
+    }
+    /**
+     * Create an instance for `PdfBitmap` class.
+     * @param encodedString Base64 string of an image.
+     * ```typescript
+     * // create a new PDF document.
+     * let document : PdfDocument = new PdfDocument();
+     * // add a page to the document.
+     * let page1 : PdfPage = document.pages.add();
+     * // base64 string of an image
+     * let imageString : string = '/9j/3+2w7em7HzY/KiijFw … 1OEYRUYrQ45yc5OUtz/9k=';
+     * //
+     * // load the image from the base64 string of original image.
+     * let image : PdfBitmap = new PdfBitmap(imageString);
+     * //
+     * // draw the image
+     * page1.graphics.drawImage(image, new RectangleF({x : 10, y : 10}, {width : 200, height : 200}));
+     * // save the document.
+     * document.save('output.pdf');
+     * // destroy the document
+     * document.destroy();
+     * ```
+     */
+    public constructor(encodedString : string) {
+        super();
+        this.loadImage(encodedString);
+    }
+    /**
+     * `Initialize` image parameters.
+     * @private
+     */
+    public initializeAsync(encodedString : string) : void {
+        let byteArray : ByteArray = new ByteArray(encodedString.length);
+        byteArray.writeFromBase64String(encodedString);
+        this.decoder = new ImageDecoder(byteArray);
+        this.height = this.decoder.height;
+        this.width = this.decoder.width;
+        // FrameCount = BitmapImageDecoder.FrameCount;
+        this.bitsPerComponent = this.decoder.bitsPerComponent;
+    }
+    /**
+     * `Saves` the image into stream.
+     * @private
+     */
+    public save() : void {
+        this.imageStatus = true;
+        this.imageStream = this.decoder.getImageDictionary();
+    }
+}