@iconify/tools 4.2.0 → 5.0.0-beta.2

package/lib/colors/attribs.d.ts

@@ -1,5 +1,4 @@
-import { Color } from '@iconify/utils/lib/colors/types';
-
+import { Color } from "@iconify/utils/lib/colors/types";
 /**
  * Color attributes
  */
@@ -23,5 +22,4 @@ declare const defaultColorValues: Record<ColorAttributes, Color>;
  * Parent elements are not checked for these tags!
  */
 declare const allowDefaultColorValue: Partial<Record<ColorAttributes, string | true>>;
-
-export { type ColorAttributes, type CommonColorAttributes, type ShapeColorAttributes, type SpecialColorAttributes, allowDefaultColorValue, commonColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes, specialColorAttributes };
+export { ColorAttributes, CommonColorAttributes, ShapeColorAttributes, SpecialColorAttributes, allowDefaultColorValue, commonColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes, specialColorAttributes };

package/lib/colors/attribs.js

@@ -0,0 +1,33 @@
+const commonColorAttributes = ["color"];
+const shapeColorAttributes = ["fill", "stroke"];
+const specialColorAttributes = ["stop-color", "flood-color"];
+/**
+* Default values
+*/
+const defaultBlackColor = {
+	type: "rgb",
+	r: 0,
+	g: 0,
+	b: 0,
+	alpha: 1
+};
+const defaultColorValues = {
+	"color": { type: "current" },
+	"fill": defaultBlackColor,
+	"stroke": { type: "none" },
+	"stop-color": defaultBlackColor,
+	"flood-color": defaultBlackColor
+};
+/**
+* Ignore default color for some tags:
+* - If value is true, allow default color
+* - If value is attribute name, allow default color if attribute is set
+*
+* Parent elements are not checked for these tags!
+*/
+const allowDefaultColorValue = {
+	"stop-color": true,
+	"flood-color": "flood-opacity"
+};
+
+export { allowDefaultColorValue, commonColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes, specialColorAttributes };

package/lib/colors/detect.d.ts

@@ -1,16 +1,8 @@
-import { IconSet } from '../icon-set/index.js';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../icon-set/types.js';
-import '../svg/index.js';
-import 'cheerio';
-import '@iconify/utils/lib/icon-set/tree';
-
+import { IconSet } from "../icon-set/index.js";
 /**
  * Detect palette
  *
  * Returns null if icon set has mixed colors
  */
 declare function detectIconSetPalette(iconSet: IconSet): boolean | null;
-
-export { detectIconSetPalette };
+export { detectIconSetPalette };

package/lib/colors/detect.js

@@ -0,0 +1,36 @@
+import { isEmptyColor, parseColors } from "./parse.js";
+
+/**
+* Detect palette
+*
+* Returns null if icon set has mixed colors
+*/
+function detectIconSetPalette(iconSet) {
+	let palette;
+	iconSet.forEachSync((name) => {
+		if (palette === null) return;
+		const svg = iconSet.toSVG(name);
+		if (!svg) return;
+		let iconPalette;
+		parseColors(svg, { callback: (attr, colorStr, color) => {
+			if (!color) {
+				iconPalette = null;
+				return colorStr;
+			}
+			if (iconPalette === null || isEmptyColor(color)) return color;
+			const isColor = color.type !== "current";
+			if (iconPalette === void 0) {
+				iconPalette = isColor;
+				return color;
+			}
+			if (iconPalette !== isColor) iconPalette = null;
+			return color;
+		} });
+		if (iconPalette === void 0) iconPalette = null;
+		if (palette === void 0) palette = iconPalette;
+		else if (palette !== iconPalette) palette = null;
+	}, ["icon"]);
+	return palette ?? null;
+}
+
+export { detectIconSetPalette };

package/lib/colors/parse.d.ts

