pdfkit 0.12.3 → 0.13.0

package/js/pdfkit.js

@@ -60,9 +60,7 @@ class PDFTree {
     return out.join('\n');
   }
 
-  _compareKeys()
-  /*a, b*/
-  {
+  _compareKeys() {
     throw new Error('Must be implemented by subclasses');
   }
 
@@ -70,9 +68,7 @@ class PDFTree {
     throw new Error('Must be implemented by subclasses');
   }
 
-  _dataForKey()
-  /*k*/
-  {
+  _dataForKey() {
     throw new Error('Must be implemented by subclasses');
   }
 
@@ -401,6 +397,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 +1463,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 +1473,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 +1540,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 +1681,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 +1702,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 +1716,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 +1810,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);
   }
 
 };
@@ -4919,29 +5032,18 @@ var OutlineMixin = {
 
 };
 
-function _defineProperty(obj, key, value) {
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-
-  return obj;
-}
-
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
 
   if (Object.getOwnPropertySymbols) {
     var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly) symbols = symbols.filter(function (sym) {
-      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    });
+
+    if (enumerableOnly) {
+      symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+
     keys.push.apply(keys, symbols);
   }
 
@@ -4968,6 +5070,21 @@ function _objectSpread2(target) {
   return target;
 }
 
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
 /*
 PDFStructureContent - a reference to a marked structure content
 By Ben Schmidt