@iconify/tools 4.2.0 → 5.0.0-beta.2

package/lib/optimise/origin.js

@@ -0,0 +1,22 @@
+import { runSVGO } from "./svgo.js";
+
+/**
+* Reset origin to 0 0
+*/
+function resetSVGOrigin(svg) {
+	const viewBox = svg.viewBox;
+	const left = viewBox.left ?? 0;
+	const top = viewBox.top ?? 0;
+	if (left || top) {
+		const content = `<svg width="${viewBox.width}" height="${viewBox.height}" viewBox="0 0 ${viewBox.width} ${viewBox.height}"><g transform="translate(${0 - left} ${0 - top})">${svg.getBody()}</g></svg>`;
+		svg.load(content);
+		runSVGO(svg, { plugins: [
+			"collapseGroups",
+			"convertTransform",
+			"convertPathData",
+			"sortAttrs"
+		] });
+	}
+}
+
+export { resetSVGOrigin };

package/lib/optimise/scale.d.ts

@@ -1,11 +1,6 @@
-import { SVG } from '../svg/index.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-
+import { SVG } from "../svg/index.js";
 /**
  * Scale icon
  */
 declare function scaleSVG(svg: SVG, scale: number): void;
-
-export { scaleSVG };
+export { scaleSVG };

package/lib/optimise/scale.js

@@ -0,0 +1,24 @@
+import { runSVGO } from "./svgo.js";
+import { resetSVGOrigin } from "./origin.js";
+
+/**
+* Scale icon
+*/
+function scaleSVG(svg, scale) {
+	resetSVGOrigin(svg);
+	if (scale !== 1) {
+		const viewBox = svg.viewBox;
+		const width = viewBox.width * scale;
+		const height = viewBox.height * scale;
+		const content = `<svg width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><g transform="scale(${scale})">${svg.getBody()}</g></svg>`;
+		svg.load(content);
+		runSVGO(svg, { plugins: [
+			"collapseGroups",
+			"convertTransform",
+			"convertPathData",
+			"sortAttrs"
+		] });
+	}
+}
+
+export { scaleSVG };

package/lib/optimise/svgo.d.ts

@@ -1,15 +1,11 @@
-import { PluginConfig } from 'svgo';
-import { SVG } from '../svg/index.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-
+import { SVG } from "../svg/index.js";
+import { PluginConfig } from "svgo";
 interface CleanupIDsOption {
-    cleanupIDs?: string | ((id: string) => string) | false;
+  cleanupIDs?: string | ((id: string) => string) | false;
 }
 interface GetSVGOPluginOptions extends CleanupIDsOption {
-    animated?: boolean;
-    keepShapes?: boolean;
+  animated?: boolean;
+  keepShapes?: boolean;
 }
 /**
  * Get list of plugins
@@ -19,19 +15,18 @@ declare function getSVGOPlugins(options: GetSVGOPluginOptions): PluginConfig[];
  * Options
  */
 interface SVGOCommonOptions {
-    multipass?: boolean;
+  multipass?: boolean;
 }
 interface SVGOOptionsWithPlugin extends SVGOCommonOptions {
-    plugins: PluginConfig[];
+  plugins: PluginConfig[];
 }
 interface SVGOptionsWithoutPlugin extends SVGOCommonOptions, CleanupIDsOption {
-    plugins?: undefined;
-    keepShapes?: boolean;
+  plugins?: undefined;
+  keepShapes?: boolean;
 }
 type SVGOOptions = SVGOOptionsWithPlugin | SVGOptionsWithoutPlugin;
 /**
  * Run SVGO on icon
  */
 declare function runSVGO(svg: SVG, options?: SVGOOptions): void;
-
-export { getSVGOPlugins, runSVGO };
+export { getSVGOPlugins, runSVGO };

package/lib/optimise/svgo.js

