@syncfusion/ej2-pdf-export 23.2.6 → 24.1.41

package/dist/ts/implementation/primitives/pdf-stream.ts

@@ -0,0 +1,306 @@
+/**
+ * PdfStream.ts class for EJ2-PDF
+ */
+import { IPdfWriter } from './../../interfaces/i-pdf-writer';
+import { PdfDictionary } from './pdf-dictionary';
+import { PdfNumber } from './pdf-number';
+import { Operators } from './../input-output/pdf-operators';
+import { PdfName } from './pdf-name';
+import { PdfArray } from './pdf-array';
+import { PdfReferenceHolder } from './pdf-reference';
+import { IPdfPrimitive } from './../../interfaces/i-pdf-primitives';
+import { CompressedStreamWriter } from '@syncfusion/ej2-compression';
+import { UnicodeTrueTypeFont } from './../graphics/fonts/unicode-true-type-font';
+/**
+ * `PdfStream` class is used to perform stream related primitive operations.
+ * @private
+ */
+export class PdfStream extends PdfDictionary {
+    //Constants
+    /**
+     * @hidden
+     * @private
+     */
+    private readonly dicPrefix : string = 'stream';
+    /**
+     * @hidden
+     * @private
+     */
+    private readonly dicSuffix : string = 'endstream';
+    //Fields
+    /**
+     * @hidden
+     * @private
+     */
+    private dataStream2 : string[];
+    /**
+     * @hidden
+     * @private
+     */
+    private blockEncryption2 : boolean;
+    /**
+     * @hidden
+     * @private
+     */
+    private bDecrypted2 : boolean;
+    /**
+     * @hidden
+     * @private
+     */
+    private bCompress2 : boolean;
+    /**
+     * @hidden
+     * @private
+     */
+    private bEncrypted2 : boolean;
+    /**
+     * Internal variable to hold `cloned object`.
+     * @private
+     */
+    private clonedObject2 : PdfStream = null;
+    /**
+     * @hidden
+     * @private
+     */
+    private bCompress : boolean = true;
+    /**
+     * Event. Raise `before the object saves`.
+     * @private
+     */
+    public cmapBeginSave : SaveCmapEventHandler;
+    /**
+     * Event. Raise `before the object saves`.
+     * @private
+     */
+    public fontProgramBeginSave : SaveFontProgramEventHandler;
+    //Constructors
+    /**
+     * Initialize an instance for `PdfStream` class.
+     * @private
+     */
+    public constructor()
+    /**
+     * Initialize an instance for `PdfStream` class.
+     * @private
+     */
+    public constructor(dictionary : PdfDictionary, data : string[])
+    public constructor(dictionary? : PdfDictionary, data? : string[]) {
+        super(dictionary);
+        if (typeof dictionary !== 'undefined' || typeof data !== 'undefined') {
+            this.dataStream2 = [];
+            this.dataStream2 = data;
+            this.bCompress2 = false;
+        } else {
+            this.dataStream2 = [];
+            this.bCompress2 = true;
+            //Pending
+        }
+    }
+    /**
+     * Gets the `internal` stream.
+     * @private
+     */
+    public get internalStream() : string[] {
+        return this.dataStream2;
+    }
+    public set internalStream(value : string[]) {
+        this.dataStream2 = [];
+        this.dataStream2 = value;
+        this.modify();
+    }
+    /**
+     * Gets or sets `compression` flag.
+     * @private
+     */
+    public get compress() : boolean {
+        return this.bCompress;
+    }
+    public set compress(value : boolean) {
+        this.bCompress = value;
+        this.modify();
+    }
+    /**
+     * Gets or sets the `data`.
+     * @private
+     */
+    public get data() : string[] {
+        return this.dataStream2;
+    }
+    public set data(value : string[]) {
+        this.dataStream2 = [];
+        this.dataStream2 = value;
+        this.modify();
+    }
+    /**
+     * `Clear` the internal stream.
+     * @private
+     */
+    public clearStream() : void {
+        this.internalStream = [];
+        if (this.items.containsKey(this.dictionaryProperties.filter)) {
+            this.remove(this.dictionaryProperties.filter);
+        }
+        this.bCompress = true;
+        this.modify();
+    }
+    /**
+     * `Writes` the specified string.
+     * @private
+     */
+    public write(text : string) : void {
+        if (text == null) {
+            throw new Error('ArgumentNullException:text');
+        }
+        if (text.length <= 0) {
+            throw new Error('ArgumentException: Can not write an empty string, text');
+        }
+        this.dataStream2.push(text);
+        this.modify();
+    }
+    /**
+     * `Writes` the specified bytes.
+     * @private
+     */
+    public writeBytes(data : number[]) : void {
+        if (data === null) {
+            throw new Error('ArgumentNullException:data');
+        }
+        if (data.length <= 0) {
+            throw new Error('ArgumentException: Can not write an empty bytes, data');
+        }
+        let text : string = '';
+        for (let i : number = 0; i < data.length; i++) {
+            text += String.fromCharCode(data[i]);
+        }
+        this.dataStream2.push(text);
+        this.modify();
+    }
+    /**
+     * Raises event `Cmap BeginSave`.
+     * @private
+     */
+    public onCmapBeginSave() : void {
+        (this.cmapBeginSave as SaveCmapEventHandler).sender.cmapBeginSave();
+    }
+    /**
+     * Raises event `Font Program BeginSave`.
+     * @private
+     */
+    protected onFontProgramBeginSave() : void {
+        (this.fontProgramBeginSave as SaveFontProgramEventHandler).sender.fontProgramBeginSave();
+    }
+    /**
+     * `Compresses the content` if it's required.
+     * @private
+     */
+    private compressContent(data : string, writer : IPdfWriter) : string {
+        if (this.bCompress) {
+            let byteArray : number[] = [];
+            for (let i : number = 0; i < data.length; i++) {
+                byteArray.push(data.charCodeAt(i));
+            }
+            let dataArray : Uint8Array = new Uint8Array(byteArray);
+            let sw : CompressedStreamWriter = new CompressedStreamWriter();
+            // data = 'Hello World!!!';
+            sw.write(dataArray, 0, dataArray.length);
+            sw.close();
+            data = sw.getCompressedString;
+            this.addFilter(this.dictionaryProperties.flatedecode);
+        }
+        return data;
+    }
+    /**
+     * `Adds a filter` to the filter array.
+     * @private
+     */
+    public addFilter(filterName : string) : void {
+        let obj : IPdfPrimitive = this.items.getValue(this.dictionaryProperties.filter);
+        if (obj instanceof PdfReferenceHolder) {
+            let rh : PdfReferenceHolder = obj as PdfReferenceHolder;
+            obj = rh.object;
+        }
+        let array : PdfArray = obj as PdfArray;
+        let name : PdfName = obj as PdfName;
+        if (name != null) {
+            array = new PdfArray();
+            array.insert(0, name);
+            this.items.setValue(this.dictionaryProperties.filter, array);
+        }
+        name = new PdfName(filterName);
+        if (array == null) {
+            this.items.setValue(this.dictionaryProperties.filter, name);
+        } else {
+            array.insert(0, name);
+        }
+    }
+    /**
+     * `Saves` the object using the specified writer.
+     * @private
+     */
+    public save(writer : IPdfWriter) : void {
+        if (typeof this.cmapBeginSave !== 'undefined') {
+            this.onCmapBeginSave();
+        }
+        if (typeof this.fontProgramBeginSave !== 'undefined') {
+            this.onFontProgramBeginSave();
+        }
+        let data : string = '';
+        for (let i : number = 0; i < this.data.length; i++) {
+            data = data + this.data[i];
+        }
+        if (data.length > 1 && !this.isResource) {
+            data = 'q\r\n' + data + 'Q\r\n';
+        }
+        data = this.compressContent(data, writer);
+        let length : number = data.length;
+        this.items.setValue(this.dictionaryProperties.length, new PdfNumber(length));
+        super.save(writer, false);
+        writer.write(this.dicPrefix);
+        writer.write(Operators.newLine);
+        if (data.length > 0) {
+            writer.write(data);
+        }
+        writer.write(Operators.newLine);
+        writer.write(this.dicSuffix);
+        writer.write(Operators.newLine);
+    }
+    /**
+     * Converts `bytes to string`.
+     * @private
+     */
+    public static bytesToString(byteArray : number[]) : string {
+        let output : string = '';
+        for (let i : number = 0; i < byteArray.length; i++ ) {
+            output = output + String.fromCharCode(byteArray[i]);
+        }
+        return output;
+    }
+}
+export class SaveCmapEventHandler {
+    /**
+     * @hidden
+     * @private
+     */
+    public sender : UnicodeTrueTypeFont;
+    /**
+     * New instance for `save section collection event handler` class.
+     * @private
+     */
+    public constructor(sender : UnicodeTrueTypeFont) {
+        this.sender = sender;
+    }
+}
+export class SaveFontProgramEventHandler {
+    /**
+     * @hidden
+     * @private
+     */
+    public sender : UnicodeTrueTypeFont;
+    /**
+     * New instance for `save section collection event handler` class.
+     * @private
+     */
+    public constructor(sender : UnicodeTrueTypeFont) {
+        this.sender = sender;
+    }
+}

