@iconify/tools 2.0.12 → 2.0.15

package/lib/misc/scan.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" />
-import type { Stats } from 'fs';
+import { Stats } from 'fs';
+
 /**
  * Callback
  *
@@ -17,10 +17,11 @@ declare type ScanDirectoryCallbackFalseResult = boolean | null | undefined;
 declare type ScanDirectoryCallbackStringResult = ScanDirectoryCallbackFalseResult | string;
 declare type ScanDirectoryCallbackAsString = (ext: string, file: string, subdir: string, path: string, stat: Stats) => ScanDirectoryCallbackStringResult | Promise<ScanDirectoryCallbackStringResult>;
 declare type ScanDirectoryCallbackAsCustom<T> = (ext: string, file: string, subdir: string, path: string, stat: Stats) => T | ScanDirectoryCallbackFalseResult | Promise<T | ScanDirectoryCallbackFalseResult>;
-export declare type ScanDirectoryCallback = ScanDirectoryCallbackAsCustom<unknown> | ScanDirectoryCallbackAsString;
+declare type ScanDirectoryCallback = ScanDirectoryCallbackAsCustom<unknown> | ScanDirectoryCallbackAsString;
 /**
  * Find all files in directory
  */
-export declare function scanDirectory(path: string, callback?: ScanDirectoryCallbackAsString, subdirs?: boolean): Promise<string[]>;
-export declare function scanDirectory<T>(path: string, callback: ScanDirectoryCallbackAsCustom<T>, subdirs?: boolean): Promise<T[]>;
-export {};
+declare function scanDirectory(path: string, callback?: ScanDirectoryCallbackAsString, subdirs?: boolean): Promise<string[]>;
+declare function scanDirectory<T>(path: string, callback: ScanDirectoryCallbackAsCustom<T>, subdirs?: boolean): Promise<T[]>;
+
+export { ScanDirectoryCallback, scanDirectory };

package/lib/misc/scan.mjs