@@ -0,0 +1,90 @@
+import { parseXMLContent, stringifyXMLContent } from "@cyberalien/svg-utils";
+import { optimize } from "svgo";
+import { changeSVGIDs } from "@cyberalien/svg-utils/lib/svg/ids/change.js";
+
+/**
+* Get list of plugins
+*/
+function getSVGOPlugins(options) {
+	return [
+		"cleanupAttrs",
+		"mergeStyles",
+		"inlineStyles",
+		"removeComments",
+		"removeUselessDefs",
+		"removeEditorsNSData",
+		"removeEmptyAttrs",
+		"removeEmptyContainers",
+		"convertStyleToAttrs",
+		"convertColors",
+		"convertTransform",
+		"removeUnknownsAndDefaults",
+		"removeNonInheritableGroupAttrs",
+		"removeUnusedNS",
+		"cleanupNumericValues",
+		"cleanupListOfValues",
+		"moveElemsAttrsToGroup",
+		"moveGroupAttrsToElems",
+		"collapseGroups",
+		"sortDefsChildren",
+		"sortAttrs",
+		...options.animated ? [] : ["removeUselessStrokeAndFill"],
+		...options.animated || options.keepShapes ? [] : [
+			"removeHiddenElems",
+			"convertShapeToPath",
+			"convertEllipseToCircle",
+			{
+				name: "convertPathData",
+				params: { noSpaceAfterFlags: true }
+			},
+			{
+				name: "mergePaths",
+				params: { noSpaceAfterFlags: true }
+			},
+			"reusePaths"
+		],
+		...!options.animated && options.cleanupIDs !== false ? ["cleanupIds"] : []
+	];
+}
+/**
+* Run SVGO on icon
+*/
+function runSVGO(svg, options = {}) {
+	const code = svg.toString();
+	const multipass = options.multipass !== false;
+	let plugins;
+	if (options.plugins) plugins = options.plugins;
+	else {
+		const animated = code.includes("<animate") || code.includes("<set");
+		plugins = getSVGOPlugins({
+			...options,
+			animated
+		});
+		if (code.includes("filter=") && code.includes("transform=")) plugins = plugins.filter((item) => item !== "moveElemsAttrsToGroup");
+	}
+	const result = optimize(code, {
+		plugins,
+		multipass
+	});
+	if (typeof result.error === "string") throw new Error(result.error);
+	let content = result.data.replace(/<defs\/>/g, "");
+	if (!options.plugins) {
+		const prefix = options.cleanupIDs !== void 0 ? options.cleanupIDs : "svgID";
+		if (prefix !== false) {
+			let counter = 0;
+			const xml = parseXMLContent(content);
+			if (xml) {
+				changeSVGIDs(xml, () => prefix + (counter++).toString(36));
+				const newContent = stringifyXMLContent(xml);
+				if (newContent) content = newContent;
+			}
+		}
+	}
+	if (!options.plugins || options.plugins.find((item) => {
+		if (typeof item === "string") return item === "reusePaths";
+		return item.name === "reusePaths";
+	})) content = content.replace(" xmlns:xlink=\"http://www.w3.org/1999/xlink\"", "").replaceAll("xlink:href=", "href=");
+	svg.load(content);
+}
+
+export { getSVGOPlugins, runSVGO };

package/lib/optimise/unwrap.d.ts

@@ -1,11 +1,6 @@
-import { SVG } from '../svg/index.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-
+import { SVG } from "../svg/index.js";
 /**
  * Removes empty group from SVG root element
  */
 declare function unwrapEmptyGroup(svg: SVG): void;
-
-export { unwrapEmptyGroup };
+export { unwrapEmptyGroup };

package/lib/optimise/unwrap.js

@@ -0,0 +1,25 @@
+import { stringifyXMLContent } from "@cyberalien/svg-utils";
+
+/**
+* Removes empty group from SVG root element
+*/
+function unwrapEmptyGroup(svg) {
+	const root = svg.$svg;
+	if (root.children.length !== 1) return;
+	const groupNode = root.children[0];
+	if (groupNode.type !== "tag" || groupNode.tag !== "g" || !groupNode.children.length) return;
+	const html = stringifyXMLContent(groupNode.children);
+	for (const attr in groupNode.attribs) {
+		const value = groupNode.attribs[attr];
+		if (typeof value !== "string") continue;
+		switch (attr) {
+			case "id":
+				if (html?.includes(value)) return;
+				break;
+			default: return;
+		}
+	}
+	root.children = groupNode.children;
+}
+
+export { unwrapEmptyGroup };

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

@@ -1,11 +1,6 @@
-import { ExtendedTagElement } from './types.js';
-import '../../misc/cheerio.js';
-import 'domhandler';
-import 'cheerio';
-
+import { ExtendedTagElement } from "./types.js";
 /**
  * Get tag for error message
  */
 declare function analyseTagError(element: ExtendedTagElement): string;
-
-export { analyseTagError };
+export { analyseTagError };

package/lib/svg/analyse/error.js

@@ -0,0 +1,12 @@
+/**
+* Get tag for error message
+*/
+function analyseTagError(element) {
+	let result = "<" + element.tag;
+	if (element._id) result += " id=\"" + element._id + "\"";
+	const value = element.attribs["d"];
+	if (typeof value === "string") result += " d=\"" + (value.length > 16 ? value.slice(0, 12) + "..." : value) + "\"";
+	return result + ">";
+}
+
+export { analyseTagError };

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