@@ -1,20 +1,14 @@
-import { Color } from '@iconify/utils/lib/colors/types';
-import { SVG } from '../svg/index.js';
-import { ColorAttributes } from './attribs.js';
-import { ElementsTreeItem, AnalyseSVGStructureResult, AnalyseSVGStructureOptions, ExtendedTagElement } from '../svg/analyse/types.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../misc/cheerio.js';
-import 'domhandler';
-
+import { ColorAttributes } from "./attribs.js";
+import { SVG } from "../svg/index.js";
+import { AnalyseSVGStructureOptions, AnalyseSVGStructureResult, ElementsTreeItem, ExtendedTagElement } from "../svg/analyse/types.js";
+import { Color } from "@iconify/utils/lib/colors/types";
 /**
  * Result
  */
 interface FindColorsResult {
-    colors: (Color | string)[];
-    hasUnsetColor: boolean;
-    hasGlobalStyle: boolean;
+  colors: (Color | string)[];
+  hasUnsetColor: boolean;
+  hasGlobalStyle: boolean;
 }
 /**
  * Callback to call for each found color
@@ -35,16 +29,16 @@ type ParseColorOptionsDefaultColorCallback = (prop: string, item: ExtendedTagEle
  * Options
  */
 interface ParseColorsOptions extends AnalyseSVGStructureOptions {
-    callback?: ParseColorsCallback;
-    defaultColor?: Color | string | ParseColorOptionsDefaultColorCallback;
+  callback?: ParseColorsCallback;
+  defaultColor?: Color | string | ParseColorOptionsDefaultColorCallback;
 }
 /**
  * Extend properties for element
  */
 type ItemColors = Partial<Record<ColorAttributes, Color | string>>;
 interface ExtendedTagElementWithColors extends ExtendedTagElement {
-    _colors?: ItemColors;
-    _removed?: boolean;
+  _colors?: ItemColors;
+  _removed?: boolean;
 }
 /**
  * Find colors in icon
@@ -57,5 +51,4 @@ declare function parseColors(svg: SVG, options?: ParseColorsOptions): FindColors
  * Check if color is empty, such as 'none' or 'transparent'
  */
 declare function isEmptyColor(color: Color): boolean;
-
-export { type ExtendedTagElementWithColors, type FindColorsResult, type ParseColorOptionsDefaultColorCallback, type ParseColorsOptions, isEmptyColor, parseColors };
+export { ExtendedTagElementWithColors, FindColorsResult, ParseColorOptionsDefaultColorCallback, ParseColorsOptions, isEmptyColor, parseColors };

package/lib/colors/parse.js

