[Feature] Add. PdfDoc.saveToTargetPath() for Writing PDF Directly to File Path

src/api/PDFDocument.ts

@@ -50,6 +50,7 @@ import {
   CreateOptions,
   EmbedFontOptions,
   SetTitleOptions,
+  FileSaveOptions,
 } from './PDFDocumentOptions';
 import PDFObject from '../core/objects/PDFObject';
 import PDFRef from '../core/objects/PDFRef';
@@ -1358,28 +1359,10 @@ export default class PDFDocument {
    * @returns Resolves with the bytes of the serialized document.
    */
   async save(options: SaveOptions = {}): Promise<Uint8Array> {
-    const {
-      useObjectStreams = true,
-      addDefaultPage = true,
-      objectsPerTick = 50,
-      updateFieldAppearances = true,
-    } = options;
-
-    assertIs(useObjectStreams, 'useObjectStreams', ['boolean']);
-    assertIs(addDefaultPage, 'addDefaultPage', ['boolean']);
-    assertIs(objectsPerTick, 'objectsPerTick', ['number']);
-    assertIs(updateFieldAppearances, 'updateFieldAppearances', ['boolean']);
-
-    if (addDefaultPage && this.getPageCount() === 0) this.addPage();
-
-    if (updateFieldAppearances) {
-      const form = this.formCache.getValue();
-      if (form) form.updateFieldAppearances();
-    }
-
-    await this.flush();
+    const defaultOptions = this.getDefaultSaveOptions(options);
+    const { objectsPerTick } = defaultOptions;
 
-    const Writer = useObjectStreams ? PDFStreamWriter : PDFWriter;
+    const Writer = await this.validateAndGetAdaptWriter(defaultOptions);
     return Writer.forContext(this.context, objectsPerTick).serializeToBuffer();
   }
 
@@ -1406,6 +1389,32 @@ export default class PDFDocument {
     return dataUri ? `data:application/pdf;base64,${base64}` : base64;
   }
 
+  /**
+   *
+   * Serialize this document to specific directory path formed with A PDF file
+   * For example:
+   * ```js
+   * const pdfBuffer = await saveToTargetPath { destPath: "/some/your/directory.pdf" }
+   * ```
+   *
+   * @param options The options are used to determine which path to write
+   * @returns Serialized Buffer Array from input Destination Path which is located The PDF file
+   *
+   */
+  async saveToTargetPath(options: FileSaveOptions): Promise<Uint8Array> {
+    options && options.outputPath && assertIsValidString(options.outputPath);
+    const resolvedSaveOptions = this.getDefaultSaveOptions(options);
+    const { objectsPerTick } = resolvedSaveOptions;
+
+    const Writer = await this.validateAndGetAdaptWriter(resolvedSaveOptions);
+    const { outputPath, forceWrite } = options;
+
+    return Writer.forContext(this.context, objectsPerTick).writeToTargetPath({
+      outputPath,
+      forceWrite: forceWrite !== undefined ? forceWrite : true,
+    });
+  }
+
   findPageForAnnotationRef(ref: PDFRef): PDFPage | undefined {
     const pages = this.getPages();
     for (let idx = 0, len = pages.length; idx < len; idx++) {
@@ -1420,6 +1429,53 @@ export default class PDFDocument {
     return undefined;
   }
 
+  private async validateAndGetAdaptWriter(
+    options: SaveOptions,
+  ): Promise<typeof PDFStreamWriter | typeof PDFWriter> {
+    const {
+      useObjectStreams,
+      addDefaultPage,
+      objectsPerTick,
+      updateFieldAppearances,
+    } = options;
+
+    assertIs(useObjectStreams, 'useObjectStreams', ['boolean']);
+    assertIs(addDefaultPage, 'addDefaultPage', ['boolean']);
+    assertIs(objectsPerTick, 'objectsPerTick', ['number']);
+    assertIs(updateFieldAppearances, 'updateFieldAppearances', ['boolean']);
+
+    if (addDefaultPage && this.getPageCount() === 0) this.addPage();
+
+    if (updateFieldAppearances) {
+      const form = this.formCache.getValue();
+      if (form) form.updateFieldAppearances();
+    }
+
+    await this.flush();
+    return useObjectStreams ? PDFStreamWriter : PDFWriter;
+  }
+
+  private getDefaultSaveOptions(options: SaveOptions): {
+    useObjectStreams: boolean;
+    addDefaultPage: boolean;
+    objectsPerTick: number;
+    updateFieldAppearances: boolean;
+  } {
+    const {
+      useObjectStreams = true,
+      addDefaultPage = true,
+      objectsPerTick = 50,
+      updateFieldAppearances = true,
+    } = options;
+
+    return {
+      useObjectStreams,
+      addDefaultPage,
+      objectsPerTick,
+      updateFieldAppearances,
+    };
+  }
+
   private async embedAll(embeddables: Embeddable[]): Promise<void> {
     for (let idx = 0, len = embeddables.length; idx < len; idx++) {
       await embeddables[idx].embed();
@@ -1486,3 +1542,7 @@ function assertIsLiteralOrHexString(
     throw new UnexpectedObjectTypeError([PDFHexString, PDFString], pdfObject);
   }
 }
+
+function assertIsValidString(str?: any): str is string {
+  return str !== null && str !== undefined && typeof str === 'string';
+}

src/api/PDFDocumentOptions.ts

@@ -21,6 +21,11 @@ export interface Base64SaveOptions extends SaveOptions {
   dataUri?: boolean;
 }
 
+export interface FileSaveOptions extends SaveOptions {
+  outputPath: string;
+  forceWrite?: boolean;
+}
+
 export interface LoadOptions {
   ignoreEncryption?: boolean;
   parseSpeed?: ParseSpeeds | number;

src/core/document/PDFCrossRefSection.ts

@@ -1,6 +1,11 @@
+import { Writable } from 'stream';
 import PDFRef from '../objects/PDFRef';
 import CharCodes from '../syntax/CharCodes';
-import { copyStringIntoBuffer, padStart } from '../../utils';
+import {
+  convertStringToUnicodeArray,
+  copyStringIntoBuffer,
+  padStart,
+} from '../../utils';
 
 export interface Entry {
   ref: PDFRef;
@@ -82,6 +87,45 @@ class PDFCrossRefSection {
     return size;
   }
 
+  writeBytesInto(stream: Writable) {
+    stream.write(
+      Buffer.from([
+        CharCodes.x,
+        CharCodes.r,
+        CharCodes.e,
+        CharCodes.f,
+        CharCodes.Newline,
+      ]),
+    );
+
+    const writeEntriesIntoStream = (entries: Entry[], stream: Writable) => {
+      entries.forEach((entry) => {
+        const entryOffset = padStart(String(entry.offset), 10, '0');
+        stream.write(convertStringToUnicodeArray(entryOffset));
+        stream.write(Buffer.from([CharCodes.Space]));
+
+        const entryGen = padStart(String(entry.ref.generationNumber), 5, '0');
+        stream.write(convertStringToUnicodeArray(entryGen));
+        stream.write(Buffer.from([CharCodes.Space]));
+        stream.write(Buffer.from([entry.deleted ? CharCodes.f : CharCodes.n]));
+        stream.write(Buffer.from([CharCodes.Space]));
+        stream.write(Buffer.from([CharCodes.Newline]));
+      });
+    };
+
+    // NOTE: String그냥쓰는 코드 있는지 확인해야해....
+    this.subsections.forEach((subsection) => {
+      stream.write(
+        convertStringToUnicodeArray(String(subsection[0].ref.objectNumber)),
+      );
+      stream.write(Buffer.from([CharCodes.Space]));
+
+      stream.write(convertStringToUnicodeArray(String(subsection.length)));
+      stream.write(Buffer.from([CharCodes.Newline]));
+      writeEntriesIntoStream(subsection, stream);
+    });
+  }
+
   copyBytesInto(buffer: Uint8Array, offset: number): number {
     const initialOffset = offset;
 

src/core/document/PDFHeader.ts

@@ -1,5 +1,10 @@
+import { Writable } from 'stream';
 import CharCodes from '../syntax/CharCodes';
-import { charFromCode, copyStringIntoBuffer } from '../../utils';
+import {
+  charFromCode,
+  convertStringToUnicodeArray,
+  copyStringIntoBuffer,
+} from '../../utils';
 
 class PDFHeader {
   static forVersion = (major: number, minor: number) =>
@@ -48,6 +53,23 @@ class PDFHeader {
 
     return offset - initialOffset;
   }
+
+  writeBytesInto(stream: Writable): void {
+    stream.write(
+      Buffer.from([
+        CharCodes.Percent,
+        CharCodes.P,
+        CharCodes.D,
+        CharCodes.F,
+        CharCodes.Dash,
+      ]),
+    );
+    stream.write(convertStringToUnicodeArray(this.major));
+    stream.write(Buffer.from([CharCodes.Period]));
+    stream.write(convertStringToUnicodeArray(this.minor));
+    stream.write(Buffer.from([CharCodes.Newline]));
+    stream.write(Buffer.from([CharCodes.Percent, 129, 129, 129, 129]));
+  }
 }
 
 export default PDFHeader;

src/core/document/PDFTrailer.ts

@@ -1,5 +1,6 @@
 import CharCodes from '../syntax/CharCodes';
-import { copyStringIntoBuffer } from '../../utils';
+import { convertStringToUnicodeArray, copyStringIntoBuffer } from '../../utils';
+import { Writable } from 'stream';
 
 class PDFTrailer {
   static forLastCrossRefSectionOffset = (offset: number) =>
@@ -44,6 +45,36 @@ class PDFTrailer {
 
     return offset - initialOffset;
   }
+
+  writeBytesInto(stream: Writable): void {
+    stream.write(
+      Buffer.from([
+        CharCodes.s,
+        CharCodes.t,
+        CharCodes.a,
+        CharCodes.r,
+        CharCodes.t,
+        CharCodes.x,
+        CharCodes.r,
+        CharCodes.e,
+        CharCodes.f,
+        CharCodes.Newline,
+      ]),
+    );
+
+    stream.write(convertStringToUnicodeArray(this.lastXRefOffset));
+
+    stream.write(
+      Buffer.from([
+        CharCodes.Newline,
+        CharCodes.Percent,
+        CharCodes.Percent,
+        CharCodes.E,
+        CharCodes.O,
+        CharCodes.F,
+      ]),
+    );
+  }
 }
 
 export default PDFTrailer;

src/core/document/PDFTrailerDict.ts

@@ -1,3 +1,4 @@
+import { Writable } from 'stream';
 import PDFDict from '../objects/PDFDict';
 import CharCodes from '../syntax/CharCodes';
 
@@ -34,6 +35,23 @@ class PDFTrailerDict {
 
     return offset - initialOffset;
   }
+
+  writeBytesInto(stream: Writable): void {
+    stream.write(
+      Buffer.from([
+        CharCodes.t,
+        CharCodes.r,
+        CharCodes.a,
+        CharCodes.i,
+        CharCodes.l,
+        CharCodes.e,
+        CharCodes.r,
+        CharCodes.Newline,
+      ]),
+    );
+
+    this.dict.writeBytesInto(stream);
+  }
 }
 
 export default PDFTrailerDict;

src/core/objects/PDFArray.ts

@@ -12,6 +12,7 @@ import PDFContext from '../PDFContext';
 import CharCodes from '../syntax/CharCodes';
 import { PDFArrayIsNotRectangleError } from '../errors';
 import PDFRawStream from './PDFRawStream';
+import { Writable } from 'stream';
 
 class PDFArray extends PDFObject {
   static withContext = (context: PDFContext) => new PDFArray(context);
@@ -171,6 +172,17 @@ class PDFArray extends PDFObject {
     return offset - initialOffset;
   }
 
+  writeBytesInto(stream: Writable): void {
+    stream.write(Buffer.from([CharCodes.LeftSquareBracket, CharCodes.Space]));
+
+    this.array.forEach((obj) => {
+      obj.writeBytesInto(stream);
+      stream.write(Buffer.from([CharCodes.Space]));
+    });
+
+    stream.write(Buffer.from([CharCodes.RightSquareBracket]));
+  }
+
   scalePDFNumbers(x: number, y: number): void {
     for (let idx = 0, len = this.size(); idx < len; idx++) {
       const el = this.lookup(idx);

src/core/objects/PDFBool.ts

@@ -1,6 +1,7 @@
 import { PrivateConstructorError } from '../errors';
 import PDFObject from './PDFObject';
 import CharCodes from '../syntax/CharCodes';
+import { Writable } from 'stream';
 
 const ENFORCER = {};
 
@@ -48,6 +49,22 @@ class PDFBool extends PDFObject {
       return 5;
     }
   }
+
+  writeBytesInto(stream: Writable): void {
+    this.value
+      ? stream.write(
+          Buffer.from([CharCodes.t, CharCodes.r, CharCodes.u, CharCodes.e]),
+        )
+      : stream.write(
+          Buffer.from([
+            CharCodes.f,
+            CharCodes.a,
+            CharCodes.l,
+            CharCodes.s,
+            CharCodes.e,
+          ]),
+        );
+  }
 }
 
 export default PDFBool;