schnee effeckt und fehler Korektur

node_modules/svgo/plugins/removeUselessStrokeAndFill.js

@@ -1,92 +1,144 @@
 'use strict';
 
-exports.type = 'perItem';
+const { visit, visitSkip, detachNodeFromParent } = require('../lib/xast.js');
+const { collectStylesheet, computeStyle } = require('../lib/style.js');
+const { elemsGroups } = require('./_collections.js');
 
+exports.type = 'visitor';
+exports.name = 'removeUselessStrokeAndFill';
 exports.active = true;
-
 exports.description = 'removes useless stroke and fill attributes';
 
-exports.params = {
-    stroke: true,
-    fill: true
-};
-
-var shape = require('./_collections').elemsGroups.shape,
-    regStrokeProps = /^stroke/,
-    regFillProps = /^fill-/,
-    styleOrScript = ['style', 'script'],
-    hasStyleOrScript = false;
-
 /**
  * Remove useless stroke and fill attrs.
  *
- * @param {Object} item current iteration item
- * @param {Object} params plugin params
- * @return {Boolean} if false, item will be filtered out
- *
  * @author Kir Belevich
+ *
+ * @type {import('../lib/types').Plugin<{
+ *  stroke?: boolean,
+ *  fill?: boolean,
+ *  removeNone?: boolean
+ * }>}
  */
-exports.fn = function(item, params) {
+exports.fn = (root, params) => {
+  const {
+    stroke: removeStroke = true,
+    fill: removeFill = true,
+    removeNone = false,
+  } = params;
 
-    if (item.isElem(styleOrScript)) {
-        hasStyleOrScript = true;
-    }
+  // style and script elements deoptimise this plugin
+  let hasStyleOrScript = false;
+  visit(root, {
+    element: {
+      enter: (node) => {
+        if (node.name === 'style' || node.name === 'script') {
+          hasStyleOrScript = true;
+        }
+      },
+    },
+  });
+  if (hasStyleOrScript) {
+    return null;
+  }
 
-    if (!hasStyleOrScript && item.isElem(shape) && !item.computedAttr('id')) {
+  const stylesheet = collectStylesheet(root);
 
-        var stroke = params.stroke && item.computedAttr('stroke'),
-            fill = params.fill && !item.computedAttr('fill', 'none');
+  return {
+    element: {
+      enter: (node, parentNode) => {
+        // id attribute deoptimise the whole subtree
+        if (node.attributes.id != null) {
+          return visitSkip;
+        }
+        if (elemsGroups.shape.includes(node.name) == false) {
+          return;
+        }
+        const computedStyle = computeStyle(stylesheet, node);
+        const stroke = computedStyle.stroke;
+        const strokeOpacity = computedStyle['stroke-opacity'];
+        const strokeWidth = computedStyle['stroke-width'];
+        const markerEnd = computedStyle['marker-end'];
+        const fill = computedStyle.fill;
+        const fillOpacity = computedStyle['fill-opacity'];
+        const computedParentStyle =
+          parentNode.type === 'element'
+            ? computeStyle(stylesheet, parentNode)
+            : null;
+        const parentStroke =
+          computedParentStyle == null ? null : computedParentStyle.stroke;
 
         // remove stroke*
-        if (
-            params.stroke &&
-            (!stroke ||
-                stroke == 'none' ||
-                item.computedAttr('stroke-opacity', '0') ||
-                item.computedAttr('stroke-width', '0')
-            )
-        ) {
-            var parentStroke = item.parentNode.computedAttr('stroke'),
-                declineStroke = parentStroke && parentStroke != 'none';
-
-            item.eachAttr(function(attr) {
-                if (regStrokeProps.test(attr.name)) {
-                    item.removeAttr(attr.name);
+        if (removeStroke) {
+          if (
+            stroke == null ||
+            (stroke.type === 'static' && stroke.value == 'none') ||
+            (strokeOpacity != null &&
+              strokeOpacity.type === 'static' &&
+              strokeOpacity.value === '0') ||
+            (strokeWidth != null &&
+              strokeWidth.type === 'static' &&
+              strokeWidth.value === '0')
+          ) {
+            // stroke-width may affect the size of marker-end
+            // marker is not visible when stroke-width is 0
+            if (
+              (strokeWidth != null &&
+                strokeWidth.type === 'static' &&
+                strokeWidth.value === '0') ||
+              markerEnd == null
+            ) {
+              for (const name of Object.keys(node.attributes)) {
+                if (name.startsWith('stroke')) {
+                  delete node.attributes[name];
                 }
-            });
-
-            if (declineStroke) item.addAttr({
-                name: 'stroke',
-                value: 'none',
-                prefix: '',
-                local: 'stroke'
-            });
+              }
+              // set explicit none to not inherit from parent
+              if (
+                parentStroke != null &&
+                parentStroke.type === 'static' &&
+                parentStroke.value !== 'none'
+              ) {
+                node.attributes.stroke = 'none';
+              }
+            }
+          }
         }
 
         // remove fill*
-        if (
-            params.fill &&
-            (!fill || item.computedAttr('fill-opacity', '0'))
-        ) {
-            item.eachAttr(function(attr) {
-                if (regFillProps.test(attr.name)) {
-                    item.removeAttr(attr.name);
-                }
-            });
-
-            if (fill) {
-                if (item.hasAttr('fill'))
-                    item.attr('fill').value = 'none';
-                else
-                    item.addAttr({
-                        name: 'fill',
-                        value: 'none',
-                        prefix: '',
-                        local: 'fill'
-                    });
+        if (removeFill) {
+          if (
+            (fill != null && fill.type === 'static' && fill.value === 'none') ||
+            (fillOpacity != null &&
+              fillOpacity.type === 'static' &&
+              fillOpacity.value === '0')
+          ) {
+            for (const name of Object.keys(node.attributes)) {
+              if (name.startsWith('fill-')) {
+                delete node.attributes[name];
+              }
             }
+            if (
+              fill == null ||
+              (fill.type === 'static' && fill.value !== 'none')
+            ) {
+              node.attributes.fill = 'none';
+            }
+          }
         }
 
-    }
-
+        if (removeNone) {
+          if (
+            (stroke == null || node.attributes.stroke === 'none') &&
+            ((fill != null &&
+              fill.type === 'static' &&
+              fill.value === 'none') ||
+              node.attributes.fill === 'none')
+          ) {
+            detachNodeFromParent(node, parentNode);
+          }
+        }
+      },
+    },
+  };
 };