@iconify/tools 4.2.0 → 5.0.0-beta.2

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

package/lib/svg/cleanup/inline-style.js

@@ -0,0 +1,80 @@
+import { parseSVG } from "../parse.js";
+import { parseInlineStyle } from "../../css/parse.js";
+import { badAttributePrefixes, badAttributes, badSoftwareAttributes, insideClipPathAttributes, tagSpecificAnimatedAttributes, tagSpecificInlineStyles, tagSpecificNonPresentationalAttributes, tagSpecificPresentationalAttributes } from "../data/attributes.js";
+
+/**
+* Allowed rules
+*
+* Contains full rules + partial rules.
+* Partial rule = first part of rule split by '-' + '*'
+*/
+const allowedStyleRules = new Set([
+	"animation",
+	"animation*",
+	"offset",
+	"offset*",
+	"transform",
+	"transform*",
+	"translate",
+	"transition",
+	"transition*"
+]);
+/**
+* Known ignored rules, exported by junk software
+*
+* Full or partial (see above)
+*
+* Checked after tag specific attributes, so list contains some valid attributes, but when used in wrong place
+*/
+const knownIgnoredRules = new Set([
+	"solid*",
+	"paint*",
+	"shape*",
+	"color-interpolation-filters",
+	"stop-opacity"
+]);
+/**
+* Expand inline style
+*/
+function cleanupInlineStyle(svg) {
+	parseSVG(svg, (item) => {
+		const node = item.node;
+		const tagName = node.tag;
+		const attribs = node.attribs;
+		if (attribs.style && typeof attribs.style === "string") {
+			const parsedStyle = parseInlineStyle(attribs.style);
+			if (parsedStyle === null) delete attribs.style;
+			else {
+				const newStyle = Object.create(null);
+				const checkRule = (prop, value) => {
+					function warn() {
+						console.warn(`Removing unexpected style on "${tagName}": ${prop}`);
+					}
+					if (badAttributes.has(prop) || tagSpecificNonPresentationalAttributes[tagName]?.has(prop)) return;
+					if (tagSpecificAnimatedAttributes[tagName]?.has(prop) || tagSpecificPresentationalAttributes[tagName]?.has(prop)) {
+						attribs[prop] = value;
+						return;
+					}
+					const partial = prop.split("-").shift() + "*";
+					if (tagSpecificInlineStyles[tagName]?.has(prop) || allowedStyleRules.has(prop) || allowedStyleRules.has(partial)) {
+						newStyle[prop] = value;
+						return;
+					}
+					if (insideClipPathAttributes.has(prop)) {
+						if (item.parents.find((item$1) => item$1.node.tag === "clipPath")) attribs[prop] = value;
+						return;
+					}
+					if (badSoftwareAttributes.has(prop) || badAttributePrefixes.has(prop.split("-").shift()) || knownIgnoredRules.has(prop) || knownIgnoredRules.has(partial)) return;
+					if (prop.slice(0, 1) === "-") return;
+					warn();
+				};
+				for (const prop in parsedStyle) checkRule(prop, parsedStyle[prop]);
+				const newStyleStr = Object.keys(newStyle).map((key) => key + ":" + newStyle[key] + ";").join("");
+				if (newStyleStr.length) attribs.style = newStyleStr;
+				else delete attribs.style;
+			}
+		}
+	});
+}
+
+export { cleanupInlineStyle };

package/lib/svg/cleanup/root-style.d.ts

@@ -1,11 +1,7 @@
-import { SVG } from '../index.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-
+import { SVG } from "../index.js";
 interface CleanupRootStyleResult {
-    animations?: Set<string>;
-    removedAtRules?: Set<string>;
+  animations?: Set<string>;
+  removedAtRules?: Set<string>;
 }
 /**
  * Clean up root style
@@ -13,5 +9,4 @@ interface CleanupRootStyleResult {
  * This function removes all at-rule tokens, such as `@font-face`, `@media`
  */
 declare function cleanupRootStyle(svg: SVG): CleanupRootStyleResult;
-
-export { cleanupRootStyle };
+export { cleanupRootStyle };

package/lib/svg/cleanup/root-style.js

