svgo-v2 2.8.0

package/plugins/convertShapeToPath.js

@@ -0,0 +1,175 @@
+'use strict';
+
+/**
+ * @typedef {import('../lib/types').PathDataItem} PathDataItem
+ */
+
+const { stringifyPathData } = require('../lib/path.js');
+const { detachNodeFromParent } = require('../lib/xast.js');
+
+exports.name = 'convertShapeToPath';
+exports.type = 'visitor';
+exports.active = true;
+exports.description = 'converts basic shapes to more compact path form';
+
+const regNumber = /[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
+
+/**
+ * Converts basic shape to more compact path.
+ * It also allows further optimizations like
+ * combining paths with similar attributes.
+ *
+ * @see https://www.w3.org/TR/SVG11/shapes.html
+ *
+ * @author Lev Solntsev
+ *
+ * @type {import('../lib/types').Plugin<{
+ *   convertArcs?: boolean,
+ *   floatPrecision?: number
+ * }>}
+ */
+exports.fn = (root, params) => {
+  const { convertArcs = false, floatPrecision: precision } = params;
+
+  return {
+    element: {
+      enter: (node, parentNode) => {
+        // convert rect to path
+        if (
+          node.name === 'rect' &&
+          node.attributes.width != null &&
+          node.attributes.height != null &&
+          node.attributes.rx == null &&
+          node.attributes.ry == null
+        ) {
+          const x = Number(node.attributes.x || '0');
+          const y = Number(node.attributes.y || '0');
+          const width = Number(node.attributes.width);
+          const height = Number(node.attributes.height);
+          // Values like '100%' compute to NaN, thus running after
+          // cleanupNumericValues when 'px' units has already been removed.
+          // TODO: Calculate sizes from % and non-px units if possible.
+          if (Number.isNaN(x - y + width - height)) return;
+          /**
+           * @type {Array<PathDataItem>}
+           */
+          const pathData = [
+            { command: 'M', args: [x, y] },
+            { command: 'H', args: [x + width] },
+            { command: 'V', args: [y + height] },
+            { command: 'H', args: [x] },
+            { command: 'z', args: [] },
+          ];
+          node.name = 'path';
+          node.attributes.d = stringifyPathData({ pathData, precision });
+          delete node.attributes.x;
+          delete node.attributes.y;
+          delete node.attributes.width;
+          delete node.attributes.height;
+        }
+
+        // convert line to path
+        if (node.name === 'line') {
+          const x1 = Number(node.attributes.x1 || '0');
+          const y1 = Number(node.attributes.y1 || '0');
+          const x2 = Number(node.attributes.x2 || '0');
+          const y2 = Number(node.attributes.y2 || '0');
+          if (Number.isNaN(x1 - y1 + x2 - y2)) return;
+          /**
+           * @type {Array<PathDataItem>}
+           */
+          const pathData = [
+            { command: 'M', args: [x1, y1] },
+            { command: 'L', args: [x2, y2] },
+          ];
+          node.name = 'path';
+          node.attributes.d = stringifyPathData({ pathData, precision });
+          delete node.attributes.x1;
+          delete node.attributes.y1;
+          delete node.attributes.x2;
+          delete node.attributes.y2;
+        }
+
+        // convert polyline and polygon to path
+        if (
+          (node.name === 'polyline' || node.name === 'polygon') &&
+          node.attributes.points != null
+        ) {
+          const coords = (node.attributes.points.match(regNumber) || []).map(
+            Number
+          );
+          if (coords.length < 4) {
+            detachNodeFromParent(node, parentNode);
+            return;
+          }
+          /**
+           * @type {Array<PathDataItem>}
+           */
+          const pathData = [];
+          for (let i = 0; i < coords.length; i += 2) {
+            pathData.push({
+              command: i === 0 ? 'M' : 'L',
+              args: coords.slice(i, i + 2),
+            });
+          }
+          if (node.name === 'polygon') {
+            pathData.push({ command: 'z', args: [] });
+          }
+          node.name = 'path';
+          node.attributes.d = stringifyPathData({ pathData, precision });
+          delete node.attributes.points;
+        }
+
+        //  optionally convert circle
+        if (node.name === 'circle' && convertArcs) {
+          const cx = Number(node.attributes.cx || '0');
+          const cy = Number(node.attributes.cy || '0');
+          const r = Number(node.attributes.r || '0');
+          if (Number.isNaN(cx - cy + r)) {
+            return;
+          }
+          /**
+           * @type {Array<PathDataItem>}
+           */
+          const pathData = [
+            { command: 'M', args: [cx, cy - r] },
+            { command: 'A', args: [r, r, 0, 1, 0, cx, cy + r] },
+            { command: 'A', args: [r, r, 0, 1, 0, cx, cy - r] },
+            { command: 'z', args: [] },
+          ];
+          node.name = 'path';
+          node.attributes.d = stringifyPathData({ pathData, precision });
+          delete node.attributes.cx;
+          delete node.attributes.cy;
+          delete node.attributes.r;
+        }
+
+        // optionally covert ellipse
+        if (node.name === 'ellipse' && convertArcs) {
+          const ecx = Number(node.attributes.cx || '0');
+          const ecy = Number(node.attributes.cy || '0');
+          const rx = Number(node.attributes.rx || '0');
+          const ry = Number(node.attributes.ry || '0');
+          if (Number.isNaN(ecx - ecy + rx - ry)) {
+            return;
+          }
+          /**
+           * @type {Array<PathDataItem>}
+           */
+          const pathData = [
+            { command: 'M', args: [ecx, ecy - ry] },
+            { command: 'A', args: [rx, ry, 0, 1, 0, ecx, ecy + ry] },
+            { command: 'A', args: [rx, ry, 0, 1, 0, ecx, ecy - ry] },
+            { command: 'z', args: [] },
+          ];
+          node.name = 'path';
+          node.attributes.d = stringifyPathData({ pathData, precision });
+          delete node.attributes.cx;
+          delete node.attributes.cy;
+          delete node.attributes.rx;
+          delete node.attributes.ry;
+        }
+      },
+    },
+  };
+};

package/plugins/convertStyleToAttrs.js

@@ -0,0 +1,132 @@
+'use strict';
+
+exports.name = 'convertStyleToAttrs';
+
+exports.type = 'perItem';
+
+exports.active = false;
+
+exports.description = 'converts style to attributes';
+
+exports.params = {
+  keepImportant: false,
+};
+
+var stylingProps = require('./_collections').attrsGroups.presentation,
+  rEscape = '\\\\(?:[0-9a-f]{1,6}\\s?|\\r\\n|.)', // Like \" or \2051. Code points consume one space.
+  rAttr = '\\s*(' + g('[^:;\\\\]', rEscape) + '*?)\\s*', // attribute name like ‘fill’
+  rSingleQuotes = "'(?:[^'\\n\\r\\\\]|" + rEscape + ")*?(?:'|$)", // string in single quotes: 'smth'
+  rQuotes = '"(?:[^"\\n\\r\\\\]|' + rEscape + ')*?(?:"|$)', // string in double quotes: "smth"
+  rQuotedString = new RegExp('^' + g(rSingleQuotes, rQuotes) + '$'),
+  // Parentheses, E.g.: url(data:image/png;base64,iVBO...).
+  // ':' and ';' inside of it should be threated as is. (Just like in strings.)
+  rParenthesis =
+    '\\(' + g('[^\'"()\\\\]+', rEscape, rSingleQuotes, rQuotes) + '*?' + '\\)',
+  // The value. It can have strings and parentheses (see above). Fallbacks to anything in case of unexpected input.
+  rValue =
+    '\\s*(' +
+    g(
+      '[^!\'"();\\\\]+?',
+      rEscape,
+      rSingleQuotes,
+      rQuotes,
+      rParenthesis,
+      '[^;]*?'
+    ) +
+    '*?' +
+    ')',
+  // End of declaration. Spaces outside of capturing groups help to do natural trimming.
+  rDeclEnd = '\\s*(?:;\\s*|$)',
+  // Important rule
+  rImportant = '(\\s*!important(?![-(\\w]))?',
+  // Final RegExp to parse CSS declarations.
+  regDeclarationBlock = new RegExp(
+    rAttr + ':' + rValue + rImportant + rDeclEnd,
+    'ig'
+  ),
+  // Comments expression. Honors escape sequences and strings.
+  regStripComments = new RegExp(
+    g(rEscape, rSingleQuotes, rQuotes, '/\\*[^]*?\\*/'),
+    'ig'
+  );
+
+/**
+ * Convert style in attributes. Cleanups comments and illegal declarations (without colon) as a side effect.
+ *
+ * @example
+ * <g style="fill:#000; color: #fff;">
+ *             ⬇
+ * <g fill="#000" color="#fff">
+ *
+ * @example
+ * <g style="fill:#000; color: #fff; -webkit-blah: blah">
+ *             ⬇
+ * <g fill="#000" color="#fff" style="-webkit-blah: blah">
+ *
+ * @param {Object} item current iteration item
+ * @return {Boolean} if false, item will be filtered out
+ *
+ * @author Kir Belevich
+ */
+exports.fn = function (item, params) {
+  if (item.type === 'element' && item.attributes.style != null) {
+    // ['opacity: 1', 'color: #000']
+    let styles = [];
+    const newAttributes = {};
+
+    // Strip CSS comments preserving escape sequences and strings.
+    const styleValue = item.attributes.style.replace(
+      regStripComments,
+      (match) => {
+        return match[0] == '/'
+          ? ''
+          : match[0] == '\\' && /[-g-z]/i.test(match[1])
+          ? match[1]
+          : match;
+      }
+    );
+
+    regDeclarationBlock.lastIndex = 0;
+    // eslint-disable-next-line no-cond-assign
+    for (var rule; (rule = regDeclarationBlock.exec(styleValue)); ) {
+      if (!params.keepImportant || !rule[3]) {
+        styles.push([rule[1], rule[2]]);
+      }
+    }
+
+    if (styles.length) {
+      styles = styles.filter(function (style) {
+        if (style[0]) {
+          var prop = style[0].toLowerCase(),
+            val = style[1];
+
+          if (rQuotedString.test(val)) {
+            val = val.slice(1, -1);
+          }
+
+          if (stylingProps.includes(prop)) {
+            newAttributes[prop] = val;
+
+            return false;
+          }
+        }
+
+        return true;
+      });
+
+      Object.assign(item.attributes, newAttributes);
+
+      if (styles.length) {
+        item.attributes.style = styles
+          .map((declaration) => declaration.join(':'))
+          .join(';');
+      } else {
+        delete item.attributes.style;
+      }
+    }
+  }
+};
+
+function g() {
+  return '(?:' + Array.prototype.join.call(arguments, '|') + ')';
+}