@@ -1,12 +1,9 @@
-import { CheerioElement } from '../../misc/cheerio.js';
-import 'domhandler';
-import 'cheerio';
-
+import { ParsedXMLTagElement } from "@cyberalien/svg-utils";
 /**
  * Options
  */
 interface AnalyseSVGStructureOptions {
-    fixErrors?: boolean;
+  fixErrors?: boolean;
 }
 /**
  * Extended properties for element
@@ -15,24 +12,24 @@ interface AnalyseSVGStructureOptions {
  * Link to element
  */
 interface LinkToElementWithID {
-    id: string;
-    usedAsMask: boolean;
-    usedByIndex: number;
+  id: string;
+  usedAsMask: boolean;
+  usedByIndex: number;
 }
 /**
  * How element is used by parent elements
  */
 interface ExtendedTagElementUses {
-    _usedAsMask: boolean;
-    _usedAsPaint: boolean;
+  _usedAsMask: boolean;
+  _usedAsPaint: boolean;
 }
 /**
  * Definition: mask, clip path, symbol, etc...
  */
 interface ReusableElement {
-    id: string;
-    isMask: boolean;
-    index: number;
+  id: string;
+  isMask: boolean;
+  index: number;
 }
 /**
  * Element with id
@@ -40,41 +37,41 @@ interface ReusableElement {
  * Similar to ReusableElement, but not necessary a definition - any element with id. Also contains list of child elements
  */
 interface ElementWithID {
-    id: string;
-    isMask: boolean;
-    indexes: Set<number>;
+  id: string;
+  isMask: boolean;
+  indexes: Set<number>;
 }
 /**
  * Parent and child elements. Unlike standard tree, this tree is for elements that inherit attributes from parent element
  */
 interface ExtendedTagElementRelations {
-    _parentElement?: number;
-    _childElements?: number[];
+  _parentElement?: number;
+  _childElements?: number[];
 }
 /**
  * Extended tag
  */