@@ -0,0 +1,27 @@
+import { parseSVGStyle } from "../parse-style.js";
+
+function assertNever(v) {}
+/**
+* Clean up root style
+*
+* This function removes all at-rule tokens, such as `@font-face`, `@media`
+*/
+function cleanupRootStyle(svg) {
+	const result = {};
+	parseSVGStyle(svg, (item) => {
+		switch (item.type) {
+			case "inline": return item.value;
+			case "global": return item.value;
+			case "at-rule":
+				(result.removedAtRules || (result.removedAtRules = /* @__PURE__ */ new Set())).add(item.prop);
+				return;
+			case "keyframes":
+				(result.animations || (result.animations = /* @__PURE__ */ new Set())).add(item.value);
+				return item.value;
+			default: assertNever(item);
+		}
+	});
+	return result;
+}
+
+export { cleanupRootStyle };

package/lib/svg/cleanup/root-svg.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";
 /**
  * Clean up SVG
  */
 declare function cleanupSVGRoot(svg: SVG): void;
-
-export { cleanupSVGRoot };
+export { cleanupSVGRoot };

package/lib/svg/cleanup/root-svg.js

@@ -0,0 +1,73 @@
+import { maskTags, reusableElementsWithPalette } from "../data/tags.js";
+import { badAttributePrefixes, badAttributes, badSoftwareAttributes, commonAttributes, junkSVGAttributes, stylingAttributes, tagSpecificNonPresentationalAttributes, tagSpecificPresentationalAttributes } from "../data/attributes.js";
+
+/**
+* Clean up SVG
+*/
+function cleanupSVGRoot(svg) {
+	const root = svg.$svg;
+	const tagName = "svg";
+	if (root.tag !== tagName) throw new Error(`Unexpected root tag <${root.tag}>`);
+	const attribs = root.attribs;
+	const moveToChildren = Object.create(null);
+	Object.keys(attribs).forEach((attr) => {
+		const value = attribs[attr];
+		if (commonAttributes.has(attr) || badAttributes.has(attr) || junkSVGAttributes.has(attr) || badSoftwareAttributes.has(attr) || badAttributePrefixes.has(attr.split("-").shift()) || attr.split(":").length > 1) {
+			delete attribs[attr];
+			return;
+		}
+		switch (attr) {
+			case "width":
+			case "height":
+				if (typeof value !== "string") return;
+				if (value.slice(-2) === "px") {
+					const num = value.replace("px", "");
+					if (parseFloat(num).toString() === num) attribs[attr] = num;
+				}
+				return;
+		}
+		if (tagSpecificNonPresentationalAttributes[tagName]?.has(attr)) return;
+		if (tagSpecificPresentationalAttributes[tagName]?.has(attr) && tagSpecificPresentationalAttributes.g.has(attr)) {
+			moveToChildren[attr] = value;
+			delete attribs[attr];
+			return;
+		}
+		if (stylingAttributes.has(attr)) {
+			switch (attr) {
+				case "style": return;
+				case "class":
+					delete attribs[attr];
+					return;
+			}
+			throw new Error(`Unexpected attribute "${attr}" on <${tagName}>`);
+		}
+		if (attr.slice(0, 2) === "on" || attr.slice(0, 5) === "aria-" || attr.slice(0, 6) === "xmlns:") {
+			delete attribs[attr];
+			return;
+		}
+		console.warn(`Removing unexpected attribute on SVG: ${attr}`);
+		delete attribs[attr];
+	});
+	if (Object.keys(moveToChildren).length) {
+		const nodesToMove = root.children;
+		const wrapper = {
+			type: "tag",
+			tag: "g",
+			attribs: moveToChildren,
+			children: []
+		};
+		root.children = [];
+		for (const child of nodesToMove) {
+			if (child.type !== "tag") {
+				wrapper.children.push(child);
+				continue;
+			}
+			const tagName$1 = child.tag;
+			if (tagName$1 === "style" || tagName$1 === "title" || reusableElementsWithPalette.has(tagName$1) || maskTags.has(tagName$1)) root.children.push(child);
+			else wrapper.children.push(child);
+		}
+		root.children.push(wrapper);
+	}
+}
+
+export { cleanupSVGRoot };

package/lib/svg/cleanup/svgo-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 convertStyleToAttrs(svg: SVG): void;
-
-export { convertStyleToAttrs };
+export { convertStyleToAttrs };

package/lib/svg/cleanup/svgo-style.js

