@iconify/tools 3.0.6 → 4.0.0-beta.2

package/lib/colors/parse.mjs

@@ -1,7 +1,7 @@
-import { stringToColor, compareColors, colorToString } from '@iconify/utils/lib/colors';
+import { stringToColor, colorToString, compareColors } from '@iconify/utils/lib/colors';
 import { animateTags, shapeTags } from '../svg/data/tags.mjs';
-import { parseSVGStyle, parseSVGStyleSync } from '../svg/parse-style.mjs';
-import { defaultColorValues, allowDefaultColorValue, specialColorAttributes, defaultBlackColor, shapeColorAttributes } from './attribs.mjs';
+import { parseSVGStyle } from '../svg/parse-style.mjs';
+import { specialColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes, allowDefaultColorValue } from './attribs.mjs';
 import { tagSpecificPresentationalAttributes } from '../svg/data/attributes.mjs';
 import { analyseSVGStructure } from '../svg/analyse.mjs';
 import '../css/parse.mjs';
@@ -16,7 +16,7 @@ import '../svg/analyse/error.mjs';
 
 const propsToCheck = Object.keys(defaultColorValues);
 const animatePropsToCheck = ["from", "to", "values"];
-function createContext(options, callback) {
+function parseColors(svg, options = {}) {
   const result = {
     colors: [],
     hasUnsetColor: false,
@@ -47,12 +47,12 @@ function createContext(options, callback) {
       itemColors[prop] = addedColor === null ? color : addedColor;
     }
   }
-  function getElementColor(prop, item, elements) {
+  function getElementColor(prop, item, elements2) {
     function find(prop2) {
       let currentItem = item;
       const allowDefaultColor = allowDefaultColorValue[prop2];
       while (currentItem) {
-        const element = elements.get(
+        const element = elements2.get(
           currentItem.index
         );
         const color = element._colors?.[prop2];
@@ -77,81 +77,69 @@ function createContext(options, callback) {
     }
     return propColor;
   }
-  function checkColor(done, prop, value, item) {
+  function checkColor(prop, value, item) {
     switch (value.trim().toLowerCase()) {
       case "":
       case "inherit":
-        return done();
+        return;
     }
     const parsedColor = stringToColor(value);
     const defaultValue = parsedColor || value;
     if (parsedColor?.type === "function" && parsedColor.func === "url") {
       addColorToItem(prop, defaultValue, item, false);
-      return done(value);
+      return value;
     }
-    if (!callback) {
+    if (!options.callback) {
       addColorToItem(prop, defaultValue, item);
-      return done(value);
+      return value;
     }
-    callback(
-      [prop, value, parsedColor, item?.tagName, item],
-      (callbackResult) => {
-        switch (callbackResult) {
-          case "remove": {
-            return done(item ? callbackResult : void 0);
-          }
-          case "unset":
-            return done();
-        }
-        if (callbackResult === value || parsedColor && callbackResult === parsedColor) {
-          addColorToItem(prop, defaultValue, item);
-          return done(value);
-        }
-        if (typeof callbackResult === "string") {
-          const newColor = stringToColor(callbackResult);
-          addColorToItem(prop, newColor || callbackResult, item);
-          return done(callbackResult);
-        }
-        const newValue = colorToString(callbackResult);
-        addColorToItem(prop, callbackResult, item);
-        return done(newValue);
-      }
+    const callbackResult = options.callback(
+      prop,
+      value,
+      parsedColor,
+      item?.tagName,
+      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") {
+      const newColor = stringToColor(callbackResult);
+      addColorToItem(prop, newColor || callbackResult, item);
+      return callbackResult;
+    }
+    const newValue = colorToString(callbackResult);
+    addColorToItem(prop, callbackResult, item);
+    return newValue;
   }
-  function parseStyleItem(item, done) {
+  parseSVGStyle(svg, (item) => {
     const prop = item.prop;
     const value = item.value;
     if (propsToCheck.indexOf(prop) === -1) {
-      return done(value);
+      return value;
     }
     const attr = prop;
-    checkColor(
-      (newValue) => {
-        if (newValue === void 0) {
-          return done(newValue);
-        }
-        if (item.type === "global") {
-          result.hasGlobalStyle = true;
-        }
-        return done(newValue);
-      },
-      attr,
-      value
-    );
-  }
-  return {
-    result,
-    defaultColor,
-    rawOptions: options,
-    findColor,
-    addColorToItem,
-    getElementColor,
-    checkColor,
-    parseStyleItem
-  };
-}
-function analyseSVG(svg, context, done) {
-  const iconData = analyseSVGStructure(svg, context.rawOptions);
+    const newValue = checkColor(attr, 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 cheerio = svg.$svg;
   const removedElements = /* @__PURE__ */ new Set();
@@ -176,15 +164,15 @@ function analyseSVG(svg, context, done) {
     removeChildren(element);
     cheerio(element).remove();
   }
-  function parseTreeItem(item, done2) {
+  function parseTreeItem(item) {
     const index = item.index;
     if (removedElements.has(index) || parsedElements.has(index)) {
-      return done2();
+      return;
     }
     parsedElements.add(index);
     const element = elements.get(index);
     if (element._removed) {
-      return done2();
+      return;
     }
     const { tagName, attribs } = element;
     if (item.parent) {
@@ -198,243 +186,112 @@ function analyseSVG(svg, context, done) {
         };
       }
     }
-    function parseCommonProps(done3) {
-      const propsQueue = [];
-      for (let i = 0; i < propsToCheck.length; i++) {
-        const prop = propsToCheck[i];
-        if (prop === "fill" && animateTags.has(tagName)) {
-          continue;
-        }
-        const value = attribs[prop];
-        if (value !== void 0) {
-          propsQueue.push([prop, value]);
-        }
+    for (let i = 0; i < propsToCheck.length; i++) {
+      const prop = propsToCheck[i];
+      if (prop === "fill" && animateTags.has(tagName)) {
+        continue;
       }
-      const parsePropsQueue = () => {
-        const queueItem = propsQueue.shift();
-        if (!queueItem) {
-          return done3();
-        }
-        const [prop, value] = queueItem;
-        context.checkColor(
-          (newValue) => {
-            if (newValue !== value) {
-              if (newValue === void 0) {
-                cheerio(element).removeAttr(prop);
-                if (element._colors) {
-                  delete element._colors[prop];
-                }
-              } else if (newValue === "remove") {
-                removeElement(index, element);
-              } else {
-                cheerio(element).attr(prop, newValue);
-              }
-            }
-            return parsePropsQueue();
-          },
-          prop,
-          value,
-          element
-        );
-      };
-      parsePropsQueue();
-    }
-    function checkAnimations(done3) {
-      const propsQueue = [];
-      if (animateTags.has(tagName)) {
-        const attr = attribs.attributeName;
-        if (propsToCheck.indexOf(attr) !== -1) {
-          for (let i = 0; i < animatePropsToCheck.length; i++) {
-            const elementProp = animatePropsToCheck[i];
-            const fullValue = attribs[elementProp];
-            if (typeof fullValue !== "string") {
-              continue;
+      const value = attribs[prop];
+      if (value !== void 0) {
+        const newValue = checkColor(prop, value, element);
+        if (newValue !== value) {
+          if (newValue === void 0) {
+            cheerio(element).removeAttr(prop);
+            if (element._colors) {
+              delete element._colors[prop];
             }
-            propsQueue.push([elementProp, fullValue]);
+          } else if (newValue === "remove") {
+            removeElement(index, element);
+            return;
+          } else {
+            cheerio(element).attr(prop, newValue);
           }
         }
       }
-      const parsePropsQueue = () => {
-        const queueItem = propsQueue.shift();
-        if (!queueItem) {
-          return done3();
-        }
-        const [elementProp, fullValue] = queueItem;
-        const splitValues = fullValue.split(";");
-        let updatedValues = false;
-        const parsedAllItems = () => {
+    }
+    if (animateTags.has(tagName)) {
+      const attr = attribs.attributeName;
+      if (propsToCheck.indexOf(attr) !== -1) {
+        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
+                // Do not pass third parameter
+              );
+              if (newValue !== value) {
+                updatedValues = true;
+                splitValues[j] = typeof newValue === "string" ? newValue : "";
+              }
+            }
+          }
           if (updatedValues) {
             cheerio(element).attr(
               elementProp,
               splitValues.join(";")
             );
           }
-          return parsePropsQueue();
-        };
-        const parseItem = (index2) => {
-          if (index2 >= splitValues.length) {
-            return parsedAllItems();
-          }
-          const value = splitValues[index2];
-          if (value === void 0) {
-            return parseItem(index2 + 1);
-          }
-          context.checkColor(
-            (newValue) => {
-              if (newValue !== value) {
-                updatedValues = true;
-                splitValues[index2] = typeof newValue === "string" ? newValue : "";
-              }
-              parseItem(index2 + 1);
-            },
-            elementProp,
-            value
-            // Do not pass third parameter
-          );
-        };
-        parseItem(0);
-      };
-      parsePropsQueue();
+        }
+      }
     }
-    parseCommonProps(() => {
-      checkAnimations(() => {
-        if (!context.result.hasGlobalStyle) {
-          let requiredProps;
-          if (shapeTags.has(tagName)) {
-            requiredProps = shapeColorAttributes;
-          }
-          specialColorAttributes.forEach((attr) => {
-            if (tagSpecificPresentationalAttributes[tagName]?.has(
-              attr
-            )) {
-              requiredProps = [attr];
-            }
-          });
-          if (requiredProps) {
-            const itemColors = element._colors || (element._colors = {});
-            for (let i = 0; i < requiredProps.length; i++) {
-              const prop = requiredProps[i];
-              const color = context.getElementColor(
+    if (!result.hasGlobalStyle) {
+      let requiredProps;
+      if (shapeTags.has(tagName)) {
+        requiredProps = shapeColorAttributes;
+      }
+      specialColorAttributes.forEach((attr) => {
+        if (tagSpecificPresentationalAttributes[tagName]?.has(attr)) {
+          requiredProps = [attr];
+        }
+      });
+      if (requiredProps) {
+        const itemColors = element._colors || (element._colors = {});
+        for (let i = 0; i < requiredProps.length; i++) {
+          const prop = requiredProps[i];
+          const color = getElementColor(prop, item, elements);
+          if (color === defaultBlackColor) {
+            if (defaultColor) {
+              const defaultColorValue = typeof defaultColor === "function" ? defaultColor(
                 prop,
+                element,
                 item,
-                elements
+                iconData
+              ) : defaultColor;
+              findColor(defaultColorValue, true);
+              cheerio(element).attr(
+                prop,
+                colorToString(defaultColorValue)
               );
-              if (color === defaultBlackColor) {
-                const defaultColor = context.defaultColor;
-                if (defaultColor) {
-                  const defaultColorValue = typeof defaultColor === "function" ? defaultColor(
-                    prop,
-                    element,
-                    item,
-                    iconData
-                  ) : defaultColor;
-                  context.findColor(defaultColorValue, true);
-                  cheerio(element).attr(
-                    prop,
-                    colorToString(defaultColorValue)
-                  );
-                  itemColors[prop] = defaultColorValue;
-                } else {
-                  context.result.hasUnsetColor = true;
-                }
-              }
-            }
-          }
-        }
-        let index2 = 0;
-        const parseChildItem = () => {
-          if (index2 >= item.children.length) {
-            return done2();
-          }
-          const childItem = item.children[index2];
-          index2++;
-          if (!childItem.usedAsMask) {
-            parseTreeItem(childItem, parseChildItem);
-          } else {
-            parseChildItem();
-          }
-        };
-        parseChildItem();
-      });
-    });
-  }
-  parseTreeItem(tree, done);
-}
-function parseColors(svg, options = {}) {
-  const callback = options.callback;
-  return new Promise((fulfill, reject) => {
-    let context;
-    try {
-      context = createContext(
-        options,
-        callback ? (params, done) => {
-          try {
-            const result = callback(...params);
-            if (result instanceof Promise) {
-              result.then(done).catch(reject);
+              itemColors[prop] = defaultColorValue;
             } else {
-              done(result);
+              result.hasUnsetColor = true;
             }
-          } catch (err) {
-            reject(err);
           }
-        } : void 0
-      );
-    } catch (err) {
-      reject(err);
-      return;
-    }
-    parseSVGStyle(svg, (item) => {
-      return new Promise((fulfill2, reject2) => {
-        try {
-          context.parseStyleItem(item, fulfill2);
-        } catch (err) {
-          reject2(err);
         }
-      });
-    }).then(() => {
-      try {
-        analyseSVG(svg, context, () => {
-          fulfill(context.result);
-        });
-      } catch (err) {
-        reject(err);
       }
-    }).catch(reject);
-  });
-}
-function parseColorsSync(svg, options = {}) {
-  const callback = options.callback;
-  const context = createContext(
-    options,
-    callback ? (params, done) => {
-      done(callback(...params));
-    } : void 0
-  );
-  parseSVGStyleSync(svg, (item) => {
-    let isSync2 = true;
-    let result;
-    context.parseStyleItem(item, (value) => {
-      if (!isSync2) {
-        throw new Error("parseStyleItem callback supposed to be sync");
+    }
+    for (let i = 0; i < item.children.length; i++) {
+      const childItem = item.children[i];
+      if (!childItem.usedAsMask) {
+        parseTreeItem(childItem);
       }
-      result = value;
-    });
-    isSync2 = false;
-    return result;
-  });
-  let isSync = true;
-  analyseSVG(svg, context, () => {
-    if (!isSync) {
-      throw new Error("analyseSVG callback supposed to be sync");
     }
-  });
-  isSync = false;
-  return context.result;
+  }
+  parseTreeItem(tree);
+  return result;
 }
 function isEmptyColor(color) {
   const type = color.type;
   return type === "none" || type === "transparent";
 }
 
-export { isEmptyColor, parseColors, parseColorsSync };
+export { isEmptyColor, parseColors };

package/lib/colors/validate.cjs

@@ -17,7 +17,8 @@ require('../svg/data/attributes.cjs');
 require('../svg/analyse.cjs');
 require('../svg/analyse/error.cjs');
 
-function checkPalette(palette, expectMonotone) {
+function validateColors(svg, expectMonotone, options) {
+  const palette = colors_parse.parseColors(svg, options);
   palette.colors.forEach((color) => {
     if (typeof color === "string") {
       throw new Error("Unexpected color: " + color);
@@ -49,17 +50,7 @@ function checkPalette(palette, expectMonotone) {
         }
     }
   });
-}
-async function validateColors(svg, expectMonotone, options) {
-  const palette = await colors_parse.parseColors(svg, options);
-  checkPalette(palette, expectMonotone);
-  return palette;
-}
-function validateColorsSync(svg, expectMonotone, options) {
-  const palette = colors_parse.parseColorsSync(svg, options);
-  checkPalette(palette, expectMonotone);
   return palette;
 }
 
 exports.validateColors = validateColors;
-exports.validateColorsSync = validateColorsSync;

package/lib/colors/validate.d.ts

@@ -1,10 +1,12 @@
 import { SVG } from '../svg/index.js';
-import { ParseColorsOptions, FindColorsResult, ParseColorsSyncOptions } from './parse.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';
 
 /**
  * Validate colors in icon
@@ -13,14 +15,6 @@ import '../svg/analyse/types.js';
  *
  * Throws exception on error
  */
-declare function validateColors(svg: SVG, expectMonotone: boolean, options?: ParseColorsOptions): Promise<FindColorsResult>;
-/**
- * Validate colors in icon, synchronous version
- *
- * If icon is monotone,
- *
- * Throws exception on error
- */
-declare function validateColorsSync(svg: SVG, expectMonotone: boolean, options?: ParseColorsSyncOptions): FindColorsResult;
+declare function validateColors(svg: SVG, expectMonotone: boolean, options?: ParseColorsOptions): FindColorsResult;
 
-export { validateColors, validateColorsSync };
+export { validateColors };

package/lib/colors/validate.mjs

@@ -1,5 +1,5 @@
 import { colorToString } from '@iconify/utils/lib/colors';
-import { parseColors, parseColorsSync } from './parse.mjs';
+import { parseColors } from './parse.mjs';
 import '../svg/data/tags.mjs';
 import '../svg/parse-style.mjs';
 import '../css/parse.mjs';
@@ -15,7 +15,8 @@ import '../svg/data/attributes.mjs';
 import '../svg/analyse.mjs';
 import '../svg/analyse/error.mjs';
 
-function checkPalette(palette, expectMonotone) {
+function validateColors(svg, expectMonotone, options) {
+  const palette = parseColors(svg, options);
   palette.colors.forEach((color) => {
     if (typeof color === "string") {
       throw new Error("Unexpected color: " + color);
@@ -47,16 +48,7 @@ function checkPalette(palette, expectMonotone) {
         }
     }
   });
-}
-async function validateColors(svg, expectMonotone, options) {
-  const palette = await parseColors(svg, options);
-  checkPalette(palette, expectMonotone);
-  return palette;
-}
-function validateColorsSync(svg, expectMonotone, options) {
-  const palette = parseColorsSync(svg, options);
-  checkPalette(palette, expectMonotone);
   return palette;
 }
 
-export { validateColors, validateColorsSync };
+export { validateColors };

package/lib/export/directory.d.ts

@@ -4,6 +4,7 @@ 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';
 
 /**

package/lib/export/icon-package.d.ts

@@ -5,6 +5,7 @@ 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';
 
 /**
@@ -18,7 +19,9 @@ interface ExportIconPackageOptions extends ExportTargetOptions, ExportOptionsWit
 /**
  * Export icon set as single icon packages
  *
- * Used for exporting `@iconify-icons/{prefix}` packages
+ * Was used for exporting `@iconify-icons/{prefix}` packages
+ *
+ * @deprecated Packages with single icons are no longer maintained.
  */
 declare function exportIconPackage(iconSet: IconSet, options: ExportIconPackageOptions): Promise<string[]>;
 

package/lib/export/json-package.cjs

@@ -135,6 +135,7 @@ async function exportJSONPackage(iconSet, options) {
   );
   files.add("index.d.ts");
   await export_helpers_customFiles.exportCustomFiles(dir, options, files);
+  options.customisePackage?.(packageJSON);
   await misc_writeJson.writeJSONFile(dir + "/package.json", packageJSON);
   files.add("package.json");
   return Array.from(files);

package/lib/export/json-package.d.ts

@@ -5,6 +5,7 @@ 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';
 
 /**
@@ -12,6 +13,7 @@ import '@iconify/utils/lib/icon-set/tree';
  */
 interface ExportJSONPackageOptions extends ExportTargetOptions, ExportOptionsWithCustomFiles {
     package?: Record<string, unknown>;
+    customisePackage?: (contents: Record<string, unknown>) => void;
 }
 /**
  * Export icon set as JSON package

package/lib/export/json-package.mjs

@@ -133,6 +133,7 @@ async function exportJSONPackage(iconSet, options) {
   );
   files.add("index.d.ts");
   await exportCustomFiles(dir, options, files);
+  options.customisePackage?.(packageJSON);
   await writeJSONFile(dir + "/package.json", packageJSON);
   files.add("package.json");
   return Array.from(files);

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

@@ -3,6 +3,7 @@ import { IconifyIconCustomisations } from '@iconify/utils/lib/customisations/def
 import { IconSetIconEntry, IconCategory, IconSetIconType, IconSetAsyncForEachCallback, IconSetSyncForEachCallback, ResolvedIconifyIcon, CommonIconProps, CheckThemeResult } from './types.js';
 import { SVG } from '../svg/index.js';
 import { ParentIconsTree } from '@iconify/utils/lib/icon-set/tree';
+import 'cheerio';
 
 /**
  * Sort theme keys: long keys first

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

@@ -4,6 +4,7 @@ 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';
 
 /**