@iconify/tools 4.2.0 → 5.0.0-beta.1

package/lib/icon-set/merge.js

@@ -0,0 +1,68 @@
+import { IconSet } from "./index.js";
+import { findMatchingIcon } from "./match.js";
+import { hasIconDataBeenModified } from "./modified.js";
+
+function assertNever(v) {}
+/**
+* Merge icon sets
+*/
+function mergeIconSets(oldIcons, newIcons) {
+	const mergedIcons = new IconSet(newIcons.export());
+	const oldEntries = oldIcons.entries;
+	const entries = mergedIcons.entries;
+	function add(name) {
+		if (entries[name]) return true;
+		const item = oldEntries[name];
+		switch (item.type) {
+			case "icon": {
+				const fullIcon = oldIcons.resolve(name, true);
+				const parent = fullIcon ? findMatchingIcon(mergedIcons, fullIcon) : null;
+				if (parent !== null) {
+					mergedIcons.setAlias(name, parent);
+					return true;
+				}
+				const props = item.props;
+				mergedIcons.setItem(name, {
+					...item,
+					props: {
+						...props,
+						hidden: true
+					},
+					categories: /* @__PURE__ */ new Set()
+				});
+				return true;
+			}
+			case "variation":
+			case "alias": {
+				let parent = item.parent;
+				if (!add(parent)) return false;
+				const parentItem = entries[parent];
+				if (parentItem.type === "alias") parent = parentItem.parent;
+				if (item.type === "variation") {
+					const props = item.props;
+					mergedIcons.setItem(name, {
+						...item,
+						parent,
+						props: {
+							...props,
+							hidden: true
+						}
+					});
+				} else mergedIcons.setItem(name, {
+					...item,
+					parent
+				});
+				return true;
+			}
+			default:
+				assertNever(item);
+				return false;
+		}
+	}
+	for (const name in oldEntries) add(name);
+	if (oldIcons.lastModified && !hasIconDataBeenModified(oldIcons, mergedIcons)) mergedIcons.updateLastModified(oldIcons.lastModified);
+	else if (newIcons.lastModified && !hasIconDataBeenModified(newIcons, mergedIcons)) mergedIcons.updateLastModified(newIcons.lastModified);
+	return mergedIcons;
+}
+
+export { mergeIconSets };

package/lib/icon-set/modified.d.ts

@@ -1,16 +1,8 @@
-import { IconSet } from './index.js';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import './types.js';
-import '../svg/index.js';
-import 'cheerio';
-import '@iconify/utils/lib/icon-set/tree';
-
+import { IconSet } from "./index.js";
 /**
  * Check if icons in an icon set were updated.
  *
  * This function checks only icons, not metadata. It also ignores icon visibility.
  */
 declare function hasIconDataBeenModified(set1: IconSet, set2: IconSet): boolean;
-
-export { hasIconDataBeenModified };
+export { hasIconDataBeenModified };

package/lib/icon-set/modified.js

@@ -0,0 +1,20 @@
+/**
+* Check if icons in an icon set were updated.
+*
+* This function checks only icons, not metadata. It also ignores icon visibility.
+*/
+function hasIconDataBeenModified(set1, set2) {
+	const entries1 = set1.entries;
+	const entries2 = set2.entries;
+	const keys1 = Object.keys(entries1);
+	const keys2 = Object.keys(entries2);
+	if (keys1.length !== keys2.length) return true;
+	for (let i = 0; i < keys1.length; i++) if (!entries2[keys1[i]]) return true;
+	for (let i = 0; i < keys1.length; i++) {
+		const name = keys1[i];
+		if (set1.toString(name) !== set2.toString(name)) return true;
+	}
+	return false;
+}
+
+export { hasIconDataBeenModified };

package/lib/icon-set/props.d.ts

@@ -1,6 +1,4 @@
-import { CommonIconProps } from './types.js';
-import '@iconify/types';
-
+import { CommonIconProps } from "./types.js";
 /**
  * Common properties for icon and alias
  */
