@iconify/tools 2.0.14 → 2.0.15

package/lib/optimise/scale.d.ts

@@ -1,5 +1,10 @@
-import type { SVG } from '../svg';
+import { SVG } from '../svg/index.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * Scale icon
  */
-export declare function scaleSVG(svg: SVG, scale: number): Promise<void>;
+declare function scaleSVG(svg: SVG, scale: number): Promise<void>;
+
+export { scaleSVG };

package/lib/optimise/scale.mjs

@@ -1,5 +1,6 @@
-// src/optimise/scale.ts
-import { runSVGO } from "./svgo.mjs";
+import { runSVGO } from './svgo.mjs';
+import 'svgo';
+
 async function scaleSVG(svg, scale) {
   const viewBox = svg.viewBox;
   const width = viewBox.width * scale;
@@ -17,6 +18,5 @@ async function scaleSVG(svg, scale) {
     ]
   });
 }
-export {
-  scaleSVG
-};
+
+export { scaleSVG };

package/lib/optimise/svgo.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const svgo = require('svgo');
+
+const defaultSVGOPlugins = [
+  "cleanupAttrs",
+  "mergeStyles",
+  "inlineStyles",
+  "removeComments",
+  "removeUselessDefs",
+  "removeEditorsNSData",
+  "removeEmptyAttrs",
+  "removeEmptyContainers",
+  "convertStyleToAttrs",
+  "convertColors",
+  "convertTransform",
+  "removeUnknownsAndDefaults",
+  "removeNonInheritableGroupAttrs",
+  "removeUselessStrokeAndFill",
+  "removeUnusedNS",
+  "cleanupNumericValues",
+  "cleanupListOfValues",
+  "moveElemsAttrsToGroup",
+  "moveGroupAttrsToElems",
+  "collapseGroups",
+  "sortDefsChildren",
+  "sortAttrs"
+];
+const shapeModifiyingSVGOPlugins = [
+  "removeHiddenElems",
+  "convertShapeToPath",
+  "convertEllipseToCircle",
+  {
+    name: "convertPathData",
+    params: {
+      noSpaceAfterFlags: true
+    }
+  },
+  {
+    name: "mergePaths",
+    params: {
+      noSpaceAfterFlags: true
+    }
+  },
+  "reusePaths"
+];
+async function runSVGO(svg, options = {}) {
+  const code = svg.toString();
+  const multipass = options.multipass !== false;
+  let plugins;
+  if (options.plugins) {
+    plugins = options.plugins;
+  } else {
+    let keepShapes = options.keepShapes;
+    if (keepShapes === void 0 && (code.indexOf("<animate") !== -1 || code.indexOf("<set") !== -1)) {
+      keepShapes = true;
+    }
+    plugins = defaultSVGOPlugins.concat(keepShapes ? [] : shapeModifiyingSVGOPlugins, options.cleanupIDs !== false ? [
+      {
+        name: "cleanupIDs",
+        params: {
+          prefix: typeof options.cleanupIDs === "string" ? options.cleanupIDs : "svgID"
+        }
+      }
+    ] : []);
+  }
+  const pluginOptions = {
+    plugins,
+    multipass
+  };
+  const result = svgo.optimize(code, pluginOptions);
+  if (typeof result.error === "string") {
+    throw new Error(result.error);
+  }
+  const content = result.data.replace(/<defs\/>/g, "");
+  svg.load(content);
+}
+
+exports.defaultSVGOPlugins = defaultSVGOPlugins;
+exports.runSVGO = runSVGO;
+exports.shapeModifiyingSVGOPlugins = shapeModifiyingSVGOPlugins;

package/lib/optimise/svgo.d.ts

@@ -1,10 +1,13 @@
-import type { Plugin } from 'svgo';
-import type { SVG } from '../svg';
-export declare const defaultSVGOPlugins: Plugin[];
+import { Plugin } from 'svgo';
+import { SVG } from '../svg/index.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
+declare const defaultSVGOPlugins: Plugin[];
 /**
  * Plugins that modify shapes. Added to plugins list, unless 'keepShapes' option is enabled
  */
-export declare const shapeModifiyingSVGOPlugins: Plugin[];
+declare const shapeModifiyingSVGOPlugins: Plugin[];
 /**
  * Options
  */
