@iconify/tools 1.3.17 → 2.0.0-dev.2

package/lib/misc/scan.mjs

@@ -0,0 +1,43 @@
+// src/misc/scan.ts
+import { promises as fs } 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);
+    for (let i = 0; i < files.length; i++) {
+      const filename = files[i];
+      if (filename.slice(0, 1) === ".") {
+        continue;
+      }
+      const stat = await fs.lstat(path + subdir + filename);
+      if (stat.isDirectory()) {
+        if (subdirs) {
+          await scan(subdir + filename + "/");
+        }
+        continue;
+      }
+      if (!stat.isFile()) {
+        continue;
+      }
+      const parts = filename.split(".");
+      const ext = parts.length > 1 ? "." + parts.pop() : "";
+      const file = parts.join(".");
+      let callbackResult = callback(ext, file, subdir, path);
+      if (callbackResult instanceof Promise) {
+        callbackResult = await callbackResult;
+      }
+      if (callbackResult === void 0 || callbackResult === false || callbackResult === null) {
+        continue;
+      }
+      results.push(callbackResult === true ? subdir + filename : callbackResult);
+    }
+  }
+  await scan("");
+  return results;
+}
+export {
+  scanDirectory
+};

package/lib/optimise/flags.d.ts

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

package/lib/optimise/flags.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deOptimisePaths = void 0;
+const parse_1 = require("../svg/parse");
+/**
+ * Command constants
+ */
+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;
+/**
+ * Number of arguments for each command
+ */
+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,
+};
+/**
+ * Check if character is a digit
+ */
+const isDigit = (num) => num >= 48 && num <= 57;
+/**
+ * Check if character is white space
+ */
+const isWhiteSpace = (num) => num === 32 || num === 9 || num === 13 || num === 10;
+/**
+ * Clean up path
+ *
+ * @param {string} path
+ * @return {string}
+ */
+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;
+        }
+    };
+    const parseNumber = () => {
+        // Number ended - validate it
+        if (currentNumber !== '' && currentCommandType) {
+            let value = Number(currentNumber);
+            if (isNaN(value)) {
+                throw new Error('Invalid number "' + currentNumber + '" at ' + i);
+            }
+            // Validate arc arguments
+            if (currentCommandType === ARC) {
+                if (currentArgs.length < 2 && value <= 0) {
+                    throw new Error('Expected positive number, got "' + value + '" at ' + i);
+                }
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    // Not flag
+                    if (currentArgs.length < 3 || currentArgs.length > 4) {
+                        break;
+                    }
+                    // Valid flag
+                    if (currentNumber === '0' || currentNumber === '1') {
+                        break;
+                    }
+                    // Unpack flag
+                    const slice = currentNumber.slice(0, 1);
+                    const newNumber = currentNumber.slice(1);
+                    const newValue = Number(newNumber);
+                    if (slice === '0' || slice === '1') {
+                        // Valid flag
+                        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);
+                }
+            }
+            // Add current number to arguments list
+            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);
+        // Test for number
+        if (isDigit(num)) {
+            currentNumber += char;
+            currentNumberHasExpDigits = currentNumberHasExp;
+            continue;
+        }
+        // Test for exponential number
+        if (char === 'e' || char === 'E') {
+            currentNumber += char;
+            currentNumberHasExp = true;
+            continue;
+        }
+        // Test for number signs
+        if ((char === '-' || char === '+') &&
+            currentNumberHasExp &&
+            !currentNumberHasExpDigits) {
+            currentNumber += char;
+            continue;
+        }
+        // Decimal point
+        if (char === '.' && !currentNumberHasExp && !currentNumberHasDecimal) {
+            currentNumber += char;
+            currentNumberHasDecimal = true;
+            continue;
+        }
+        // Number ended - validate it
+        parseNumber();
+        // White space
+        if (isWhiteSpace(num)) {
+            continue;
+        }
+        // Only one comma per command
+        if (canParseCommandOrComma && char === ',') {
+            canParseCommandOrComma = false;
+            continue;
+        }
+        // New number
+        if (char === '+' || char === '-' || char === '.') {
+            currentNumber = char;
+            currentNumberHasDecimal = char === '.';
+            continue;
+        }
+        // Expecting new command, so argument should be empty
+        if (currentArgs.length > 0) {
+            throw new Error('Unexpected command at ' + i);
+        }
+        // Test comma, reset value
+        if (!canParseCommandOrComma) {
+            throw new Error('Command cannot follow comma at ' + i + '');
+        }
+        canParseCommandOrComma = false;
+        // Detect next command
+        currentCommand = char;
+        switch (char) {
+            case 'z':
+            case 'Z':
+                // Close path
+                commands.push({
+                    command: char,
+                    params: [],
+                });
+                canParseCommandOrComma = true;
+                currentCommandType = null;
+                currentCommand = null;
+                break;
+            case 'h':
+            case 'H':
+                // Horizontal move
+                currentCommandType = HORIZ_LINE_TO;
+                break;
+            case 'v':
+            case 'V':
+                // Vertical move
+                currentCommandType = VERT_LINE_TO;
+                break;
+            case 'm':
+            case 'M':
+                // Move to
+                currentCommandType = MOVE_TO;
+                break;
+            case 'l':
+            case 'L':
+                // Line to
+                currentCommandType = LINE_TO;
+                break;
+            case 'c':
+            case 'C':
+                // Curve
+                currentCommandType = CURVE_TO;
+                break;
+            case 's':
+            case 'S':
+                // Smooth curve
+                currentCommandType = SMOOTH_CURVE_TO;
+                break;
+            case 'q':
+            case 'Q':
+                // Quadratic bezier curve
+                currentCommandType = QUAD_TO;
+                break;
+            case 't':
+            case 'T':
+                // Smooth quadratic bezier curve
+                currentCommandType = SMOOTH_QUAD_TO;
+                break;
+            case 'a':
+            case 'A':
+                // Elliptic arc
+                currentCommandType = ARC;
+                break;
+            default:
+                throw new Error('Unexpected character "' + char + '" at ' + i);
+        }
+    }
+    // Parse last number
+    parseNumber();
+    // Add last command
+    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();
+    }
+    // Build path
+    let output = '';
+    commands.forEach((item) => {
+        output += item.command;
+        item.params.forEach((value, index) => {
+            if (index > 0) {
+                const char = value[0];
+                // noinspection FallThroughInSwitchStatementJS
+                switch (char) {
+                    case '-':
+                    case '+':
+                        // Number - no space
+                        break;
+                    case '.':
+                        // Dot - no space if previous entry was command
+                        if (index < 1) {
+                            break;
+                        }
+                        // No space if previous entry had dot
+                        if (item.params[index - 1].indexOf('.') !== -1) {
+                            break;
+                        }
+                    // no-fallthrough
+                    default:
+                        output += ' ';
+                }
+            }
+            output += value;
+        });
+    });
+    return output;
+}
+/**
+ * De-optimise paths. Compressed paths are still not supported by some software.
+ */
+async function deOptimisePaths(svg) {
+    await (0, parse_1.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.mjs

@@ -0,0 +1,241 @@
+// 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 = {
+  [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
+};
+var isDigit = (num) => num >= 48 && num <= 57;
+var 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;
+    }
+  };
+  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 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) {
+      }
+    }
+  });
+}
+export {
+  deOptimisePaths
+};