@@ -9,5 +7,4 @@ declare const defaultCommonProps: Required<CommonIconProps>;
  * Filter icon props: copies properties, removing undefined and default entries
  */
 declare function filterProps(data: CommonIconProps, reference: CommonIconProps, compareDefaultValues: boolean): CommonIconProps;
-
-export { defaultCommonProps, filterProps };
+export { defaultCommonProps, filterProps };

package/lib/icon-set/props.js

@@ -0,0 +1,19 @@
+import { defaultIconProps } from "@iconify/utils";
+import { commonObjectProps, unmergeObjects } from "@iconify/utils/lib/misc/objects";
+
+/**
+* Common properties for icon and alias
+*/
+const defaultCommonProps = Object.freeze({
+	...defaultIconProps,
+	hidden: false
+});
+/**
+* Filter icon props: copies properties, removing undefined and default entries
+*/
+function filterProps(data, reference, compareDefaultValues) {
+	const result = commonObjectProps(data, reference);
+	return compareDefaultValues ? unmergeObjects(result, reference) : result;
+}
+
+export { defaultCommonProps, filterProps };

package/lib/icon-set/tags.d.ts

@@ -1,19 +1,12 @@
-import { IconSet } from './index.js';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import './types.js';
-import '../svg/index.js';
-import 'cheerio';
-import '@iconify/utils/lib/icon-set/tree';
-
+import { IconSet } from "./index.js";
 declare const paletteTags: {
-    monotone: string;
-    palette: string;
+  monotone: string;
+  palette: string;
 };
 declare const sizeTags: {
-    square: string;
-    gridPrefix: string;
-    heightPrefix: string;
+  square: string;
+  gridPrefix: string;
+  heightPrefix: string;
 };
 /**
  * Add tags to icon set
@@ -21,5 +14,4 @@ declare const sizeTags: {
  * @deprecated
  */
 declare function addTagsToIconSet(iconSet: IconSet, customTags?: string[]): string[];
-
-export { addTagsToIconSet, paletteTags, sizeTags };
+export { addTagsToIconSet, paletteTags, sizeTags };

package/lib/icon-set/tags.js

@@ -0,0 +1,53 @@
+import { detectIconSetPalette } from "../colors/detect.js";
+import { defaultIconDimensions } from "@iconify/utils/lib/icon/defaults";
+
+const paletteTags = {
+	monotone: "Monotone",
+	palette: "Has Colors"
+};
+const sizeTags = {
+	square: "Square",
+	gridPrefix: "Grid: ",
+	heightPrefix: "Height: "
+};
+/**
+* Add tags to icon set
+*
+* @deprecated
+*/
+function addTagsToIconSet(iconSet, customTags) {
+	const info = iconSet.info;
+	const tags = [];
+	const iconNames = Object.keys(iconSet.entries).filter((key) => {
+		const item = iconSet.entries[key];
+		if (item.type !== "icon") return false;
+		if (item.props.hidden) return false;
+		return true;
+	});
+	if (iconNames.length) {
+		let hasPalette = info?.palette;
+		if (hasPalette === void 0) hasPalette = detectIconSetPalette(iconSet);
+		if (hasPalette === true) tags.push(paletteTags.palette);
+		if (hasPalette === false) tags.push(paletteTags.monotone);
+		let isSquare = true;
+		let height;
+		for (let i = 0; i < iconNames.length; i++) {
+			const icon = iconSet.entries[iconNames[i]];
+			if (icon.type !== "icon") continue;
+			const iconProps = icon.props;
+			const iconWidth = iconProps.width || defaultIconDimensions.width;
+			const iconHeight = iconProps.height || defaultIconDimensions.height;
+			if (isSquare && iconWidth !== iconHeight) isSquare = false;
+			if (height === void 0) height = iconHeight;
+			else if (height && iconHeight !== height) height = null;
+			if (!height && !isSquare) break;
+		}
+		if (height && Math.round(height) === height) tags.push((isSquare ? sizeTags.gridPrefix : sizeTags.heightPrefix) + height.toString());
+		if (isSquare) tags.push(sizeTags.square);
+	}
+	const result = tags.concat(customTags || []);
+	if (info) info.tags = result;
+	return result;
+}
+
+export { addTagsToIconSet, paletteTags, sizeTags };