package/dist/ts/implementation/primitives/pdf-string.ts

@@ -0,0 +1,397 @@
+/**
+ * PdfString.ts class for EJ2-PDF
+ */
+import { IPdfPrimitive } from './../../interfaces/i-pdf-primitives';
+import { IPdfWriter } from './../../interfaces/i-pdf-writer';
+import { ObjectStatus } from './../input-output/enum';
+import { PdfCrossTable } from './../input-output/pdf-cross-table';
+/**
+ * `PdfString` class is used to perform string related primitive operations.
+ * @private
+ */
+export namespace InternalEnum {
+    //Internals
+    /**
+     * public Enum for `ForceEncoding`.
+     * @private
+     */
+    export enum ForceEncoding {
+        /**
+         * Specifies the type of `None`.
+         * @private
+         */
+        None,
+        /**
+         * Specifies the type of `Ascii`.
+         * @private
+         */
+        Ascii,
+        /**
+         * Specifies the type of `Unicode`.
+         * @private
+         */
+        Unicode
+    }
+    /**
+     * public Enum for `SourceType`.
+     * @private
+     */
+    enum SourceType {
+        /**
+         * Specifies the type of `StringValue`.
+         * @private
+         */
+        StringValue,
+        /**
+         * Specifies the type of `ByteBuffer`.
+         * @private
+         */
+        ByteBuffer,
+    }
+}
+export class PdfString implements IPdfPrimitive {
+    //constants = ;
+    /**
+     * `General markers` for string.
+     * @private
+     */
+    public static readonly stringMark : string = '()';
+    /**
+     * `Hex markers` for string.
+     * @private
+     */
+    public static readonly hexStringMark : string = '<>';
+    /**
+     * Format of password data.
+     * @private
+     */
+    private static readonly hexFormatPattern : string = '{0:X2}';
+    //Fields
+    /**
+     * Value of the object.
+     * @private
+     */
+    private stringValue : string;
+    /**
+     * The byte data of the string.
+     * @private
+     */
+    private data : number[];
+    /**
+     * Value indicating whether the string was converted to hex.
+     * @default false
+     * @private
+     */
+    private bHex : boolean = false;
+    /**
+     * Shows the type of object `status` whether it is object registered or other status;
+     * @private
+     */
+    private status1 : ObjectStatus;
+    /**
+     * Indicates if the object is currently in `saving state or not`.
+     * @private
+     */
+    private isSaving1 : boolean;
+    /**
+     * Internal variable to store the `position`.
+     * @default -1
+     * @private
+     */
+    private position1 : number = -1;
+    /**
+     * Internal variable to hold `PdfCrossTable` reference.
+     * @private
+     */
+    private crossTable : PdfCrossTable;
+    /**
+     * Internal variable to hold `cloned object`.
+     * @default null
+     * @private
+     */
+    private clonedObject1 : PdfString = null;
+    /**
+     * Indicates whether to check if the value `has unicode characters`.
+     * @private
+     */
+    private bConverted : boolean;
+    /**
+     * Indicates whether we should convert `data to Unicode`.
+     * @private
+     */
+    private bForceEncoding : InternalEnum.ForceEncoding;
+    /**
+     * `Shows` if the data of the stream was decrypted.
+     * @default false
+     * @private
+     */
+    private bDecrypted : boolean = false;
+    /**
+     * Holds the `index` number of the object.
+     * @private
+     */
+    private index1 : number;
+    /**
+     * Shows if the data of the stream `was decrypted`.
+     * @default false
+     * @private
+     */
+    private isParentDecrypted : boolean = false;
+    /**
+     * Gets a value indicating whether the object is `packed or not`.
+     * @default false
+     * @private
+     */
+    private isPacked : boolean = false;
+    /**
+     * @hidden
+     * @private
+     */
+    public isFormField : boolean = false;
+    /**
+     * @hidden
+     * @private
+     */
+    public isColorSpace : boolean = false;
+    /**
+     * @hidden
+     * @private
+     */
+    public isHexString : boolean = true;
+    /**
+     * @hidden
+     * @private
+     */
+    private encodedBytes : number[];
+    //constructor
+    /**
+     * Initializes a new instance of the `PdfString` class.
+     * @private
+     */
+    public constructor()
+    /**
+     * Initializes a new instance of the `PdfString` class.
+     * @private
+     */
+    public constructor(value : string)
+    public constructor(value? : string) {
+        if (typeof value === 'undefined') {
+            this.bHex = false;
+        } else {
+            if (!(value.length > 0 && value[0] === '0xfeff')) {
+                this.stringValue = value;
+                this.data = [];
+                for (let i : number = 0; i < value.length; ++i) {
+                    this.data.push(value.charCodeAt(i));
+                }
+            }
+        }
+    }
+    //Property
+    /**
+     * Gets a value indicating whether string is in `hex`.
+     * @private
+     */
+    public get hex() : boolean {
+        return this.bHex;
+    }
+    /**
+     * Gets or sets string `value` of the object.
+     * @private
+     */
+    public get value() : string {
+        return this.stringValue;
+    }
+    public set value(value : string) {
+        this.stringValue = value;
+        this.data = null;
+    }
+    /**
+     * Gets or sets the `Status` of the specified object.
+     * @private
+     */
+    public get status() : ObjectStatus {
+        return this.status1;
+    }
+    public set status(value : ObjectStatus) {
+        this.status1 = value;
+    }
+    /**
+     * Gets or sets a value indicating whether this document `is saving` or not.
+     * @private
+     */
+    public get isSaving() : boolean {
+        return this.isSaving1;
+    }
+    public set isSaving(value : boolean) {
+        this.isSaving1 = value;
+    }
+    /**
+     * Gets or sets the `index` value of the specified object.
+     * @private
+     */
+    public get objectCollectionIndex() : number {
+        return this.index1;
+    }
+    public set objectCollectionIndex(value : number) {
+        this.index1 = value;
+    }
+    /**
+     * Returns `cloned object`.
+     * @private
+     */
+    public get clonedObject() : IPdfPrimitive {
+        return this.clonedObject1;
+    }
+    /**
+     * Gets or sets the `position` of the object.
+     * @private
+     */
+    public get position() : number {
+        return this.position1;
+    }
+    public set position(value : number) {
+        this.position1 = value;
+    }
+    /**
+     * Returns `PdfCrossTable` associated with the object.
+     * @private
+     */
+    public get CrossTable() : PdfCrossTable {
+        return this.crossTable;
+    }
+    /**
+     * Gets a value indicating whether to check if the value has unicode characters.
+     * @private
+     */
+    public get converted() : boolean {
+        return this.bConverted;
+    }
+    /**
+     * sets a value indicating whether to check if the value has unicode characters.
+     * @private
+     */
+    public set converted(value : boolean) {
+        this.bConverted = value;
+    }
+    /**
+     * Gets value indicating whether we should convert data to Unicode.
+     */
+    public get encode() : InternalEnum.ForceEncoding {
+        return this.bForceEncoding;
+    }
+    public set encode(value : InternalEnum.ForceEncoding) {
+        this.bForceEncoding = value;
+    }
+    //Methods
+    /**
+     * Converts `bytes to string using hex format` for representing string.
+     * @private
+     */
+    public static bytesToHex(bytes : number[]) : string {
+        if (bytes == null) {
+            return '';
+        }
+        let builder : string = '';
+        return builder;
+    }
+    /**
+     * `Saves` the object using the specified writer.
+     * @private
+     */
+    public save(writer : IPdfWriter) : void {
+        if (writer === null) {
+            throw new Error('ArgumentNullException : writer');
+        }
+        if (this.encode !== undefined && this.encode === InternalEnum.ForceEncoding.Ascii) {
+            writer.write(this.pdfEncode());
+        } else {
+            writer.write(PdfString.stringMark[0] + this.value + PdfString.stringMark[1]);
+        }
+    }
+    public pdfEncode() : string {
+        let result : string = '';
+        if (this.encode !== undefined && this.encode === InternalEnum.ForceEncoding.Ascii) {
+            let data : number[] = this.escapeSymbols(this.value);
+            for (let i : number = 0; i < data.length; i++) {
+                result += String.fromCharCode(data[i]);
+            }
+            result = PdfString.stringMark[0] + result + PdfString.stringMark[1];
+        } else {
+            result = this.value;
+        }
+        return result;
+    }
+    private escapeSymbols(value : string) : number[] {
+        let data : number[] = [];
+        for (let i : number = 0; i < value.length; i++) {
+            let currentData : number = value.charCodeAt(i);
+            switch (currentData) {
+                case 40:
+                case 41:
+                    data.push(92);
+                    data.push(currentData);
+                    break;
+                case 13:
+                    data.push(92);
+                    data.push(114);
+                    break;
+                case 92:
+                    data.push(92);
+                    data.push(currentData);
+                    break;
+
+                default:
+                    data.push(currentData);
+                    break;
+            }
+        }
+        return data;
+    }
+    /**
+     * Creates a `copy of PdfString`.
+     * @private
+     */
+    public clone(crossTable : PdfCrossTable) : IPdfPrimitive {
+        if (this.clonedObject1 !== null && this.clonedObject1.CrossTable === crossTable) {
+            return this.clonedObject1;
+        } else {
+            this.clonedObject1 = null;
+        }
+        let newString : PdfString = new PdfString(this.stringValue);
+        newString.bHex = this.bHex;
+        newString.crossTable = crossTable;
+        newString.isColorSpace = this.isColorSpace;
+        this.clonedObject1 = newString;
+        return newString;
+    }
+    /**
+     * Converts string to array of unicode symbols.
+     */
+    public static toUnicodeArray(value : string, bAddPrefix : boolean) : number[] {
+        if (value == null) {
+            throw new Error('Argument Null Exception : value');
+        }
+        let startIndex : number = 0;
+        let output : number[] = [];
+        for (let i : number = 0; i < value.length; i++) {
+            let code : number = value.charCodeAt(i);
+            output.push(code / 256 >>> 0);
+            output.push(code & 0xff);
+        }
+        return output;
+    }
+    /**
+     * Converts byte data to string.
+     */
+    public static byteToString(data : number[]) : string {
+        if (data == null) {
+            throw new Error('Argument Null Exception : stream');
+        }
+        let result : string = '';
+        for (let i : number = 0; i < data.length; ++i) {
+            result += String.fromCharCode(data[i]);
+        }
+        return result;
+    }
+}