pdfkit 0.12.3 → 0.14.0

package/js/pdfkit.js

@@ -401,6 +401,11 @@ class PDFPage {
     return data.Pattern != null ? data.Pattern : data.Pattern = {};
   }
 
+  get colorSpaces() {
+    const data = this.resources.data;
+    return data.ColorSpace || (data.ColorSpace = {});
+  }
+
   get annotations() {
     const data = this.dictionary.data;
     return data.Annots != null ? data.Annots : data.Annots = [];
@@ -1462,7 +1467,7 @@ class PDFGradient {
     return pattern;
   }
 
-  apply(op) {
+  apply(stroke) {
     // apply gradient transform to existing document ctm
     const [m0, m1, m2, m3, m4, m5] = this.doc._ctm;
     const [m11, m12, m21, m22, dx, dy] = this.transform;
@@ -1472,6 +1477,9 @@ class PDFGradient {
       this.embed(m);
     }
 
+    this.doc._setColorSpace('Pattern', stroke);
+
+    const op = stroke ? 'SCN' : 'scn';
     return this.doc.addContent(`/${this.id} ${op}`);
   }
 
@@ -1536,24 +1544,119 @@ var Gradient = {
   PDFRadialGradient
 };
 
+/*
+PDF tiling pattern support. Uncolored only.
+ */
+const underlyingColorSpaces = ['DeviceCMYK', 'DeviceRGB'];
+
+class PDFTilingPattern {
+  constructor(doc, bBox, xStep, yStep, stream) {
+    this.doc = doc;
+    this.bBox = bBox;
+    this.xStep = xStep;
+    this.yStep = yStep;
+    this.stream = stream;
+  }
+
+  createPattern() {
+    // no resources needed for our current usage
+    // required entry
+    const resources = this.doc.ref();
+    resources.end(); // apply default transform matrix (flipped in the default doc._ctm)
+    // see document.js & gradient.js
+
+    const [m0, m1, m2, m3, m4, m5] = this.doc._ctm;
+    const [m11, m12, m21, m22, dx, dy] = [1, 0, 0, 1, 0, 0];
+    const m = [m0 * m11 + m2 * m12, m1 * m11 + m3 * m12, m0 * m21 + m2 * m22, m1 * m21 + m3 * m22, m0 * dx + m2 * dy + m4, m1 * dx + m3 * dy + m5];
+    const pattern = this.doc.ref({
+      Type: 'Pattern',
+      PatternType: 1,
+      // tiling
+      PaintType: 2,
+      // 1-colored, 2-uncolored
+      TilingType: 2,
+      // 2-no distortion
+      BBox: this.bBox,
+      XStep: this.xStep,
+      YStep: this.yStep,
+      Matrix: m.map(v => +v.toFixed(5)),
+      Resources: resources
+    });
+    pattern.end(this.stream);
+    return pattern;
+  }
+
+  embedPatternColorSpaces() {
+    // map each pattern to an underlying color space
+    // and embed on each page
+    underlyingColorSpaces.forEach(csName => {
+      const csId = this.getPatternColorSpaceId(csName);
+      if (this.doc.page.colorSpaces[csId]) return;
+      const cs = this.doc.ref(['Pattern', csName]);
+      cs.end();
+      this.doc.page.colorSpaces[csId] = cs;
+    });
+  }
+
+  getPatternColorSpaceId(underlyingColorspace) {
+    return `CsP${underlyingColorspace}`;
+  }
+
+  embed() {
+    if (!this.id) {
+      this.doc._patternCount = this.doc._patternCount + 1;
+      this.id = 'P' + this.doc._patternCount;
+      this.pattern = this.createPattern();
+    } // patterns are embedded in each page
+
+
+    if (!this.doc.page.patterns[this.id]) {
+      this.doc.page.patterns[this.id] = this.pattern;
+    }
+  }
+
+  apply(stroke, patternColor) {
+    // do any embedding/creating that might be needed
+    this.embedPatternColorSpaces();
+    this.embed();
+
+    const normalizedColor = this.doc._normalizeColor(patternColor);
+
+    if (!normalizedColor) throw Error(`invalid pattern color. (value: ${patternColor})`); // select one of the pattern color spaces
+
+    const csId = this.getPatternColorSpaceId(this.doc._getColorSpace(normalizedColor));
+
+    this.doc._setColorSpace(csId, stroke); // stroke/fill using the pattern and color (in the above underlying color space)
+
+
+    const op = stroke ? 'SCN' : 'scn';
+    return this.doc.addContent(`${normalizedColor.join(' ')} /${this.id} ${op}`);
+  }
+
+}
+
+var pattern = {
+  PDFTilingPattern
+};
+
 const {
   PDFGradient: PDFGradient$1,
   PDFLinearGradient: PDFLinearGradient$1,
   PDFRadialGradient: PDFRadialGradient$1
 } = Gradient;
+const {
+  PDFTilingPattern: PDFTilingPattern$1
+} = pattern;
 var ColorMixin = {
   initColor() {
     // The opacity dictionaries
     this._opacityRegistry = {};
     this._opacityCount = 0;
+    this._patternCount = 0;
     return this._gradCount = 0;
   },
 
   _normalizeColor(color) {
-    if (color instanceof PDFGradient$1) {
-      return color;
-    }
-
     if (typeof color === 'string') {
       if (color.charAt(0) === '#') {
         if (color.length === 4) {
@@ -1582,6 +1685,19 @@ var ColorMixin = {
   },
 
   _setColor(color, stroke) {
+    if (color instanceof PDFGradient$1) {
+      color.apply(stroke);
+      return true; // see if tiling pattern, decode & apply it it
+    } else if (Array.isArray(color) && color[0] instanceof PDFTilingPattern$1) {
+      color[0].apply(stroke, color[1]);
+      return true;
+    } // any other case should be a normal color and not a pattern
+
+
+    return this._setColorCore(color, stroke);
+  },
+
+  _setColorCore(color, stroke) {
     color = this._normalizeColor(color);
 
     if (!color) {
@@ -1590,19 +1706,12 @@ var ColorMixin = {
 
     const op = stroke ? 'SCN' : 'scn';
 
-    if (color instanceof PDFGradient$1) {
-      this._setColorSpace('Pattern', stroke);
+    const space = this._getColorSpace(color);
 
-      color.apply(op);
-    } else {
-      const space = color.length === 4 ? 'DeviceCMYK' : 'DeviceRGB';
-
-      this._setColorSpace(space, stroke);
-
-      color = color.join(' ');
-      this.addContent(`${color} ${op}`);
-    }
+    this._setColorSpace(space, stroke);
 
+    color = color.join(' ');
+    this.addContent(`${color} ${op}`);
     return true;
   },
 
@@ -1611,6 +1720,10 @@ var ColorMixin = {
     return this.addContent(`/${space} ${op}`);
   },
 
+  _getColorSpace(color) {
+    return color.length === 4 ? 'DeviceCMYK' : 'DeviceRGB';
+  },
+
   fillColor(color, opacity) {
     const set = this._setColor(color, false);
 
@@ -1701,6 +1814,10 @@ var ColorMixin = {
 
   radialGradient(x1, y1, r1, x2, y2, r2) {
     return new PDFRadialGradient$1(this, x1, y1, r1, x2, y2, r2);
+  },
+
+  pattern(bbox, xStep, yStep, stream) {
+    return new PDFTilingPattern$1(this, bbox, xStep, yStep, stream);
   }
 
 };
@@ -3173,6 +3290,14 @@ class EmbeddedFont extends PDFFont {
       descriptor.data.FontFile2 = fontFile;
     }
 
+    if (this.document.subset) {
+      const CIDSet = Buffer.from('FFFFFFFFC0', 'hex');
+      const CIDSetRef = this.document.ref();
+      CIDSetRef.write(CIDSet);
+      CIDSetRef.end();
+      descriptor.data.CIDSet = CIDSetRef;
+    }
+
     descriptor.end();
     const descendantFontData = {
       Type: 'Font',
@@ -5944,6 +6069,219 @@ function isEqual(a, b) {
   return a.Subtype === b.Subtype && a.Params.CheckSum.toString() === b.Params.CheckSum.toString() && a.Params.Size === b.Params.Size && a.Params.CreationDate === b.Params.CreationDate && a.Params.ModDate === b.Params.ModDate;
 }
 
+var PDFA = {
+  initPDFA(pSubset) {
+    if (pSubset.charAt(pSubset.length - 3) === '-') {
+      this.subset_conformance = pSubset.charAt(pSubset.length - 1).toUpperCase();
+      this.subset = parseInt(pSubset.charAt(pSubset.length - 2));
+    } else {
+      // Default to Basic conformance when user doesn't specify
+      this.subset_conformance = 'B';
+      this.subset = parseInt(pSubset.charAt(pSubset.length - 1));
+    }
+  },
+
+  endSubset() {
+    this._addPdfaMetadata();
+
+    const jsPath = `${__dirname}/data/sRGB_IEC61966_2_1.icc`;
+    const jestPath = `${__dirname}/../color_profiles/sRGB_IEC61966_2_1.icc`;
+
+    this._addColorOutputIntent(fs.existsSync(jsPath) ? jsPath : jestPath);
+  },
+
+  _addColorOutputIntent(pICCPath) {
+    const iccProfile = fs.readFileSync(pICCPath);
+    const colorProfileRef = this.ref({
+      Length: iccProfile.length,
+      N: 3
+    });
+    colorProfileRef.write(iccProfile);
+    colorProfileRef.end();
+    const intentRef = this.ref({
+      Type: 'OutputIntent',
+      S: 'GTS_PDFA1',
+      Info: new String('sRGB IEC61966-2.1'),
+      OutputConditionIdentifier: new String('sRGB IEC61966-2.1'),
+      DestOutputProfile: colorProfileRef
+    });
+    intentRef.end();
+    this._root.data.OutputIntents = [intentRef];
+  },
+
+  _getPdfaid() {
+    return `
+        <rdf:Description xmlns:pdfaid="http://www.aiim.org/pdfa/ns/id/" rdf:about="">
+            <pdfaid:part>${this.subset}</pdfaid:part>
+            <pdfaid:conformance>${this.subset_conformance}</pdfaid:conformance>
+        </rdf:Description>
+        `;
+  },
+
+  _addPdfaMetadata() {
+    this.appendXML(this._getPdfaid());
+  }
+
+};
+
+var SubsetMixin = {
+  _importSubset(subset) {
+    Object.assign(this, subset);
+  },
+
+  initSubset(options) {
+    switch (options.subset) {
+      case 'PDF/A-1':
+      case 'PDF/A-1a':
+      case 'PDF/A-1b':
+      case 'PDF/A-2':
+      case 'PDF/A-2a':
+      case 'PDF/A-2b':
+      case 'PDF/A-3':
+      case 'PDF/A-3a':
+      case 'PDF/A-3b':
+        this._importSubset(PDFA);
+
+        this.initPDFA(options.subset);
+        break;
+    }
+  }
+
+};
+
+class PDFMetadata {
+  constructor() {
+    this._metadata = `
+        <?xpacket begin="\ufeff" id="W5M0MpCehiHzreSzNTczkc9d"?>
+            <x:xmpmeta xmlns:x="adobe:ns:meta/">
+                <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+        `;
+  }
+
+  _closeTags() {
+    this._metadata = this._metadata.concat(`
+                </rdf:RDF>
+            </x:xmpmeta>
+        <?xpacket end="w"?>
+        `);
+  }
+
+  append(xml, newline = true) {
+    this._metadata = this._metadata.concat(xml);
+    if (newline) this._metadata = this._metadata.concat('\n');
+  }
+
+  getXML() {
+    return this._metadata;
+  }
+
+  getLength() {
+    return this._metadata.length;
+  }
+
+  end() {
+    this._closeTags();
+
+    this._metadata = this._metadata.trim();
+  }
+
+}
+
+var MetadataMixin = {
+  initMetadata() {
+    this.metadata = new PDFMetadata();
+  },
+
+  appendXML(xml, newline = true) {
+    this.metadata.append(xml, newline);
+  },
+
+  _addInfo() {
+    this.appendXML(`
+        <rdf:Description rdf:about="" xmlns:xmp="http://ns.adobe.com/xap/1.0/">
+            <xmp:CreateDate>${this.info.CreationDate.toISOString().split('.')[0] + "Z"}</xmp:CreateDate>
+            <xmp:CreatorTool>${this.info.Creator}</xmp:CreatorTool>
+        </rdf:Description>
+        `);
+
+    if (this.info.Title || this.info.Author || this.info.Subject) {
+      this.appendXML(`
+            <rdf:Description rdf:about="" xmlns:dc="http://purl.org/dc/elements/1.1/">
+            `);
+
+      if (this.info.Title) {
+        this.appendXML(`
+                <dc:title>
+                    <rdf:Alt>
+                        <rdf:li xml:lang="x-default">${this.info.Title}</rdf:li>
+                    </rdf:Alt>
+                </dc:title>
+                `);
+      }
+
+      if (this.info.Author) {
+        this.appendXML(`
+                <dc:creator>
+                    <rdf:Seq>
+                        <rdf:li>${this.info.Author}</rdf:li>
+                    </rdf:Seq>
+                </dc:creator>
+                `);
+      }
+
+      if (this.info.Subject) {
+        this.appendXML(`
+                <dc:description>
+                    <rdf:Alt>
+                        <rdf:li xml:lang="x-default">${this.info.Subject}</rdf:li>
+                    </rdf:Alt>
+                </dc:description>
+                `);
+      }
+
+      this.appendXML(`
+            </rdf:Description>
+            `);
+    }
+
+    this.appendXML(`
+        <rdf:Description rdf:about="" xmlns:pdf="http://ns.adobe.com/pdf/1.3/">
+            <pdf:Producer>${this.info.Creator}</pdf:Producer>`, false);
+
+    if (this.info.Keywords) {
+      this.appendXML(`
+            <pdf:Keywords>${this.info.Keywords}</pdf:Keywords>`, false);
+    }
+
+    this.appendXML(`
+        </rdf:Description>
+        `);
+  },
+
+  endMetadata() {
+    this._addInfo();
+
+    this.metadata.end();
+    /*
+    Metadata was introduced in PDF 1.4, so adding it to 1.3 
+    will likely only take up more space.
+    */
+
+    if (this.version != 1.3) {
+      this.metadataRef = this.ref({
+        length: this.metadata.getLength(),
+        Type: 'Metadata',
+        Subtype: 'XML'
+      });
+      this.metadataRef.compress = false;
+      this.metadataRef.write(Buffer.from(this.metadata.getXML(), 'utf-8'));
+      this.metadataRef.end();
+      this._root.data.Metadata = this.metadataRef;
+    }
+  }
+
+};
+
 /*
 PDFDocument - represents an entire PDF document
 By Devon Govett
@@ -6007,13 +6345,15 @@ class PDFDocument extends stream.Readable {
 
     this.page = null; // Initialize mixins
 
+    this.initMetadata();
     this.initColor();
     this.initVector();
     this.initFonts(options.font);
     this.initText();
     this.initImages();
     this.initOutline();
-    this.initMarkings(options); // Initialize the metadata
+    this.initMarkings(options);
+    this.initSubset(options); // Initialize the metadata
 
     this.info = {
       Producer: 'PDFKit',
@@ -6234,6 +6574,12 @@ Please pipe the document into a Node stream.\
     this.endOutline();
     this.endMarkings();
 
+    if (this.subset) {
+      this.endSubset();
+    }
+
+    this.endMetadata();
+
     this._root.end();
 
     this._root.data.Pages.end();
@@ -6309,6 +6655,7 @@ const mixin = methods => {
   Object.assign(PDFDocument.prototype, methods);
 };
 
+mixin(MetadataMixin);
 mixin(ColorMixin);
 mixin(VectorMixin);
 mixin(FontsMixin);
@@ -6319,6 +6666,7 @@ mixin(OutlineMixin);
 mixin(MarkingsMixin);
 mixin(AcroFormMixin);
 mixin(AttachmentsMixin);
+mixin(SubsetMixin);
 PDFDocument.LineWrapper = LineWrapper;
 
 module.exports = PDFDocument;