@@ -0,0 +1,241 @@
+import { parseSVGStyle } from "../svg/parse-style.js";
+import { animateTags, shapeTags } from "../svg/data/tags.js";
+import { tagSpecificPresentationalAttributes } from "../svg/data/attributes.js";
+import { analyseSVGStructure } from "../svg/analyse.js";
+import { allowDefaultColorValue, defaultBlackColor, defaultColorValues, shapeColorAttributes, specialColorAttributes } from "./attribs.js";
+import { colorToString, compareColors, stringToColor } from "@iconify/utils/lib/colors";
+
+/**
+* Properties to check
+*/
+const propsToCheck = Object.keys(defaultColorValues);
+const animatePropsToCheck = [
+	"from",
+	"to",
+	"values"
+];
+/**
+* Find colors in icon
+*
+* Clean up icon before running this function to convert style to attributes using
+* cleanupInlineStyle() or cleanupSVG(), otherwise results might be inaccurate
+*/
+function parseColors(svg, options = {}) {
+	const result = {
+		colors: [],
+		hasUnsetColor: false,
+		hasGlobalStyle: false
+	};
+	const defaultColor = typeof options.defaultColor === "string" ? stringToColor(options.defaultColor) : options.defaultColor;
+	/**
+	* Find matching color in results
+	*/
+	function findColor(color, add = false) {
+		const isString = typeof color === "string";
+		for (let i = 0; i < result.colors.length; i++) {
+			const item = result.colors[i];
+			if (item === color) return item;
+			if (!isString && typeof item !== "string" && compareColors(item, color)) return item;
+		}
+		if (add) {
+			result.colors.push(color);
+			return color;
+		}
+		return null;
+	}
+	/**
+	* Add color to item and to results
+	*/
+	function addColorToItem(prop, color, item, add = true) {
+		const addedColor = findColor(color, add !== false);
+		if (item) {
+			const itemColors = item._colors || (item._colors = {});
+			itemColors[prop] = addedColor === null ? color : addedColor;
+		}
+	}
+	/**
+	* Get element color
+	*/
+	function getElementColor(prop, item, elements$1) {
+		function find(prop$1) {
+			let currentItem = item;
+			const allowDefaultColor = allowDefaultColorValue[prop$1];
+			while (currentItem) {
+				const element = elements$1.get(currentItem.index);
+				const color = element._colors?.[prop$1];
+				if (color !== void 0) return color;
+				if (allowDefaultColor) {
+					if (allowDefaultColor === true || element.attribs[allowDefaultColor]) return null;
+				}
+				currentItem = currentItem.parent;
+				if (currentItem?.usedAsMask) return defaultColorValues[prop$1];
+			}
+			return defaultColorValues[prop$1];
+		}
+		let propColor = find(prop);
+		if (propColor !== null && typeof propColor === "object" && propColor.type === "current" && prop !== "color") propColor = find("color");
+		return propColor;
+	}
+	/**
+	* Change color
+	*/
+	function checkColor(prop, value, item) {
+		switch (value.trim().toLowerCase()) {
+			case "":
+			case "inherit": return;
+		}
+		const parsedColor = stringToColor(value);
+		const defaultValue = parsedColor || value;
+		if (parsedColor?.type === "function" && parsedColor.func === "url") {
+			addColorToItem(prop, defaultValue, item, false);
+			return value;
+		}
+		if (!options.callback) {
+			addColorToItem(prop, defaultValue, item);
+			return value;
+		}
+		const callbackResult = options.callback(prop, value, parsedColor, item?.tag, item);
+		if (callbackResult instanceof Promise) throw new Error("parseColors does not support async callbacks");
+		switch (callbackResult) {
+			case "remove": return item ? callbackResult : void 0;
+			case "unset": return;
+		}
+		if (callbackResult === value || parsedColor && callbackResult === parsedColor) {
+			addColorToItem(prop, defaultValue, item);
+			return value;
+		}
+		if (typeof callbackResult === "string") {
+			addColorToItem(prop, stringToColor(callbackResult) || callbackResult, item);
+			return callbackResult;
+		}
+		const newValue = colorToString(callbackResult);
+		addColorToItem(prop, callbackResult, item);
+		return newValue;
+	}
+	parseSVGStyle(svg, (item) => {
+		const prop = item.prop;
+		const value = item.value;
+		if (!propsToCheck.includes(prop)) return value;
+		const newValue = checkColor(prop, value);
+		if (newValue === void 0) return newValue;
+		if (item.type === "global") result.hasGlobalStyle = true;
+		return newValue;
+	});
+	const iconData = analyseSVGStructure(svg, options);
+	const { elements, tree } = iconData;
+	const removedElements = /* @__PURE__ */ new Set();
+	const parsedElements = /* @__PURE__ */ new Set();
+	function removeElement(index, element) {
+		function removeChildren(element$1) {
+			element$1.children.forEach((item) => {
+				if (item.type !== "tag") return;
+				const element$2 = item;
+				const index$1 = element$2._index;
+				if (index$1 && !removedElements.has(index$1)) {
+					element$2._removed = true;
+					removedElements.add(index$1);
+					removeChildren(element$2);
+				}
+			});
+		}
+		element._removed = true;
+		removedElements.add(index);
+		removeChildren(element);
+	}
+	function parseTreeItem(item) {
+		const index = item.index;
+		if (removedElements.has(index) || parsedElements.has(index)) return;
+		parsedElements.add(index);
+		const element = elements.get(index);
+		if (element._removed) return;
+		const { tag, attribs } = element;
+		if (item.parent) {
+			const parentIndex = item.parent.index;
+			const parentElement = elements.get(parentIndex);
+			if (parentElement._colors) element._colors = { ...parentElement._colors };
+		}
+		for (let i = 0; i < propsToCheck.length; i++) {
+			const prop = propsToCheck[i];
+			if (prop === "fill" && animateTags.has(tag)) continue;
+			const value = attribs[prop];
+			if (typeof value === "string") {
+				const newValue = checkColor(prop, value, element);
+				if (newValue !== value) if (newValue === void 0) {
+					delete attribs[prop];
+					if (element._colors) delete element._colors[prop];
+				} else if (newValue === "remove") {
+					removeElement(index, element);
+					return;
+				} else attribs[prop] = newValue;
+			}
+		}
+		if (animateTags.has(tag)) {
+			const attr = attribs.attributeName;
+			if (propsToCheck.includes(attr)) for (let i = 0; i < animatePropsToCheck.length; i++) {
+				const elementProp = animatePropsToCheck[i];
+				const fullValue = attribs[elementProp];
+				if (typeof fullValue !== "string") continue;
+				const splitValues = fullValue.split(";");
+				let updatedValues = false;
+				for (let j = 0; j < splitValues.length; j++) {
+					const value = splitValues[j];
+					if (value !== void 0) {
+						const newValue = checkColor(elementProp, value);
+						if (newValue !== value) {
+							updatedValues = true;
+							splitValues[j] = typeof newValue === "string" ? newValue : "";
+						}
+					}
+				}
+				if (updatedValues) attribs[elementProp] = splitValues.join(";");
+			}
+		}
+		if (!result.hasGlobalStyle) {
+			let requiredProps;
+			if (shapeTags.has(tag)) requiredProps = shapeColorAttributes;
+			specialColorAttributes.forEach((attr) => {
+				if (tagSpecificPresentationalAttributes[tag]?.has(attr)) requiredProps = [attr];
+			});
+			if (requiredProps) {
+				const itemColors = element._colors || (element._colors = {});
+				for (let i = 0; i < requiredProps.length; i++) {
+					const prop = requiredProps[i];
+					if (getElementColor(prop, item, elements) === defaultBlackColor) if (defaultColor) {
+						const defaultColorValue = typeof defaultColor === "function" ? defaultColor(prop, element, item, iconData) : defaultColor;
+						findColor(defaultColorValue, true);
+						attribs[prop] = colorToString(defaultColorValue);
+						itemColors[prop] = defaultColorValue;
+					} else result.hasUnsetColor = true;
+				}
+			}
+		}
+		for (let i = 0; i < item.children.length; i++) {
+			const childItem = item.children[i];
+			if (!childItem.usedAsMask) parseTreeItem(childItem);
+		}
+	}
+	parseTreeItem(tree);
+	function removeElements(node, parent) {
+		if (parent) {
+			const index = node.index;
+			if (removedElements.has(index) || elements.get(index)._removed) {
+				parent.children = parent.children.filter((item) => item.index !== index);
+				return;
+			}
+		}
+		node.children.forEach((child) => {
+			removeElements(child, node);
+		});
+	}
+	removeElements(tree);
+	return result;
+}
+/**
+* Check if color is empty, such as 'none' or 'transparent'
+*/
+function isEmptyColor(color) {
+	const type = color.type;
+	return type === "none" || type === "transparent";
+}
+
+export { isEmptyColor, parseColors };

