@iconify/tools 4.0.0-dev.1 → 4.0.1

package/lib/colors/parse.d.cts

@@ -0,0 +1,60 @@
+import { Color } from '@iconify/utils/lib/colors/types';
+import { SVG } from '../svg/index.cjs';
+import { ColorAttributes } from './attribs.cjs';
+import { ElementsTreeItem, AnalyseSVGStructureResult, AnalyseSVGStructureOptions, ExtendedTagElement } from '../svg/analyse/types.cjs';
+import 'cheerio';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations/defaults';
+import '../misc/cheerio.cjs';
+
+/**
+ * Result
+ */
+interface FindColorsResult {
+    colors: (Color | string)[];
+    hasUnsetColor: boolean;
+    hasGlobalStyle: boolean;
+}
+/**
+ * Callback to call for each found color
+ *
+ * Callback should return:
+ * - new color value to change color
+ * - first parameter to keep old value
+ * - 'unset' to delete old value
+ * - 'remove' to remove shape or rule
+ */
+type ParseColorsCallbackResult = Color | string | 'remove' | 'unset';
+type ParseColorsCallback = (attr: ColorAttributes, colorString: string, parsedColor: Color | null, tagName?: string, item?: ExtendedTagElementWithColors) => ParseColorsCallbackResult;
+/**
+ * Callback for default color
+ */
+type ParseColorOptionsDefaultColorCallback = (prop: string, item: ExtendedTagElementWithColors, treeItem: ElementsTreeItem, iconData: AnalyseSVGStructureResult) => Color;
+/**
+ * Options
+ */
+interface ParseColorsOptions extends AnalyseSVGStructureOptions {
+    callback?: ParseColorsCallback;
+    defaultColor?: Color | string | ParseColorOptionsDefaultColorCallback;
+}
+/**
+ * Extend properties for element
+ */
+type ItemColors = Partial<Record<ColorAttributes, Color | string>>;
+interface ExtendedTagElementWithColors extends ExtendedTagElement {
+    _colors?: ItemColors;
+    _removed?: boolean;
+}
+/**
+ * Find colors in icon
+ *
+ * Clean up icon before running this function to convert style to attributes using
+ * cleanupInlineStyle() or cleanupSVG(), otherwise results might be inaccurate
+ */
+declare function parseColors(svg: SVG, options?: ParseColorsOptions): FindColorsResult;
+/**
+ * Check if color is empty, such as 'none' or 'transparent'
+ */
+declare function isEmptyColor(color: Color): boolean;
+
+export { type ExtendedTagElementWithColors, type FindColorsResult, type ParseColorOptionsDefaultColorCallback, type ParseColorsOptions, isEmptyColor, parseColors };

package/lib/colors/parse.d.mts

@@ -0,0 +1,60 @@
+import { Color } from '@iconify/utils/lib/colors/types';
+import { SVG } from '../svg/index.mjs';
+import { ColorAttributes } from './attribs.mjs';
+import { ElementsTreeItem, AnalyseSVGStructureResult, AnalyseSVGStructureOptions, ExtendedTagElement } from '../svg/analyse/types.mjs';
+import 'cheerio';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations/defaults';
+import '../misc/cheerio.mjs';
+
+/**
+ * Result
+ */
+interface FindColorsResult {
+    colors: (Color | string)[];
+    hasUnsetColor: boolean;
+    hasGlobalStyle: boolean;
+}
+/**
+ * Callback to call for each found color
+ *
+ * Callback should return:
+ * - new color value to change color
+ * - first parameter to keep old value
+ * - 'unset' to delete old value
+ * - 'remove' to remove shape or rule
+ */
+type ParseColorsCallbackResult = Color | string | 'remove' | 'unset';
+type ParseColorsCallback = (attr: ColorAttributes, colorString: string, parsedColor: Color | null, tagName?: string, item?: ExtendedTagElementWithColors) => ParseColorsCallbackResult;
+/**
+ * Callback for default color
+ */
+type ParseColorOptionsDefaultColorCallback = (prop: string, item: ExtendedTagElementWithColors, treeItem: ElementsTreeItem, iconData: AnalyseSVGStructureResult) => Color;
+/**
+ * Options
+ */
+interface ParseColorsOptions extends AnalyseSVGStructureOptions {
+    callback?: ParseColorsCallback;
+    defaultColor?: Color | string | ParseColorOptionsDefaultColorCallback;
+}
+/**
+ * Extend properties for element
+ */
+type ItemColors = Partial<Record<ColorAttributes, Color | string>>;
+interface ExtendedTagElementWithColors extends ExtendedTagElement {
+    _colors?: ItemColors;
+    _removed?: boolean;
+}
+/**
+ * Find colors in icon
+ *
+ * Clean up icon before running this function to convert style to attributes using
+ * cleanupInlineStyle() or cleanupSVG(), otherwise results might be inaccurate
+ */
+declare function parseColors(svg: SVG, options?: ParseColorsOptions): FindColorsResult;
+/**
+ * Check if color is empty, such as 'none' or 'transparent'
+ */
+declare function isEmptyColor(color: Color): boolean;
+
+export { type ExtendedTagElementWithColors, type FindColorsResult, type ParseColorOptionsDefaultColorCallback, type ParseColorsOptions, isEmptyColor, parseColors };