package/lib/optimise/scale.d.ts

@@ -0,0 +1,5 @@
+import type { SVG } from '../svg';
+/**
+ * Scale icon
+ */
+export declare function scaleSVG(svg: SVG, scale: number): Promise<void>;

package/lib/optimise/scale.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaleSVG = void 0;
+const svgo_1 = require("./svgo");
+/**
+ * Scale icon
+ */
+async function scaleSVG(svg, scale) {
+    const viewBox = svg.viewBox;
+    const width = viewBox.width * scale;
+    const height = viewBox.height * scale;
+    const left = viewBox.left * scale;
+    const top = viewBox.top * scale;
+    const content = '<svg width="' +
+        width +
+        '" height="' +
+        height +
+        '" viewBox="' +
+        left +
+        ' ' +
+        top +
+        ' ' +
+        width +
+        ' ' +
+        height +
+        '">' +
+        '<g transform="scale(' +
+        scale +
+        ')">' +
+        svg.getBody() +
+        '</g></svg>';
+    svg.load(content);
+    await (0, svgo_1.runSVGO)(svg, {
+        plugins: [
+            'collapseGroups',
+            'convertTransform',
+            'convertPathData',
+            'sortAttrs',
+        ],
+    });
+}
+exports.scaleSVG = scaleSVG;

package/lib/optimise/scale.mjs

@@ -0,0 +1,22 @@
+// src/optimise/scale.ts
+import { runSVGO } from "./svgo.mjs";
+async function scaleSVG(svg, scale) {
+  const viewBox = svg.viewBox;
+  const width = viewBox.width * scale;
+  const height = viewBox.height * scale;
+  const left = viewBox.left * scale;
+  const top = viewBox.top * scale;
+  const content = '<svg width="' + width + '" height="' + height + '" viewBox="' + left + " " + top + " " + width + " " + height + '"><g transform="scale(' + scale + ')">' + svg.getBody() + "</g></svg>";
+  svg.load(content);
+  await runSVGO(svg, {
+    plugins: [
+      "collapseGroups",
+      "convertTransform",
+      "convertPathData",
+      "sortAttrs"
+    ]
+  });
+}
+export {
+  scaleSVG
+};

package/lib/optimise/svgo.d.ts

@@ -0,0 +1,27 @@
+import type { Plugin } from 'svgo';
+import type { SVG } from '../svg';
+export declare const defaultSVGOPlugins: Plugin[];
+/**
+ * Plugins that modify shapes. Added to plugins list, unless 'keepShapes' option is enabled
+ */
+export declare const shapeModifiyingSVGOPlugins: Plugin[];
+/**
+ * Options
+ */
+interface SVGOCommonOptions {
+    multipass?: boolean;
+}
+interface SVGOOptionsWithPlugin extends SVGOCommonOptions {
+    plugins: Plugin[];
+}
+interface SVGOptionsWithoutPlugin extends SVGOCommonOptions {
+    plugins?: undefined;
+    keepShapes?: boolean;
+    cleanupIDs?: string | false;
+}
+declare type SVGOOptions = SVGOOptionsWithPlugin | SVGOptionsWithoutPlugin;
+/**
+ * Run SVGO on icon
+ */
+export declare function runSVGO(svg: SVG, options?: SVGOOptions): Promise<void>;
+export {};