@@ -1,18 +1,18 @@
-// src/misc/scan.ts
-import { promises as fs } from "fs";
+import { promises } from 'fs';
+
 async function scanDirectory(path, callback, subdirs = true) {
   const results = [];
   if (path.length && path.slice(-1) !== "/") {
     path += "/";
   }
   async function scan(subdir) {
-    const files = await fs.readdir(path + subdir);
+    const files = await promises.readdir(path + subdir);
     for (let i = 0; i < files.length; i++) {
       const filename = files[i];
       if (filename.slice(0, 1) === ".") {
         continue;
       }
-      const stat = await fs.stat(path + subdir + filename);
+      const stat = await promises.stat(path + subdir + filename);
       if (stat.isDirectory()) {
         if (subdirs) {
           await scan(subdir + filename + "/");
@@ -43,6 +43,5 @@ async function scanDirectory(path, callback, subdirs = true) {
   await scan("");
   return results;
 }
-export {
-  scanDirectory
-};
+
+export { scanDirectory };

package/lib/misc/write-json.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fs = require('fs');
+
+async function writeJSONFile(filename, data) {
+  return fs.promises.writeFile(filename, JSON.stringify(data, null, "	") + "\n");
+}
+
+exports.writeJSONFile = writeJSONFile;

package/lib/misc/write-json.d.ts

@@ -1,4 +1,6 @@
 /**
  * Write JSON file
  */
-export declare function writeJSONFile(filename: string, data: unknown): Promise<void>;
+declare function writeJSONFile(filename: string, data: unknown): Promise<void>;
+
+export { writeJSONFile };

package/lib/misc/write-json.mjs

@@ -1,8 +1,7 @@
-// src/misc/write-json.ts
-import { promises as fs } from "fs";
+import { promises } from 'fs';
+
 async function writeJSONFile(filename, data) {
-  return fs.writeFile(filename, JSON.stringify(data, null, "	") + "\n");
+  return promises.writeFile(filename, JSON.stringify(data, null, "	") + "\n");
 }
-export {
-  writeJSONFile
-};
+
+export { writeJSONFile };

package/lib/optimise/flags.cjs

@@ -0,0 +1,252 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const svg_parse = require('../svg/parse.cjs');
+
+const CLOSE_PATH = 1;
+const MOVE_TO = 2;
+const HORIZ_LINE_TO = 4;
+const VERT_LINE_TO = 8;
+const LINE_TO = 16;
+const CURVE_TO = 32;
+const SMOOTH_CURVE_TO = 64;
+const QUAD_TO = 128;
+const SMOOTH_QUAD_TO = 256;
+const ARC = 512;
+const argCount = {
+  [MOVE_TO]: 2,
+  [LINE_TO]: 2,
+  [HORIZ_LINE_TO]: 1,
+  [VERT_LINE_TO]: 1,
+  [CLOSE_PATH]: 0,
+  [QUAD_TO]: 4,
+  [SMOOTH_QUAD_TO]: 2,
+  [CURVE_TO]: 6,
+  [SMOOTH_CURVE_TO]: 4,
+  [ARC]: 7
+};
+const isDigit = (num) => num >= 48 && num <= 57;
+const isWhiteSpace = (num) => num === 32 || num === 9 || num === 13 || num === 10;
+function cleanPath(path) {
+  const commands = [];
+  const length = path.length;
+  let currentNumber = "";
+  let currentNumberHasExp = false;
+  let currentNumberHasExpDigits = false;
+  let currentNumberHasDecimal = false;
+  let canParseCommandOrComma = true;
+  let currentCommand = null;
+  let currentCommandType = null;
+  let currentArgs = [];
+  let i = 0;
+  const finishCommand = () => {
+    if (currentCommand !== null) {
+      commands.push({
+        command: currentCommand,
+        params: currentArgs.slice(0)
+      });
+      currentArgs = [];
+      canParseCommandOrComma = true;
+      switch (currentCommand) {
+        case "M":
+          currentCommand = "L";
+          break;
+        case "m":
+          currentCommand = "l";
+          break;
+      }
+    }
+  };
+  const parseNumber = () => {
+    if (currentNumber !== "" && currentCommandType) {
+      let value = Number(currentNumber);
+      if (isNaN(value)) {
+        throw new Error('Invalid number "' + currentNumber + '" at ' + i);
+      }
+      if (currentCommandType === ARC) {
+        if (currentArgs.length < 2 && value <= 0) {
+          throw new Error('Expected positive number, got "' + value + '" at ' + i);
+        }
+        while (true) {
+          if (currentArgs.length < 3 || currentArgs.length > 4) {
+            break;
+          }
+          if (currentNumber === "0" || currentNumber === "1") {
+            break;
+          }
+          const slice = currentNumber.slice(0, 1);
+          const newNumber = currentNumber.slice(1);
+          const newValue = Number(newNumber);
+          if (slice === "0" || slice === "1") {
+            if (isNaN(newValue)) {
+              throw new Error('Invalid number "' + currentNumber + '" at ' + i);
+            }
+            currentArgs.push(slice);
+            currentNumber = newNumber;
+            value = newValue;
+            continue;
+          }
+          throw new Error('Expected a flag, got "' + currentNumber + '" at ' + i);
+        }
+      }
+      currentArgs.push(currentNumber);
+      if (currentArgs.length === argCount[currentCommandType]) {
+        finishCommand();
+      }
+      currentNumber = "";
+      currentNumberHasExpDigits = false;
+      currentNumberHasExp = false;
+      currentNumberHasDecimal = false;
+      canParseCommandOrComma = true;
+    }
+  };
+  for (i = 0; i < length; i++) {
+    const char = path[i];
+    const num = char.charCodeAt(0);
+    if (isDigit(num)) {
+      currentNumber += char;
+      currentNumberHasExpDigits = currentNumberHasExp;
+      continue;
+    }
+    if (char === "e" || char === "E") {
+      currentNumber += char;
+      currentNumberHasExp = true;
+      continue;
+    }
+    if ((char === "-" || char === "+") && currentNumberHasExp && !currentNumberHasExpDigits) {
+      currentNumber += char;
+      continue;
+    }
+    if (char === "." && !currentNumberHasExp && !currentNumberHasDecimal) {
+      currentNumber += char;
+      currentNumberHasDecimal = true;
+      continue;
+    }
+    parseNumber();
+    if (isWhiteSpace(num)) {
+      continue;
+    }
+    if (canParseCommandOrComma && char === ",") {
+      canParseCommandOrComma = false;
+      continue;
+    }
+    if (char === "+" || char === "-" || char === ".") {
+      currentNumber = char;
+      currentNumberHasDecimal = char === ".";
+      continue;
+    }
+    if (currentArgs.length > 0) {
+      throw new Error("Unexpected command at " + i);
+    }
+    if (!canParseCommandOrComma) {
+      throw new Error("Command cannot follow comma at " + i);
+    }
+    canParseCommandOrComma = false;
+    currentCommand = char;
+    switch (char) {
+      case "z":
+      case "Z":
+        commands.push({
+          command: char,
+          params: []
+        });
+        canParseCommandOrComma = true;
+        currentCommandType = null;
+        currentCommand = null;
+        break;
+      case "h":
+      case "H":
+        currentCommandType = HORIZ_LINE_TO;
+        break;
+      case "v":
+      case "V":
+        currentCommandType = VERT_LINE_TO;
+        break;
+      case "m":
+      case "M":
+        currentCommandType = MOVE_TO;
+        break;
+      case "l":
+      case "L":
+        currentCommandType = LINE_TO;
+        break;
+      case "c":
+      case "C":
+        currentCommandType = CURVE_TO;
+        break;
+      case "s":
+      case "S":
+        currentCommandType = SMOOTH_CURVE_TO;
+        break;
+      case "q":
+      case "Q":
+        currentCommandType = QUAD_TO;
+        break;
+      case "t":
+      case "T":
+        currentCommandType = SMOOTH_QUAD_TO;
+        break;
+      case "a":
+      case "A":
+        currentCommandType = ARC;
+        break;
+      default:
+        throw new Error('Unexpected character "' + char + '" at ' + i);
+    }
+  }
+  parseNumber();
+  if (currentArgs.length) {
+    if (!currentCommandType) {
+      throw new Error("Empty path");
+    }
+    if (currentArgs.length !== argCount[currentCommandType]) {
+      throw new Error("Unexpected end of path at " + i);
+    }
+    finishCommand();
+  }
+  let output = "";
+  commands.forEach((item) => {
+    output += item.command;
+    item.params.forEach((value, index) => {
+      if (index > 0) {
+        const char = value[0];
+        switch (char) {
+          case "-":
+          case "+":
+            break;
+          case ".":
+            if (index < 1) {
+              break;
+            }
+            if (item.params[index - 1].indexOf(".") !== -1) {
+              break;
+            }
+          default:
+            output += " ";
+        }
+      }
+      output += value;
+    });
+  });
+  return output;
+}
+async function deOptimisePaths(svg) {
+  await svg_parse.parseSVG(svg, (item) => {
+    if (item.tagName !== "path") {
+      return;
+    }
+    const d = item.element.attribs.d;
+    if (typeof d === "string") {
+      try {
+        const optimised = cleanPath(d);
+        if (optimised !== d) {
+          item.$element.attr("d", optimised);
+        }
+      } catch (err) {
+      }
+    }
+  });
+}
+
+exports.deOptimisePaths = deOptimisePaths;

package/lib/optimise/flags.d.ts

@@ -1,5 +1,10 @@
-import type { SVG } from '../svg';
+import { SVG } from '../svg/index.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * De-optimise paths. Compressed paths are still not supported by some software.
  */
-export declare function deOptimisePaths(svg: SVG): Promise<void>;
+declare function deOptimisePaths(svg: SVG): Promise<void>;
+
+export { deOptimisePaths };

package/lib/optimise/flags.mjs

@@ -1,16 +1,16 @@
-// src/optimise/flags.ts
-import { parseSVG } from "../svg/parse.mjs";
-var CLOSE_PATH = 1;
-var MOVE_TO = 2;
-var HORIZ_LINE_TO = 4;
-var VERT_LINE_TO = 8;
-var LINE_TO = 16;
-var CURVE_TO = 32;
-var SMOOTH_CURVE_TO = 64;
-var QUAD_TO = 128;
-var SMOOTH_QUAD_TO = 256;
-var ARC = 512;
-var argCount = {
+import { parseSVG } from '../svg/parse.mjs';
+
+const CLOSE_PATH = 1;
+const MOVE_TO = 2;
+const HORIZ_LINE_TO = 4;
+const VERT_LINE_TO = 8;
+const LINE_TO = 16;
+const CURVE_TO = 32;
+const SMOOTH_CURVE_TO = 64;
+const QUAD_TO = 128;
+const SMOOTH_QUAD_TO = 256;
+const ARC = 512;
+const argCount = {
   [MOVE_TO]: 2,
   [LINE_TO]: 2,
   [HORIZ_LINE_TO]: 1,
@@ -22,8 +22,8 @@ var argCount = {
   [SMOOTH_CURVE_TO]: 4,
   [ARC]: 7
 };
-var isDigit = (num) => num >= 48 && num <= 57;
-var isWhiteSpace = (num) => num === 32 || num === 9 || num === 13 || num === 10;
+const isDigit = (num) => num >= 48 && num <= 57;
+const isWhiteSpace = (num) => num === 32 || num === 9 || num === 13 || num === 10;
 function cleanPath(path) {
   const commands = [];
   const length = path.length;
@@ -136,7 +136,7 @@ function cleanPath(path) {
       throw new Error("Unexpected command at " + i);
     }
     if (!canParseCommandOrComma) {
-      throw new Error("Command cannot follow comma at " + i + "");
+      throw new Error("Command cannot follow comma at " + i);
     }
     canParseCommandOrComma = false;
     currentCommand = char;
@@ -244,6 +244,5 @@ async function deOptimisePaths(svg) {
     }
   });
 }
-export {
-  deOptimisePaths
-};
+
+export { deOptimisePaths };

package/lib/optimise/global-style.cjs

@@ -0,0 +1,154 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const svg_data_tags = require('../svg/data/tags.cjs');
+const svg_parse = require('../svg/parse.cjs');
+const svg_parseStyle = require('../svg/parse-style.cjs');
+require('../css/parse.cjs');
+require('../css/parser/tokens.cjs');
+require('../css/parser/error.cjs');
+require('../css/parser/strings.cjs');
+require('../css/parser/text.cjs');
+require('../css/parser/export.cjs');
+require('../css/parser/tree.cjs');
+
+function getClassList(value) {
+  return value?.split(/\s+/);
+}
+const tempDataAttrbiute = "data-gstyle-temp";
+async function cleanupGlobalStyle(svg) {
+  const backup = svg.toString();
+  let containsTempAttr = false;
+  const animatedClasses = /* @__PURE__ */ new Set();
+  await svg_parse.parseSVG(svg, (item) => {
+    if (!svg_data_tags.animateTags.has(item.tagName)) {
+      return;
+    }
+    const $element = item.$element;
+    if ($element.attr("attributeName") !== "class") {
+      return;
+    }
+    ["from", "to", "values"].forEach((attr) => {
+      const value = $element.attr(attr);
+      if (typeof value !== "string") {
+        return;
+      }
+      value.split(";").forEach((item2) => {
+        getClassList(item2).forEach((className) => {
+          animatedClasses.add(className);
+        });
+      });
+    });
+  });
+  try {
+    await svg_parseStyle.parseSVGStyle(svg, async (styleItem) => {
+      const returnValue = styleItem.value;
+      if (styleItem.type !== "global") {
+        return returnValue;
+      }
+      const selectorTokens = styleItem.selectorTokens;
+      for (let i = 0; i < selectorTokens.length; i++) {
+        const selectorToken = selectorTokens[i];
+        if (selectorToken.type !== "selector") {
+          return returnValue;
+        }
+      }
+      const selectors = styleItem.selectors;
+      const matches = [];
+      for (let i = 0; i < selectors.length; i++) {
+        const selector = styleItem.selectors[i];
+        const firstChar = selector.charAt(0);
+        let matchType;
+        if (firstChar === ".") {
+          matchType = "class";
+        } else if (firstChar === "#") {
+          matchType = "id";
+        } else if (svg_data_tags.allValidTags.has(selector)) {
+          matchType = "tag";
+        } else {
+          return returnValue;
+        }
+        const valueMatch = matchType === "tag" ? selector : selector.slice(1);
+        if (matchType === "class" && animatedClasses.has(valueMatch)) {
+          return returnValue;
+        }
+        matches.push({
+          type: matchType,
+          value: valueMatch
+        });
+      }
+      const isMatch = (tagName, $element) => {
+        for (let i = 0; i < matches.length; i++) {
+          const { type, value } = matches[i];
+          switch (type) {
+            case "id":
+              if ($element.attr("id") === value) {
+                return true;
+              }
+              break;
+            case "tag":
+              if (tagName === value) {
+                return true;
+              }
+              break;
+            case "class": {
+              const className = $element.attr("class");
+              if (className && getClassList(className).indexOf(value) !== -1) {
+                return true;
+              }
+            }
+          }
+        }
+        return false;
+      };
+      await svg_parse.parseSVG(svg, (svgItem) => {
+        const tagName = svgItem.tagName;
+        const $element = svgItem.$element;
+        if (!isMatch(tagName, $element)) {
+          return;
+        }
+        const addedAttributes = new Set($element.attr(tempDataAttrbiute)?.split(/\s+/));
+        const prop = styleItem.prop;
+        if ($element.attr(prop) !== void 0) {
+          if (addedAttributes.has(prop)) {
+            throw new Error("Duplicate attribute");
+          }
+        }
+        $element.attr(prop, styleItem.value);
+        addedAttributes.add(prop);
+        $element.attr(tempDataAttrbiute, Array.from(addedAttributes).join(" "));
+        containsTempAttr = true;
+      });
+      const classMatches = matches.filter((item) => item.type === "class").map((item) => item.value);
+      if (classMatches.length && styleItem.nextTokens[0]?.type === "close") {
+        await svg_parse.parseSVG(svg, (svgItem) => {
+          const $element = svgItem.$element;
+          if (!isMatch("", $element)) {
+            return;
+          }
+          const classList = getClassList($element.attr("class"));
+          if (!classList) {
+            return;
+          }
+          const filtered = classList.filter((item) => classMatches.indexOf(item) === -1);
+          if (!filtered.length) {
+            $element.removeAttr("class");
+          } else {
+            $element.attr("class", filtered.join(" "));
+          }
+        });
+      }
+      return;
+    });
+    if (containsTempAttr) {
+      await svg_parse.parseSVG(svg, (item) => {
+        item.$element.removeAttr(tempDataAttrbiute);
+      });
+    }
+  } catch (err) {
+    svg.load(backup);
+  }
+}
+
+exports.cleanupGlobalStyle = cleanupGlobalStyle;

package/lib/optimise/global-style.d.ts

@@ -1,5 +1,10 @@
-import type { SVG } from '../svg';
+import { SVG } from '../svg/index.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+
 /**
  * Expand global style
  */
-export declare function cleanupGlobalStyle(svg: SVG): Promise<void>;
+declare function cleanupGlobalStyle(svg: SVG): Promise<void>;
+
+export { cleanupGlobalStyle };