@iconify/tools 4.1.5 → 5.0.0-beta.1

package/lib/index.js

@@ -0,0 +1,56 @@
+import { SVG } from "./svg/index.js";
+import { parseSVG } from "./svg/parse.js";
+import { parseSVGStyle } from "./svg/parse-style.js";
+import { analyseSVGStructure } from "./svg/analyse.js";
+import { removeBadAttributes } from "./svg/cleanup/attribs.js";
+import { checkBadTags } from "./svg/cleanup/bad-tags.js";
+import { cleanupInlineStyle } from "./svg/cleanup/inline-style.js";
+import { cleanupRootStyle } from "./svg/cleanup/root-style.js";
+import { cleanupSVGRoot } from "./svg/cleanup/root-svg.js";
+import { runSVGO } from "./optimise/svgo.js";
+import { convertStyleToAttrs } from "./svg/cleanup/svgo-style.js";
+import { cleanupSVG } from "./svg/cleanup.js";
+import { IconSet, blankIconSet } from "./icon-set/index.js";
+import { mergeIconSets } from "./icon-set/merge.js";
+import { isEmptyColor, parseColors } from "./colors/parse.js";
+import { detectIconSetPalette } from "./colors/detect.js";
+import { addTagsToIconSet } from "./icon-set/tags.js";
+import { scanDirectory, scanDirectorySync } from "./misc/scan.js";
+import { axiosConfig, fetchCallbacks } from "./download/api/config.js";
+import { setFetch } from "./download/api/fetch.js";
+import { sendAPIQuery } from "./download/api/index.js";
+import { defaultQueueParams, runConcurrentQueries } from "./download/api/queue.js";
+import { importFromFigma } from "./import/figma/index.js";
+import { cleanupIconKeyword } from "./misc/keyword.js";
+import { importDirectory, importDirectorySync } from "./import/directory.js";
+import { prepareDirectoryForExport } from "./export/helpers/prepare.js";
+import { execAsync } from "./misc/exec.js";
+import { getGitRepoBranch } from "./download/git/branch.js";
+import { getGitRepoHash } from "./download/git/hash.js";
+import { resetGitRepoContents } from "./download/git/reset.js";
+import { downloadGitRepo } from "./download/git/index.js";
+import { getGitHubRepoHash } from "./download/github/hash.js";
+import { downloadFile } from "./download/api/download.js";
+import { unzip } from "./download/helpers/unzip.js";
+import { downloadGitHubRepo } from "./download/github/index.js";
+import { getGitLabRepoHash } from "./download/gitlab/hash.js";
+import { downloadGitLabRepo } from "./download/gitlab/index.js";
+import { untar } from "./download/helpers/untar.js";
+import { getNPMVersion, getPackageVersion } from "./download/npm/version.js";
+import { downloadNPMPackage } from "./download/npm/index.js";
+import { downloadPackage } from "./download/index.js";
+import { validateColors } from "./colors/validate.js";
+import { removeFigmaClipPathFromSVG } from "./optimise/figma.js";
+import { deOptimisePaths } from "./optimise/flags.js";
+import { resetSVGOrigin } from "./optimise/origin.js";
+import { convertSVGToMask } from "./optimise/mask.js";
+import { scaleSVG } from "./optimise/scale.js";
+import { cleanupGlobalStyle } from "./optimise/global-style.js";
+import { exportToDirectory } from "./export/directory.js";
+import { writeJSONFile } from "./misc/write-json.js";
+import { exportJSONPackage } from "./export/json-package.js";
+import { exportIconPackage } from "./export/icon-package.js";
+import { compareDirectories } from "./misc/compare-dirs.js";
+import { bumpVersion } from "./misc/bump-version.js";
+
+export { IconSet, SVG, addTagsToIconSet, analyseSVGStructure, axiosConfig, blankIconSet, bumpVersion, checkBadTags, cleanupGlobalStyle, cleanupIconKeyword, cleanupInlineStyle, cleanupRootStyle, cleanupSVG, cleanupSVGRoot, compareDirectories, convertSVGToMask, convertStyleToAttrs, deOptimisePaths, defaultQueueParams, detectIconSetPalette, downloadFile, downloadGitHubRepo, downloadGitLabRepo, downloadGitRepo, downloadNPMPackage, downloadPackage, execAsync, exportIconPackage, exportJSONPackage, exportToDirectory, fetchCallbacks, getGitHubRepoHash, getGitLabRepoHash, getGitRepoBranch, getGitRepoHash, getNPMVersion, getPackageVersion, importDirectory, importDirectorySync, importFromFigma, isEmptyColor, mergeIconSets, parseColors, parseSVG, parseSVGStyle, prepareDirectoryForExport, removeBadAttributes, removeFigmaClipPathFromSVG, resetGitRepoContents, resetSVGOrigin, runConcurrentQueries, runSVGO, scaleSVG, scanDirectory, scanDirectorySync, sendAPIQuery, setFetch, untar, unzip, validateColors, writeJSONFile };

