@iconify/tools 4.1.5 → 5.0.0-beta.1

package/lib/svg/index.d.ts

@@ -1,52 +1,43 @@
-import * as cheerio from 'cheerio';
-import { IconifyIcon } from '@iconify/types';
-export { IconifyIcon } from '@iconify/types';
-import { IconifyIconCustomisations } from '@iconify/utils/lib/customisations/defaults';
-export { IconifyIconCustomisations } from '@iconify/utils/lib/customisations/defaults';
-
-interface ViewBox {
-    left: number;
-    top: number;
-    width: number;
-    height: number;
-}
-
+import { ParsedXMLTagElement } from "@cyberalien/svg-utils";
+import { IconifyIcon } from "@iconify/types";
+import { IconifyIconCustomisations } from "@iconify/utils/lib/customisations/defaults";
+import { IconViewBox } from "@cyberalien/svg-utils/lib/svg/viewbox/types.js";
+type ViewBox = IconViewBox;
 /**
  * SVG class, used to manipulate icon content.
  */
 declare class SVG {
-    $svg: cheerio.CheerioAPI;
-    viewBox: ViewBox;
-    /**
-     * Constructor
-     */
-    constructor(content: string);
-    /**
-     * Get SVG as string
-     */
-    toString(customisations?: IconifyIconCustomisations): string;
-    /**
-     * Get SVG as string without whitespaces
-     */
-    toMinifiedString(customisations?: IconifyIconCustomisations): string;
-    /**
-     * Get SVG as string with whitespaces
-     */
-    toPrettyString(customisations?: IconifyIconCustomisations): string;
-    /**
-     * Get body
-     */
-    getBody(): string;
-    /**
-     * Get icon as IconifyIcon
-     */
-    getIcon(): IconifyIcon;
-    /**
-     * Load SVG
-     *
-     * @param {string} content
-     */
-    load(content: string): void;
+  $svg: ParsedXMLTagElement;
+  viewBox: ViewBox;
+  /**
+   * Constructor
+   */
+  constructor(content: string);
+  /**
+   * Get SVG as string
+   */
+  toString(customisations?: IconifyIconCustomisations, prettyPrint?: boolean): string;
+  /**
+   * Get SVG as string without whitespaces
+   */
+  toMinifiedString(customisations?: IconifyIconCustomisations): string;
+  /**
+   * Get SVG as string with whitespaces
+   */
+  toPrettyString(customisations?: IconifyIconCustomisations): string;
+  /**
+   * Get body
+   */
+  getBody(): string;
+  /**
+   * Get icon as IconifyIcon
+   */
+  getIcon(): IconifyIcon;
+  /**
+   * Load SVG
+   *
+   * @param {string} content
+   */
+  load(content: string): void;
 }
-
-export { SVG, type ViewBox };
+export { type IconifyIcon, type IconifyIconCustomisations, SVG, type ViewBox };

package/lib/svg/index.js

