@syncfusion/ej2-pdf 1.0.23 → 23.1.38

package/src/pdf/core/form/index.d.ts

@@ -0,0 +1,2 @@
+export * from './form';
+export * from './field';

package/src/pdf/core/form/index.js

@@ -0,0 +1,2 @@
+export * from './form';
+export * from './field';

package/src/pdf/core/graphics/images/image-decoder.d.ts

@@ -0,0 +1,38 @@
+import { _PdfStream } from './../../base-stream';
+import { _PdfDictionary } from './../../pdf-primitives';
+import { _ImageFormat } from './../../enumerator';
+export declare class _ImageDecoder {
+    _stream: Uint8Array;
+    _format: _ImageFormat;
+    _height: number;
+    _width: number;
+    _bitsPerComponent: number;
+    _imageData: Uint8Array;
+    _imageStream: _PdfStream;
+    _position: number;
+    _noOfComponents: number;
+    static _jpegHeader: number[];
+    /**
+     * Initializes a new instance of the `_ImageDecoder` class.
+     *
+     * @private
+     * @param {Uint8Array} stream byte array.
+     */
+    constructor(stream: Uint8Array);
+    readonly _imageDataAsNumberArray: ArrayBuffer;
+    _initialize(): void;
+    _reset(): void;
+    _parseJpegImage(): void;
+    _checkIfJpeg(): boolean;
+    _read(buffer: Uint8Array, offset: number, count: number): void;
+    _getBuffer(index: number): number;
+    _getImageDictionary(): _PdfStream;
+    _getColorSpace(): string;
+    _getDecodeParams(): _PdfDictionary;
+    _seek(length: number): void;
+    _readByte(): number;
+    _skipStream(): void;
+    _readExceededJpegImage(): void;
+    _toUnsigned16(value: number): number;
+    _getMarker(): number;
+}

package/src/pdf/core/graphics/images/image-decoder.js