@@ -0,0 +1,24 @@
+import { parseSVGStyle } from "../parse-style.js";
+import { badAttributePrefixes, badAttributes, badSoftwareAttributes } from "../data/attributes.js";
+import { runSVGO } from "../../optimise/svgo.js";
+
+/**
+* Expand inline style
+*/
+function convertStyleToAttrs(svg) {
+	let hasStyle = false;
+	parseSVGStyle(svg, (item) => {
+		if (item.type !== "inline" && item.type !== "global") return item.value;
+		const prop = item.prop;
+		if (badAttributes.has(prop) || badSoftwareAttributes.has(prop) || badAttributePrefixes.has(prop.split("-").shift())) return;
+		hasStyle = true;
+		return item.value;
+	});
+	if (!hasStyle) return;
+	runSVGO(svg, {
+		plugins: ["convertStyleToAttrs", "inlineStyles"],
+		multipass: true
+	});
+}
+
+export { convertStyleToAttrs };

package/lib/svg/cleanup.d.ts

@@ -1,9 +1,5 @@
-import { SVG } from './index.js';
-import { CheckBadTagsOptions } from './cleanup/bad-tags.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-
+import { SVG } from "./index.js";
+import { CheckBadTagsOptions } from "./cleanup/bad-tags.js";
 /**
  * Options
  */
@@ -12,5 +8,4 @@ type CleanupSVGOptions = CheckBadTagsOptions;
  * Clean up SVG before parsing/optimising it
  */
 declare function cleanupSVG(svg: SVG, options?: CleanupSVGOptions): void;
-
-export { type CleanupSVGOptions, cleanupSVG };
+export { CleanupSVGOptions, cleanupSVG };

package/lib/svg/cleanup.js

@@ -0,0 +1,20 @@
+import { removeBadAttributes } from "./cleanup/attribs.js";
+import { checkBadTags } from "./cleanup/bad-tags.js";
+import { cleanupInlineStyle } from "./cleanup/inline-style.js";
+import { cleanupRootStyle } from "./cleanup/root-style.js";
+import { cleanupSVGRoot } from "./cleanup/root-svg.js";
+import { convertStyleToAttrs } from "./cleanup/svgo-style.js";
+
+/**
+* Clean up SVG before parsing/optimising it
+*/
+function cleanupSVG(svg, options) {
+	cleanupInlineStyle(svg);
+	convertStyleToAttrs(svg);
+	cleanupSVGRoot(svg);
+	checkBadTags(svg, options);
+	removeBadAttributes(svg);
+	cleanupRootStyle(svg);
+}
+
+export { cleanupSVG };

package/lib/svg/data/attributes.d.ts

@@ -73,5 +73,4 @@ declare const tagSpecificNonPresentationalAttributes: Record<string, Set<string>
  * Styles to keep in tags
  */
 declare const tagSpecificInlineStyles: Record<string, Set<string>>;
-
-export { animationTimingAttributes, animationValueAttributes, badAttributePrefixes, badAttributes, badSoftwareAttributes, commonAttributes, commonColorPresentationalAttributes, commonFeAttributes, commonGradientAttributes, feFuncAttributes, fillPresentationalAttributes, insideClipPathAttributes, junkSVGAttributes, markerAttributes, otherAnimationAttributes, otherPresentationalAttributes, otherShapeAttributes, presentationalAttributes, strokePresentationalAttributes, stylingAttributes, tagSpecificAnimatedAttributes, tagSpecificInlineStyles, tagSpecificNonPresentationalAttributes, tagSpecificPresentationalAttributes, urlPresentationalAttributes, visibilityPresentationalAttributes };
+export { animationTimingAttributes, animationValueAttributes, badAttributePrefixes, badAttributes, badSoftwareAttributes, commonAttributes, commonColorPresentationalAttributes, commonFeAttributes, commonGradientAttributes, feFuncAttributes, fillPresentationalAttributes, insideClipPathAttributes, junkSVGAttributes, markerAttributes, otherAnimationAttributes, otherPresentationalAttributes, otherShapeAttributes, presentationalAttributes, strokePresentationalAttributes, stylingAttributes, tagSpecificAnimatedAttributes, tagSpecificInlineStyles, tagSpecificNonPresentationalAttributes, tagSpecificPresentationalAttributes, urlPresentationalAttributes, visibilityPresentationalAttributes };