@@ -0,0 +1,117 @@
+import { iconToSVG, trimSVG } from "@iconify/utils";
+import { parseXMLContent, stringifyXMLContent } from "@cyberalien/svg-utils";
+import { parseViewBox } from "@cyberalien/svg-utils/lib/svg/viewbox/parse.js";
+
+/**
+* SVG class, used to manipulate icon content.
+*/
+var SVG = class {
+	$svg;
+	viewBox;
+	/**
+	* Constructor
+	*/
+	constructor(content) {
+		this.load(content);
+	}
+	/**
+	* Get SVG as string
+	*/
+	toString(customisations, prettyPrint = false) {
+		if (customisations) {
+			const data = iconToSVG(this.getIcon(), customisations);
+			let svgAttributes = " xmlns=\"http://www.w3.org/2000/svg\"";
+			if (data.body.includes("xlink:")) svgAttributes += " xmlns:xlink=\"http://www.w3.org/1999/xlink\"";
+			for (const key in data.attributes) {
+				const value = data.attributes[key];
+				svgAttributes += " " + key + "=\"" + value + "\"";
+			}
+			return "<svg" + svgAttributes + ">" + data.body + "</svg>";
+		}
+		const $root = this.$svg;
+		const attribs = $root.attribs;
+		const box = this.viewBox;
+		if (!attribs["viewBox"]) attribs["viewBox"] = `${box.left} ${box.top} ${box.width} ${box.height}`;
+		for (const prop of ["width", "height"]) if (!attribs[prop]) attribs[prop] = box[prop];
+		return stringifyXMLContent([$root], { prettyPrint });
+	}
+	/**
+	* Get SVG as string without whitespaces
+	*/
+	toMinifiedString(customisations) {
+		return trimSVG(this.toString(customisations, false));
+	}
+	/**
+	* Get SVG as string with whitespaces
+	*/
+	toPrettyString(customisations) {
+		return this.toString(customisations, true);
+	}
+	/**
+	* Get body
+	*/
+	getBody() {
+		const $root = this.$svg;
+		const attribs = $root.attribs;
+		for (const key in attribs) switch (key.split("-").shift()) {
+			case "fill":
+			case "stroke":
+			case "opacity": throw new Error(`Cannot use getBody() on icon that was not cleaned up with cleanupSVGRoot(). Icon has attribute ${key}="${attribs[key]}"`);
+		}
+		return stringifyXMLContent($root.children);
+	}
+	/**
+	* Get icon as IconifyIcon
+	*/
+	getIcon() {
+		const props = this.viewBox;
+		const body = this.getBody();
+		return {
+			...props,
+			body
+		};
+	}
+	/**
+	* Load SVG
+	*
+	* @param {string} content
+	*/
+	load(content) {
+		function remove(str1, str2, append) {
+			let start = 0;
+			while ((start = content.indexOf(str1, start)) !== -1) {
+				const end = content.indexOf(str2, start + str1.length);
+				if (end === -1) return;
+				content = content.slice(0, start) + append + content.slice(end + str2.length);
+				start = start + append.length;
+			}
+		}
+		remove("<!--", "-->", "");
+		remove("<?xml", "?>", "");
+		remove("<!DOCTYPE svg", "<svg", "<svg");
+		remove("xmlns:x=\"&ns_extend;\" xmlns:i=\"&ns_ai;\" xmlns:graph=\"&ns_graphs;\"", "", "");
+		remove("xml:space=\"preserve\"", "", "");
+		content = content.replace(/<g>\s*<\/g>/g, "");
+		const root = parseXMLContent(content);
+		if (!root || root.length !== 1) throw new Error("Invalid SVG file");
+		const rootTag = root[0];
+		if (rootTag.type !== "tag" || rootTag.tag !== "svg") throw new Error("Invalid SVG file: missing <svg> root element");
+		this.$svg = rootTag;
+		const attribs = rootTag.attribs;
+		const viewBox = attribs["viewBox"];
+		if (typeof viewBox === "string") {
+			const parsed = parseViewBox(viewBox);
+			if (!parsed) throw new Error("Invalid SVG file: bad viewBox attribute");
+			this.viewBox = parsed;
+		} else {
+			const width = attribs["width"];
+			const height = attribs["height"];
+			if (!width || !height) throw new Error("Invalid SVG file: missing dimensions");
+			const parsed = parseViewBox(`0 0 ${width} ${height}`);
+			if (!parsed) throw new Error("Invalid SVG file: bad size attributes and no viewBox");
+			this.viewBox = parsed;
+		}
+	}
+};
+
+export { SVG };

package/lib/svg/parse-style.d.ts