package/lib/colors/validate.d.ts

@@ -1,14 +1,5 @@
-import { SVG } from '../svg/index.js';
-import { ParseColorsOptions, FindColorsResult } from './parse.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '@iconify/utils/lib/colors/types';
-import './attribs.js';
-import '../svg/analyse/types.js';
-import '../misc/cheerio.js';
-import 'domhandler';
-
+import { SVG } from "../svg/index.js";
+import { FindColorsResult, ParseColorsOptions } from "./parse.js";
 /**
  * Validate colors in icon
  *
@@ -17,5 +8,4 @@ import 'domhandler';
  * Throws exception on error
  */
 declare function validateColors(svg: SVG, expectMonotone: boolean, options?: ParseColorsOptions): FindColorsResult;
-
-export { validateColors };
+export { validateColors };

package/lib/colors/validate.js

@@ -0,0 +1,31 @@
+import { parseColors } from "./parse.js";
+import { colorToString } from "@iconify/utils/lib/colors";
+
+/**
+* Validate colors in icon
+*
+* If icon is monotone,
+*
+* Throws exception on error
+*/
+function validateColors(svg, expectMonotone, options) {
+	const palette = parseColors(svg, options);
+	palette.colors.forEach((color) => {
+		if (typeof color === "string") throw new Error("Unexpected color: " + color);
+		switch (color.type) {
+			case "none":
+			case "transparent": return;
+			case "current":
+				if (!expectMonotone) throw new Error("Unexpected color: " + colorToString(color));
+				return;
+			case "rgb":
+			case "hsl":
+				if (expectMonotone) throw new Error("Unexpected color: " + colorToString(color));
+				return;
+			default: if (color.type !== "function" || color.func !== "url") throw new Error("Unexpected color: " + colorToString(color));
+		}
+	});
+	return palette;
+}
+
+export { validateColors };