package/lib/icon-set/types.d.ts

@@ -1,18 +1,15 @@
-import { ExtendedIconifyIcon, ExtendedIconifyAlias, IconifyOptional, IconifyIcon } from '@iconify/types';
-
+import { ExtendedIconifyAlias, ExtendedIconifyIcon, IconifyIcon, IconifyOptional } from "@iconify/types";
 /**
  * Category item
  */
 interface IconCategory {
-    title: string;
-    count: number;
+  title: string;
+  count: number;
 }
 /**
  * Get common properties: IconifyOptional + APIIconAttributes
  */
-type CommonProps<A, B> = {
-    [K in keyof A & keyof B]?: A[K] extends B[K] ? A[K] : never;
-};
+type CommonProps<A, B> = { [K in keyof A & keyof B]?: A[K] extends B[K] ? A[K] : never };
 type CommonIconProps = CommonProps<ExtendedIconifyIcon, ExtendedIconifyAlias>;
 /**
  * Exclude IconifyOptional from CommonIconProps
@@ -22,29 +19,29 @@ type ExtraIconProps = Omit<CommonIconProps, keyof IconifyOptional>;
  * Partials
  */
 interface IconWithChars {
-    chars: Set<string>;
+  chars: Set<string>;
 }
 interface IconWithPropsData extends IconWithChars {
-    props: CommonIconProps;
+  props: CommonIconProps;
 }
 interface IconWithCategories {
-    categories: Set<IconCategory>;
+  categories: Set<IconCategory>;
 }
 interface IconParentData {
-    parent: string;
+  parent: string;
 }
 /**
  * Icon types
  */
 interface IconSetIcon extends IconWithPropsData, IconWithCategories {
-    type: 'icon';
-    body: string;
+  type: 'icon';
+  body: string;
 }
 interface IconSetIconAlias extends IconWithChars, IconParentData {
-    type: 'alias';
+  type: 'alias';
 }
 interface IconSetIconVariation extends IconWithPropsData, IconParentData {
-    type: 'variation';
+  type: 'variation';
 }
 /**
  * All icon types
@@ -54,14 +51,13 @@ type IconSetIconType = IconSetIconEntry['type'];
 /**
  * Full icon with extra stuff
  */
