@iconify/tools 4.0.0-dev.1 → 4.0.0

package/lib/svg/parse-style.mjs

@@ -2,161 +2,152 @@ import { parseInlineStyle } from '../css/parse.mjs';
 import { tokensToString } from '../css/parser/export.mjs';
 import { getTokens } from '../css/parser/tokens.mjs';
 import { tokensTree } from '../css/parser/tree.mjs';
-import { parseSVG, parseSVGSync } from './parse.mjs';
+import { parseSVG } from './parse.mjs';
 import '../css/parser/error.mjs';
 import '../css/parser/strings.mjs';
 import '../css/parser/text.mjs';
 
-function parseItem(item, callback, done) {
-  const tagName = item.tagName;
-  const $element = item.$element;
-  function parseStyleItem(done2) {
-    const content = $element.text();
-    if (typeof content !== "string") {
-      $element.remove();
-      return done2();
-    }
-    const tokens = getTokens(content);
-    if (!(tokens instanceof Array)) {
-      throw new Error("Error parsing style");
-    }
-    let changed2 = false;
-    const selectorStart = [];
-    let newTokens = [];
-    const parsedTokens = () => {
-      if (changed2) {
-        const tree = tokensTree(
-          newTokens.filter((token) => token !== null)
-        );
-        if (!tree.length) {
-          $element.remove();
-        } else {
-          const newContent = tokensToString(tree);
-          item.$element.text("\n" + newContent);
-        }
+function assertNotOldCode(value) {
+  if (value instanceof Promise) {
+    throw new Error("parseSVGStyle does not support async callbacks");
+  }
+}
+function parseSVGStyle(svg, callback) {
+  parseSVG(svg, (item) => {
+    const tagName = item.tagName;
+    const $element = item.$element;
+    function parseStyleItem() {
+      const content = $element.text();
+      if (typeof content !== "string") {
+        $element.remove();
+        return;
       }
-      done2();
-    };
-    const nextToken = () => {
-      const token = tokens.shift();
-      if (token === void 0) {
-        return parsedTokens();
+      const tokens = getTokens(content);
+      if (!(tokens instanceof Array)) {
+        throw new Error("Error parsing style");
       }
-      switch (token.type) {
-        case "selector":
-          selectorStart.push(newTokens.length);
-          newTokens.push(token);
-          return nextToken();
-        case "close":
-          selectorStart.pop();
-          newTokens.push(token);
-          return nextToken();
-        case "at-rule": {
-          selectorStart.push(newTokens.length);
-          const prop = token.rule;
-          const value = token.value;
-          const isAnimation = prop === "keyframes" || prop.slice(0, 1) === "-" && prop.split("-").pop() === "keyframes";
-          const childTokens = [];
-          const animationRules = /* @__PURE__ */ Object.create(null);
-          let depth = 1;
-          let index = 0;
-          let isFrom = false;
-          while (depth > 0) {
-            const childToken = tokens[index];
-            index++;
-            if (!childToken) {
-              throw new Error("Something went wrong parsing CSS");
-            }
-            childTokens.push(childToken);
-            switch (childToken.type) {
-              case "close": {
-                depth--;
-                isFrom = false;
-                break;
+      let changed2 = false;
+      const selectorStart = [];
+      let newTokens = [];
+      while (tokens.length) {
+        const token = tokens.shift();
+        if (!token) {
+          break;
+        }
+        switch (token.type) {
+          case "selector":
+            selectorStart.push(newTokens.length);
+            newTokens.push(token);
+            break;
+          case "close":
+            selectorStart.pop();
+            newTokens.push(token);
+            break;
+          case "at-rule": {
+            selectorStart.push(newTokens.length);
+            const prop = token.rule;
+            const value = token.value;
+            const isAnimation = prop === "keyframes" || prop.slice(0, 1) === "-" && prop.split("-").pop() === "keyframes";
+            const childTokens = [];
+            const animationRules = /* @__PURE__ */ Object.create(null);
+            let depth = 1;
+            let index = 0;
+            let isFrom = false;
+            while (depth > 0) {
+              const childToken = tokens[index];
+              index++;
+              if (!childToken) {
+                throw new Error(
+                  "Something went wrong parsing CSS"
+                );
               }
-              case "selector": {
-                depth++;
-                if (isAnimation) {
-                  const rule = childToken.code;
-                  if (rule === "from" || rule === "0%") {
-                    isFrom = true;
+              childTokens.push(childToken);
+              switch (childToken.type) {
+                case "close": {
+                  depth--;
+                  isFrom = false;
+                  break;
+                }
+                case "selector": {
+                  depth++;
+                  if (isAnimation) {
+                    const rule = childToken.code;
+                    if (rule === "from" || rule === "0%") {
+                      isFrom = true;
+                    }
                   }
+                  break;
                 }
-                break;
-              }
-              case "at-rule": {
-                depth++;
-                if (isAnimation) {
-                  throw new Error(
-                    "Nested at-rule in keyframes ???"
-                  );
+                case "at-rule": {
+                  depth++;
+                  if (isAnimation) {
+                    throw new Error(
+                      "Nested at-rule in keyframes ???"
+                    );
+                  }
+                  break;
                 }
-                break;
-              }
-              case "rule": {
-                if (isAnimation && isFrom) {
-                  animationRules[childToken.prop] = childToken.value;
+                case "rule": {
+                  if (isAnimation && isFrom) {
+                    animationRules[childToken.prop] = childToken.value;
+                  }
+                  break;
                 }
-                break;
               }
             }
-          }
-          const skipCount = childTokens.length;
-          callback(
-            isAnimation ? {
-              type: "keyframes",
-              prop,
-              value,
-              token,
-              childTokens,
-              from: animationRules,
-              prevTokens: newTokens,
-              nextTokens: tokens.slice(0)
-            } : {
-              type: "at-rule",
-              prop,
-              value,
-              token,
-              childTokens,
-              prevTokens: newTokens,
-              nextTokens: tokens.slice(0)
-            },
-            (result) => {
-              if (result !== void 0) {
-                if (isAnimation) {
-                  if (result !== value) {
-                    changed2 = true;
-                    token.value = result;
-                  }
-                  newTokens.push(token);
-                  for (let i = 0; i < skipCount; i++) {
-                    tokens.shift();
-                  }
-                  newTokens = newTokens.concat(childTokens);
-                } else {
-                  if (result !== value) {
-                    throw new Error(
-                      "Changing value for at-rule is not supported"
-                    );
-                  }
-                  newTokens.push(token);
+            const skipCount = childTokens.length;
+            const result = callback(
+              isAnimation ? {
+                type: "keyframes",
+                prop,
+                value,
+                token,
+                childTokens,
+                from: animationRules,
+                prevTokens: newTokens,
+                nextTokens: tokens.slice(0)
+              } : {
+                type: "at-rule",
+                prop,
+                value,
+                token,
+                childTokens,
+                prevTokens: newTokens,
+                nextTokens: tokens.slice(0)
+              }
+            );
+            if (result !== void 0) {
+              assertNotOldCode(result);
+              if (isAnimation) {
+                if (result !== value) {
+                  changed2 = true;
+                  token.value = result;
                 }
-              } else {
-                changed2 = true;
+                newTokens.push(token);
                 for (let i = 0; i < skipCount; i++) {
                   tokens.shift();
                 }
+                newTokens = newTokens.concat(childTokens);
+              } else {
+                if (result !== value) {
+                  throw new Error(
+                    "Changing value for at-rule is not supported"
+                  );
+                }
+                newTokens.push(token);
+              }
+            } else {
+              changed2 = true;
+              for (let i = 0; i < skipCount; i++) {
+                tokens.shift();
               }
-              nextToken();
             }
-          );
-          return;
-        }
-        case "rule": {
-          const value = token.value;
-          const selectorTokens = selectorStart.map((index) => newTokens[index]).filter((item2) => item2 !== null);
-          callback(
-            {
+            break;
+          }
+          case "rule": {
+            const value = token.value;
+            const selectorTokens = selectorStart.map((index) => newTokens[index]).filter((item2) => item2 !== null);
+            const result = callback({
               type: "global",
               prop: token.prop,
               value,
@@ -177,121 +168,74 @@ function parseItem(item, callback, done) {
               ),
               prevTokens: newTokens,
               nextTokens: tokens.slice(0)
-            },
-            (result) => {
-              if (result !== void 0) {
-                if (result !== value) {
-                  changed2 = true;
-                  token.value = result;
-                }
-                newTokens.push(token);
-              } else {
+            });
+            if (result !== void 0) {
+              assertNotOldCode(result);
+              if (result !== value) {
                 changed2 = true;
+                token.value = result;
               }
-              nextToken();
+              newTokens.push(token);
+            } else {
+              changed2 = true;
             }
-          );
-          return;
+            break;
+          }
         }
       }
-    };
-    nextToken();
-  }
-  if (tagName === "style") {
-    return parseStyleItem(done);
-  }
-  const attribs = item.element.attribs;
-  if (attribs.style === void 0) {
-    return done();
-  }
-  const parsedStyle = parseInlineStyle(attribs.style);
-  if (parsedStyle === null) {
-    $element.removeAttr("style");
-    return done();
-  }
-  const propsQueue = Object.keys(parsedStyle);
-  let changed = false;
-  const parsedProps = () => {
-    if (changed) {
-      const newStyle = Object.keys(parsedStyle).map((key) => key + ":" + parsedStyle[key] + ";").join("");
-      if (!newStyle.length) {
-        $element.removeAttr("style");
-      } else {
-        $element.attr("style", newStyle);
+      if (changed2) {
+        const tree = tokensTree(
+          newTokens.filter((token) => token !== null)
+        );
+        if (!tree.length) {
+          $element.remove();
+        } else {
+          const newContent = tokensToString(tree);
+          item.$element.text("\n" + newContent);
+        }
       }
     }
-    done();
-  };
-  const nextProp = () => {
-    const prop = propsQueue.shift();
-    if (prop === void 0) {
-      return parsedProps();
+    if (tagName === "style") {
+      parseStyleItem();
+      return;
+    }
+    const attribs = item.element.attribs;
+    if (attribs.style === void 0) {
+      return;
+    }
+    const parsedStyle = parseInlineStyle(attribs.style);
+    if (parsedStyle === null) {
+      $element.removeAttr("style");
+      return;
     }
-    const value = parsedStyle[prop];
-    callback(
-      {
+    let changed = false;
+    for (const prop in parsedStyle) {
+      const value = parsedStyle[prop];
+      const result = callback({
         type: "inline",
         prop,
         value,
         item
-      },
-      (result) => {
-        if (result !== value) {
-          changed = true;
-          if (result === void 0) {
-            delete parsedStyle[prop];
-          } else {
-            parsedStyle[prop] = result;
-          }
+      });
+      assertNotOldCode(result);
+      if (result !== value) {
+        changed = true;
+        if (result === void 0) {
+          delete parsedStyle[prop];
+        } else {
+          parsedStyle[prop] = result;
         }
-        nextProp();
-      }
-    );
-  };
-  nextProp();
-}
-async function parseSVGStyle(svg, callback) {
-  return parseSVG(svg, (item) => {
-    return new Promise((fulfill, reject) => {
-      try {
-        parseItem(
-          item,
-          (styleItem, done) => {
-            try {
-              const result = callback(styleItem);
-              if (result instanceof Promise) {
-                result.then(done).catch(reject);
-              } else {
-                done(result);
-              }
-            } catch (err) {
-              reject(err);
-            }
-          },
-          fulfill
-        );
-      } catch (err) {
-        reject(err);
       }
-    });
-  });
-}
-function parseSVGStyleSync(svg, callback) {
-  let isSync = true;
-  parseSVGSync(svg, (item) => {
-    parseItem(
-      item,
-      (styleItem, done) => {
-        done(callback(styleItem));
-      },
-      () => {
-        if (!isSync) {
-          throw new Error("parseSVGStyleSync callback was async");
-        }
+    }
+    if (changed) {
+      const newStyle = Object.keys(parsedStyle).map((key) => key + ":" + parsedStyle[key] + ";").join("");
+      if (!newStyle.length) {
+        $element.removeAttr("style");
+      } else {
+        $element.attr("style", newStyle);
       }
-    );
+    }
   });
-  isSync = false;
 }
 
-export { parseSVGStyle, parseSVGStyleSync };
+export { parseSVGStyle };

package/lib/svg/parse.cjs

@@ -1,11 +1,13 @@
 'use strict';
 
-function parse(svg, callback, done) {
-  function checkNode(element, parents, done2) {
+function parseSVG(svg, callback) {
+  const cheerio = svg.$svg;
+  const $root = svg.$svg(":root");
+  function checkNode(element, parents) {
     if (element.type !== "tag") {
-      return done2();
+      return;
     }
-    const $element = cheerio2(element);
+    const $element = cheerio(element);
     const tagName = element.tagName;
     const item = {
       tagName,
@@ -16,63 +18,29 @@ function parse(svg, callback, done) {
       testChildren: true,
       removeNode: false
     };
-    callback(item, () => {
-      const newParents = parents.slice(0);
-      newParents.unshift(item);
-      let queue = [];
-      if (tagName !== "style" && item.testChildren && !item.removeNode) {
-        const children = $element.children().toArray();
-        queue = children.slice(0);
-      }
-      const next = () => {
-        const queueItem = queue.shift();
-        if (!queueItem) {
-          if (item.removeNode) {
-            $element.remove();
-          }
-          return done2();
-        }
-        checkNode(queueItem, newParents, next);
-      };
-      next();
-    });
-  }
-  const cheerio2 = svg.$svg;
-  const $root = svg.$svg(":root");
-  checkNode($root.get(0), [], done);
-}
-function parseSVG(svg, callback) {
-  return new Promise((fulfill, reject) => {
-    parse(
-      svg,
-      (item, next) => {
-        const result = callback(item);
-        if (result instanceof Promise) {
-          result.then(next).catch(reject);
-        } else {
-          next();
-        }
-      },
-      fulfill
-    );
-  });
-}
-function parseSVGSync(svg, callback) {
-  let isSync = true;
-  parse(
-    svg,
-    (item, next) => {
-      callback(item);
-      next();
-    },
-    () => {
-      if (!isSync) {
-        throw new Error("parseSVGSync callback was async");
+    const callbackResult = callback(item);
+    if (callbackResult instanceof Promise) {
+      throw new Error("parseSVG does not support async callbacks");
+    }
+    const newParents = parents.slice(0);
+    newParents.unshift(item);
+    let queue = [];
+    if (tagName !== "style" && item.testChildren && !item.removeNode) {
+      const children = $element.children().toArray();
+      queue = children.slice(0);
+    }
+    while (queue.length) {
+      const queueItem = queue.shift();
+      if (!queueItem || item.removeNode) {
+        break;
       }
+      checkNode(queueItem, newParents);
+    }
+    if (item.removeNode) {
+      $element.remove();
     }
-  );
-  isSync = false;
+  }
+  checkNode($root.get(0), []);
 }
 
 exports.parseSVG = parseSVG;
-exports.parseSVGSync = parseSVGSync;

package/lib/svg/parse.d.cts

@@ -0,0 +1,30 @@
+import { CheerioElement, WrappedCheerioElement } from '../misc/cheerio.cjs';
+import { SVG } from './index.cjs';
+import 'cheerio';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations/defaults';
+
+/**
+ * Item in callback
+ */
+interface ParseSVGCallbackItem {
+    tagName: string;
+    element: CheerioElement;
+    $element: WrappedCheerioElement;
+    svg: SVG;
+    parents: ParseSVGCallbackItem[];
+    testChildren: boolean;
+    removeNode: boolean;
+}
+/**
+ * Callback function
+ */
+type ParseSVGCallback = (item: ParseSVGCallbackItem) => void;
+/**
+ * Parse SVG
+ *
+ * This function finds all elements in SVG and calls callback for each element.
+ */
+declare function parseSVG(svg: SVG, callback: ParseSVGCallback): void;
+
+export { type ParseSVGCallback, type ParseSVGCallbackItem, parseSVG };

package/lib/svg/parse.d.mts

@@ -0,0 +1,30 @@
+import { CheerioElement, WrappedCheerioElement } from '../misc/cheerio.mjs';
+import { SVG } from './index.mjs';
+import 'cheerio';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations/defaults';
+
+/**
+ * Item in callback
+ */
+interface ParseSVGCallbackItem {
+    tagName: string;
+    element: CheerioElement;
+    $element: WrappedCheerioElement;
+    svg: SVG;
+    parents: ParseSVGCallbackItem[];
+    testChildren: boolean;
+    removeNode: boolean;
+}
+/**
+ * Callback function
+ */
+type ParseSVGCallback = (item: ParseSVGCallbackItem) => void;
+/**
+ * Parse SVG
+ *
+ * This function finds all elements in SVG and calls callback for each element.
+ */
+declare function parseSVG(svg: SVG, callback: ParseSVGCallback): void;
+
+export { type ParseSVGCallback, type ParseSVGCallbackItem, parseSVG };

package/lib/svg/parse.d.ts

@@ -19,19 +19,12 @@ interface ParseSVGCallbackItem {
 /**
  * Callback function
  */
-type Callback<T> = (item: ParseSVGCallbackItem) => T;
-type ParseSVGCallback = Callback<void | Promise<void>>;
-type ParseSVGCallbackSync = Callback<void>;
+type ParseSVGCallback = (item: ParseSVGCallbackItem) => void;
 /**
  * Parse SVG
  *
  * This function finds all elements in SVG and calls callback for each element.
- * Callback can be asynchronous.
  */
-declare function parseSVG(svg: SVG, callback: ParseSVGCallback): Promise<void>;
-/**
- * Sync version
- */
-declare function parseSVGSync(svg: SVG, callback: ParseSVGCallbackSync): void;
+declare function parseSVG(svg: SVG, callback: ParseSVGCallback): void;
 
-export { ParseSVGCallback, ParseSVGCallbackItem, ParseSVGCallbackSync, parseSVG, parseSVGSync };
+export { type ParseSVGCallback, type ParseSVGCallbackItem, parseSVG };