package/lib/css/parse.d.ts

@@ -2,5 +2,4 @@
  * Parse inline style
  */
 declare function parseInlineStyle(style: string): Record<string, string> | null;
-
-export { parseInlineStyle };
+export { parseInlineStyle };

package/lib/css/parse.js

@@ -0,0 +1,18 @@
+import { getTokens } from "./parser/tokens.js";
+
+/**
+* Parse inline style
+*/
+function parseInlineStyle(style) {
+	const tokens = getTokens(style);
+	if (!(tokens instanceof Array)) return null;
+	const results = Object.create(null);
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token.type !== "rule") return null;
+		results[token.prop] = token.value;
+	}
+	return results;
+}
+
+export { parseInlineStyle };

package/lib/css/parser/error.d.ts

@@ -1,13 +1,12 @@
 interface StyleParseError {
-    type: 'style-parse-error';
-    message: string;
-    code: string;
-    index?: number;
-    fullMessage: string;
+  type: 'style-parse-error';
+  message: string;
+  code: string;
+  index?: number;
+  fullMessage: string;
 }
 /**
  * Create error message
  */
 declare function styleParseError(message: string, code: string, index?: number): StyleParseError;
-
-export { type StyleParseError, styleParseError };
+export { StyleParseError, styleParseError };

package/lib/css/parser/error.js

@@ -0,0 +1,24 @@
+/**
+* Create error message
+*/
+function styleParseError(message, code, index) {
+	let fullMessage = message;
+	if (typeof index === "number" && index !== -1) {
+		const start = index;
+		const remaining = code.slice(index) + "!";
+		const trimmed = remaining.trim();
+		const end = start + remaining.length - trimmed.length;
+		const code2 = code.slice(0, end);
+		const line = code2.length - code2.replace(/\n/g, "").length + 1;
+		fullMessage = message + " on line " + line.toString();
+	}
+	return {
+		type: "style-parse-error",
+		message,
+		code,
+		index,
+		fullMessage
+	};
+}
+
+export { styleParseError };

package/lib/css/parser/export.d.ts

@@ -1,8 +1,6 @@
-import { CSSTreeToken } from './types.js';
-
+import { CSSTreeToken } from "./types.js";
 /**
  * Convert tokens tree to string
  */
 declare function tokensToString(tree: CSSTreeToken[]): string;
-
-export { tokensToString };
+export { tokensToString };

package/lib/css/parser/export.js