-interface ResolvedIconifyIcon extends IconifyIcon, ExtraIconProps {
-}
+interface ResolvedIconifyIcon extends IconifyIcon, ExtraIconProps {}
 /**
  * Result for checking theme: list of names for each theme
  */
 interface CheckThemeResult {
-    valid: Record<string, string[]>;
-    invalid: string[];
+  valid: Record<string, string[]>;
+  invalid: string[];
 }
 /**
  * Callback for forEach functions
@@ -71,5 +67,4 @@ interface CheckThemeResult {
 type IconSetForEachCallbackResult = void | false;
 type IconSetAsyncForEachCallback = (name: string, type: IconSetIconEntry['type']) => Promise<IconSetForEachCallbackResult> | IconSetForEachCallbackResult;
 type IconSetSyncForEachCallback = (name: string, type: IconSetIconEntry['type']) => IconSetForEachCallbackResult;
-
-export type { CheckThemeResult, CommonIconProps, ExtraIconProps, IconCategory, IconParentData, IconSetAsyncForEachCallback, IconSetIcon, IconSetIconAlias, IconSetIconEntry, IconSetIconType, IconSetIconVariation, IconSetSyncForEachCallback, IconWithCategories, IconWithChars, IconWithPropsData, ResolvedIconifyIcon };
+export { CheckThemeResult, CommonIconProps, ExtraIconProps, IconCategory, IconParentData, IconSetAsyncForEachCallback, IconSetIcon, IconSetIconAlias, IconSetIconEntry, IconSetIconType, IconSetIconVariation, IconSetSyncForEachCallback, IconWithCategories, IconWithChars, IconWithPropsData, ResolvedIconifyIcon };

package/lib/icon-set/types.js

@@ -0,0 +1 @@
+export {  };

package/lib/import/directory.d.ts

@@ -1,21 +1,13 @@
-import { IconSet } from '../icon-set/index.js';
-import { CleanupSVGOptions } from '../svg/cleanup.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 '../svg/cleanup/bad-tags.js';
-
+import { IconSet } from "../icon-set/index.js";
+import { CleanupSVGOptions } from "../svg/cleanup.js";
 /**
  * Entry for file
  */
 interface ImportDirectoryFileEntry {
-    path: string;
-    subdir: string;
-    file: string;
-    ext: string;
+  path: string;
+  subdir: string;
+  file: string;
+  ext: string;
 }
 /**
  * Callback to get keyword for icon based on file name
@@ -35,10 +27,10 @@ type ImportDirectoryKeywordSyncCallback = Callback<ImportDirectoryKeywordCallbac
  * Options
  */
 interface ImportDirectoryOptions<K> extends CleanupSVGOptions {
-    prefix?: string;
-    includeSubDirs?: boolean;
-    keyword?: K;
-    ignoreImportErrors?: boolean | 'warn';
+  prefix?: string;
+  includeSubDirs?: boolean;
+  keyword?: K;
+  ignoreImportErrors?: boolean | 'warn';
 }
 /**
  * Import all icons from directory
@@ -48,5 +40,4 @@ declare function importDirectory(path: string, options?: ImportDirectoryOptions<
  * Import all icons from directory synchronously
  */
 declare function importDirectorySync(path: string, options?: ImportDirectoryOptions<ImportDirectoryKeywordSyncCallback>): IconSet;
-
-export { type ImportDirectoryFileEntry, type ImportDirectoryKeywordCallback, type ImportDirectoryKeywordSyncCallback, importDirectory, importDirectorySync };
+export { ImportDirectoryFileEntry, ImportDirectoryKeywordCallback, ImportDirectoryKeywordSyncCallback, importDirectory, importDirectorySync };

package/lib/import/directory.js

@@ -0,0 +1,101 @@
+import { SVG } from "../svg/index.js";
+import { cleanupSVG } from "../svg/cleanup.js";
+import { blankIconSet } from "../icon-set/index.js";
+import { scanDirectory, scanDirectorySync } from "../misc/scan.js";
+import { cleanupIconKeyword } from "../misc/keyword.js";
+import { promises, readFileSync } from "fs";
+
+function importDir(iconSet, options, getKeyword, files, readFile, done) {
+	let i = 0;
+	const next = () => {
+		if (i >= files.length) return done(iconSet);
+		const file = files[i];
+		i++;
+		getKeyword([
+			file,
+			cleanupIconKeyword(file.file),
+			iconSet
+		], (keyword) => {
+			if (typeof keyword !== "string" || !keyword.length) return next();
+			readFile(file.path + file.subdir + file.file + file.ext, (content) => {
+				try {
+					const svg = new SVG(content);
+					cleanupSVG(svg, options);
+					iconSet.fromSVG(keyword, svg);
+				} catch (err) {
+					const ignore = options.ignoreImportErrors ?? false;
+					if (ignore === false || ignore === "warn") {
+						let msg = `Failed to import "${keyword}"`;
+						if (err instanceof Error) msg += `: ${err.message}`;
+						if (ignore === false) throw new Error(msg);
+						else console.warn(msg);
+					}
+				}
+				next();
+			});
+		});
+	};
+	next();
+}
+function isValidFile(item) {
+	return item.ext.toLowerCase() === ".svg";
+}
+/**
+* Import all icons from directory
+*/
+function importDirectory(path, options = {}) {
+	return new Promise((fulfill, reject) => {
+		scanDirectory(path, (ext, file, subdir, path$1) => {
+			const result = {
+				file,
+				ext,
+				subdir,
+				path: path$1
+			};
+			return isValidFile(result) ? result : false;
+		}, options.includeSubDirs !== false).then((files) => {
+			const iconSet = blankIconSet(options.prefix || "");
+			try {
+				importDir(iconSet, options, (params, done) => {
+					if (options.keyword) {
+						const result = options.keyword(...params);
+						if (result instanceof Promise) result.then(done).catch(reject);
+						else done(result);
+					} else done(params[1]);
+				}, files, (filename, done) => {
+					promises.readFile(filename, "utf8").then(done).catch(reject);
+				}, fulfill);
+			} catch (err) {
+				reject(err);
+			}
+		}).catch(reject);
+	});
+}
+/**
+* Import all icons from directory synchronously
+*/
+function importDirectorySync(path, options = {}) {
+	const files = scanDirectorySync(path, (ext, file, subdir, path$1) => {
+		const result = {
+			file,
+			ext,
+			subdir,
+			path: path$1
+		};
+		return isValidFile(result) ? result : false;
+	}, options.includeSubDirs !== false);
+	const iconSet = blankIconSet(options.prefix || "");
+	let isSync = true;
+	importDir(iconSet, options, (params, done) => {
+		if (options.keyword) done(options.keyword(...params));
+		else done(params[1]);
+	}, files, (filename, done) => {
+		done(readFileSync(filename, "utf8"));
+	}, () => {
+		if (!isSync) throw new Error("importDirectorySync supposed to be synchronous");
+	});
+	isSync = false;
+	return iconSet;
+}
+
+export { importDirectory, importDirectorySync };

