@iconify/tools 4.1.5 → 5.0.0-beta.1

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 };

package/lib/svg/cleanup/attribs.js

@@ -0,0 +1,37 @@
+import { parseSVG } from "../parse.js";
+import { defsTag } from "../data/tags.js";
+import { badAttributePrefixes, badAttributes, badSoftwareAttributes, tagSpecificPresentationalAttributes } from "../data/attributes.js";
+
+/**
+* Remove useless attributes
+*/
+function removeBadAttributes(svg) {
+	parseSVG(svg, (item) => {
+		const node = item.node;
+		const tagName = node.tag;
+		const attribs = node.attribs;
+		Object.keys(attribs).forEach((attr) => {
+			if (attr.slice(0, 2) === "on" || badAttributes.has(attr) || badSoftwareAttributes.has(attr) || badAttributePrefixes.has(attr.split("-").shift())) {
+				delete attribs[attr];
+				return;
+			}
+			if (defsTag.has(tagName) && !tagSpecificPresentationalAttributes[tagName].has(attr)) {
+				delete attribs[attr];
+				return;
+			}
+			const nsParts = attr.split(":");
+			if (nsParts.length > 1) {
+				const namespace = nsParts.shift();
+				const newAttr = nsParts.join(":");
+				switch (namespace) {
+					case "xlink":
+						if (attribs[newAttr] === void 0) attribs[newAttr] = attribs[attr];
+						break;
+				}
+				delete attribs[attr];
+			}
+		});
+	});
+}
+
+export { removeBadAttributes };

package/lib/svg/cleanup/bad-tags.d.ts

@@ -1,17 +1,12 @@
-import { SVG } from '../index.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-
+import { SVG } from "../index.js";
 /**
  * Options
  */
 interface CheckBadTagsOptions {
-    keepTitles?: boolean;
+  keepTitles?: boolean;
 }
 /**
  * Test for bag tags
  */
 declare function checkBadTags(svg: SVG, options?: CheckBadTagsOptions): void;
-
-export { type CheckBadTagsOptions, checkBadTags };
+export { CheckBadTagsOptions, checkBadTags };

package/lib/svg/cleanup/bad-tags.js

@@ -0,0 +1,57 @@
+import { parseSVG } from "../parse.js";
+import { allValidTags, animateMotionChildTags, badTags, feComponentTransferChildTag, feLightningChildTags, feLightningTags, feMergeChildTags, filterChildTags, filterTag, gradientChildTags, gradientTags, unsupportedTags } from "../data/tags.js";
+import { stringifyXMLContent } from "@cyberalien/svg-utils";
+
+const requiredParentTags = /* @__PURE__ */ new Map();
+requiredParentTags.set(new Set(["feComponentTransfer"]), feComponentTransferChildTag);
+requiredParentTags.set(new Set(["feMerge"]), feMergeChildTags);
+requiredParentTags.set(feLightningTags, feLightningChildTags);
+requiredParentTags.set(filterTag, filterChildTags);
+requiredParentTags.set(gradientTags, gradientChildTags);
+requiredParentTags.set(new Set(["animateMotion"]), animateMotionChildTags);
+const defaultOptions = { keepTitles: false };
+/**
+* Test for bag tags
+*/
+function checkBadTags(svg, options) {
+	const { keepTitles } = {
+		...defaultOptions,
+		...options
+	};
+	parseSVG(svg, (item) => {
+		const node = item.node;
+		const tagName = node.tag;
+		if (tagName === "svg") {
+			if (item.parents.length) throw new Error(`Unexpected element: <${tagName}>`);
+			return;
+		}
+		if (keepTitles && tagName === "title") {
+			const content = stringifyXMLContent(node.children);
+			if (content?.includes("<") || content?.includes(">")) {
+				item.removeNode = true;
+				item.testChildren = false;
+			}
+			return;
+		}
+		if (unsupportedTags.has(tagName)) {
+			item.removeNode = true;
+			item.testChildren = false;
+			return;
+		}
+		if (badTags.has(tagName) || !allValidTags.has(tagName)) {
+			if (tagName.split(":").length > 1) {
+				item.removeNode = true;
+				item.testChildren = false;
+				return;
+			}
+			throw new Error(`Unexpected element: <${tagName}>`);
+		}
+		const parentTagName = item.parents[0]?.node.tag ?? "";
+		for (const [parents, children] of requiredParentTags) if (children.has(tagName)) {
+			if (!parents.has(parentTagName)) throw new Error(`Element <${tagName}> has wrong parent element`);
+			return;
+		}
+	});
+}
+
+export { checkBadTags };

package/lib/svg/cleanup/inline-style.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";
 /**
  * Expand inline style
  */
 declare function cleanupInlineStyle(svg: SVG): void;
-
-export { cleanupInlineStyle };
+export { cleanupInlineStyle };