@iconify/tools 2.2.6 → 3.0.0-beta.1

package/lib/colors/parse.mjs

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

package/lib/colors/validate.cjs

@@ -17,8 +17,7 @@ require('../svg/data/attributes.cjs');
 require('../svg/analyse.cjs');
 require('../svg/analyse/error.cjs');
 
-async function validateColors(svg, expectMonotone, options) {
-  const palette = await colors_parse.parseColors(svg, options);
+function checkPalette(palette, expectMonotone) {
   palette.colors.forEach((color) => {
     if (typeof color === "string") {
       throw new Error("Unexpected color: " + color);
@@ -50,7 +49,17 @@ async function validateColors(svg, expectMonotone, options) {
         }
     }
   });
+}
+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,5 +1,5 @@
 import { SVG } from '../svg/index.js';
-import { ParseColorsOptions, FindColorsResult } from './parse.js';
+import { ParseColorsOptions, FindColorsResult, ParseColorsSyncOptions } from './parse.js';
 import '@iconify/types';
 import '@iconify/utils/lib/customisations/defaults';
 import '@iconify/utils/lib/colors/types';
@@ -14,5 +14,13 @@ 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;
 
-export { validateColors };
+export { validateColors, validateColorsSync };

package/lib/colors/validate.mjs

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

package/lib/download/api/download.cjs

@@ -1,11 +1,10 @@
 'use strict';
 
-const fetch = require('node-fetch');
 const util = require('util');
 const stream = require('stream');
-const fs = require('fs');
+const promises = require('fs/promises');
 
-const streamPipeline = util.promisify(stream.pipeline);
+util.promisify(stream.pipeline);
 async function downloadFile(query, target) {
   const params = query.params ? query.params.toString() : "";
   const url = query.uri + (params ? "?" + params : "");
@@ -16,7 +15,8 @@ async function downloadFile(query, target) {
   if (!response.ok || !response.body) {
     throw new Error(`Error downloading ${url}: ${response.status}`);
   }
-  await streamPipeline(response.body, fs.createWriteStream(target));
+  const data = await response.arrayBuffer();
+  await promises.writeFile(target, Buffer.from(data));
 }
 
 exports.downloadFile = downloadFile;

package/lib/download/api/download.mjs

@@ -1,9 +1,8 @@
-import fetch from 'node-fetch';
 import { promisify } from 'util';
 import { pipeline } from 'stream';
-import { createWriteStream } from 'fs';
+import { writeFile } from 'fs/promises';
 
-const streamPipeline = promisify(pipeline);
+promisify(pipeline);
 async function downloadFile(query, target) {
   const params = query.params ? query.params.toString() : "";
   const url = query.uri + (params ? "?" + params : "");
@@ -14,7 +13,8 @@ async function downloadFile(query, target) {
   if (!response.ok || !response.body) {
     throw new Error(`Error downloading ${url}: ${response.status}`);
   }
-  await streamPipeline(response.body, createWriteStream(target));
+  const data = await response.arrayBuffer();
+  await writeFile(target, Buffer.from(data));
 }
 
 export { downloadFile };

package/lib/download/api/index.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-const fetch = require('node-fetch');
 const download_api_cache = require('./cache.cjs');
 require('fs');
 require('crypto');

package/lib/download/api/index.mjs

@@ -1,4 +1,3 @@
-import fetch from 'node-fetch';
 import { apiCacheKey, getAPICache, storeAPICache } from './cache.mjs';
 import 'fs';
 import 'crypto';

package/lib/download/git/index.cjs

@@ -23,11 +23,11 @@ require('@iconify/utils/lib/icon-set/convert-info');
 require('../../icon-set/props.cjs');
 require('@iconify/utils/lib/misc/objects');
 require('@iconify/utils/lib/colors');
-require('node-fetch');
 require('crypto');
 require('../api/download.cjs');
 require('util');
 require('stream');
+require('fs/promises');
 require('extract-zip');
 require('tar');
 

package/lib/download/git/index.mjs

@@ -21,11 +21,11 @@ import '@iconify/utils/lib/icon-set/convert-info';
 import '../../icon-set/props.mjs';
 import '@iconify/utils/lib/misc/objects';
 import '@iconify/utils/lib/colors';
-import 'node-fetch';
 import 'crypto';
 import '../api/download.mjs';
 import 'util';
 import 'stream';
+import 'fs/promises';
 import 'extract-zip';
 import 'tar';