package/lib/import/figma/index.d.ts

@@ -1,20 +1,9 @@
-import { DocumentNotModified } from '../../download/types/modified.js';
-import { FigmaIfModifiedSinceOption, FigmaImportOptions } from './types/options.js';
-import { FigmaImportResult } from './types/result.js';
-import '../../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 './types/nodes.js';
-import './types/api.js';
-
+import { DocumentNotModified } from "../../download/types/modified.js";
+import { FigmaImportResult } from "./types/result.js";
+import { FigmaIfModifiedSinceOption, FigmaImportOptions } from "./types/options.js";
 /**
  * Import icon set from Figma
  */
 declare function importFromFigma<T extends FigmaIfModifiedSinceOption & FigmaImportOptions>(options: T): Promise<FigmaImportResult | DocumentNotModified>;
 declare function importFromFigma(options: FigmaImportOptions): Promise<FigmaImportResult>;
-
-export { importFromFigma };
+export { importFromFigma };

package/lib/import/figma/index.js

@@ -0,0 +1,61 @@
+import { SVG } from "../../svg/index.js";
+import { cleanupSVG } from "../../svg/cleanup.js";
+import { blankIconSet } from "../../icon-set/index.js";
+import { getFigmaIconNodes } from "./nodes.js";
+import { figmaDownloadImages, figmaFilesQuery, figmaImagesQuery } from "./query.js";
+
+async function importFromFigma(options) {
+	const cacheOptions = options.cacheDir ? {
+		ttl: options.cacheAPITTL || 3600 * 24,
+		dir: options.cacheDir
+	} : void 0;
+	const cacheSVGOptions = options.cacheDir ? {
+		ttl: options.cacheSVGTTL || 3600 * 24 * 30,
+		dir: options.cacheDir
+	} : void 0;
+	const document = await figmaFilesQuery(options, cacheOptions);
+	if (document === "not_modified") return document;
+	options.version = document.version;
+	const nodes = getFigmaIconNodes(document, options);
+	await figmaImagesQuery(options, nodes, cacheOptions);
+	await figmaDownloadImages(nodes, cacheSVGOptions);
+	const iconSet = blankIconSet(options.prefix);
+	const icons = nodes.icons;
+	const missing = [];
+	const iconIDs = Object.keys(icons);
+	for (let i = 0; i < iconIDs.length; i++) {
+		const item = icons[iconIDs[i]];
+		if (typeof item.content !== "string") {
+			missing.push(item);
+			continue;
+		}
+		if (options.beforeImportingIcon) {
+			const callbackResult = options.beforeImportingIcon(item, iconSet);
+			if (callbackResult instanceof Promise) await callbackResult;
+		}
+		try {
+			const svg = new SVG(item.content);
+			cleanupSVG(svg);
+			iconSet.fromSVG(item.keyword, svg);
+		} catch (err) {
+			missing.push(item);
+			continue;
+		}
+		if (options.afterImportingIcon) {
+			const callbackResult = options.afterImportingIcon(item, iconSet);
+			if (callbackResult instanceof Promise) await callbackResult;
+		}
+	}
+	return {
+		name: document.name,
+		version: document.version,
+		lastModified: document.lastModified,
+		nodesCount: nodes.nodesCount,
+		generatedIconsCount: nodes.generatedIconsCount,
+		downloadedIconsCount: nodes.downloadedIconsCount,
+		iconSet,
+		missing
+	};
+}
+
+export { importFromFigma };

