@iconify/tools 4.0.0-dev.1 → 4.0.0

package/lib/colors/attribs.d.cts

@@ -0,0 +1,27 @@
+import { Color } from '@iconify/utils/lib/colors/types';
+
+/**
+ * Color attributes
+ */
+type CommonColorAttributes = 'color';
+declare const commonColorAttributes: CommonColorAttributes[];
+type ShapeColorAttributes = 'fill' | 'stroke';
+declare const shapeColorAttributes: ShapeColorAttributes[];
+type SpecialColorAttributes = 'stop-color' | 'flood-color';
+declare const specialColorAttributes: SpecialColorAttributes[];
+type ColorAttributes = CommonColorAttributes | ShapeColorAttributes | SpecialColorAttributes;
+/**
+ * Default values
+ */
+declare const defaultBlackColor: Color;
+declare const defaultColorValues: Record<ColorAttributes, Color>;
+/**
+ * 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!
+ */
+declare const allowDefaultColorValue: Partial<Record<ColorAttributes, string | true>>;
+
+export { type ColorAttributes, type CommonColorAttributes, type ShapeColorAttributes, type SpecialColorAttributes, allowDefaultColorValue, commonColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes, specialColorAttributes };

package/lib/colors/attribs.d.mts

@@ -0,0 +1,27 @@
+import { Color } from '@iconify/utils/lib/colors/types';
+
+/**
+ * Color attributes
+ */
+type CommonColorAttributes = 'color';
+declare const commonColorAttributes: CommonColorAttributes[];
+type ShapeColorAttributes = 'fill' | 'stroke';
+declare const shapeColorAttributes: ShapeColorAttributes[];
+type SpecialColorAttributes = 'stop-color' | 'flood-color';
+declare const specialColorAttributes: SpecialColorAttributes[];
+type ColorAttributes = CommonColorAttributes | ShapeColorAttributes | SpecialColorAttributes;
+/**
+ * Default values
+ */
+declare const defaultBlackColor: Color;
+declare const defaultColorValues: Record<ColorAttributes, Color>;
+/**
+ * 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!
+ */
+declare const allowDefaultColorValue: Partial<Record<ColorAttributes, string | true>>;
+
+export { type ColorAttributes, type CommonColorAttributes, type ShapeColorAttributes, type SpecialColorAttributes, allowDefaultColorValue, commonColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes, specialColorAttributes };

package/lib/colors/attribs.d.ts

@@ -24,4 +24,4 @@ declare const defaultColorValues: Record<ColorAttributes, Color>;
  */
 declare const allowDefaultColorValue: Partial<Record<ColorAttributes, string | true>>;
 
-export { ColorAttributes, CommonColorAttributes, ShapeColorAttributes, SpecialColorAttributes, allowDefaultColorValue, commonColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes, specialColorAttributes };
+export { type ColorAttributes, type CommonColorAttributes, type ShapeColorAttributes, type SpecialColorAttributes, allowDefaultColorValue, commonColorAttributes, defaultBlackColor, defaultColorValues, shapeColorAttributes, specialColorAttributes };

package/lib/colors/detect.cjs

@@ -29,7 +29,7 @@ function detectIconSetPalette(iconSet) {
         return;
       }
       let iconPalette;
