@iconify/tools 4.0.0-dev.1 → 4.0.1

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

@@ -0,0 +1,58 @@
+import { SVG } from './index.cjs';
+import { CSSRuleToken, CSSToken, CSSAtRuleToken } from '../css/parser/types.cjs';
+import { ParseSVGCallbackItem } from './parse.cjs';
+import 'cheerio';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations/defaults';
+import '../misc/cheerio.cjs';
+
+/**
+ * Item in callback
+ */
+interface ParseSVGStyleCallbackItemCommon {
+    prop: string;
+    value: string;
+}
+interface ParseSVGStyleCallbackItemInline extends ParseSVGStyleCallbackItemCommon {
+    type: 'inline';
+    item: ParseSVGCallbackItem;
+}
+interface ParseSVGStyleCallbackItemGlobal extends ParseSVGStyleCallbackItemCommon {
+    type: 'global';
+    token: CSSRuleToken;
+    selectors: string[];
+    selectorTokens: CSSToken[];
+    prevTokens: (CSSToken | null)[];
+    nextTokens: CSSToken[];
+}
+interface ParseSVGStyleCallbackItemGlobalAtRule extends ParseSVGStyleCallbackItemCommon {
+    token: CSSAtRuleToken;
+    childTokens: CSSToken[];
+    prevTokens: (CSSToken | null)[];
+    nextTokens: CSSToken[];
+}
+interface ParseSVGStyleCallbackItemGlobalGenericAtRule extends ParseSVGStyleCallbackItemGlobalAtRule {
+    type: 'at-rule';
+}
+interface ParseSVGStyleCallbackItemGlobalKeyframesAtRule extends ParseSVGStyleCallbackItemGlobalAtRule {
+    type: 'keyframes';
+    from: Record<string, string>;
+}
+type ParseSVGStyleCallbackItem = ParseSVGStyleCallbackItemInline | ParseSVGStyleCallbackItemGlobal | ParseSVGStyleCallbackItemGlobalGenericAtRule | ParseSVGStyleCallbackItemGlobalKeyframesAtRule;
+/**
+ * Result: undefined to remove item, string to change/keep item
+ */
+type ParseSVGStyleCallbackResult = string | undefined;
+/**
+ * Callback function
+ */
+type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult;
+/**
+ * Parse styles in SVG
+ *
+ * This function finds CSS in SVG, parses it, calls callback for each rule.
+ * Callback should return new value (string) or undefined to remove rule.
+ */
+declare function parseSVGStyle(svg: SVG, callback: ParseSVGStyleCallback): void;
+
+export { type ParseSVGStyleCallback, type ParseSVGStyleCallbackItem, type ParseSVGStyleCallbackResult, parseSVGStyle };

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

@@ -0,0 +1,58 @@
+import { SVG } from './index.mjs';
+import { CSSRuleToken, CSSToken, CSSAtRuleToken } from '../css/parser/types.mjs';
+import { ParseSVGCallbackItem } from './parse.mjs';
+import 'cheerio';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations/defaults';
+import '../misc/cheerio.mjs';
+
+/**
+ * Item in callback
+ */
+interface ParseSVGStyleCallbackItemCommon {
+    prop: string;
+    value: string;
+}
+interface ParseSVGStyleCallbackItemInline extends ParseSVGStyleCallbackItemCommon {
+    type: 'inline';
+    item: ParseSVGCallbackItem;
+}
+interface ParseSVGStyleCallbackItemGlobal extends ParseSVGStyleCallbackItemCommon {
+    type: 'global';
+    token: CSSRuleToken;
+    selectors: string[];
+    selectorTokens: CSSToken[];
+    prevTokens: (CSSToken | null)[];
+    nextTokens: CSSToken[];
+}
+interface ParseSVGStyleCallbackItemGlobalAtRule extends ParseSVGStyleCallbackItemCommon {
+    token: CSSAtRuleToken;
+    childTokens: CSSToken[];
+    prevTokens: (CSSToken | null)[];
+    nextTokens: CSSToken[];
+}
+interface ParseSVGStyleCallbackItemGlobalGenericAtRule extends ParseSVGStyleCallbackItemGlobalAtRule {
+    type: 'at-rule';
+}
+interface ParseSVGStyleCallbackItemGlobalKeyframesAtRule extends ParseSVGStyleCallbackItemGlobalAtRule {
+    type: 'keyframes';
+    from: Record<string, string>;
+}
+type ParseSVGStyleCallbackItem = ParseSVGStyleCallbackItemInline | ParseSVGStyleCallbackItemGlobal | ParseSVGStyleCallbackItemGlobalGenericAtRule | ParseSVGStyleCallbackItemGlobalKeyframesAtRule;
+/**
+ * Result: undefined to remove item, string to change/keep item
+ */
+type ParseSVGStyleCallbackResult = string | undefined;
+/**
+ * Callback function
+ */
+type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult;
+/**
+ * Parse styles in SVG
+ *
+ * This function finds CSS in SVG, parses it, calls callback for each rule.
+ * Callback should return new value (string) or undefined to remove rule.
+ */
+declare function parseSVGStyle(svg: SVG, callback: ParseSVGStyleCallback): void;
+
+export { type ParseSVGStyleCallback, type ParseSVGStyleCallbackItem, type ParseSVGStyleCallbackResult, parseSVGStyle };

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

@@ -46,19 +46,13 @@ type ParseSVGStyleCallbackResult = string | undefined;
 /**
  * Callback function
  */
-type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult | Promise<ParseSVGStyleCallbackResult>;
-type ParseSVGStyleCallbackSync = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult;
+type ParseSVGStyleCallback = (item: ParseSVGStyleCallbackItem) => ParseSVGStyleCallbackResult;
 /**
  * Parse styles in SVG
  *
  * This function finds CSS in SVG, parses it, calls callback for each rule.
  * Callback should return new value (string) or undefined to remove rule.
- * Callback can be asynchronous.
  */
-declare function parseSVGStyle(svg: SVG, callback: ParseSVGStyleCallback): Promise<void>;
-/**
- * Synchronous version
- */
-declare function parseSVGStyleSync(svg: SVG, callback: ParseSVGStyleCallbackSync): void;
+declare function parseSVGStyle(svg: SVG, callback: ParseSVGStyleCallback): void;
 
-export { ParseSVGStyleCallback, ParseSVGStyleCallbackItem, ParseSVGStyleCallbackResult, ParseSVGStyleCallbackSync, parseSVGStyle, parseSVGStyleSync };
+export { type ParseSVGStyleCallback, type ParseSVGStyleCallbackItem, type ParseSVGStyleCallbackResult, parseSVGStyle };

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 };