@digicole/pdfmake-rtl 1.2.0 → 2.1.1

package/src/3rd-party/svg-to-pdfkit/source.js

@@ -60,7 +60,8 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       'display':            {inherit: false, initial: 'inline', values: {'none':'none', 'inline':'inline', 'block':'inline'}},
       'clip-path':          {inherit: false, initial: 'none'},
       'mask':               {inherit: false, initial: 'none'},
-      'overflow':           {inherit: false, initial: 'hidden', values: {'hidden':'hidden', 'scroll':'hidden', 'visible':'visible'}}
+      'overflow':           {inherit: false, initial: 'hidden', values: {'hidden':'hidden', 'scroll':'hidden', 'visible':'visible'}},
+      'vector-effect':      {inherit: true, initial: 'none', values: {'none':'none', 'non-scaling-stroke':'non-scaling-stroke'}}
     };
 
     function docBeginGroup(bbox) {
@@ -113,11 +114,13 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       doc.addContent('/' + name + ' gs');
     }
     function docCreatePattern(group, dx, dy, matrix) {
-      let pattern = new (function PDFPattern() {})();
-      pattern.group = group;
-      pattern.dx = dx;
-      pattern.dy = dy;
-      pattern.matrix = matrix || [1, 0, 0, 1, 0, 0];
+      let pattern = {
+        type: 'PDFPattern',
+        group: group,
+        dx: dx,
+        dy: dy,
+        matrix: matrix || [1, 0, 0, 1, 0, 0],
+      }
       return pattern;
     }
     function docUsePattern(pattern, stroke) {
@@ -153,14 +156,62 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       let mode = fill && stroke ? 2 : stroke ? 1 : fill ? 0 : 3;
       doc.addContent(mode + ' Tr');
     }
