@iconify/tools 2.0.8 → 2.0.12

package/lib/svg/analyse.d.ts

@@ -0,0 +1,8 @@
+import type { SVG } from './index';
+import type { AnalyseSVGStructureResult, AnalyseSVGStructureOptions } from './analyse/types';
+/**
+ * Find all IDs, links, which elements use palette, which items aren't used
+ *
+ * Before running this function run cleanup functions to change inline style to attributes and fix attributes
+ */
+export declare function analyseSVGStructure(svg: SVG, options?: AnalyseSVGStructureOptions): Promise<AnalyseSVGStructureResult>;

package/lib/svg/analyse.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyseSVGStructure = void 0;
+const parse_1 = require("./parse");
+const attributes_1 = require("./data/attributes");
+const tags_1 = require("./data/tags");
+const error_1 = require("./analyse/error");
+/**
+ * Find all IDs, links, which elements use palette, which items aren't used
+ *
+ * Before running this function run cleanup functions to change inline style to attributes and fix attributes
+ */
+async function analyseSVGStructure(svg, options = {}) {
+    // Options
+    const fixErrors = options.fixErrors;
+    // Root element
+    let root = svg.$svg(':root').get(0);
+    if (root._parsed) {
+        // Reload to reset custom properties
+        svg.load(svg.toString());
+        root = svg.$svg(':root').get(0);
+    }
+    root._parsed = true;
+    const cheerio = svg.$svg;
+    // List of all elements
+    const elements = new Map();
+    // List of IDs
+    const ids = Object.create(null);
+    // Links
+    let links = [];
+    /**
+     * Found element with id
+     */
+    function addID(element, id) {
+        if (ids[id]) {
+            throw new Error(`Duplicate id "${id}"`);
+        }
+        element._id = id;
+        ids[id] = element._index;
+        return true;
+    }
+    /**
+     * Add _belongsTo
+     */
+    function gotElementWithID(element, id, isMask) {
+        addID(element, id);
+        if (!element._belongsTo) {
+            element._belongsTo = [];
+        }
+        element._belongsTo.push({
+            id,
+            isMask,
+            indexes: new Set([element._index]),
+        });
+        return;
+    }
+    /**
+     * Mark element as reusable, set properties
+     */
+    function gotReusableElement(item, isMask) {
+        const element = item.element;
+        const attribs = element.attribs;
+        const index = element._index;
+        const id = attribs['id'];
+        if (typeof id !== 'string') {
+            const message = `Definition element ${(0, error_1.analyseTagError)(element)} does not have id`;
+            if (fixErrors) {
+                item.removeNode = true;
+                item.testChildren = false;
+                console.warn(message);
+                return false;
+            }
+            throw new Error(message);
+        }
+        if (ids[id] && fixErrors) {
+            console.warn(`Duplicate id "${id}"`);
+            item.removeNode = true;
+            item.testChildren = false;
+            return false;
+        }
+        element._reusableElement = {
+            id,
+            isMask,
+            index,
+        };
+        gotElementWithID(element, id, isMask);
+        return true;
+    }
+    /**
+     * Found element that uses another element
+     */
+    function gotElementReference(item, id, usedAsMask) {
+        const element = item.element;
+        const usedByIndex = element._index;
+        const link = {
+            id,
+            usedByIndex,
+            usedAsMask,
+        };
+        // Add to global list
+        links.push(link);
+        // Add to element and parent elements
+        if (!element._linksTo) {
+            element._linksTo = [];
+        }
+        element._linksTo.push(link);
+    }
+    // Find all reusable elements and all usages
+    let index = 0;
+    await (0, parse_1.parseSVG)(svg, (item) => {
+        var _a;
+        const { tagName, parents } = item;
+        if (tags_1.styleTag.has(tagName)) {
+            item.testChildren = false;
+            return;
+        }
+        const element = item.element;
+        const attribs = element.attribs;
+        // Set index
+        index++;
+        element._index = index;
+        elements.set(index, element);
+        if (!parents.length) {
+            // root <svg>
+            element._usedAsMask = false;
+            element._usedAsPaint = true;
+            return;
+        }
+        element._usedAsMask = false;
+        element._usedAsPaint = false;
+        // Get parent element
+        const parentItem = parents[0];
+        const parentElement = parentItem.element;
+        // Check for mask or clip path
+        if (tags_1.maskTags.has(tagName)) {
+            // Element can only be used as mask or clip path
+            if (!gotReusableElement(item, true)) {
+                return;
+            }
+        }
+        else if (tags_1.reusableElementsWithPalette.has(tagName)) {
+            // Reusable element that uses palette
+            if (!gotReusableElement(item, false)) {
+                return;
+            }
+        }
+        else if (tags_1.defsTag.has(parentItem.tagName)) {
+            // Symbol without <symbol> tag
+            if (!gotReusableElement(item, false)) {
+                return;
+            }
+        }
+        else if (!tags_1.defsTag.has(tagName)) {
+            // Not reusable element, not <defs>. Copy parent stuff
+            element._usedAsMask = parentElement._usedAsMask;
+            element._usedAsPaint = parentElement._usedAsPaint;
+            element._parentElement = parentElement._index;
+            if (!parentElement._childElements) {
+                parentElement._childElements = [];
+            }
+            parentElement._childElements.push(index);
+            // Copy id of reusable element from parent
+            const parentReusableElement = parentElement._reusableElement;
+            if (parentReusableElement) {
+                if (element._reusableElement) {
+                    // Reusable element inside reusable element: should not happen!
+                    throw new Error(`Reusable element ${(0, error_1.analyseTagError)(element)} is inside another reusable element id="${parentReusableElement.id}"`);
+                }
+                element._reusableElement = parentReusableElement;
+            }
+            // Copy all parent ids
+            const parentBelongsTo = parentElement._belongsTo;
+            if (parentBelongsTo) {
+                const list = element._belongsTo || (element._belongsTo = []);
+                parentBelongsTo.forEach((item) => {
+                    item.indexes.add(index);
+                    list.push(item);
+                });
+            }
+            // Check if element has its own id
+            if (element._id === void 0) {
+                const id = attribs['id'];
+                if (typeof id === 'string') {
+                    if (ids[id] && fixErrors) {
+                        console.warn(`Duplicate id "${id}"`);
+                        cheerio(element).removeAttr('id');
+                    }
+                    else {
+                        gotElementWithID(element, id, false);
+                    }
+                }
+            }
+        }
+        // Check if element uses any ID
+        if ((_a = attributes_1.tagSpecificNonPresentationalAttributes[tagName]) === null || _a === void 0 ? void 0 : _a.has('href')) {
+            const href = attribs['href'] || attribs['xlink:href'];
+            if (typeof href === 'string') {
+                if (href.slice(0, 1) !== '#') {
+                    throw new Error(`Invalid link in ${(0, error_1.analyseTagError)(element)}`);
+                }
+                const id = href.slice(1);
+                gotElementReference(item, id, false);
+            }
+        }
+        // Check colors
+        Object.keys(attribs).forEach((attr) => {
+            // Get id
+            let value = attribs[attr];
+            if (value.slice(0, 5).toLowerCase() !== 'url(#') {
+                return;
+            }
+            value = value.slice(5);
+            if (value.slice(-1) !== ')') {
+                return;
+            }
+            const id = value.slice(0, value.length - 1).trim();
+            if (attributes_1.urlPresentationalAttributes.has(attr)) {
+                // Used as mask, clip path or filter
+                gotElementReference(item, id, attr !== 'filter');
+                return;
+            }
+            if (attributes_1.commonColorPresentationalAttributes.has(attr) ||
+                attributes_1.markerAttributes.has(attr)) {
+                // Used as paint
+                gotElementReference(item, id, false);
+                return;
+            }
+        });
+    });
+    // Make sure all required IDs exist
+    links = links.filter((item) => {
+        const id = item.id;
+        if (ids[id]) {
+            return true;
+        }
+        // Attempt to fix error
+        function fix() {
+            const index = item.usedByIndex;
+            const element = elements.get(index);
+            const tagName = element.tagName;
+            function remove() {
+                var _a;
+                const $element = cheerio(element);
+                const parent = element.parent;
+                if (parent) {
+                    if (parent._childElements) {
+                        parent._childElements = parent._childElements.filter((num) => num !== index);
+                    }
+                    (_a = parent._belongsTo) === null || _a === void 0 ? void 0 : _a.forEach((list) => {
+                        list.indexes.delete(index);
+                    });
+                }
+                $element.remove();
+            }
+            // Remove links
+            if (element._linksTo) {
+                element._linksTo = element._linksTo.filter((item) => item.id !== id);
+            }
+            // Remove <use /> without children
+            if (!element.children.length) {
+                if (tags_1.useTag.has(tagName)) {
+                    remove();
+                    return;
+                }
+            }
+            // Remove attributes that use id
+            const matches = new Set(['#' + id, 'url(#' + id + ')']);
+            const attribs = element.attribs;
+            for (const attr in attribs) {
+                if (matches.has(attribs[attr])) {
+                    cheerio(element).removeAttr(attr);
+                }
+            }
+        }
+        const message = `Missing element with id="${id}"`;
+        if (fixErrors) {
+            fix();
+            console.warn(message);
+        }
+        else {
+            throw new Error(message);
+        }
+        return false;
+    });
+    // Check if tree item already has child item
+    function hasChildItem(tree, child, canThrow) {
+        const item = tree.children.find((item) => item.index === child.index &&
+            item.usedAsMask === child.usedAsMask);
+        if (item && canThrow) {
+            throw new Error('Recursion');
+        }
+        return !!item;
+    }
+    // Generate tree
+    const tree = {
+        index: 1,
+        usedAsMask: false,
+        children: [],
+    };
+    function parseTreeItem(tree, usedItems, inMask) {
+        var _a, _b;
+        const element = elements.get(tree.index);
+        // Add usage
+        if (tree.usedAsMask || inMask) {
+            element._usedAsMask = true;
+            inMask = true;
+        }
+        else {
+            element._usedAsPaint = true;
+        }
+        usedItems = usedItems.slice(0);
+        usedItems.push(element._index);
+        // Add all child elements
+        (_a = element._childElements) === null || _a === void 0 ? void 0 : _a.forEach((childIndex) => {
+            if (usedItems.indexOf(childIndex) !== -1) {
+                throw new Error('Recursion');
+            }
+            const childItem = {
+                index: childIndex,
+                usedAsMask: false,
+                children: [],
+                parent: tree,
+            };
+            tree.children.push(childItem);
+            parseTreeItem(childItem, usedItems, inMask);
+        });
+        // Add all links
+        (_b = element._linksTo) === null || _b === void 0 ? void 0 : _b.forEach((link) => {
+            const linkIndex = ids[link.id];
+            const usedAsMask = link.usedAsMask;
+            const childItem = {
+                index: linkIndex,
+                usedAsMask,
+                children: [],
+                parent: tree,
+            };
+            if (hasChildItem(tree, childItem, false)) {
+                return;
+            }
+            tree.children.push(childItem);
+            parseTreeItem(childItem, usedItems, inMask || usedAsMask);
+        });
+    }
+    parseTreeItem(tree, [0], false);
+    return {
+        elements,
+        ids,
+        links,
+        tree,
+    };
+}
+exports.analyseSVGStructure = analyseSVGStructure;