@@ -1,43 +1,37 @@
-import { SVG } from './index.js';
-import { CSSRuleToken, CSSToken, CSSAtRuleToken } from '../css/parser/types.js';
-import { ParseSVGCallbackItem } from './parse.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../misc/cheerio.js';
-import 'domhandler';
-
+import { SVG } from "./index.js";
+import { CSSAtRuleToken, CSSRuleToken, CSSToken } from "../css/parser/types.js";
+import { ParseSVGCallbackItem } from "./parse.js";
 /**
  * Item in callback
  */
 interface ParseSVGStyleCallbackItemCommon {
-    prop: string;
-    value: string;
+  prop: string;
+  value: string;
 }
 interface ParseSVGStyleCallbackItemInline extends ParseSVGStyleCallbackItemCommon {
-    type: 'inline';
-    item: ParseSVGCallbackItem;
+  type: 'inline';
+  item: ParseSVGCallbackItem;
 }
 interface ParseSVGStyleCallbackItemGlobal extends ParseSVGStyleCallbackItemCommon {
-    type: 'global';
-    token: CSSRuleToken;
-    selectors: string[];
-    selectorTokens: CSSToken[];
-    prevTokens: (CSSToken | null)[];
-    nextTokens: CSSToken[];
+  type: 'global';
+  token: CSSRuleToken;
+  selectors: string[];
+  selectorTokens: CSSToken[];
+  prevTokens: (CSSToken | null)[];
+  nextTokens: CSSToken[];
 }
 interface ParseSVGStyleCallbackItemGlobalAtRule extends ParseSVGStyleCallbackItemCommon {
-    token: CSSAtRuleToken;
-    childTokens: CSSToken[];
-    prevTokens: (CSSToken | null)[];
-    nextTokens: CSSToken[];
+  token: CSSAtRuleToken;
+  childTokens: CSSToken[];
+  prevTokens: (CSSToken | null)[];
+  nextTokens: CSSToken[];
 }
 interface ParseSVGStyleCallbackItemGlobalGenericAtRule extends ParseSVGStyleCallbackItemGlobalAtRule {
-    type: 'at-rule';
+  type: 'at-rule';
 }
 interface ParseSVGStyleCallbackItemGlobalKeyframesAtRule extends ParseSVGStyleCallbackItemGlobalAtRule {
-    type: 'keyframes';
-    from: Record<string, string>;
+  type: 'keyframes';
+  from: Record<string, string>;
 }
 type ParseSVGStyleCallbackItem = ParseSVGStyleCallbackItemInline | ParseSVGStyleCallbackItemGlobal | ParseSVGStyleCallbackItemGlobalGenericAtRule | ParseSVGStyleCallbackItemGlobalKeyframesAtRule;
 /**
@@ -55,5 +49,4 @@ type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleC
  * Callback should return new value (string) or undefined to remove rule.
  */
 declare function parseSVGStyle(svg: SVG, callback: ParseSVGStyleCallback): void;
-
-export { type ParseSVGStyleCallback, type ParseSVGStyleCallbackItem, type ParseSVGStyleCallbackResult, parseSVGStyle };
+export { ParseSVGStyleCallback, ParseSVGStyleCallbackItem, ParseSVGStyleCallbackResult, parseSVGStyle };

package/lib/svg/parse-style.js