package/lib/import/figma/nodes.d.ts

@@ -1,18 +1,8 @@
-import { FigmaDocument } from './types/api.js';
-import { FigmaGetIconNodesOptions } from './types/options.js';
-import { FigmaNodesImportResult } from './types/result.js';
-import '../../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 './types/nodes.js';
-
+import { FigmaDocument } from "./types/api.js";
+import { FigmaNodesImportResult } from "./types/result.js";
+import { FigmaGetIconNodesOptions } from "./types/options.js";
 /**
  * Get node ids for icons
  */
 declare function getFigmaIconNodes(document: FigmaDocument, options: FigmaGetIconNodesOptions): FigmaNodesImportResult;
-
-export { getFigmaIconNodes };
+export { getFigmaIconNodes };

package/lib/import/figma/nodes.js

@@ -0,0 +1,80 @@
+function assertNever(v) {}
+/**
+* Get node ids for icons
+*/
+function getFigmaIconNodes(document, options) {
+	const nodes = { icons: Object.create(null) };
+	let found = 0;
+	const check = (node, parents) => {
+		const iconNodeType = node.type;
+		switch (iconNodeType) {
+			case "COMPONENT":
+			case "INSTANCE":
+			case "FRAME": {
+				const iconNode = node;
+				if (iconNode.absoluteBoundingBox) {
+					const box = iconNode.absoluteBoundingBox;
+					const item = {
+						...node,
+						type: iconNodeType,
+						width: box.width,
+						height: box.height,
+						parents
+					};
+					const keyword = options.iconNameForNode(item, nodes, document);
+					if (typeof keyword === "string") {
+						found++;
+						nodes.icons[node.id] = {
+							id: node.id,
+							name: node.name,
+							keyword
+						};
+						return;
+					}
+					if (keyword && typeof keyword === "object" && typeof keyword.keyword === "string") {
+						found++;
+						nodes.icons[node.id] = {
+							...keyword,
+							id: node.id,
+							name: node.name
+						};
+						return;
+					}
+				}
+				break;
+			}
+			default: assertNever(iconNodeType);
+		}
+		if (!node.children) return;
+		const parentNodeType = node.type;
+		switch (parentNodeType) {
+			case "CANVAS":
+			case "FRAME":
+			case "GROUP":
+			case "SECTION":
+			case "COMPONENT_SET": {
+				const parentItem = {
+					...node,
+					type: parentNodeType
+				};
+				const newParents = parents.concat([parentItem]);
+				if (!parents.length && options.pages) {
+					const allowedPages = options.pages;
+					if (!allowedPages.includes(node.id) && !allowedPages.includes(node.name.trim())) return;
+				} else if (options.filterParentNode && !options.filterParentNode(newParents, document)) return;
+				node.children.forEach((childNode) => {
+					check(childNode, newParents);
+				});
+				break;
+			}
+			default: assertNever(parentNodeType);
+		}
+	};
+	document.document.children.forEach((node) => {
+		check(node, []);
+	});
+	nodes.nodesCount = found;
+	return nodes;
+}
+
+export { getFigmaIconNodes };