package/lib/misc/bump-version.d.ts

@@ -2,5 +2,4 @@
  * Bump version number
  */
 declare function bumpVersion(version: string): string;
-
-export { bumpVersion };
+export { bumpVersion };

package/lib/misc/bump-version.js

@@ -0,0 +1,13 @@
+/**
+* Bump version number
+*/
+function bumpVersion(version) {
+	const versionParts = version.split(".");
+	const lastPart = versionParts.pop();
+	const num = parseInt(lastPart);
+	if (isNaN(num) || num.toString() !== lastPart) versionParts.push(lastPart + ".1");
+	else versionParts.push((num + 1).toString());
+	return versionParts.join(".");
+}
+
+export { bumpVersion };

package/lib/misc/compare-dirs.d.ts

@@ -1,11 +1,10 @@
 interface CompareDirectoriesOptions {
-    ignoreNewLine?: boolean;
-    ignoreVersions?: boolean;
-    textExtensions?: string[];
+  ignoreNewLine?: boolean;
+  ignoreVersions?: boolean;
+  textExtensions?: string[];
 }
 /**
  * Compare directories. Returns true if files are identical, false if different
  */
 declare function compareDirectories(dir1: string, dir2: string, options?: CompareDirectoriesOptions): Promise<boolean>;
-
-export { type CompareDirectoriesOptions, compareDirectories };
+export { CompareDirectoriesOptions, compareDirectories };

package/lib/misc/compare-dirs.js

@@ -0,0 +1,65 @@
+import { scanDirectory } from "./scan.js";
+import { normalizeDir } from "../export/helpers/prepare.js";
+import { promises } from "fs";
+
+/**
+* Extensions that are treated as text
+*/
+const textFileExtensions = [
+	"json",
+	"ts",
+	"js",
+	"mjs",
+	"cjs",
+	"jsx",
+	"tsx",
+	"vue",
+	"svelte",
+	"svg",
+	"txt",
+	"md"
+];
+/**
+* Compare directories. Returns true if files are identical, false if different
+*/
+async function compareDirectories(dir1, dir2, options) {
+	dir1 = normalizeDir(dir1);
+	dir2 = normalizeDir(dir2);
+	const files1 = await scanDirectory(dir1);
+	const files2 = await scanDirectory(dir2);
+	if (files1.length !== files2.length) return false;
+	options = options || {};
+	const ignoreNewLine = options.ignoreNewLine !== false;
+	const ignoreVersions = options.ignoreVersions !== false;
+	const textExtensions = new Set((options.textExtensions || []).concat(textFileExtensions));
+	for (let i = 0; i < files1.length; i++) {
+		const file = files1[i];
+		if (!files2.includes(file)) return false;
+		const ext = file.split(".").pop().toLowerCase();
+		if (!textExtensions.has(ext)) {
+			const content1$1 = await promises.readFile(dir1 + "/" + file);
+			const content2$1 = await promises.readFile(dir2 + "/" + file);
+			if (Buffer.compare(content1$1, content2$1) !== 0) return false;
+			continue;
+		}
+		let content1 = await promises.readFile(dir1 + "/" + file, "utf8");
+		let content2 = await promises.readFile(dir2 + "/" + file, "utf8");
+		if (content1 === content2) continue;
+		if (ignoreNewLine) {
+			content1 = content1.replace(/\s+\n/g, "\n").trimEnd();
+			content2 = content2.replace(/\s+\n/g, "\n").trimEnd();
+		}
+		if (ignoreVersions && file.split("/").pop() === "package.json") {
+			const data1 = JSON.parse(content1);
+			const data2 = JSON.parse(content2);
+			delete data1.version;
+			delete data2.version;
+			content1 = JSON.stringify(data1);
+			content2 = JSON.stringify(data2);
+		}
+		if (content1 !== content2) return false;
+	}
+	return true;
+}
+
+export { compareDirectories };