@@ -0,0 +1,199 @@
+import { parseSVG } from "./parse.js";
+import { getTokens } from "../css/parser/tokens.js";
+import { parseInlineStyle } from "../css/parse.js";
+import { tokensToString } from "../css/parser/export.js";
+import { tokensTree } from "../css/parser/tree.js";
+import { stringifyXMLContent } from "@cyberalien/svg-utils";
+
+function assertNever(v) {}
+/**
+* Check callback result for Promise instance, which used to be supported in old version
+*/
+function assertNotOldCode(value) {
+	if (value instanceof Promise) throw new Error("parseSVGStyle does not support async callbacks");
+}
+/**
+* Parse styles in SVG
+*
+* This function finds CSS in SVG, parses it, calls callback for each rule.
+* Callback should return new value (string) or undefined to remove rule.
+*/
+function parseSVGStyle(svg, callback) {
+	parseSVG(svg, (item) => {
+		const node = item.node;
+		const tagName = node.tag;
+		function parseStyleItem() {
+			const content = stringifyXMLContent(node.children);
+			if (!content) {
+				item.removeNode = true;
+				return;
+			}
+			const tokens = getTokens(content);
+			if (!(tokens instanceof Array)) throw new Error("Error parsing style. This parser can handle only basic CSS");
+			let changed$1 = false;
+			const selectorStart = [];
+			let newTokens = [];
+			while (tokens.length) {
+				const token = tokens.shift();
+				if (!token) break;
+				switch (token.type) {
+					case "selector":
+						selectorStart.push(newTokens.length);
+						newTokens.push(token);
+						break;
+					case "close":
+						selectorStart.pop();
+						newTokens.push(token);
+						break;
+					case "at-rule": {
+						selectorStart.push(newTokens.length);
+						const prop = token.rule;
+						const value = token.value;
+						const isAnimation = prop === "keyframes" || prop.slice(0, 1) === "-" && prop.split("-").pop() === "keyframes";
+						const childTokens = [];
+						const animationRules = Object.create(null);
+						let depth = 1;
+						let index = 0;
+						let isFrom = false;
+						while (depth > 0) {
+							const childToken = tokens[index];
+							index++;
+							if (!childToken) throw new Error("Something went wrong parsing CSS");
+							childTokens.push(childToken);
+							switch (childToken.type) {
+								case "close":
+									depth--;
+									isFrom = false;
+									break;
+								case "selector":
+									depth++;
+									if (isAnimation) {
+										const rule = childToken.code;
+										if (rule === "from" || rule === "0%") isFrom = true;
+									}
+									break;
+								case "at-rule":
+									depth++;
+									if (isAnimation) throw new Error("Nested at-rule in keyframes ???");
+									break;
+								case "rule":
+									if (isAnimation && isFrom) animationRules[childToken.prop] = childToken.value;
+									break;
+								default: assertNever(childToken);
+							}
+						}
+						const skipCount = childTokens.length;
+						const result = callback(isAnimation ? {
+							type: "keyframes",
+							prop,
+							value,
+							token,
+							childTokens,
+							from: animationRules,
+							prevTokens: newTokens,
+							nextTokens: tokens.slice(0)
+						} : {
+							type: "at-rule",
+							prop,
+							value,
+							token,
+							childTokens,
+							prevTokens: newTokens,
+							nextTokens: tokens.slice(0)
+						});
+						if (result !== void 0) {
+							assertNotOldCode(result);
+							if (isAnimation) {
+								if (result !== value) {
+									changed$1 = true;
+									token.value = result;
+								}
+								newTokens.push(token);
+								for (let i = 0; i < skipCount; i++) tokens.shift();
+								newTokens = newTokens.concat(childTokens);
+							} else {
+								if (result !== value) throw new Error("Changing value for at-rule is not supported");
+								newTokens.push(token);
+							}
+						} else {
+							changed$1 = true;
+							for (let i = 0; i < skipCount; i++) tokens.shift();
+						}
+						break;
+					}
+					case "rule": {
+						const value = token.value;
+						const selectorTokens = selectorStart.map((index) => newTokens[index]).filter((item$1) => item$1 !== null);
+						const result = callback({
+							type: "global",
+							prop: token.prop,
+							value,
+							token,
+							selectorTokens,
+							selectors: selectorTokens.reduce((prev, current) => {
+								switch (current.type) {
+									case "selector": return prev.concat(current.selectors);
+								}
+								return prev;
+							}, []),
+							prevTokens: newTokens,
+							nextTokens: tokens.slice(0)
+						});
+						if (result !== void 0) {
+							assertNotOldCode(result);
+							if (result !== value) {
+								changed$1 = true;
+								token.value = result;
+							}
+							newTokens.push(token);
+						} else changed$1 = true;
+						break;
+					}
+					default: assertNever(token);
+				}
+			}
+			if (changed$1) {
+				const tree = tokensTree(newTokens.filter((token) => token !== null));
+				if (!tree.length) item.removeNode = true;
+				else node.children = [{
+					type: "text",
+					content: "\n" + tokensToString(tree)
+				}];
+			}
+		}
+		if (tagName === "style") {
+			parseStyleItem();
+			return;
+		}
+		const attribs = node.attribs;
+		if (!attribs.style || typeof attribs.style !== "string") return;
+		const parsedStyle = parseInlineStyle(attribs.style);
+		if (parsedStyle === null) {
+			delete attribs.style;
+			return;
+		}
+		let changed = false;
+		for (const prop in parsedStyle) {
+			const value = parsedStyle[prop];
+			const result = callback({
+				type: "inline",
+				prop,
+				value,
+				item
+			});
+			assertNotOldCode(result);
+			if (result !== value) {
+				changed = true;
+				if (result === void 0) delete parsedStyle[prop];
+				else parsedStyle[prop] = result;
+			}
+		}
+		if (changed) {
+			const newStyle = Object.keys(parsedStyle).map((key) => key + ":" + parsedStyle[key] + ";").join("");
+			if (!newStyle.length) delete attribs.style;
+			else attribs.style = newStyle;
+		}
+	});
+}
+
+export { parseSVGStyle };