@@ -0,0 +1,34 @@
+const tab = "	";
+const nl = "\n";
+/**
+* Convert tokens tree to string
+*/
+function tokensToString(tree) {
+	let compact = true;
+	for (let i = 0; i < tree.length; i++) if (tree[i].type !== "rule") {
+		compact = false;
+		break;
+	}
+	return tree.map((token) => {
+		return parseToken(token, compact, 0);
+	}).join("");
+}
+/**
+* Old code
+*/
+function parseToken(token, compact, depth) {
+	let content;
+	switch (token.type) {
+		case "rule": return (compact ? "" : tab.repeat(depth)) + token.prop + (compact ? ":" : ": ") + token.value + ";" + (compact ? "" : nl);
+		case "at-rule":
+			content = `@${token.rule} ${token.value}`.trim();
+			break;
+		case "selector": content = token.selectors.join(compact ? "," : ", ");
+	}
+	const children = token.children.map((item) => {
+		return parseToken(item, compact, depth + 1);
+	});
+	return (compact ? "" : tab.repeat(depth)) + content + (compact ? "{" : " {" + nl) + children.join("") + (compact ? "}" : tab.repeat(depth) + "}\n");
+}
+
+export { tokensToString };

package/lib/css/parser/strings.d.ts

@@ -1,5 +1,4 @@
-import { StyleParseError } from './error.js';
-
+import { StyleParseError } from "./error.js";
 /**
  * Find end of quoted string
  *
@@ -12,5 +11,4 @@ declare function findEndOfQuotedString(code: string, quote: string, start: numbe
  * Returns index of character after end of URL
  */
 declare function findEndOfURL(code: string, start: number): number | StyleParseError;
-
-export { findEndOfQuotedString, findEndOfURL };
+export { findEndOfQuotedString, findEndOfURL };

package/lib/css/parser/strings.js

@@ -0,0 +1,66 @@
+import { styleParseError } from "./error.js";
+
+/**
+* Find end of quoted string
+*
+* Returns index of character after quote
+*/
+function findEndOfQuotedString(code, quote, start) {
+	let nextEscape = code.indexOf("\\", start + 1);
+	let end = code.indexOf(quote, start + 1);
+	if (end === -1) return null;
+	while (nextEscape !== -1 && nextEscape < end) {
+		if (end === nextEscape + 1) {
+			end = code.indexOf(quote, end + 1);
+			if (end === -1) return null;
+		}
+		nextEscape = code.indexOf("\\", nextEscape + 2);
+	}
+	return end + 1;
+}
+/**
+* Find end of url
+*
+* Returns index of character after end of URL
+*/
+function findEndOfURL(code, start) {
+	let index = (start || 0) + 4;
+	const length = code.length;
+	while (true) {
+		if (index >= length) return styleParseError("Cannot find end of URL", code, start);
+		let next = code.charAt(index);
+		switch (next) {
+			case "\"":
+			case "'": {
+				let end = findEndOfQuotedString(code, next, index);
+				if (end === null) return styleParseError("Incomplete string", code, index);
+				end = code.indexOf(")", end);
+				return end === -1 ? styleParseError("Cannot find end of URL", code, start) : end + 1;
+			}
+			case " ":
+			case "	":
+			case "\r":
+			case "\n":
+				index++;
+				break;
+			default: while (true) {
+				switch (next) {
+					case ")": return index + 1;
+					case "\"":
+					case "'":
+					case "(":
+					case " ":
+					case "	":
+					case "\r":
+					case "\n": return styleParseError("Invalid URL", code, start);
+					default: if (code.charCodeAt(index) < 32) return styleParseError("Invalid URL", code, start);
+				}
+				index++;
+				if (index >= length) return styleParseError("Cannot find end of URL", code, start);
+				next = code.charAt(index);
+			}
+		}
+	}
+}
+
+export { findEndOfQuotedString, findEndOfURL };

package/lib/css/parser/text.d.ts

@@ -1,5 +1,4 @@
-import { TextToken, CSSRuleToken, CSSTokenWithSelector } from './types.js';
-
+import { CSSRuleToken, CSSTokenWithSelector, TextToken } from "./types.js";
 /**
  * Merge text tokens to string
  */
@@ -16,5 +15,4 @@ declare function textTokensToRule(tokens: TextToken[]): CSSRuleToken | null;
  * Create at-rule or selector token from text tokens
  */
 declare function textTokensToSelector(tokens: TextToken[]): CSSTokenWithSelector | null;
-
-export { getSelectors, mergeTextTokens, textTokensToRule, textTokensToSelector };
+export { getSelectors, mergeTextTokens, textTokensToRule, textTokensToSelector };