-    function docWriteGlyph(glyph) {
-      doc.addContent('<' + glyph + '> Tj');
+    function docWriteGlyphs(positions, font) {
+      let commands = [];
+      let commandStr = '';
+      const skew = font.fauxItalic ? -0.25 : 0;
+
+      // Add the given character to the 'TJ' command string.
+      function addChar(char) {
+        commandStr += char.glyph;
+        if (char.kern === 0) return;
+        commands.push(`<${commandStr}> ${validateNumber(char.kern)}`);
+        commandStr = '';
+      };
+
+      // Flush the current TJ command string to the output stream.
+      function flush() {
+        if (commandStr.length) {
+          commands.push(`<${commandStr}> 0`);
+          commandStr = '';
+        }
+        if (commands.length) {
+          doc.addContent(`[${commands.join(' ')}] TJ`);
+          commands = [];
+        }
+      };
+
+      for (let i = 0; i < positions.length; i++) {
+        const pos = positions[i];
+
+        if (pos.hidden || isEqual(pos.width, 0)) {
+          flush();
+          continue;
+        }
+
+        if (pos.continuous) {
+          addChar(pos);
+          continue;
+        }
+
+        // If this character is non-continuous, flush the command buffer.
+        flush();
+
+        // Start a new TJ command after writing a Text Matrix (Tm)
+        const cos = Math.cos(pos.rotate);
+        const sin = Math.sin(pos.rotate);
+        docSetTextMatrix(cos * pos.scale, sin * pos.scale, cos * skew - sin, sin * skew + cos, pos.x, pos.y);
+        addChar(pos);
+      };
+
+      // Flush any remaining characters in the buffer.
+      flush();
     }
     function docEndText() {
       doc.addContent('ET');
     }
     function docFillColor(color) {
-      if (color[0].constructor.name === 'PDFPattern') {
+      if (color[0].type === 'PDFPattern') {
         doc.fillOpacity(color[1]);
         docUsePattern(color[0], false);
       } else {
@@ -168,13 +219,127 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       }
     }
     function docStrokeColor(color) {
-      if (color[0].constructor.name === 'PDFPattern') {
+      if (color[0].type === 'PDFPattern') {
         doc.strokeOpacity(color[1]);
         docUsePattern(color[0], true);
       } else {
         doc.strokeColor(color[0], color[1]);
       }
     }
+    // PDFKit doesn't accept any 0s in the dash array, but that's perfectly
+    // valid in SVG. So this function applys a dash array and offset, detecting
+    // any 0s in the dash array and updating it and the dash offset as needed to
+    // remove the zeros, but preserve the end result.
+    //
+    // `dashArray` must have an even number of elements
+    function docApplyDash(dashArray, dashOffset) {
+      let index;
+      // Anytime there's a 0 that isn't the first or last element of the array,
+      // we can remove it by combining the previous or next value. If it's a
+      // dash, then it's a zero-length dash between two spaces, so the dash can
+      // be eliminated and spaces combined by summing them, replacing all three
+      // values with the sum of the two spaces. If the 0 value is a space, then
+      // it's a zero-length space between two dashes, and the dashes can be
+      // similarly combined. So first we run that logic iteratively to remove
+      // all the 0s from the dash array that aren't the first or last element.
+      // Note that because we replace 3 values with one value, this doesn't
+      // change the even-ness of the length of dashArray.
+      while ((index = dashArray.slice(1, -1).indexOf(0)) !== -1) {
+        let actualIndex = index + 1;
+        let replacementValue = dashArray[actualIndex - 1] + dashArray[actualIndex + 1];
+        dashArray = dashArray
+          .slice(0, actualIndex - 1)
+          .concat([replacementValue])
+          .concat(dashArray.slice(actualIndex + 2));
+      }
+
+      // The stroke array only having two elements (a dash value and space
+      // value) is a special case.
+      if (dashArray.length === 2) {
+        if (dashArray[0] === 0) {
+          // Regardless of the space value, the dash length is zero, so we're
+          // not actually drawing a stroke. We can't describe that in a
+          // doc.dash() call in a way that PDFKit will accept, so we set the
+          // stroke opacity to zero as our best approximation.
+          doc.strokeOpacity(0);
+          return;
+        } else if (dashArray[1] === 0) {
+          // Regardless of the dash value, the space value is zero, meaning
+          // we're actually drawing a solid stroke, not a dashed one. We can
+          // make this happen by just emptying out the dash array.
+          dashArray = [];
+        }
+      } else {
+        if (dashArray[0] === 0) {
+          // The first dash is zero-length. We fix this by combining the first
+          // space (just after the first dash) with the last space and updating
+          // the dash offset accordingly. For example, if we had
+          //
+          // [ 0 4 3 2 5 1 ] (dash offset 0)
+          //
+          // ␣␣␣␣---␣␣-----␣
+          // ⎸
+          //
+          // we'd end up with
+          //
+          // [ 3 2 5 5 ] (dash offset -4)
+          //
+          // ---␣␣-----␣␣␣␣␣
+          //            ⎸
+          //
+          // Another example where the dash array also ends with a 0:
+          //
+          // [ 0 4 3 2 5 0 ] (dash offset 0)
+          //
+          // ␣␣␣␣---␣␣-----
+          // ⎸
+          //
+          // we'd end up with
+          //
+          // [ 3 2 5 4 ] (dash offset -4)
+          //
+          // ---␣␣-----␣␣␣␣
+          //           ⎸
+          dashOffset -= dashArray[1];
+          dashArray[dashArray.length - 1] += dashArray[1];
+          dashArray = dashArray.slice(2);
+        }
+        if (dashArray[dashArray.length - 1] === 0) {
+          // The last space is zero-length. We fix this by combining the last dash
+          // (just before the last space) with the first dash and updating the
+          // dash offset accordingly. For example, if we had
+          //
+          // [ 1 4 3 2 5 0 ] (dash offset 0)
+          //
+          // -␣␣␣␣---␣␣-----
+          // ⎸
+          //
+          // we'd end up with
+          //
+          // [ 6 4 3 2 ] (dash offset 5)
+          //
+          // ------␣␣␣␣---␣␣
+          //      ⎸
+          //
+          dashOffset += dashArray[dashArray.length - 2];
+          dashArray[0] += dashArray[dashArray.length - 2];
+          dashArray = dashArray.slice(0, -2);
+        }  
+      }
+
+      // Ensure the dash offset is non-negative (because of crbug.com/660850).
+      // First compute the total length of the dash array so we can add it to
+      // dash offset until dash offset is non-negative.
+      let length = 0;
+      for (let i = 0; i < dashArray.length; i++) {length += dashArray[i];}
+      if (length > 0) {
+        while (dashOffset < 0) {
+          dashOffset += length;
+        }
+      }
+
+      doc.dash(dashArray, {phase: dashOffset});
+    }
     function docInsertLink(x, y, w, h, url) {
       let ref = doc.ref({
         Type: 'Annot',
@@ -308,6 +473,11 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       raw = (raw || '').trim();
       if (temp = NamedColors[raw]) {
         result = [temp.slice(), 1];
+      } else if (temp = raw.match(/^cmyk\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9.]+)\s*\)$/i)) {
+        temp[1] = parseInt(temp[1]); temp[2] = parseInt(temp[2]); temp[3] = parseInt(temp[3]); temp[4] = parseFloat(temp[4]);
+        if (temp[1] <= 100 && temp[2] <= 100 && temp[3] <= 100 && temp[4] <= 100) {
+          result = [temp.slice(1, 5), 1];
+        }
       } else if (temp = raw.match(/^rgba\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9.]+)\s*\)$/i)) {
         temp[1] = parseInt(temp[1]); temp[2] = parseInt(temp[2]); temp[3] = parseInt(temp[3]); temp[4] = parseFloat(temp[4]);
         if (temp[1] < 256 && temp[2] < 256 && temp[3] < 256 && temp[4] <= 1) {
@@ -367,6 +537,11 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       return new SvgShape().M(0, 0).L(doc.page.width, 0).L(doc.page.width, doc.page.height).L(0, doc.page.height)
                            .transform(inverseMatrix(getGlobalMatrix())).getBoundingBox();
     }
+    function getPageScale() {
+      const bbox = getPageBBox();
+      const width = doc.page.width;
+      return width / bbox[2];
+    }
     function inverseMatrix(m) {
       let dt = m[0] * m[3] - m[1] * m[2];
       return [m[3] / dt, -m[1] / dt, -m[2] / dt, m[0] / dt, (m[2]*m[5] - m[3]*m[4]) / dt, (m[1]*m[4] - m[0]*m[5]) / dt];
@@ -615,6 +790,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
         data.push({
           glyph: hex[i],
           unicode: unicode,
+          kern: pos[i].advanceWidth - pos[i].xAdvance,
           width: pos[i].advanceWidth * size / 1000,
           xOffset: pos[i].xOffset * size / 1000,
           yOffset: pos[i].yOffset * size / 1000,
@@ -1266,12 +1442,6 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
                 break;
               case 'stroke-dashoffset':
                 result = this.computeLength(value, this.getViewport());
-                if (result != null) {
-                  if (result < 0) { // fix for crbug.com/660850
-                    let dasharray = this.get('stroke-dasharray');
-                    for (let j = 0; j < dasharray.length; j++) {result += dasharray[j];}
-                  }
-                }
                 break;
             }
             if (result != null) {return styleCache[key] = result;}
@@ -1322,7 +1492,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       this.clip = function() {
         if (this.get('clip-path') !== 'none') {
           let clipPath = new SvgElemClipPath(this.get('clip-path'), null);
-          clipPath.useMask(this.getBoundingBox());
+          clipPath.useMask((clipPath.attr('clipPathUnits') === 'objectBoundingBox') ? this.getBoundingBox() : null);
           return true;
         }
       };
@@ -1788,7 +1958,11 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       this.drawInDocument = function(isClip, isMask) {
         if (this.get('visibility') === 'hidden' || !this.shape) {return;}
         doc.save();
-        this.transform();
+        if (this.get('vector-effect') === 'non-scaling-stroke') {
+          this.shape.transform(this.getTransformation());
+        } else {
+          this.transform();
+        }
         this.clip();
         if (!isClip) {
           let masked = this.mask(),
@@ -1801,6 +1975,11 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
               stroke = this.getStroke(isClip, isMask),
               lineWidth = this.get('stroke-width'),
               lineCap = this.get('stroke-linecap');
+
+          if (this.get('vector-effect') === 'non-scaling-stroke') {
+            lineWidth = lineWidth / getPageScale();
+          }
+          
           if (fill || stroke) {
             if (fill) {
               docFillColor(fill);
@@ -1835,8 +2014,8 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
               doc.lineWidth(lineWidth)
                  .miterLimit(this.get('stroke-miterlimit'))
                  .lineJoin(this.get('stroke-linejoin'))
-                 .lineCap(lineCap)
-                 .dash(dashArray, {phase: dashOffset});
+                 .lineCap(lineCap);
+              docApplyDash(dashArray, dashOffset);
             }
             for (let j = 0; j < subPaths.length; j++) {
               if (subPaths[j].totalLength > 0) {
@@ -1856,7 +2035,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
               markerEnd = this.get('marker-end');
           if (markerStart !== 'none' || markerMid !== 'none' || markerEnd !== 'none') {
             let markersPos = this.shape.getMarkers();
-            if (markerStart !== 'none') {
+            if (markerStart !== 'none' && markersPos.length > 0) {
               let marker = new SvgElemMarker(markerStart, null);
               marker.drawMarker(false, isMask, markersPos[0], lineWidth);
             }
@@ -1866,7 +2045,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
                 marker.drawMarker(false, isMask, markersPos[i], lineWidth);
               }
             }
-            if (markerEnd !== 'none') {
+            if (markerEnd !== 'none' && markersPos.length > 0) {
               let marker = new SvgElemMarker(markerEnd, null);
               marker.drawMarker(false, isMask, markersPos[markersPos.length - 1], lineWidth);
             }
@@ -2028,6 +2207,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       this.useMask = function(bBox) {
         let group = docBeginGroup(getPageBBox());
         doc.save();
+        doc.transform.apply(doc, this.get('transform'));
         if (this.attr('clipPathUnits') === 'objectBoundingBox') {
           doc.transform(bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]);
         }
@@ -2056,7 +2236,6 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
           w = this.getLength('width', this.getVWidth(), 1.2) * (bBox[2] - bBox[0]);
           h = this.getLength('height', this.getVHeight(), 1.2) * (bBox[3] - bBox[1]);
         }
-        doc.rect(x, y, w, h).clip();
         if (this.attr('maskContentUnits') === 'objectBoundingBox') {
           doc.transform(bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]);
         }
@@ -2125,18 +2304,12 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
                   doc.lineWidth(strokeWidth)
                      .miterLimit(this.get('stroke-miterlimit'))
                      .lineJoin(this.get('stroke-linejoin'))
-                     .lineCap(this.get('stroke-linecap'))
-                     .dash(this.get('stroke-dasharray'), {phase:this.get('stroke-dashoffset')});
+                     .lineCap(this.get('stroke-linecap'));
+                  docApplyDash(this.get('stroke-dasharray'), this.get('stroke-dashoffset'));
                 }
                 docBeginText(this._font.font, this._font.size);
                 docSetTextMode(!!fill, !!stroke);
-                for (let j = 0, pos = childElem._pos; j < pos.length; j++) {
-                  if (!pos[j].hidden && isNotEqual(pos[j].width, 0)) {
-                    let cos = Math.cos(pos[j].rotate), sin = Math.sin(pos[j].rotate), skew = (this._font.fauxItalic ? -0.25 : 0);
-                    docSetTextMatrix(cos * pos[j].scale, sin * pos[j].scale, cos * skew - sin, sin * skew + cos, pos[j].x, pos[j].y);
-                    docWriteGlyph(pos[j].glyph);
-                  }
-                }
+                docWriteGlyphs(childElem._pos, this._font);
                 docEndText();
               }
               break;
@@ -2157,8 +2330,8 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
           doc.lineWidth(this.get('stroke-width'))
              .miterLimit(this.get('stroke-miterlimit'))
              .lineJoin(this.get('stroke-linejoin'))
-             .lineCap(this.get('stroke-linecap'))
-             .dash(this.get('stroke-dasharray'), {phase:this.get('stroke-dashoffset')});
+             .lineCap(this.get('stroke-linecap'));
+          docApplyDash(this.get('stroke-dasharray'), this.get('stroke-dashoffset'));
         }
         for (let j = 0, pos = this._pos; j < pos.length; j++) {
           if (!pos[j].hidden && isNotEqual(pos[j].width, 0)) {
@@ -2234,6 +2407,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
             let textScale = length / (endX - startX);
             if (textScale > 0 && textScale < Infinity) {
               for (let j = 0; j < pos.length; j++) {
+                pos[j].continuous = false;
                 pos[j].x = startX + textScale * (pos[j].x - startX);
                 pos[j].scale *= textScale;
                 pos[j].width *= textScale;
@@ -2243,6 +2417,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
             if (pos.length >= 2) {
               let spaceDiff = (length - (endX - startX)) / (pos.length - 1);
               for (let j = 0; j < pos.length; j++) {
+                pos[j].continuous = false;
                 pos[j].x += j * spaceDiff;
               }
             }
@@ -2262,7 +2437,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
           try {
             doc.font(fontNameorLink);
           } catch(e) {
-            warningCallback('SVGElemText: failed to open font "' + fontNameorLink + '" in PDFKit');
+            warningCallback('SVGElemText: failed to open font "' + fontNameorLink + '" in PDFKit: ' + e.message);
           }
           currentElem._pos = [];
           currentElem._index = 0;
@@ -2273,7 +2448,22 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
               letterSpacing = currentElem.get('letter-spacing'),
               textAnchor = currentElem.get('text-anchor'),
               textDirection = currentElem.get('direction'),
-              baseline = getBaseline(currentElem._font.font, currentElem._font.size, currentElem.get('alignment-baseline') || currentElem.get('dominant-baseline'), currentElem.get('baseline-shift'));
+              // `alignment-baseline` and `baseline-shift` have no effect on
+              // `<text>` elements according to the SVG spec. So, detect when
+              // we're styling a `<text>` element and ignore
+              // `alignment-baseline` (only factoring in `dominant-baseline`)
+              // and `baseline-shift` (which can only have the default value of
+              // `baseline`).
+              //
+              // Note that Chrome (as of v99) incorrectly factors in
+              // `alignment-baseline` on `<text>` elements, while Firefox
+              // correctly follows the spec and ignores it. This means that our
+              // output will differ from Chrome's in these cases, but conform to
+              // SVG specification.
+              isTextElem = currentElem.name === 'text',
+              baselineAttr = isTextElem ? currentElem.get('dominant-baseline') : (currentElem.get('alignment-baseline') || currentElem.get('dominant-baseline')),
+              baselineShiftAttr = isTextElem ? 'baseline' : currentElem.get('baseline-shift'),
+              baseline = getBaseline(currentElem._font.font, currentElem._font.size, baselineAttr, baselineShiftAttr);
           if (currentElem.name === 'textPath') {
             doAnchoring();
             currentX = currentY = 0;
@@ -2313,6 +2503,8 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
                         dyAttr = currentElem._dy[index],
                         rotAttr = currentElem._rot[index],
                         continuous = !(w === 0 && j === 0);
+                    if (letterSpacing !== 0) {continuous = false}
+                    if (wordSpacing !== 0) {continuous = false}
                     if (xAttr !== undefined) {continuous = false; doAnchoring(); currentX = xAttr;}
                     if (yAttr !== undefined) {continuous = false; doAnchoring(); currentY = yAttr;}
                     if (dxAttr !== undefined) {continuous = false; currentX += dxAttr;}
@@ -2322,6 +2514,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
                       glyph: pos[j].glyph,
                       rotate: (Math.PI / 180) * currentElem.chooseValue(rotAttr, currentElem._defRot),
                       x: currentX + pos[j].xOffset,
+                      kern: pos[j].kern,
                       y: currentY + baseline + pos[j].yOffset,
                       width: pos[j].width,
                       ascent: getAscent(currentElem._font.font, currentElem._font.size),

package/src/3rd-party/svg-to-pdfkit.js

@@ -1,3 +1,3 @@
-var SVGtoPDF = require('./svg-to-pdfkit/source.js');
-
-module.exports = SVGtoPDF;
+import SVGtoPDF from './svg-to-pdfkit/source.js';
+
+export default SVGtoPDF;

package/src/OutputDocument.js

@@ -0,0 +1,64 @@
+class OutputDocument {
+
+	/**
+	 * @param {Promise<object>} pdfDocumentPromise
+	 */
+	constructor(pdfDocumentPromise) {
+		this.bufferSize = 1073741824;
+		this.pdfDocumentPromise = pdfDocumentPromise;
+		this.bufferPromise = null;
+	}
+
+	/**
+	 * @returns {Promise<object>}
+	 */
+	getStream() {
+		return this.pdfDocumentPromise;
+	}
+
+	/**
+	 * @returns {Promise<Buffer>}
+	 */
+	getBuffer() {
+		const getBufferInternal = (async () => {
+			const stream = await this.getStream();
+			return new Promise((resolve) => {
+				let chunks = [];
+				stream.on('readable', () => {
+					let chunk;
+					while ((chunk = stream.read(this.bufferSize)) !== null) {
+						chunks.push(chunk);
+					}
+				});
+				stream.on('end', () => {
+					resolve(Buffer.concat(chunks));
+				});
+				stream.end();
+			});
+		});
+
+		if (this.bufferPromise === null) {
+			this.bufferPromise = getBufferInternal();
+		}
+		return this.bufferPromise;
+	}
+
+	/**
+	 * @returns {Promise<string>}
+	 */
+	async getBase64() {
+		const buffer = await this.getBuffer();
+		return buffer.toString('base64');
+	}
+
+	/**
+	 * @returns {Promise<string>}
+	 */
+	async getDataUrl() {
+		const data = await this.getBase64();
+		return 'data:application/pdf;base64,' + data;
+	}
+
+}
+
+export default OutputDocument;

package/src/OutputDocumentServer.js

@@ -0,0 +1,32 @@
+import OutputDocument from './OutputDocument';
+import fs from 'fs';
+
+class OutputDocumentServer extends OutputDocument {
+
+	/**
+	 * @param {string} filename
+	 * @returns {Promise}
+	 */
+	async write(filename) {
+		const stream = await this.getStream();
+		const writeStream = fs.createWriteStream(filename);
+
+		const streamEnded = new Promise((resolve, reject) => {
+			stream.on('end', resolve);
+			stream.on('error', reject);
+		});
+
+		const writeClosed = new Promise((resolve, reject) => {
+			writeStream.on('close', resolve);
+			writeStream.on('error', reject);
+		});
+
+		stream.pipe(writeStream);
+		stream.end();
+
+		await Promise.all([streamEnded, writeClosed]);
+	}
+
+}
+
+export default OutputDocumentServer;