package/lib/svg/parse.d.ts

@@ -1,21 +1,14 @@
-import { CheerioElement, WrappedCheerioElement } from '../misc/cheerio.js';
-import { SVG } from './index.js';
-import 'domhandler';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-
+import { SVG } from "./index.js";
+import { ParsedXMLTagElement } from "@cyberalien/svg-utils";
 /**
  * Item in callback
  */
 interface ParseSVGCallbackItem {
-    tagName: string;
-    element: CheerioElement;
-    $element: WrappedCheerioElement;
-    svg: SVG;
-    parents: ParseSVGCallbackItem[];
-    testChildren: boolean;
-    removeNode: boolean;
+  node: ParsedXMLTagElement;
+  svg: SVG;
+  parents: ParseSVGCallbackItem[];
+  testChildren: boolean;
+  removeNode: boolean;
 }
 /**
  * Callback function
@@ -27,5 +20,4 @@ type ParseSVGCallback = (item: ParseSVGCallbackItem) => void;
  * This function finds all elements in SVG and calls callback for each element.
  */
 declare function parseSVG(svg: SVG, callback: ParseSVGCallback): void;
-
-export { type ParseSVGCallback, type ParseSVGCallbackItem, parseSVG };
+export { ParseSVGCallback, ParseSVGCallbackItem, parseSVG };

package/lib/svg/parse.js

@@ -0,0 +1,32 @@
+import { iterateXMLContent } from "@cyberalien/svg-utils";
+
+/**
+* Parse SVG
+*
+* This function finds all elements in SVG and calls callback for each element.
+*/
+function parseSVG(svg, callback) {
+	const map = /* @__PURE__ */ new Map();
+	iterateXMLContent([svg.$svg], (node, stack) => {
+		if (node.type !== "tag") return;
+		const parents = [];
+		for (const parent of stack) {
+			const parentItem = map.get(parent);
+			if (!parentItem.testChildren) return "skip";
+			parents.unshift(parentItem);
+		}
+		const item = {
+			svg,
+			node,
+			parents,
+			testChildren: true,
+			removeNode: false
+		};
+		map.set(node, item);
+		if (callback(item) instanceof Promise) throw new Error("parseSVG does not support async callbacks");
+		if (item.removeNode) return "remove";
+		if (!item.testChildren) return "skip";
+	});
+}
+
+export { parseSVG };