package/lib/misc/exec.d.ts

@@ -1,12 +1,10 @@
-import { ExecOptions } from 'child_process';
-
+import { ExecOptions } from "child_process";
 interface ExecResult {
-    stdout: string;
-    stderr: string;
+  stdout: string;
+  stderr: string;
 }
 /**
  * Exec as Promise
  */
 declare function execAsync(cmd: string, options?: ExecOptions): Promise<ExecResult>;
-
-export { type ExecResult, execAsync };
+export { ExecResult, execAsync };

package/lib/misc/exec.js

@@ -0,0 +1,23 @@
+import { resolve } from "pathe";
+import { exec } from "child_process";
+
+/**
+* Exec as Promise
+*/
+function execAsync(cmd, options) {
+	return new Promise((fulfill, reject) => {
+		if (typeof options?.cwd === "string") options = {
+			...options,
+			cwd: resolve(options.cwd)
+		};
+		exec(cmd, options, (error, stdout, stderr) => {
+			if (error) reject(error);
+			else fulfill({
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+
+export { execAsync };

package/lib/misc/keyword.d.ts

@@ -2,5 +2,4 @@
  * Clean up keyword
  */
 declare function cleanupIconKeyword(keyword: string, convertCamelCase?: boolean): string;
-
-export { cleanupIconKeyword };
+export { cleanupIconKeyword };

package/lib/misc/keyword.js

@@ -0,0 +1,12 @@
+/**
+* Clean up keyword
+*/
+function cleanupIconKeyword(keyword, convertCamelCase = false) {
+	if (convertCamelCase) keyword = keyword.replace(/[A-Z]+/g, (chars) => "_" + chars.toLowerCase());
+	keyword = keyword.toLowerCase().trim().replace(/[\s_.:/\\]/g, "-").replace(/[^a-z0-9-]/g, "").replace(/[-]+/g, "-");
+	if (keyword.slice(0, 1) === "-") keyword = keyword.slice(1);
+	if (keyword.slice(-1) === "-") keyword = keyword.slice(0, -1);
+	return keyword;
+}
+
+export { cleanupIconKeyword };

package/lib/misc/scan.d.ts

@@ -1,5 +1,4 @@
-import { Stats } from 'fs';
-
+import { Stats } from "fs";
 /**
  * Callback
  *
@@ -17,8 +16,8 @@ type ScanDirectoryCallbackFalseResult = boolean | null | undefined;
 type ScanDirectoryCallbackStringResult = ScanDirectoryCallbackFalseResult | string;
 type Callback<T> = (ext: string, file: string, subdir: string, path: string, stat: Stats) => T;
 type AsyncCallback<T> = Callback<T | Promise<T>>;
-type ScanDirectoryCallback = AsyncCallback<ScanDirectoryCallbackStringResult | undefined>;
-type ScanDirectorySyncCallback = Callback<ScanDirectoryCallbackStringResult | undefined>;
+type ScanDirectoryCallback = AsyncCallback<ScanDirectoryCallbackStringResult>;
+type ScanDirectorySyncCallback = Callback<ScanDirectoryCallbackStringResult>;
 /**
  * Find all files in directory
  */
@@ -29,5 +28,4 @@ declare function scanDirectory<T>(path: string, callback: AsyncCallback<T | Scan
  */
 declare function scanDirectorySync(path: string, callback?: Callback<ScanDirectoryCallbackStringResult>, subdirs?: boolean): string[];
 declare function scanDirectorySync<T>(path: string, callback: Callback<T | ScanDirectoryCallbackFalseResult>, subdirs?: boolean): T[];
-
-export { type ScanDirectoryCallback, type ScanDirectorySyncCallback, scanDirectory, scanDirectorySync };
+export { ScanDirectoryCallback, ScanDirectorySyncCallback, scanDirectory, scanDirectorySync };

package/lib/misc/scan.js

@@ -0,0 +1,87 @@
+import { promises, readdirSync, statSync } from "fs";
+
+/**
+* Reusable functions
+*/
+function cleanPath(path) {
+	if (path.length && path.slice(-1) !== "/") return path + "/";
+	return path;
+}
+function isHidden(filename) {
+	return filename.slice(0, 1) === ".";
+}
+function split(filename) {
+	const parts = filename.split(".");
+	return {
+		ext: parts.length > 1 ? "." + parts.pop() : "",
+		file: parts.join(".")
+	};
+}
+function isIgnoredResult(result) {
+	return result === void 0 || result === false || result === null;
+}
+async function scanDirectory(path, callback, subdirs = true) {
+	const results = [];
+	path = cleanPath(path);
+	async function scan(subdir) {
+		const files = await promises.readdir(path + subdir);
+		for (let i = 0; i < files.length; i++) {
+			const filename = files[i];
+			if (isHidden(filename)) continue;
+			let stat;
+			try {
+				stat = await promises.stat(path + subdir + filename);
+			} catch {
+				continue;
+			}
+			if (stat.isDirectory()) {
+				if (subdirs) await scan(subdir + filename + "/");
+				continue;
+			}
+			if (!stat.isFile()) continue;
+			const { ext, file } = split(filename);
+			let callbackResult;
+			if (callback) {
+				callbackResult = callback(ext, file, subdir, path, stat);
+				if (callbackResult instanceof Promise) callbackResult = await callbackResult;
+				if (isIgnoredResult(callbackResult)) continue;
+			} else callbackResult = true;
+			results.push(callbackResult === true ? subdir + filename : callbackResult);
+		}
+	}
+	await scan("");
+	return results;
+}
+function scanDirectorySync(path, callback, subdirs = true) {
+	const results = [];
+	path = cleanPath(path);
+	function scan(subdir) {
+		const files = readdirSync(path + subdir);
+		for (let i = 0; i < files.length; i++) {
+			const filename = files[i];
+			if (isHidden(filename)) continue;
+			let stat;
+			try {
+				stat = statSync(path + subdir + filename);
+			} catch {
+				continue;
+			}
+			if (stat.isDirectory()) {
+				if (subdirs) scan(subdir + filename + "/");
+				continue;
+			}
+			if (!stat.isFile()) continue;
+			const { ext, file } = split(filename);
+			let callbackResult;
+			if (callback) {
+				callbackResult = callback(ext, file, subdir, path, stat);
+				if (isIgnoredResult(callbackResult)) continue;
+			} else callbackResult = true;
+			results.push(callbackResult === true ? subdir + filename : callbackResult);
+		}
+	}
+	scan("");
+	return results;
+}
+
+export { scanDirectory, scanDirectorySync };

package/lib/misc/write-json.d.ts

@@ -2,5 +2,4 @@
  * Write JSON file
  */
 declare function writeJSONFile(filename: string, data: unknown): Promise<void>;
-
-export { writeJSONFile };
+export { writeJSONFile };

package/lib/misc/write-json.js

@@ -0,0 +1,10 @@
+import { promises } from "fs";
+
+/**
+* Write JSON file
+*/
+async function writeJSONFile(filename, data) {
+	return promises.writeFile(filename, JSON.stringify(data, null, "	") + "\n");
+}
+
+export { writeJSONFile };

package/lib/optimise/figma.d.ts

@@ -1,8 +1,4 @@
-import { SVG } from '../svg/index.js';
-import 'cheerio';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-
+import { SVG } from "../svg/index.js";
 /**
  * Removes clip path from SVG, which Figma and Penpot add to icons that might have overflowing elements.
  * Also removes mess generated by Penpot
@@ -10,5 +6,4 @@ import '@iconify/utils/lib/customisations/defaults';
  * Function was originally designed for Figma only, but later added support for Penpot
  */
 declare function removeFigmaClipPathFromSVG(svg: SVG): boolean;
-
-export { removeFigmaClipPathFromSVG };
+export { removeFigmaClipPathFromSVG };

package/lib/optimise/figma.js

@@ -0,0 +1,189 @@
+import { parseSVG } from "../svg/parse.js";
+import { defsTag, maskTags, symbolTag } from "../svg/data/tags.js";
+import { cleanupInlineStyle } from "../svg/cleanup/inline-style.js";
+import { unwrapEmptyGroup } from "./unwrap.js";
+import { colorToString, stringToColor } from "@iconify/utils";
+
+/**
+* Checks if number is tiny, used to remove bad Figma transformations
+*/
+function isTinyNumber(value, limit) {
+	const num = parseInt(value);
+	return !isNaN(num) && Math.abs(num) < limit;
+}
+/**
+* Check node
+*
+* Returns CheckClipPathResult on success, false on error
+*/
+function checkClipPathNode(clipNode, expectedWidth, expectedHeight) {
+	for (const attr in clipNode.attribs) if (attr !== "id") return false;
+	const children = clipNode.children.filter((node) => node.type !== "text");
+	if (children.length !== 1) return false;
+	const childNode = children[0];
+	if (childNode.type !== "tag" || childNode.children.length) return false;
+	const attribs = { ...childNode.attribs };
+	delete attribs["fill"];
+	const fill = childNode.attribs["fill"];
+	const colorValue = typeof fill === "string" ? stringToColor(fill) : null;
+	const colorString = colorValue ? colorToString(colorValue) : null;
+	if (fill && colorString !== "#fff") {
+		console.warn("Unxepected fill on clip path:", childNode.attribs["fill"]);
+		return false;
+	}
+	switch (childNode.tag) {
+		case "rect": {
+			const widthValue = attribs["width"];
+			const heightValue = attribs["height"];
+			if ((typeof widthValue === "string" ? parseInt(widthValue) : widthValue) !== expectedWidth || (typeof heightValue === "string" ? parseInt(heightValue) : heightValue) !== expectedHeight) {
+				console.warn("Invalid size of clip path");
+				return false;
+			}
+			delete attribs["width"];
+			delete attribs["height"];
+			break;
+		}
+		default:
+			console.warn("Unexpected tag in Figma clip path:", childNode.tag);
+			return false;
+	}
+	Object.keys(attribs).forEach((attr) => {
+		const value = attribs[attr];
+		if (typeof value !== "string") return;
+		switch (attr) {
+			case "transform": if (value.startsWith("translate(") && value.endsWith(")")) {
+				const translateParts = value.slice(10, -1).split(/\s+/);
+				const limit = Math.min(expectedWidth, expectedHeight) / 1e3;
+				if (translateParts.length === 2 && isTinyNumber(translateParts[0], limit) && isTinyNumber(translateParts[1], limit)) delete attribs[attr];
+			}
+		}
+	});
+	return {
+		node: clipNode,
+		attribs
+	};
+}
+const urlStart = "url(#";
+const urlEnd = ")";
+/**
+* Does the job
+*
+* Can mess with SVG because on failure backup will be restored
+*/
+function remove(svg) {
+	unwrapEmptyGroup(svg);
+	let content = svg.toString();
+	const backup = content;
+	if (content.includes("frame-clip-def")) {
+		cleanupInlineStyle(svg);
+		parseSVG(svg, (item) => {
+			const node = item.node;
+			const tagName = node.tag;
+			const attribs$1 = node.attribs;
+			Object.keys(attribs$1).forEach((attr) => {
+				const value = attribs$1[attr];
+				if (typeof value !== "string") return;
+				switch (attr) {
+					case "id":
+						if (!maskTags.has(tagName) && !symbolTag.has(tagName)) delete attribs$1[attr];
+						break;
+					case "class":
+					case "xmlns:xlink":
+					case "version":
+						delete attribs$1[attr];
+						break;
+					case "transform": {
+						const trimmed = value.replace(/\s+/g, "").replace(/\.0+/g, "");
+						if (!trimmed || trimmed === "matrix(1,0,0,1,0,0)") delete attribs$1[attr];
+						break;
+					}
+					case "rx":
+					case "ry":
+					case "x":
+					case "y":
+						if (value === "0") delete attribs$1[attr];
+						break;
+					case "fill-opacity":
+					case "stroke-opacity":
+					case "opacity":
+						if (value === "1") delete attribs$1[attr];
+						break;
+					case "fill":
+					case "stroke": {
+						const colorValue = stringToColor(value);
+						if (colorValue?.type === "rgb") attribs$1[attr] = colorToString(colorValue);
+					}
+				}
+			});
+		});
+		content = svg.toString();
+	}
+	const clipPathBlocks = content.match(/<clipPath[^>]*>[\s\S]+?<\/clipPath>/g);
+	if (clipPathBlocks?.length === 2 && clipPathBlocks[0] === clipPathBlocks[1]) {
+		const split = clipPathBlocks[0];
+		const lines = content.split(split);
+		content = lines.shift() + split + lines.join("");
+	}
+	if (content.includes("<defs>")) content = content.replace(/<\/?defs>/g, "");
+	if (content !== backup) svg.load(content);
+	const rootNode = svg.$svg;
+	const children = rootNode.children.slice(0);
+	const shapesToClip = [];
+	let clipID;
+	for (let i = 0; i < children.length; i++) {
+		const node = children[i];
+		if (node.type === "tag") {
+			const tagName = node.tag;
+			if (!defsTag.has(tagName) && !maskTags.has(tagName) && !symbolTag.has(tagName)) {
+				const clipPath$1 = node.attribs["clip-path"];
+				if (typeof clipPath$1 !== "string" || !clipPath$1.startsWith(urlStart) || !clipPath$1.endsWith(urlEnd)) return false;
+				const id = clipPath$1.slice(5, -1);
+				if (typeof clipID === "string" && clipID !== id) return false;
+				clipID = id;
+				shapesToClip.push(node);
+			}
+		}
+	}
+	if (typeof clipID !== "string") return false;
+	const findClipPath = () => {
+		for (let i = 0; i < children.length; i++) {
+			const node = children[i];
+			if (node.type === "tag" && node.tag === "clipPath") {
+				if (node.attribs["id"] === clipID) {
+					const result = checkClipPathNode(node, svg.viewBox.width, svg.viewBox.height);
+					rootNode.children = rootNode.children.filter((n) => n !== node);
+					return result;
+				}
+				return;
+			}
+		}
+	};
+	const clipPath = findClipPath();
+	if (!clipPath) return false;
+	const attribs = clipPath.attribs;
+	for (let i = 0; i < shapesToClip.length; i++) {
+		const node = shapesToClip[i];
+		delete node.attribs["clip-path"];
+		for (const attr in attribs) {
+			if (node.attribs[attr] !== void 0) return false;
+			node.attribs[attr] = attribs[attr];
+		}
+	}
+	return true;
+}
+/**
+* Removes clip path from SVG, which Figma and Penpot add to icons that might have overflowing elements.
+* Also removes mess generated by Penpot
+*
+* Function was originally designed for Figma only, but later added support for Penpot
+*/
+function removeFigmaClipPathFromSVG(svg) {
+	const backup = svg.toString();
+	try {
+		if (remove(svg)) return true;
+	} catch {}
+	svg.load(backup);
+	return false;
+}
+
+export { removeFigmaClipPathFromSVG };

package/lib/optimise/flags.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";
 /**
  * De-optimise paths. Compressed paths are still not supported by some software.
  */
 declare function deOptimisePaths(svg: SVG): void;
-
-export { deOptimisePaths };
+export { deOptimisePaths };