package/lib/svg/analyse.mjs

@@ -0,0 +1,302 @@
+// src/svg/analyse.ts
+import { parseSVG } from "./parse.mjs";
+import {
+  commonColorPresentationalAttributes,
+  markerAttributes,
+  tagSpecificNonPresentationalAttributes,
+  urlPresentationalAttributes
+} from "./data/attributes.mjs";
+import {
+  defsTag,
+  maskTags,
+  reusableElementsWithPalette,
+  styleTag,
+  useTag
+} from "./data/tags.mjs";
+import { analyseTagError } from "./analyse/error.mjs";
+async function analyseSVGStructure(svg, options = {}) {
+  const fixErrors = options.fixErrors;
+  let root = svg.$svg(":root").get(0);
+  if (root._parsed) {
+    svg.load(svg.toString());
+    root = svg.$svg(":root").get(0);
+  }
+  root._parsed = true;
+  const cheerio = svg.$svg;
+  const elements = new Map();
+  const ids = Object.create(null);
+  let links = [];
+  function addID(element, id) {
+    if (ids[id]) {
+      throw new Error(`Duplicate id "${id}"`);
+    }
+    element._id = id;
+    ids[id] = element._index;
+    return true;
+  }
+  function gotElementWithID(element, id, isMask) {
+    addID(element, id);
+    if (!element._belongsTo) {
+      element._belongsTo = [];
+    }
+    element._belongsTo.push({
+      id,
+      isMask,
+      indexes: new Set([element._index])
+    });
+    return;
+  }
+  function gotReusableElement(item, isMask) {
+    const element = item.element;
+    const attribs = element.attribs;
+    const index2 = element._index;
+    const id = attribs["id"];
+    if (typeof id !== "string") {
+      const message = `Definition element ${analyseTagError(element)} does not have id`;
+      if (fixErrors) {
+        item.removeNode = true;
+        item.testChildren = false;
+        console.warn(message);
+        return false;
+      }
+      throw new Error(message);
+    }
+    if (ids[id] && fixErrors) {
+      console.warn(`Duplicate id "${id}"`);
+      item.removeNode = true;
+      item.testChildren = false;
+      return false;
+    }
+    element._reusableElement = {
+      id,
+      isMask,
+      index: index2
+    };
+    gotElementWithID(element, id, isMask);
+    return true;
+  }
+  function gotElementReference(item, id, usedAsMask) {
+    const element = item.element;
+    const usedByIndex = element._index;
+    const link = {
+      id,
+      usedByIndex,
+      usedAsMask
+    };
+    links.push(link);
+    if (!element._linksTo) {
+      element._linksTo = [];
+    }
+    element._linksTo.push(link);
+  }
+  let index = 0;
+  await parseSVG(svg, (item) => {
+    var _a;
+    const { tagName, parents } = item;
+    if (styleTag.has(tagName)) {
+      item.testChildren = false;
+      return;
+    }
+    const element = item.element;
+    const attribs = element.attribs;
+    index++;
+    element._index = index;
+    elements.set(index, element);
+    if (!parents.length) {
+      element._usedAsMask = false;
+      element._usedAsPaint = true;
+      return;
+    }
+    element._usedAsMask = false;
+    element._usedAsPaint = false;
+    const parentItem = parents[0];
+    const parentElement = parentItem.element;
+    if (maskTags.has(tagName)) {
+      if (!gotReusableElement(item, true)) {
+        return;
+      }
+    } else if (reusableElementsWithPalette.has(tagName)) {
+      if (!gotReusableElement(item, false)) {
+        return;
+      }
+    } else if (defsTag.has(parentItem.tagName)) {
+      if (!gotReusableElement(item, false)) {
+        return;
+      }
+    } else if (!defsTag.has(tagName)) {
+      element._usedAsMask = parentElement._usedAsMask;
+      element._usedAsPaint = parentElement._usedAsPaint;
+      element._parentElement = parentElement._index;
+      if (!parentElement._childElements) {
+        parentElement._childElements = [];
+      }
+      parentElement._childElements.push(index);
+      const parentReusableElement = parentElement._reusableElement;
+      if (parentReusableElement) {
+        if (element._reusableElement) {
+          throw new Error(`Reusable element ${analyseTagError(element)} is inside another reusable element id="${parentReusableElement.id}"`);
+        }
+        element._reusableElement = parentReusableElement;
+      }
+      const parentBelongsTo = parentElement._belongsTo;
+      if (parentBelongsTo) {
+        const list = element._belongsTo || (element._belongsTo = []);
+        parentBelongsTo.forEach((item2) => {
+          item2.indexes.add(index);
+          list.push(item2);
+        });
+      }
+      if (element._id === void 0) {
+        const id = attribs["id"];
+        if (typeof id === "string") {
+          if (ids[id] && fixErrors) {
+            console.warn(`Duplicate id "${id}"`);
+            cheerio(element).removeAttr("id");
+          } else {
+            gotElementWithID(element, id, false);
+          }
+        }
+      }
+    }
+    if ((_a = tagSpecificNonPresentationalAttributes[tagName]) == null ? void 0 : _a.has("href")) {
+      const href = attribs["href"] || attribs["xlink:href"];
+      if (typeof href === "string") {
+        if (href.slice(0, 1) !== "#") {
+          throw new Error(`Invalid link in ${analyseTagError(element)}`);
+        }
+        const id = href.slice(1);
+        gotElementReference(item, id, false);
+      }
+    }
+    Object.keys(attribs).forEach((attr) => {
+      let value = attribs[attr];
+      if (value.slice(0, 5).toLowerCase() !== "url(#") {
+        return;
+      }
+      value = value.slice(5);
+      if (value.slice(-1) !== ")") {
+        return;
+      }
+      const id = value.slice(0, value.length - 1).trim();
+      if (urlPresentationalAttributes.has(attr)) {
+        gotElementReference(item, id, attr !== "filter");
+        return;
+      }
+      if (commonColorPresentationalAttributes.has(attr) || markerAttributes.has(attr)) {
+        gotElementReference(item, id, false);
+        return;
+      }
+    });
+  });
+  links = links.filter((item) => {
+    const id = item.id;
+    if (ids[id]) {
+      return true;
+    }
+    function fix() {
+      const index2 = item.usedByIndex;
+      const element = elements.get(index2);
+      const tagName = element.tagName;
+      function remove() {
+        var _a;
+        const $element = cheerio(element);
+        const parent = element.parent;
+        if (parent) {
+          if (parent._childElements) {
+            parent._childElements = parent._childElements.filter((num) => num !== index2);
+          }
+          (_a = parent._belongsTo) == null ? void 0 : _a.forEach((list) => {
+            list.indexes.delete(index2);
+          });
+        }
+        $element.remove();
+      }
+      if (element._linksTo) {
+        element._linksTo = element._linksTo.filter((item2) => item2.id !== id);
+      }
+      if (!element.children.length) {
+        if (useTag.has(tagName)) {
+          remove();
+          return;
+        }
+      }
+      const matches = new Set(["#" + id, "url(#" + id + ")"]);
+      const attribs = element.attribs;
+      for (const attr in attribs) {
+        if (matches.has(attribs[attr])) {
+          cheerio(element).removeAttr(attr);
+        }
+      }
+    }
+    const message = `Missing element with id="${id}"`;
+    if (fixErrors) {
+      fix();
+      console.warn(message);
+    } else {
+      throw new Error(message);
+    }
+    return false;
+  });
+  function hasChildItem(tree2, child, canThrow) {
+    const item = tree2.children.find((item2) => item2.index === child.index && item2.usedAsMask === child.usedAsMask);
+    if (item && canThrow) {
+      throw new Error("Recursion");
+    }
+    return !!item;
+  }
+  const tree = {
+    index: 1,
+    usedAsMask: false,
+    children: []
+  };
+  function parseTreeItem(tree2, usedItems, inMask) {
+    var _a, _b;
+    const element = elements.get(tree2.index);
+    if (tree2.usedAsMask || inMask) {
+      element._usedAsMask = true;
+      inMask = true;
+    } else {
+      element._usedAsPaint = true;
+    }
+    usedItems = usedItems.slice(0);
+    usedItems.push(element._index);
+    (_a = element._childElements) == null ? void 0 : _a.forEach((childIndex) => {
+      if (usedItems.indexOf(childIndex) !== -1) {
+        throw new Error("Recursion");
+      }
+      const childItem = {
+        index: childIndex,
+        usedAsMask: false,
+        children: [],
+        parent: tree2
+      };
+      tree2.children.push(childItem);
+      parseTreeItem(childItem, usedItems, inMask);
+    });
+    (_b = element._linksTo) == null ? void 0 : _b.forEach((link) => {
+      const linkIndex = ids[link.id];
+      const usedAsMask = link.usedAsMask;
+      const childItem = {
+        index: linkIndex,
+        usedAsMask,
+        children: [],
+        parent: tree2
+      };
+      if (hasChildItem(tree2, childItem, false)) {
+        return;
+      }
+      tree2.children.push(childItem);
+      parseTreeItem(childItem, usedItems, inMask || usedAsMask);
+    });
+  }
+  parseTreeItem(tree, [0], false);
+  return {
+    elements,
+    ids,
+    links,
+    tree
+  };
+}
+export {
+  analyseSVGStructure
+};

package/lib/svg/cleanup/attribs.d.ts

@@ -1,4 +1,4 @@
-import type { SVG } from '..';
+import type { SVG } from '../../svg';
 /**
  * Remove useless attributes
  */

package/lib/svg/cleanup/attribs.js

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeBadAttributes = void 0;
 const attributes_1 = require("../data/attributes");
+const tags_1 = require("../data/tags");
 const parse_1 = require("../parse");
 /**
  * Remove useless attributes
  */
 async function removeBadAttributes(svg) {
     await (0, parse_1.parseSVG)(svg, (item) => {
+        const tagName = item.tagName;
         const attribs = item.element.attribs;
         const $element = item.$element;
         // Common tags
@@ -20,6 +22,12 @@ async function removeBadAttributes(svg) {
                 $element.removeAttr(attr);
                 return;
             }
+            // Attributes on <defs> aren't passed to child nodes, so remove everything)
+            if (tags_1.defsTag.has(tagName) &&
+                !attributes_1.tagSpecificPresentationalAttributes[tagName].has(attr)) {
+                $element.removeAttr(attr);
+                return;
+            }
             // Check for namespace
             const nsParts = attr.split(':');
             if (nsParts.length > 1) {