@iconify/tools 4.0.0-dev.1 → 4.0.1

package/lib/svg/index.cjs

@@ -17,11 +17,21 @@ function _interopNamespaceCompat(e) {
 
 const cheerio__namespace = /*#__PURE__*/_interopNamespaceCompat(cheerio);
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class SVG {
   /**
    * Constructor
    */
   constructor(content) {
+    // Cheerio tree, initialized in load()
+    __publicField(this, "$svg");
+    // Dimensions, initialized in load()
+    __publicField(this, "viewBox");
     this.load(content);
   }
   /**
@@ -31,7 +41,7 @@ class SVG {
     if (customisations) {
       const data = utils.iconToSVG(this.getIcon(), customisations);
       let svgAttributes = ' xmlns="http://www.w3.org/2000/svg"';
-      if (data.body.indexOf("xlink:") !== -1) {
+      if (data.body.includes("xlink:")) {
         svgAttributes += ' xmlns:xlink="http://www.w3.org/1999/xlink"';
       }
       for (const key in data.attributes) {
@@ -62,6 +72,13 @@ class SVG {
   toMinifiedString(customisations) {
     return utils.trimSVG(this.toString(customisations));
   }
+  /**
+   * Get SVG as string with whitespaces
+   */
+  toPrettyString(customisations) {
+    const str = this.toMinifiedString(customisations);
+    return utils.prettifySVG(str) ?? str;
+  }
   /**
    * Get body
    */

package/lib/svg/index.d.cts

@@ -0,0 +1,52 @@
+import * as cheerio from 'cheerio';
+import { IconifyIcon } from '@iconify/types';
+export { IconifyIcon } from '@iconify/types';
+import { IconifyIconCustomisations } from '@iconify/utils/lib/customisations/defaults';
+export { IconifyIconCustomisations } from '@iconify/utils/lib/customisations/defaults';
+
+interface ViewBox {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+
+/**
+ * SVG class, used to manipulate icon content.
+ */
+declare class SVG {
+    $svg: cheerio.CheerioAPI;
+    viewBox: ViewBox;
+    /**
+     * Constructor
+     */
+    constructor(content: string);
+    /**
+     * Get SVG as string
+     */
+    toString(customisations?: IconifyIconCustomisations): string;
+    /**
+     * Get SVG as string without whitespaces
+     */
+    toMinifiedString(customisations?: IconifyIconCustomisations): string;
+    /**
+     * Get SVG as string with whitespaces
+     */
+    toPrettyString(customisations?: IconifyIconCustomisations): string;
+    /**
+     * Get body
+     */
+    getBody(): string;
+    /**
+     * Get icon as IconifyIcon
+     */
+    getIcon(): IconifyIcon;
+    /**
+     * Load SVG
+     *
+     * @param {string} content
+     */
+    load(content: string): void;
+}
+
+export { SVG, type ViewBox };

package/lib/svg/index.d.mts

@@ -0,0 +1,52 @@
+import * as cheerio from 'cheerio';
+import { IconifyIcon } from '@iconify/types';
+export { IconifyIcon } from '@iconify/types';
+import { IconifyIconCustomisations } from '@iconify/utils/lib/customisations/defaults';
+export { IconifyIconCustomisations } from '@iconify/utils/lib/customisations/defaults';
+
+interface ViewBox {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+
+/**
+ * SVG class, used to manipulate icon content.
+ */
+declare class SVG {
+    $svg: cheerio.CheerioAPI;
+    viewBox: ViewBox;
+    /**
+     * Constructor
+     */
+    constructor(content: string);
+    /**
+     * Get SVG as string
+     */
+    toString(customisations?: IconifyIconCustomisations): string;
+    /**
+     * Get SVG as string without whitespaces
+     */
+    toMinifiedString(customisations?: IconifyIconCustomisations): string;
+    /**
+     * Get SVG as string with whitespaces
+     */
+    toPrettyString(customisations?: IconifyIconCustomisations): string;
+    /**
+     * Get body
+     */
+    getBody(): string;
+    /**
+     * Get icon as IconifyIcon
+     */
+    getIcon(): IconifyIcon;
+    /**
+     * Load SVG
+     *
+     * @param {string} content
+     */
+    load(content: string): void;
+}
+
+export { SVG, type ViewBox };

package/lib/svg/index.d.ts

@@ -29,6 +29,10 @@ declare class SVG {
      * Get SVG as string without whitespaces
      */
     toMinifiedString(customisations?: IconifyIconCustomisations): string;
+    /**
+     * Get SVG as string with whitespaces
+     */
+    toPrettyString(customisations?: IconifyIconCustomisations): string;
     /**
      * Get body
      */
@@ -45,4 +49,4 @@ declare class SVG {
     load(content: string): void;
 }
 
-export { SVG, ViewBox };
+export { SVG, type ViewBox };

package/lib/svg/index.mjs

@@ -1,11 +1,21 @@
 import * as cheerio from 'cheerio';
-import { iconToSVG, trimSVG } from '@iconify/utils';
+import { iconToSVG, trimSVG, prettifySVG } from '@iconify/utils';
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class SVG {
   /**
    * Constructor
    */
   constructor(content) {
+    // Cheerio tree, initialized in load()
+    __publicField(this, "$svg");
+    // Dimensions, initialized in load()
+    __publicField(this, "viewBox");
     this.load(content);
   }
   /**
@@ -15,7 +25,7 @@ class SVG {
     if (customisations) {
       const data = iconToSVG(this.getIcon(), customisations);
       let svgAttributes = ' xmlns="http://www.w3.org/2000/svg"';
-      if (data.body.indexOf("xlink:") !== -1) {
+      if (data.body.includes("xlink:")) {
         svgAttributes += ' xmlns:xlink="http://www.w3.org/1999/xlink"';
       }
       for (const key in data.attributes) {
@@ -46,6 +56,13 @@ class SVG {
   toMinifiedString(customisations) {
     return trimSVG(this.toString(customisations));
   }
+  /**
+   * Get SVG as string with whitespaces
+   */
+  toPrettyString(customisations) {
+    const str = this.toMinifiedString(customisations);
+    return prettifySVG(str) ?? str;
+  }
   /**
    * Get body
    */

package/lib/svg/parse-style.cjs

@@ -9,156 +9,147 @@ require('../css/parser/error.cjs');
 require('../css/parser/strings.cjs');
 require('../css/parser/text.cjs');
 
-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 = [];
-    let 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("\n" + newContent);
-        }
+function assertNotOldCode(value) {
+  if (value instanceof Promise) {
+    throw new Error("parseSVGStyle does not support async callbacks");
+  }
+}
+function parseSVGStyle(svg, callback) {
+  svg_parse.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 = css_parser_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,
@@ -179,122 +170,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 = 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);
+      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("\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 = css_parse.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 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) {
+      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;