package/lib/colors/parse.d.ts

@@ -1,10 +1,11 @@
 import { Color } from '@iconify/utils/lib/colors/types';
 import { SVG } from '../svg/index.js';
 import { ColorAttributes } from './attribs.js';
-import { ElementsTreeItem, AnalyseSVGStructureResult, ExtendedTagElement, AnalyseSVGStructureOptions } from '../svg/analyse/types.js';
+import { ElementsTreeItem, AnalyseSVGStructureResult, AnalyseSVGStructureOptions, ExtendedTagElement } from '../svg/analyse/types.js';
 import 'cheerio';
 import '@iconify/types';
 import '@iconify/utils/lib/customisations/defaults';
+import '../misc/cheerio.js';
 
 /**
  * Result
@@ -24,7 +25,7 @@ interface FindColorsResult {
  * - 'remove' to remove shape or rule
  */
 type ParseColorsCallbackResult = Color | string | 'remove' | 'unset';
-type ParseColorsCallback<T> = (attr: ColorAttributes, colorString: string, parsedColor: Color | null, tagName?: string, item?: ExtendedTagElementWithColors) => T;
+type ParseColorsCallback = (attr: ColorAttributes, colorString: string, parsedColor: Color | null, tagName?: string, item?: ExtendedTagElementWithColors) => ParseColorsCallbackResult;
 /**
  * Callback for default color
  */
@@ -32,12 +33,10 @@ type ParseColorOptionsDefaultColorCallback = (prop: string, item: ExtendedTagEle
 /**
  * Options
  */
-interface Options<T> extends AnalyseSVGStructureOptions {
-    callback?: T;
+interface ParseColorsOptions extends AnalyseSVGStructureOptions {
+    callback?: ParseColorsCallback;
     defaultColor?: Color | string | ParseColorOptionsDefaultColorCallback;
 }
-type ParseColorsOptions = Options<ParseColorsCallback<ParseColorsCallbackResult | Promise<ParseColorsCallbackResult>>>;
-type ParseColorsSyncOptions = Options<ParseColorsCallback<ParseColorsCallbackResult>>;
 /**
  * Extend properties for element
  */
@@ -52,17 +51,10 @@ interface ExtendedTagElementWithColors extends ExtendedTagElement {
  * Clean up icon before running this function to convert style to attributes using
  * cleanupInlineStyle() or cleanupSVG(), otherwise results might be inaccurate
  */
-declare function parseColors(svg: SVG, options?: ParseColorsOptions): Promise<FindColorsResult>;
-/**
- * Find colors in icon, synchronous version
- *
- * Clean up icon before running this function to convert style to attributes using
- * cleanupInlineStyle() or cleanupSVG(), otherwise results might be inaccurate
- */
-declare function parseColorsSync(svg: SVG, options?: ParseColorsSyncOptions): FindColorsResult;
+declare function parseColors(svg: SVG, options?: ParseColorsOptions): FindColorsResult;
 /**
  * Check if color is empty, such as 'none' or 'transparent'
  */
 declare function isEmptyColor(color: Color): boolean;
 
-export { ExtendedTagElementWithColors, FindColorsResult, ParseColorOptionsDefaultColorCallback, ParseColorsOptions, ParseColorsSyncOptions, isEmptyColor, parseColors, parseColorsSync };
+export { type ExtendedTagElementWithColors, type FindColorsResult, type ParseColorOptionsDefaultColorCallback, type ParseColorsOptions, isEmptyColor, parseColors };

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);
+    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 = 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.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 (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 };