@@ -0,0 +1,227 @@
+import { _PdfStream } from './../../base-stream';
+import { _PdfDictionary, _PdfName } from './../../pdf-primitives';
+import { _ImageFormat } from './../../enumerator';
+var _ImageDecoder = /** @class */ (function () {
+    /**
+     * Initializes a new instance of the `_ImageDecoder` class.
+     *
+     * @private
+     * @param {Uint8Array} stream byte array.
+     */
+    function _ImageDecoder(stream) {
+        this._format = _ImageFormat.unknown;
+        this._height = 0;
+        this._width = 0;
+        this._bitsPerComponent = 8;
+        this._position = 0;
+        this._noOfComponents = -1;
+        this._stream = stream;
+        this._initialize();
+    }
+    Object.defineProperty(_ImageDecoder.prototype, "_imageDataAsNumberArray", {
+        get: function () {
+            return this._imageData;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    _ImageDecoder.prototype._initialize = function () {
+        if (this._format === _ImageFormat.unknown && this._checkIfJpeg()) {
+            this._format = _ImageFormat.jpeg;
+            this._parseJpegImage();
+        }
+        else {
+            throw new TypeError('Only the JPEG format is supported');
+        }
+        this._reset();
+        this._imageData = new Uint8Array(this._stream.byteLength);
+        this._read(this._imageData, 0, this._imageData.byteLength);
+    };
+    _ImageDecoder.prototype._reset = function () {
+        this._position = 0;
+    };
+    _ImageDecoder.prototype._parseJpegImage = function () {
+        this._reset();
+        var imgData = new Uint8Array(this._stream.byteLength);
+        this._read(imgData, 0, imgData.byteLength);
+        var i = 4;
+        var length = this._getBuffer(i) * 256 + this._getBuffer(i + 1);
+        var isLengthExceed = false;
+        while (i < imgData.byteLength) {
+            i += length;
+            if (i < imgData.byteLength) {
+                if (this._getBuffer(i + 1) === 192) {
+                    this._height = this._getBuffer(i + 5) * 256 + this._getBuffer(i + 6);
+                    this._width = this._getBuffer(i + 7) * 256 + this._getBuffer(i + 8);
+                    this._noOfComponents = this._getBuffer(i + 9);
+                    if (this._width !== 0 && this._height !== 0) {
+                        return;
+                    }
+                }
+                else {
+                    i += 2;
+                    length = this._getBuffer(i) * 256 + this._getBuffer(i + 1);
+                }
+            }
+            else {
+                isLengthExceed = true;
+                break;
+            }
+        }
+        if (isLengthExceed) {
+            this._reset();
+            this._seek(2);
+            this._readExceededJpegImage();
+        }
+    };
+    _ImageDecoder.prototype._checkIfJpeg = function () {
+        this._reset();
+        for (var i = 0; i < _ImageDecoder._jpegHeader.length; i++) {
+            if (_ImageDecoder._jpegHeader[Number.parseInt(i.toString(), 10)] !== this._getBuffer(i)) {
+                return false;
+            }
+            this._position++;
+        }
+        return true;
+    };
+    _ImageDecoder.prototype._read = function (buffer, offset, count) {
+        for (var index = offset; index < count; index++) {
+            var position = this._position;
+            buffer[Number.parseInt(index.toString(), 10)] = this._getBuffer(position);
+            this._position++;
+        }
+    };
+    _ImageDecoder.prototype._getBuffer = function (index) {
+        return this._stream[Number.parseInt(index.toString(), 10)];
+    };
+    _ImageDecoder.prototype._getImageDictionary = function () {
+        var data = []; // eslint-disable-line
+        this._imageStream = new _PdfStream(data, new _PdfDictionary());
+        this._imageStream.isImageStream = true;
+        var tempString = '';
+        var decodedString = '';
+        for (var i = 0; i < this._imageDataAsNumberArray.byteLength; i++) {
+            tempString += ' ' + String.fromCharCode(this._getBuffer(i));
+        }
+        for (var i = 0; i < tempString.length; i++) {
+            if (i % 2 !== 0) {
+                decodedString += tempString[Number.parseInt(i.toString(), 10)];
+            }
+        }
+        this._imageStream.data = [decodedString];
+        this._imageStream._isCompress = false;
+        var dictionary = new _PdfDictionary();
+        dictionary.set('Type', new _PdfName('XObject'));
+        dictionary.set('Subtype', new _PdfName('Image'));
+        dictionary.set('Width', this._width);
+        dictionary.set('Height', this._height);
+        dictionary.set('BitsPerComponent', this._bitsPerComponent);
+        dictionary.set('Filter', new _PdfName('DCTDecode'));
+        dictionary.set('ColorSpace', new _PdfName(this._getColorSpace()));
+        dictionary.set('DecodeParms', this._getDecodeParams());
+        this._imageStream.dictionary = dictionary;
+        this._imageStream.bytes = new Uint8Array(this._imageStream.data[0].length);
+        for (var i = 0; i < this._imageStream.data[0].length; i++) {
+            this._imageStream.bytes[Number.parseInt(i.toString(), 10)] = this._imageStream.data[0].charCodeAt(i);
+        }
+        this._imageStream.end = this._imageStream.bytes.length;
+        this._imageStream.dictionary._updated = true;
+        return this._imageStream;
+    };
+    _ImageDecoder.prototype._getColorSpace = function () {
+        if (this._noOfComponents === 1) {
+            return 'DeviceGray';
+        }
+        else if (this._noOfComponents === 4) {
+            return 'DeviceCMYK';
+        }
+        return 'DeviceRGB';
+    };
+    _ImageDecoder.prototype._getDecodeParams = function () {
+        var decodeParams = new _PdfDictionary();
+        decodeParams.set('Columns', this._width);
+        decodeParams.set('BlackIs1', true);
+        decodeParams.set('K', -1);
+        decodeParams.set('Predictor', 15);
+        decodeParams.set('BitsPerComponent', this._bitsPerComponent);
+        return decodeParams;
+    };
+    _ImageDecoder.prototype._seek = function (length) {
+        this._position += length;
+    };
+    _ImageDecoder.prototype._readByte = function () {
+        if (this._position < this._stream.byteLength) {
+            var value = this._getBuffer(this._position);
+            this._position += 1;
+            return value;
+        }
+        else {
+            throw new Error('Error decoding JPEG image. Invalid offset.');
+        }
+    };
+    _ImageDecoder.prototype._skipStream = function () {
+        var length = this._getBuffer(this._position) << 8 | this._getBuffer(this._position + 1);
+        this._seek(2);
+        if (length < 2) {
+            throw new Error('Error decoding JPEG image');
+        }
+        else if (length > 0) {
+            this._seek(length - 2);
+        }
+    };
+    _ImageDecoder.prototype._readExceededJpegImage = function () {
+        var isContinueReading = true;
+        while (isContinueReading) {
+            var marker = this._getMarker();
+            switch (marker) {
+                case 0x00C0:
+                case 0x00C1:
+                case 0x00C2:
+                case 0x00C3:
+                case 0x00C5:
+                case 0x00C6:
+                case 0x00C7:
+                case 0x00C9:
+                case 0x00CA:
+                case 0x00CB:
+                case 0x00CD:
+                case 0x00CE:
+                case 0x00CF:
+                    this._seek(3);
+                    this._height = this._getBuffer(this._position) << 8 | this._getBuffer(this._position + 1);
+                    this._seek(2);
+                    this._width = this._getBuffer(this._position) << 8 | this._getBuffer(this._position + 1);
+                    this._seek(2);
+                    this._noOfComponents = this._getBuffer(this._position);
+                    this._seek(1);
+                    isContinueReading = false;
+                    break;
+                default:
+                    this._skipStream();
+                    break;
+            }
+        }
+    };
+    _ImageDecoder.prototype._toUnsigned16 = function (value) {
+        value = value & 0xFFFF;
+        return value < 0 ? (value + 0x10000) : value;
+    };
+    _ImageDecoder.prototype._getMarker = function () {
+        var skippedByte = 0;
+        var marker = this._readByte();
+        while (marker != 255) {
+            skippedByte++;
+            marker = this._readByte();
+        }
+        do {
+            marker = this._readByte();
+        } while (marker == 255);
+        if (skippedByte != 0) {
+            throw new Error('Error decoding JPEG image');
+        }
+        return this._toUnsigned16(marker);
+    };
+    _ImageDecoder._jpegHeader = [255, 216];
+    return _ImageDecoder;
+}());
+export { _ImageDecoder };

package/src/{implementation → pdf/core}/graphics/images/index.d.ts

@@ -1,8 +1,3 @@
-/**
- * Images classes
- * @hidden
- */
-export * from './byte-array';
 export * from './image-decoder';
 export * from './pdf-bitmap';
 export * from './pdf-image';

package/{dist/es6/implementation → src/pdf/core}/graphics/images/index.js

@@ -1,4 +1,3 @@
-export * from './byte-array';
 export * from './image-decoder';
 export * from './pdf-bitmap';
 export * from './pdf-image';

package/src/pdf/core/graphics/images/pdf-bitmap.d.ts

@@ -0,0 +1,73 @@
+import { _ImageDecoder } from './../../graphics/images/image-decoder';
+import { PdfImage } from './pdf-image';
+/**
+ * The 'PdfBitmap' contains methods and properties to handle the Bitmap images.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Access first page
+ * let page: PdfPage = document.getPage(0);
+ * // Gets the graphics of the PDF page
+ * let graphics: PdfGraphics = page.graphics;
+ * // Create new image object by using JPEG image data as Base64 string format
+ * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+ * //Draw the image.
+ * graphics.drawImage(image, 10, 20, 400, 400);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+export declare class PdfBitmap extends PdfImage {
+    _imageStatus: boolean;
+    _checkImageType: number;
+    _decoder: _ImageDecoder;
+    /**
+     * Create an instance for `PdfBitmap` class.
+     *
+     * @param {string} encodedString Image as Base64 string.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Access first page
+     * let page: PdfPage = document.getPage(0);
+     * // Gets the graphics of the PDF page
+     * let graphics: PdfGraphics = page.graphics;
+     * // Create new image object by using JPEG image data as Base64 string format
+     * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+     * //Draw the image.
+     * graphics.drawImage(image, 10, 20, 400, 400);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    constructor(encodedString: string);
+    /**
+     * Create an instance for `PdfBitmap` class.
+     *
+     * @param {Uint8Array} encodedString Image data as byte array.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Access first page
+     * let page: PdfPage = document.getPage(0);
+     * // Gets the graphics of the PDF page
+     * let graphics: PdfGraphics = page.graphics;
+     * // Create new image object by using JPEG image data as array of bytes
+     * let image: PdfImage = new PdfBitmap(array);
+     * //Draw the image.
+     * graphics.drawImage(image, 10, 20, 400, 400);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    constructor(encodedString: Uint8Array);
+    _initializeAsync(encodedString: string): void;
+    _initializeAsync(encodedString: Uint8Array): void;
+    _save(): void;
+}

package/src/pdf/core/graphics/images/pdf-bitmap.js

@@ -0,0 +1,68 @@
+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 { _ImageDecoder } from './../../graphics/images/image-decoder';
+import { PdfImage } from './pdf-image';
+import { _decode } from './../../utils';
+/**
+ * The 'PdfBitmap' contains methods and properties to handle the Bitmap images.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Access first page
+ * let page: PdfPage = document.getPage(0);
+ * // Gets the graphics of the PDF page
+ * let graphics: PdfGraphics = page.graphics;
+ * // Create new image object by using JPEG image data as Base64 string format
+ * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+ * //Draw the image.
+ * graphics.drawImage(image, 10, 20, 400, 400);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+var PdfBitmap = /** @class */ (function (_super) {
+    __extends(PdfBitmap, _super);
+    function PdfBitmap(encodedString) {
+        var _this = _super.call(this) || this;
+        _this._imageStatus = true;
+        if (encodedString !== null && typeof encodedString !== 'undefined' && typeof encodedString === 'string') {
+            _this._initializeAsync(encodedString);
+        }
+        else {
+            _this._initializeAsync(encodedString);
+        }
+        return _this;
+    }
+    PdfBitmap.prototype._initializeAsync = function (encodedString) {
+        var byteArray = new Uint8Array(encodedString.length);
+        if (encodedString !== null && typeof encodedString !== 'undefined' && typeof encodedString === 'string') {
+            byteArray = _decode(encodedString, false);
+        }
+        else if (encodedString instanceof Uint8Array) {
+            byteArray = encodedString;
+        }
+        this._decoder = new _ImageDecoder(byteArray);
+        this.height = this._decoder._height;
+        this.width = this._decoder._width;
+        this._bitsPerComponent = this._decoder._bitsPerComponent;
+    };
+    PdfBitmap.prototype._save = function () {
+        this._imageStatus = true;
+        this._imageStream = this._decoder._getImageDictionary();
+    };
+    return PdfBitmap;
+}(PdfImage));
+export { PdfBitmap };

package/src/pdf/core/graphics/images/pdf-image.d.ts

@@ -0,0 +1,201 @@
+import { _PdfReference } from './../../pdf-primitives';
+import { _PdfStream } from './../../base-stream';
+import { PdfGraphics } from './../../graphics/pdf-graphics';
+/**
+ * The 'PdfImage' contains methods and properties to handle the images.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Access first page
+ * let page: PdfPage = document.getPage(0);
+ * // Gets the graphics of the PDF page
+ * let graphics: PdfGraphics = page.graphics;
+ * // Create new image object by using JPEG image data as Base64 string format
+ * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+ * //Draw the image.
+ * graphics.drawImage(image, 10, 20, 400, 400);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+export declare abstract class PdfImage {
+    _imageWidth: number;
+    _imageHeight: number;
+    _bitsPerComponent: number;
+    _horizontalResolution: number;
+    _verticalResolution: number;
+    _imagePhysicalDimension: number[];
+    _imageStream: _PdfStream;
+    _reference: _PdfReference;
+    /**
+     * Gets the width of the PDF image.
+     *
+     * @returns {number} image width.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Access first page
+     * let page: PdfPage = document.getPage(0);
+     * // Gets the graphics of the PDF page
+     * let graphics: PdfGraphics = page.graphics;
+     * // Create new image object by using JPEG image data as Base64 string format
+     * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+     * // Gets the width of the image.
+     * let width: number = image.width;
+     * //Draw the image.
+     * image.draw(graphics);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    /**
+    * Sets the width of the PDF image.
+    *
+    * @param {number} value value.
+    * ```typescript
+    * // Load an existing PDF document
+    * let document: PdfDocument = new PdfDocument(data, password);
+    * // Access first page
+    * let page: PdfPage = document.getPage(0);
+    * // Gets the graphics of the PDF page
+    * let graphics: PdfGraphics = page.graphics;
+    * // Create new image object by using JPEG image data as Base64 string format
+    * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+    * // Sets the width of the image.
+    * image.width = 100;
+    * //Draw the image.
+    * image.draw(graphics);
+    * // Save the document
+    * document.save('output.pdf');
+    * // Destroy the document
+    * document.destroy();
+    * ```
+    */
+    width: number;
+    /**
+     * Gets the height of the PDF image.
+     *
+     * @returns {number} image height.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Access first page
+     * let page: PdfPage = document.getPage(0);
+     * // Gets the graphics of the PDF page
+     * let graphics: PdfGraphics = page.graphics;
+     * // Create new image object by using JPEG image data as Base64 string format
+     * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+     * // Gets the height of the image.
+     * let height: number = image.height;
+     * //Draw the image.
+     * image.draw(graphics);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    /**
+    * Sets the height of the PDF image.
+    *
+    * @param {number} value value.
+    * ```typescript
+    * // Load an existing PDF document
+    * let document: PdfDocument = new PdfDocument(data, password);
+    * // Access first page
+    * let page: PdfPage = document.getPage(0);
+    * // Gets the graphics of the PDF page
+    * let graphics: PdfGraphics = page.graphics;
+    * // Create new image object by using JPEG image data as Base64 string format
+    * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+    * // Sets the height of the image.
+    * image.height = 100;
+    * //Draw the image.
+    * image.draw(graphics);
+    * // Save the document
+    * document.save('output.pdf');
+    * // Destroy the document
+    * document.destroy();
+    * ```
+    */
+    height: number;
+    /**
+     * Gets the physical dimension of the PDF image (Read only).
+     *
+     * @returns {number[]} image physical dimension.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Access first page
+     * let page: PdfPage = document.getPage(0);
+     * // Gets the graphics of the PDF page
+     * let graphics: PdfGraphics = page.graphics;
+     * // Create new image object by using JPEG image data as Base64 string format
+     * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+     * // Gets the physical dimension of the image.
+     * let dimension: number[] = image.physicalDimension;
+     * //Draw the image.
+     * image.draw(graphics);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    readonly physicalDimension: number[];
+    /**
+     * Represents a method to draw a image on the PDF graphics.
+     *
+     * @param {PdfGraphics} graphics value.
+     * @returns {void} Draws a image on the page graphics.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Access first page
+     * let page: PdfPage = document.getPage(0);
+     * // Gets the graphics of the PDF page
+     * let graphics: PdfGraphics = page.graphics;
+     * // Create new image object by using JPEG image data as Base64 string format
+     * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+     * //Draw the image.
+     * image.draw(graphics);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    draw(graphics: PdfGraphics): void;
+    /**
+     * Represents a method to draw a image on the PDF graphics.
+     *
+     * @param {PdfGraphics} graphics value.
+     * @param {number} x The x-coordinate of the image
+     * @param {number} y The y-coordinate of the image.
+     * @returns {void} Draws a image on the page graphics.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Access first page
+     * let page: PdfPage = document.getPage(0);
+     * // Gets the graphics of the PDF page
+     * let graphics: PdfGraphics = page.graphics;
+     * // Create new image object by using JPEG image data as Base64 string format
+     * let image: PdfImage = new PdfBitmap('/9j/4AAQSkZJRgABAQEAkACQAAD/4....QB//Z');
+     * //Draw the image.
+     * image.draw(graphics, 10, 10);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    draw(graphics: PdfGraphics, x: number, y: number): void;
+    abstract _save(): void;
+    _getPointSize(width: number, height: number): number[];
+    _getPointSize(width: number, height: number, horizontalResolution: number): number[];
+}