-interface ExtendedTagElement extends CheerioElement, ExtendedTagElementUses, ExtendedTagElementRelations {
-    _index: number;
-    _id?: string;
-    _belongsTo?: ElementWithID[];
-    _reusableElement?: ReusableElement;
-    _linksTo?: LinkToElementWithID[];
+interface ExtendedTagElement extends ParsedXMLTagElement, ExtendedTagElementUses, ExtendedTagElementRelations {
+  _index: number;
+  _id?: string;
+  _belongsTo?: ElementWithID[];
+  _reusableElement?: ReusableElement;
+  _linksTo?: LinkToElementWithID[];
 }
 /**
  * Additional stuff for <svg>
  */
 interface ExtendedRootTagElement extends ExtendedTagElement {
-    _parsed?: boolean;
+  _parsed?: boolean;
 }
 /**
  * Tree
  */
 interface ElementsTreeItem {
-    index: number;
-    usedAsMask: boolean;
-    parent?: ElementsTreeItem;
-    children: ElementsTreeItem[];
+  index: number;
+  usedAsMask: boolean;
+  parent?: ElementsTreeItem;
+  children: ElementsTreeItem[];
 }
 /**
  * Elements map
@@ -84,10 +81,9 @@ type ElementsMap = Map<number, ExtendedTagElement>;
  * Result
  */
 interface AnalyseSVGStructureResult {
-    elements: ElementsMap;
-    ids: Record<string, number>;
-    links: LinkToElementWithID[];
-    tree: ElementsTreeItem;
+  elements: ElementsMap;
+  ids: Record<string, number>;
+  links: LinkToElementWithID[];
+  tree: ElementsTreeItem;
 }
-
-export type { AnalyseSVGStructureOptions, AnalyseSVGStructureResult, ElementWithID, ElementsMap, ElementsTreeItem, ExtendedRootTagElement, ExtendedTagElement, ExtendedTagElementUses, LinkToElementWithID };
+export { AnalyseSVGStructureOptions, AnalyseSVGStructureResult, ElementWithID, ElementsMap, ElementsTreeItem, ExtendedRootTagElement, ExtendedTagElement, ExtendedTagElementUses, LinkToElementWithID };

package/lib/svg/analyse/types.js

@@ -0,0 +1 @@
+export {  };

package/lib/svg/analyse.d.ts

@@ -1,16 +1,9 @@
-import { SVG } from './index.js';
-import { AnalyseSVGStructureOptions, AnalyseSVGStructureResult } from './analyse/types.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../misc/cheerio.js';
-import 'domhandler';
-
+import { SVG } from "./index.js";
+import { AnalyseSVGStructureOptions, AnalyseSVGStructureResult } from "./analyse/types.js";
 /**
  * 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
  */
 declare function analyseSVGStructure(svg: SVG, options?: AnalyseSVGStructureOptions): AnalyseSVGStructureResult;
-
-export { analyseSVGStructure };
+export { analyseSVGStructure };

package/lib/svg/analyse.js

@@ -0,0 +1,256 @@
+import { parseSVG } from "./parse.js";
+import { defsTag, maskTags, reusableElementsWithPalette, styleTag, useTag } from "./data/tags.js";
+import { commonColorPresentationalAttributes, markerAttributes, tagSpecificNonPresentationalAttributes, urlPresentationalAttributes } from "./data/attributes.js";
+import { analyseTagError } from "./analyse/error.js";
+
+/**
+* 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
+*/
+function analyseSVGStructure(svg, options = {}) {
+	const fixErrors = options.fixErrors;
+	let root = svg.$svg;
+	if (root._parsed) {
+		svg.load(svg.toString());
+		root = svg.$svg;
+	}
+	root._parsed = true;
+	const elements = /* @__PURE__ */ new Map();
+	const ids = Object.create(null);
+	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])
+		});
+	}
+	/**
+	* Mark element as reusable, set properties
+	*/
+	function gotReusableElement(item, isMask) {
+		const element = item.node;
+		const attribs = element.attribs;
+		const index$1 = 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: index$1
+		};
+		gotElementWithID(element, id, isMask);
+		return true;
+	}
+	/**
+	* Found element that uses another element
+	*/
+	function gotElementReference(item, id, usedAsMask) {
+		const element = item.node;
+		const link = {
+			id,
+			usedByIndex: element._index,
+			usedAsMask
+		};
+		links.push(link);
+		if (!element._linksTo) element._linksTo = [];
+		element._linksTo.push(link);
+	}
+	let index = 0;
+	parseSVG(svg, (item) => {
+		const parents = item.parents;
+		const element = item.node;
+		const tagName = element.tag;
+		if (styleTag.has(tagName)) {
+			item.testChildren = false;
+			return;
+		}
+		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.node;
+		if (maskTags.has(tagName)) {
+			if (!gotReusableElement(item, true)) return;
+		} else if (reusableElementsWithPalette.has(tagName)) {
+			if (!gotReusableElement(item, false)) return;
+		} else if (defsTag.has(parentItem.node.tag)) {
+			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((item$1) => {
+					item$1.indexes.add(index);
+					list.push(item$1);
+				});
+			}
+			if (element._id === void 0) {
+				const id = attribs["id"];
+				if (typeof id === "string") if (ids[id] && fixErrors) {
+					console.warn(`Duplicate id "${id}"`);
+					delete attribs["id"];
+				} else gotElementWithID(element, id, false);
+			}
+		}
+		if (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 ${analyseTagError(element)}`);
+				gotElementReference(item, href.slice(1), false);
+			}
+		}
+		Object.keys(attribs).forEach((attr) => {
+			let value = attribs[attr];
+			if (typeof value !== "string") return;
+			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 index$1 = item.usedByIndex;
+			const element = elements.get(index$1);
+			const tagName = element.tag;
+			function remove() {
+				const parentIndex = element._parentElement;
+				const parent = typeof parentIndex === "number" ? elements.get(parentIndex) : null;
+				if (parent) {
+					if (parent._childElements) parent._childElements = parent._childElements.filter((num) => num !== index$1);
+					parent._belongsTo?.forEach((list) => {
+						list.indexes.delete(index$1);
+					});
+					parent.children = parent.children.filter((node) => node !== element);
+				}
+			}
+			if (element._linksTo) element._linksTo = element._linksTo.filter((item$1) => item$1.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])) delete attribs[attr];
+		}
+		const message = `Missing element with id="${id}"`;
+		if (fixErrors) {
+			fix();
+			console.warn(message);
+		} else throw new Error(message);
+		return false;
+	});
+	function hasChildItem(tree$1, child, canThrow) {
+		const item = tree$1.children.find((item$1) => item$1.index === child.index && item$1.usedAsMask === child.usedAsMask);
+		if (item && canThrow) throw new Error("Recursion");
+		return !!item;
+	}
+	const tree = {
+		index: 1,
+		usedAsMask: false,
+		children: []
+	};
+	function parseTreeItem(tree$1, usedItems, inMask) {
+		const element = elements.get(tree$1.index);
+		if (tree$1.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.includes(childIndex)) throw new Error("Recursion");
+			const childItem = {
+				index: childIndex,
+				usedAsMask: false,
+				children: [],
+				parent: tree$1
+			};
+			tree$1.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: tree$1
+			};
+			if (hasChildItem(tree$1, childItem, false)) return;
+			tree$1.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,11 +1,6 @@
-import { SVG } from '../index.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-
+import { SVG } from "../index.js";
 /**
  * Remove useless attributes
  */
 declare function removeBadAttributes(svg: SVG): void;
-
-export { removeBadAttributes };
+export { removeBadAttributes };