@iconify/tools 2.2.5 → 3.0.0-beta.1

package/lib/svg/parse-style.cjs

@@ -9,41 +9,58 @@ require('../css/parser/error.cjs');
 require('../css/parser/strings.cjs');
 require('../css/parser/text.cjs');
 
-async function parseSVGStyle(svg, callback) {
-  return svg_parse.parseSVG(svg, async (item) => {
-    const tagName = item.tagName;
-    const $element = item.$element;
-    if (tagName === "style") {
-      const content = $element.text();
-      if (typeof content !== "string") {
-        $element.remove();
-        return;
+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 = css_parser_tokens.getTokens(content);
+    if (!(tokens instanceof Array)) {
+      throw new Error("Error parsing style");
+    }
+    let changed2 = false;
+    const selectorStart = [];
+    const newTokens = [];
+    const parsedTokens = () => {
+      if (changed2) {
+        const tree = css_parser_tree.tokensTree(
+          newTokens.filter((token) => token !== null)
+        );
+        if (!tree.length) {
+          $element.remove();
+        } else {
+          const newContent = css_parser_export.tokensToString(tree);
+          item.$element.text(newContent);
+        }
       }
-      const tokens = css_parser_tokens.getTokens(content);
-      if (!(tokens instanceof Array)) {
-        throw new Error("Error parsing style");
+      done2();
+    };
+    const nextToken = () => {
+      const token = tokens.shift();
+      if (token === void 0) {
+        return parsedTokens();
       }
-      let changed2 = false;
-      const selectorStart = [];
-      const newTokens = [];
-      for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
-        switch (token.type) {
-          case "selector":
-          case "at-rule":
-            selectorStart.push(newTokens.length);
-            break;
-          case "close":
-            selectorStart.pop();
-            break;
-        }
-        if (token.type !== "rule") {
-          newTokens.push(token);
-          continue;
-        }
-        const value = token.value;
-        const selectorTokens = selectorStart.map((index) => newTokens[index]).filter((item2) => item2 !== null);
-        let result = callback({
+      switch (token.type) {
+        case "selector":
+        case "at-rule":
+          selectorStart.push(newTokens.length);
+          break;
+        case "close":
+          selectorStart.pop();
+          break;
+      }
+      if (token.type !== "rule") {
+        newTokens.push(token);
+        return nextToken();
+      }
+      const value = token.value;
+      const selectorTokens = selectorStart.map((index) => newTokens[index]).filter((item2) => item2 !== null);
+      callback(
+        {
           type: "global",
           prop: token.prop,
           value,
@@ -61,77 +78,120 @@ async function parseSVGStyle(svg, callback) {
             []
           ),
           prevTokens: newTokens,
-          nextTokens: tokens.slice(i + 1)
-        });
-        if (result instanceof Promise) {
-          result = await result;
-        }
-        if (result !== void 0) {
-          if (result !== value) {
+          nextTokens: tokens.slice(0)
+        },
+        (result) => {
+          if (result !== void 0) {
+            if (result !== value) {
+              changed2 = true;
+              token.value = result;
+            }
+            newTokens.push(token);
+          } else {
             changed2 = true;
-            token.value = result;
           }
-          newTokens.push(token);
-        } else {
-          changed2 = true;
+          nextToken();
         }
-      }
-      if (!changed2) {
-        return;
-      }
-      const tree = css_parser_tree.tokensTree(
-        newTokens.filter((token) => token !== null)
       );
-      if (!tree.length) {
-        $element.remove();
-        return;
+    };
+    nextToken();
+  }
+  if (tagName === "style") {
+    return parseStyleItem(done);
+  }
+  const attribs = item.element.attribs;
+  if (attribs.style === void 0) {
+    return done();
+  }
+  const parsedStyle = css_parse.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);
       }
-      const newContent = css_parser_export.tokensToString(tree);
-      item.$element.text(newContent);
-      return;
     }
-    const attribs = item.element.attribs;
-    if (attribs.style === void 0) {
-      return;
+    done();
+  };
+  const nextProp = () => {
+    const prop = propsQueue.shift();
+    if (prop === void 0) {
+      return parsedProps();
     }
-    const parsedStyle = css_parse.parseInlineStyle(attribs.style);
-    if (parsedStyle === null) {
-      $element.removeAttr("style");
-      return;
-    }
-    const props = Object.keys(parsedStyle);
-    let changed = false;
-    for (let i = 0; i < props.length; i++) {
-      const prop = props[i];
-      const value = parsedStyle[prop];
-      let result = callback({
+    const value = parsedStyle[prop];
+    callback(
+      {
         type: "inline",
         prop,
         value,
         item
-      });
-      if (result instanceof Promise) {
-        result = await result;
+      },
+      (result) => {
+        if (result !== value) {
+          changed = true;
+          if (result === void 0) {
+            delete parsedStyle[prop];
+          } else {
+            parsedStyle[prop] = result;
+          }
+        }
+        nextProp();
       }
-      if (result !== value) {
-        changed = true;
-        if (result === void 0) {
-          delete parsedStyle[prop];
-        } else {
-          parsedStyle[prop] = result;
+    );
+  };
+  nextProp();
+}
+async function parseSVGStyle(svg, callback) {
+  return svg_parse.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;
+  svg_parse.parseSVGSync(svg, (item) => {
+    parseItem(
+      item,
+      (styleItem, done) => {
+        done(callback(styleItem));
+      },
+      () => {
+        if (!isSync) {
+          throw new Error("parseSVGStyleSync callback was async");
         }
       }
-    }
-    if (!changed) {
-      return;
-    }
-    const newStyle = Object.keys(parsedStyle).map((key) => key + ":" + parsedStyle[key] + ";").join("");
-    if (!newStyle.length) {
-      $element.removeAttr("style");
-    } else {
-      $element.attr("style", newStyle);
-    }
+    );
   });
+  isSync = false;
 }
 
 exports.parseSVGStyle = parseSVGStyle;
+exports.parseSVGStyleSync = parseSVGStyleSync;

package/lib/svg/parse-style.d.ts

@@ -33,6 +33,7 @@ type ParseSVGStyleCallbackResult = string | undefined;
  * Callback function
  */
 type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult | Promise<ParseSVGStyleCallbackResult>;
+type ParseSVGStyleCallbackSync = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult;
 /**
  * Parse styles in SVG
  *
@@ -41,5 +42,9 @@ type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleC
  * Callback can be asynchronous.
  */
 declare function parseSVGStyle(svg: SVG, callback: ParseSVGStyleCallback): Promise<void>;
+/**
+ * Synchronous version
+ */
+declare function parseSVGStyleSync(svg: SVG, callback: ParseSVGStyleCallbackSync): void;
 
-export { ParseSVGStyleCallback, ParseSVGStyleCallbackItem, ParseSVGStyleCallbackResult, parseSVGStyle };
+export { ParseSVGStyleCallback, ParseSVGStyleCallbackItem, ParseSVGStyleCallbackResult, ParseSVGStyleCallbackSync, parseSVGStyle, parseSVGStyleSync };

package/lib/svg/parse-style.mjs

@@ -2,46 +2,63 @@ 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 } from './parse.mjs';
+import { parseSVG, parseSVGSync } from './parse.mjs';
 import '../css/parser/error.mjs';
 import '../css/parser/strings.mjs';
 import '../css/parser/text.mjs';
 
-async function parseSVGStyle(svg, callback) {
-  return parseSVG(svg, async (item) => {
-    const tagName = item.tagName;
-    const $element = item.$element;
-    if (tagName === "style") {
-      const content = $element.text();
-      if (typeof content !== "string") {
-        $element.remove();
-        return;
+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 = [];
+    const 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(newContent);
+        }
       }
-      const tokens = getTokens(content);
-      if (!(tokens instanceof Array)) {
-        throw new Error("Error parsing style");
+      done2();
+    };
+    const nextToken = () => {
+      const token = tokens.shift();
+      if (token === void 0) {
+        return parsedTokens();
       }
-      let changed2 = false;
-      const selectorStart = [];
-      const newTokens = [];
-      for (let i = 0; i < tokens.length; i++) {
-        const token = tokens[i];
-        switch (token.type) {
-          case "selector":
-          case "at-rule":
-            selectorStart.push(newTokens.length);
-            break;
-          case "close":
-            selectorStart.pop();
-            break;
-        }
-        if (token.type !== "rule") {
-          newTokens.push(token);
-          continue;
-        }
-        const value = token.value;
-        const selectorTokens = selectorStart.map((index) => newTokens[index]).filter((item2) => item2 !== null);
-        let result = callback({
+      switch (token.type) {
+        case "selector":
+        case "at-rule":
+          selectorStart.push(newTokens.length);
+          break;
+        case "close":
+          selectorStart.pop();
+          break;
+      }
+      if (token.type !== "rule") {
+        newTokens.push(token);
+        return nextToken();
+      }
+      const value = token.value;
+      const selectorTokens = selectorStart.map((index) => newTokens[index]).filter((item2) => item2 !== null);
+      callback(
+        {
           type: "global",
           prop: token.prop,
           value,
@@ -59,77 +76,119 @@ async function parseSVGStyle(svg, callback) {
             []
           ),
           prevTokens: newTokens,
-          nextTokens: tokens.slice(i + 1)
-        });
-        if (result instanceof Promise) {
-          result = await result;
-        }
-        if (result !== void 0) {
-          if (result !== value) {
+          nextTokens: tokens.slice(0)
+        },
+        (result) => {
+          if (result !== void 0) {
+            if (result !== value) {
+              changed2 = true;
+              token.value = result;
+            }
+            newTokens.push(token);
+          } else {
             changed2 = true;
-            token.value = result;
           }
-          newTokens.push(token);
-        } else {
-          changed2 = true;
+          nextToken();
         }
-      }
-      if (!changed2) {
-        return;
-      }
-      const tree = tokensTree(
-        newTokens.filter((token) => token !== null)
       );
-      if (!tree.length) {
-        $element.remove();
-        return;
+    };
+    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);
       }
-      const newContent = tokensToString(tree);
-      item.$element.text(newContent);
-      return;
     }
-    const attribs = item.element.attribs;
-    if (attribs.style === void 0) {
-      return;
+    done();
+  };
+  const nextProp = () => {
+    const prop = propsQueue.shift();
+    if (prop === void 0) {
+      return parsedProps();
     }
-    const parsedStyle = parseInlineStyle(attribs.style);
-    if (parsedStyle === null) {
-      $element.removeAttr("style");
-      return;
-    }
-    const props = Object.keys(parsedStyle);
-    let changed = false;
-    for (let i = 0; i < props.length; i++) {
-      const prop = props[i];
-      const value = parsedStyle[prop];
-      let result = callback({
+    const value = parsedStyle[prop];
+    callback(
+      {
         type: "inline",
         prop,
         value,
         item
-      });
-      if (result instanceof Promise) {
-        result = await result;
+      },
+      (result) => {
+        if (result !== value) {
+          changed = true;
+          if (result === void 0) {
+            delete parsedStyle[prop];
+          } else {
+            parsedStyle[prop] = result;
+          }
+        }
+        nextProp();
       }
-      if (result !== value) {
-        changed = true;
-        if (result === void 0) {
-          delete parsedStyle[prop];
-        } else {
-          parsedStyle[prop] = result;
+    );
+  };
+  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) {
-      return;
-    }
-    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 };
+export { parseSVGStyle, parseSVGStyleSync };

package/lib/svg/parse.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-async function parseSVG(svg, callback) {
-  async function checkNode(element, parents) {
+function parse(svg, callback, done) {
+  function checkNode(element, parents, done2) {
     if (element.type !== "tag") {
-      return;
+      return done2();
     }
     const $element = cheerio(element);
     const tagName = element.tagName;
@@ -16,25 +16,63 @@ async function parseSVG(svg, callback) {
       testChildren: true,
       removeNode: false
     };
-    const result = callback(item);
-    if (result instanceof Promise) {
-      await result;
-    }
-    const newParents = parents.slice(0);
-    newParents.unshift(item);
-    if (tagName !== "style" && item.testChildren && !item.removeNode) {
-      const children = $element.children().toArray();
-      for (let i = 0; i < children.length; i++) {
-        await checkNode(children[i], newParents);
+    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);
       }
-    }
-    if (item.removeNode) {
-      $element.remove();
-    }
+      const next = () => {
+        const queueItem = queue.shift();
+        if (!queueItem) {
+          if (item.removeNode) {
+            $element.remove();
+          }
+          return done2();
+        }
+        checkNode(queueItem, newParents, next);
+      };
+      next();
+    });
   }
   const cheerio = svg.$svg;
   const $root = svg.$svg(":root");
-  await checkNode($root.get(0), []);
+  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");
+      }
+    }
+  );
+  isSync = false;
 }
 
 exports.parseSVG = parseSVG;
+exports.parseSVGSync = parseSVGSync;

package/lib/svg/parse.d.ts

@@ -18,7 +18,9 @@ interface ParseSVGCallbackItem {
 /**
  * Callback function
  */
-type ParseSVGCallback = (item: ParseSVGCallbackItem) => void | Promise<void>;
+type Callback<T> = (item: ParseSVGCallbackItem) => T;
+type ParseSVGCallback = Callback<void | Promise<void>>;
+type ParseSVGCallbackSync = Callback<void>;
 /**
  * Parse SVG
  *
@@ -26,5 +28,9 @@ type ParseSVGCallback = (item: ParseSVGCallbackItem) => void | Promise<void>;
  * Callback can be asynchronous.
  */
 declare function parseSVG(svg: SVG, callback: ParseSVGCallback): Promise<void>;
+/**
+ * Sync version
+ */
+declare function parseSVGSync(svg: SVG, callback: ParseSVGCallbackSync): void;
 
-export { ParseSVGCallback, ParseSVGCallbackItem, parseSVG };
+export { ParseSVGCallback, ParseSVGCallbackItem, ParseSVGCallbackSync, parseSVG, parseSVGSync };