-      colors_parse.parseColorsSync(svg, {
+      colors_parse.parseColors(svg, {
         callback: (attr, colorStr, color) => {
           if (!color) {
             iconPalette = null;
@@ -60,7 +60,7 @@ function detectIconSetPalette(iconSet) {
     },
     ["icon"]
   );
-  return palette === void 0 ? null : palette;
+  return palette ?? null;
 }
 
 exports.detectIconSetPalette = detectIconSetPalette;

package/lib/colors/detect.d.cts

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

package/lib/colors/detect.d.mts

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

package/lib/colors/detect.mjs

@@ -1,4 +1,4 @@
-import { parseColorsSync, isEmptyColor } from './parse.mjs';
+import { parseColors, isEmptyColor } from './parse.mjs';
 import '@iconify/utils/lib/colors';
 import '../svg/data/tags.mjs';
 import '../svg/parse-style.mjs';
@@ -27,7 +27,7 @@ function detectIconSetPalette(iconSet) {
         return;
       }
       let iconPalette;
-      parseColorsSync(svg, {
+      parseColors(svg, {
         callback: (attr, colorStr, color) => {
           if (!color) {
             iconPalette = null;
@@ -58,7 +58,7 @@ function detectIconSetPalette(iconSet) {
     },
     ["icon"]
   );
-  return palette === void 0 ? null : palette;
+  return palette ?? null;
 }
 
 export { detectIconSetPalette };

package/lib/colors/parse.cjs

@@ -18,7 +18,7 @@ require('../svg/analyse/error.cjs');
 
 const propsToCheck = Object.keys(colors_attribs.defaultColorValues);
 const animatePropsToCheck = ["from", "to", "values"];
-function createContext(options, callback) {
+function parseColors(svg, options = {}) {
   const result = {
     colors: [],
     hasUnsetColor: false,
@@ -49,12 +49,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 = colors_attribs.allowDefaultColorValue[prop2];
       while (currentItem) {
-        const element = elements.get(
+        const element = elements2.get(
           currentItem.index
         );
         const color = element._colors?.[prop2];
@@ -79,81 +79,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 = colors.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 = colors.stringToColor(callbackResult);
-          addColorToItem(prop, newColor || callbackResult, item);
-          return done(callbackResult);
-        }
-        const newValue = colors.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 = colors.stringToColor(callbackResult);
+      addColorToItem(prop, newColor || callbackResult, item);
+      return callbackResult;
+    }
+    const newValue = colors.colorToString(callbackResult);
+    addColorToItem(prop, callbackResult, item);
+    return newValue;
   }
-  function parseStyleItem(item, done) {
+  svg_parseStyle.parseSVGStyle(svg, (item) => {
     const prop = item.prop;
     const value = item.value;
-    if (propsToCheck.indexOf(prop) === -1) {
-      return done(value);
+    if (!propsToCheck.includes(prop)) {
+      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 = svg_analyse.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 = svg_analyse.analyseSVGStructure(svg, options);
   const { elements, tree } = iconData;
   const cheerio = svg.$svg;
   const removedElements = /* @__PURE__ */ new Set();
@@ -178,15 +166,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) {
@@ -200,239 +188,108 @@ 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" && svg_data_tags.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" && svg_data_tags.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 (svg_data_tags.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 (svg_data_tags.animateTags.has(tagName)) {
+      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
+                // 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 (svg_data_tags.shapeTags.has(tagName)) {
-            requiredProps = colors_attribs.shapeColorAttributes;
-          }
-          colors_attribs.specialColorAttributes.forEach((attr) => {
-            if (svg_data_attributes.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 (svg_data_tags.shapeTags.has(tagName)) {
+        requiredProps = colors_attribs.shapeColorAttributes;
+      }
+      colors_attribs.specialColorAttributes.forEach((attr) => {
+        if (svg_data_attributes.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 === colors_attribs.defaultBlackColor) {
+            if (defaultColor) {
+              const defaultColorValue = typeof defaultColor === "function" ? defaultColor(
                 prop,
+                element,
                 item,
-                elements
+                iconData
+              ) : defaultColor;
+              findColor(defaultColorValue, true);
+              cheerio(element).attr(
+                prop,
+                colors.colorToString(defaultColorValue)
               );
-              if (color === colors_attribs.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,
-                    colors.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;
-    }
-    svg_parseStyle.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
-  );
-  svg_parseStyle.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;
@@ -441,4 +298,3 @@ function isEmptyColor(color) {
 
 exports.isEmptyColor = isEmptyColor;
 exports.parseColors = parseColors;
-exports.parseColorsSync = parseColorsSync;