@@ -23,5 +26,6 @@ declare type SVGOOptions = SVGOOptionsWithPlugin | SVGOptionsWithoutPlugin;
 /**
  * Run SVGO on icon
  */
-export declare function runSVGO(svg: SVG, options?: SVGOOptions): Promise<void>;
-export {};
+declare function runSVGO(svg: SVG, options?: SVGOOptions): Promise<void>;
+
+export { defaultSVGOPlugins, runSVGO, shapeModifiyingSVGOPlugins };

package/lib/optimise/svgo.mjs

@@ -1,6 +1,6 @@
-// src/optimise/svgo.ts
-import { optimize } from "svgo";
-var defaultSVGOPlugins = [
+import { optimize } from 'svgo';
+
+const defaultSVGOPlugins = [
   "cleanupAttrs",
   "mergeStyles",
   "inlineStyles",
@@ -24,7 +24,7 @@ var defaultSVGOPlugins = [
   "sortDefsChildren",
   "sortAttrs"
 ];
-var shapeModifiyingSVGOPlugins = [
+const shapeModifiyingSVGOPlugins = [
   "removeHiddenElems",
   "convertShapeToPath",
   "convertEllipseToCircle",
@@ -73,8 +73,5 @@ async function runSVGO(svg, options = {}) {
   const content = result.data.replace(/<defs\/>/g, "");
   svg.load(content);
 }
-export {
-  defaultSVGOPlugins,
-  runSVGO,
-  shapeModifiyingSVGOPlugins
-};
+
+export { defaultSVGOPlugins, runSVGO, shapeModifiyingSVGOPlugins };

package/lib/svg/analyse/error.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function analyseTagError(element) {
+  let result = "<" + element.tagName;
+  if (element._id) {
+    result += ' id="' + element._id + '"';
+  }
+  const attribs = element.attribs;
+  if (attribs["d"]) {
+    const value = attribs["d"];
+    result += ' d="' + (value.length > 16 ? value.slice(0, 12) + "..." : value) + '"';
+  }
+  return result + ">";
+}
+
+exports.analyseTagError = analyseTagError;

package/lib/svg/analyse/error.d.ts

@@ -1,5 +1,8 @@
-import type { ExtendedTagElement } from './types';
+import { ExtendedTagElement } from './types.js';
+
 /**
  * Get tag for error message
  */
-export declare function analyseTagError(element: ExtendedTagElement): string;
+declare function analyseTagError(element: ExtendedTagElement): string;
+
+export { analyseTagError };

package/lib/svg/analyse/error.mjs

@@ -1,4 +1,3 @@
-// src/svg/analyse/error.ts
 function analyseTagError(element) {
   let result = "<" + element.tagName;
   if (element._id) {
@@ -11,6 +10,5 @@ function analyseTagError(element) {
   }
   return result + ">";
 }
-export {
-  analyseTagError
-};
+
+export { analyseTagError };

package/lib/svg/analyse/types.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/lib/svg/analyse/types.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="cheerio" />
 /**
  * Options
  */
-export interface AnalyseSVGStructureOptions {
+interface AnalyseSVGStructureOptions {
     fixErrors?: boolean;
 }
 /**
@@ -11,7 +10,7 @@ export interface AnalyseSVGStructureOptions {
 /**
  * Link to element
  */
-export interface LinkToElementWithID {
+interface LinkToElementWithID {
     id: string;
     usedAsMask: boolean;
     usedByIndex: number;
@@ -19,7 +18,7 @@ export interface LinkToElementWithID {
 /**
  * How element is used by parent elements
  */
-export interface ExtendedTagElementUses {
+interface ExtendedTagElementUses {
     _usedAsMask: boolean;
     _usedAsPaint: boolean;
 }
@@ -36,7 +35,7 @@ interface ReusableElement {
  *
  * Similar to ReusableElement, but not necessary a definition - any element with id. Also contains list of child elements
  */
-export interface ElementWithID {
+interface ElementWithID {
     id: string;
     isMask: boolean;
     indexes: Set<number>;
@@ -51,7 +50,7 @@ interface ExtendedTagElementRelations {
 /**
  * Extended tag
  */
-export interface ExtendedTagElement extends cheerio.TagElement, ExtendedTagElementUses, ExtendedTagElementRelations {
+interface ExtendedTagElement extends cheerio.TagElement, ExtendedTagElementUses, ExtendedTagElementRelations {
     _index: number;
     _id?: string;
     _belongsTo?: ElementWithID[];
@@ -61,13 +60,13 @@ export interface ExtendedTagElement extends cheerio.TagElement, ExtendedTagEleme
 /**
  * Additional stuff for <svg>
  */
-export interface ExtendedRootTagElement extends ExtendedTagElement {
+interface ExtendedRootTagElement extends ExtendedTagElement {
     _parsed?: boolean;
 }
 /**
  * Tree
  */
-export interface ElementsTreeItem {
+interface ElementsTreeItem {
     index: number;
     usedAsMask: boolean;
     parent?: ElementsTreeItem;
@@ -76,14 +75,15 @@ export interface ElementsTreeItem {
 /**
  * Elements map
  */
-export declare type ElementsMap = Map<number, ExtendedTagElement>;
+declare type ElementsMap = Map<number, ExtendedTagElement>;
 /**
  * Result
  */
-export interface AnalyseSVGStructureResult {
+interface AnalyseSVGStructureResult {
     elements: ElementsMap;
     ids: Record<string, number>;
     links: LinkToElementWithID[];
     tree: ElementsTreeItem;
 }
-export {};
+
+export { AnalyseSVGStructureOptions, AnalyseSVGStructureResult, ElementWithID, ElementsMap, ElementsTreeItem, ExtendedRootTagElement, ExtendedTagElement, ExtendedTagElementUses, LinkToElementWithID };

package/lib/svg/analyse/types.mjs

@@ -0,0 +1 @@
+

package/lib/svg/analyse.cjs

@@ -0,0 +1,291 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const svg_parse = require('./parse.cjs');
+const svg_data_attributes = require('./data/attributes.cjs');
+const svg_data_tags = require('./data/tags.cjs');
+const svg_analyse_error = require('./analyse/error.cjs');
+
+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 = /* @__PURE__ */ new Map();
+  const ids = /* @__PURE__ */ 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: /* @__PURE__ */ 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 ${svg_analyse_error.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 svg_parse.parseSVG(svg, (item) => {
+    const { tagName, parents } = item;
+    if (svg_data_tags.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 (svg_data_tags.maskTags.has(tagName)) {
+      if (!gotReusableElement(item, true)) {
+        return;
+      }
+    } else if (svg_data_tags.reusableElementsWithPalette.has(tagName)) {
+      if (!gotReusableElement(item, false)) {
+        return;
+      }
+    } else if (svg_data_tags.defsTag.has(parentItem.tagName)) {
+      if (!gotReusableElement(item, false)) {
+        return;
+      }
+    } else if (!svg_data_tags.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 ${svg_analyse_error.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 (svg_data_attributes.tagSpecificNonPresentationalAttributes[tagName]?.has("href")) {
+      const href = attribs["href"] || attribs["xlink:href"];
+      if (typeof href === "string") {
+        if (href.slice(0, 1) !== "#") {
+          throw new Error(`Invalid link in ${svg_analyse_error.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 (svg_data_attributes.urlPresentationalAttributes.has(attr)) {
+        gotElementReference(item, id, attr !== "filter");
+        return;
+      }
+      if (svg_data_attributes.commonColorPresentationalAttributes.has(attr) || svg_data_attributes.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() {
+        const $element = cheerio(element);
+        const parent = element.parent;
+        if (parent) {
+          if (parent._childElements) {
+            parent._childElements = parent._childElements.filter((num) => num !== index2);
+          }
+          parent._belongsTo?.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 (svg_data_tags.useTag.has(tagName)) {
+          remove();
+          return;
+        }
+      }
+      const matches = /* @__PURE__ */ 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) {
+    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);
+    element._childElements?.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);
+    });
+    element._linksTo?.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
+  };
+}
+
+exports.analyseSVGStructure = analyseSVGStructure;

package/lib/svg/analyse.d.ts

@@ -1,8 +1,13 @@
-import type { SVG } from './index';
-import type { AnalyseSVGStructureResult, AnalyseSVGStructureOptions } from './analyse/types';
+import { SVG } from './index.js';
+import { AnalyseSVGStructureOptions, AnalyseSVGStructureResult } from './analyse/types.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * 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>;
+declare function analyseSVGStructure(svg: SVG, options?: AnalyseSVGStructureOptions): Promise<AnalyseSVGStructureResult>;
+
+export { analyseSVGStructure };