schnee effeckt und fehler Korektur

node_modules/svgo/plugins/collapseGroups.js

@@ -1,19 +1,37 @@
 'use strict';
 
-exports.type = 'perItemReverse';
+/**
+ * @typedef {import('../lib/types').XastNode} XastNode
+ */
 
+const { inheritableAttrs, elemsGroups } = require('./_collections.js');
+
+exports.type = 'visitor';
+exports.name = 'collapseGroups';
 exports.active = true;
-
 exports.description = 'collapses useless groups';
 
-var animationElems = require('./_collections').elemsGroups.animation;
+/**
+ * @type {(node: XastNode, name: string) => boolean}
+ */
+const hasAnimatedAttr = (node, name) => {
+  if (node.type === 'element') {
+    if (
+      elemsGroups.animation.includes(node.name) &&
+      node.attributes.attributeName === name
+    ) {
+      return true;
+    }
+    for (const child of node.children) {
+      if (hasAnimatedAttr(child, name)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
 
-function hasAnimatedAttr(item) {
-    return item.isElem(animationElems) && item.hasAttr('attributeName', this) ||
-        !item.isEmpty() && item.content.some(hasAnimatedAttr, this);
-}
-
-/*
+/**
  * Collapse useless groups.
  *
  * @example
@@ -31,50 +49,87 @@ function hasAnimatedAttr(item) {
  *         ⬇
  * <path attr1="val1" d="..."/>
  *
- * @param {Object} item current iteration item
- * @return {Boolean} if false, item will be filtered out
- *
  * @author Kir Belevich
+ *
+ * @type {import('../lib/types').Plugin<void>}
  */
-exports.fn = function(item) {
+exports.fn = () => {
+  return {
+    element: {
+      exit: (node, parentNode) => {
+        if (parentNode.type === 'root' || parentNode.name === 'switch') {
+          return;
+        }
+        // non-empty groups
+        if (node.name !== 'g' || node.children.length === 0) {
+          return;
+        }
 
-    // non-empty elements
-    if (item.isElem() && !item.isElem('switch') && !item.isEmpty()) {
-
-        item.content.forEach(function(g, i) {
-
-            // non-empty groups
-            if (g.isElem('g') && !g.isEmpty()) {
-
-                // move group attibutes to the single content element
-                if (g.hasAttr() && g.content.length === 1) {
-                    var inner = g.content[0];
-
-                    if (inner.isElem() && !inner.hasAttr('id') && (
-                        !g.hasAttr('clip-path') ||
-                        inner.isElem('g') && !g.hasAttr('transform') && !inner.hasAttr('transform')
-                    )) {
-                        g.eachAttr(function(attr) {
-                            if (g.content.some(hasAnimatedAttr, attr.name)) return;
-
-                            if (!inner.hasAttr(attr.name)) {
-                                inner.addAttr(attr);
-                            } else if (attr.name == 'transform' || attr.name == 'class') {
-                                inner.attr(attr.name).value = attr.value + ' ' + inner.attr(attr.name).value;
-                            }
-                            g.removeAttr(attr.name);
-                        });
-                    }
-                }
-
-                // collapse groups without attributes
-                if (!g.hasAttr() && !g.content.some(function(item) { return item.isElem(animationElems) })) {
-                    item.spliceContent(i, 1, g.content);
-                }
+        // move group attibutes to the single child element
+        if (
+          Object.keys(node.attributes).length !== 0 &&
+          node.children.length === 1
+        ) {
+          const firstChild = node.children[0];
+          // TODO untangle this mess
+          if (
+            firstChild.type === 'element' &&
+            firstChild.attributes.id == null &&
+            node.attributes.filter == null &&
+            (node.attributes.class == null ||
+              firstChild.attributes.class == null) &&
+            ((node.attributes['clip-path'] == null &&
+              node.attributes.mask == null) ||
+              (firstChild.name === 'g' &&
+                node.attributes.transform == null &&
+                firstChild.attributes.transform == null))
+          ) {
+            for (const [name, value] of Object.entries(node.attributes)) {
+              // avoid copying to not conflict with animated attribute
+              if (hasAnimatedAttr(firstChild, name)) {
+                return;
+              }
+              if (firstChild.attributes[name] == null) {
+                firstChild.attributes[name] = value;
+              } else if (name === 'transform') {
+                firstChild.attributes[name] =
+                  value + ' ' + firstChild.attributes[name];
+              } else if (firstChild.attributes[name] === 'inherit') {
+                firstChild.attributes[name] = value;
+              } else if (
+                inheritableAttrs.includes(name) === false &&
+                firstChild.attributes[name] !== value
+              ) {
+                return;
+              }
+              delete node.attributes[name];
             }
+          }
+        }
 
-        });
-
-    }
-
+        // collapse groups without attributes
+        if (Object.keys(node.attributes).length === 0) {
+          // animation elements "add" attributes to group
+          // group should be preserved
+          for (const child of node.children) {
+            if (
+              child.type === 'element' &&
+              elemsGroups.animation.includes(child.name)
+            ) {
+              return;
+            }
+          }
+          // replace current node with all its children
+          const index = parentNode.children.indexOf(node);
+          parentNode.children.splice(index, 1, ...node.children);
+          // TODO remove in v3
+          for (const child of node.children) {
+            // @ts-ignore parentNode is forbidden for public usage
+            // and will be moved in v3
+            child.parentNode = parentNode;
+          }
+        }
+      },
+    },
+  };
 };