@iconify/tools 1.3.17 → 2.0.0-dev.2

package/.editorconfig

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = tab
+indent_size = 4
+charset = utf-8
+trim_trailing_whitespace = true
+
+[{*.json,*.yml}]
+indent_style = space
+indent_size = 2

package/.eslintignore

@@ -0,0 +1,2 @@
+lib
+tests-compiled

package/lib/colors/attribs.d.ts

@@ -0,0 +1,16 @@
+import type { Color } from '@iconify/utils/lib/colors/types';
+/**
+ * Color attributes
+ */
+export declare type CommonColorAttributes = 'color';
+export declare const commonColorAttributes: CommonColorAttributes[];
+export declare type ShapeColorAttributes = 'fill' | 'stroke';
+export declare const shapeColorAttributes: ShapeColorAttributes[];
+export declare type SpecialColorAttributes = 'stop-color' | 'flood-color';
+export declare const specialColorAttributes: SpecialColorAttributes[];
+export declare type ColorAttributes = CommonColorAttributes | ShapeColorAttributes | SpecialColorAttributes;
+/**
+ * Default values
+ */
+export declare const defaultBlackColor: Color;
+export declare const defaultColorValues: Record<ColorAttributes, Color>;

package/lib/colors/attribs.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultColorValues = exports.defaultBlackColor = exports.specialColorAttributes = exports.shapeColorAttributes = exports.commonColorAttributes = void 0;
+exports.commonColorAttributes = ['color'];
+exports.shapeColorAttributes = ['fill', 'stroke'];
+exports.specialColorAttributes = [
+    'stop-color',
+    'flood-color',
+];
+/**
+ * Default values
+ */
+exports.defaultBlackColor = {
+    type: 'rgb',
+    r: 0,
+    g: 0,
+    b: 0,
+    alpha: 1,
+};
+exports.defaultColorValues = {
+    'color': { type: 'current' },
+    'fill': exports.defaultBlackColor,
+    'stroke': { type: 'none' },
+    'stop-color': exports.defaultBlackColor,
+    'flood-color': exports.defaultBlackColor,
+};

package/lib/colors/attribs.mjs

@@ -0,0 +1,28 @@
+// src/colors/attribs.ts
+var commonColorAttributes = ["color"];
+var shapeColorAttributes = ["fill", "stroke"];
+var specialColorAttributes = [
+  "stop-color",
+  "flood-color"
+];
+var defaultBlackColor = {
+  type: "rgb",
+  r: 0,
+  g: 0,
+  b: 0,
+  alpha: 1
+};
+var defaultColorValues = {
+  "color": { type: "current" },
+  "fill": defaultBlackColor,
+  "stroke": { type: "none" },
+  "stop-color": defaultBlackColor,
+  "flood-color": defaultBlackColor
+};
+export {
+  commonColorAttributes,
+  defaultBlackColor,
+  defaultColorValues,
+  shapeColorAttributes,
+  specialColorAttributes
+};

package/lib/colors/parse.d.ts

@@ -0,0 +1,37 @@
+import type { Color } from '@iconify/utils/lib/colors/types';
+import type { SVG } from '../svg';
+import { ColorAttributes } from './attribs';
+/**
+ * Result
+ */
+interface FindColorsResult {
+    colors: (Color | string)[];
+    hasUnsetColor: boolean;
+    hasGlobalStyle: boolean;
+}
+/**
+ * Callback to call for each found color
+ *
+ * Callback should return:
+ * - new color value to change color
+ * - first parameter to keep old value
+ * - undefined to delete old value
+ */
+declare type ParseColorsCallbackResult = Color | string | undefined;
+declare type ParseColorsCallback = (attr: ColorAttributes, color: Color | string, tagName?: string) => ParseColorsCallbackResult | Promise<ParseColorsCallbackResult>;
+/**
+ * Options
+ */
+export interface ParseColorsOptions {
+    callback?: ParseColorsCallback;
+    defaultColor?: Color | string;
+}
+/**
+ * Find colors in icon
+ */
+export declare function parseColors(svg: SVG, options?: ParseColorsOptions): Promise<FindColorsResult>;
+/**
+ * Check if color is empty, such as 'none' or 'transparent'
+ */
+export declare function isEmptyColor(color: Color): boolean;
+export {};

package/lib/colors/parse.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmptyColor = exports.parseColors = void 0;
+const colors_1 = require("@iconify/utils/lib/colors");
+const parse_1 = require("../svg/parse");
+const tags_1 = require("../svg/data/tags");
+const parse_style_1 = require("../svg/parse-style");
+const attribs_1 = require("./attribs");
+const attributes_1 = require("../svg/data/attributes");
+/**
+ * Properties to check
+ */
+const propsToCheck = Object.keys(attribs_1.defaultColorValues);
+const animatePropsToCheck = ['from', 'to', 'values'];
+/**
+ * Find colors in icon
+ */
+async function parseColors(svg, options = {}) {
+    const result = {
+        colors: [],
+        hasUnsetColor: false,
+        hasGlobalStyle: false,
+    };
+    // Default color
+    const defaultColor = typeof options.defaultColor === 'string'
+        ? (0, colors_1.stringToColor)(options.defaultColor)
+        : options.defaultColor;
+    function findColor(color, add = false) {
+        const isString = typeof color === 'string';
+        for (let i = 0; i < result.colors.length; i++) {
+            const item = result.colors[i];
+            if (item === color) {
+                return item;
+            }
+            if (!isString &&
+                typeof item !== 'string' &&
+                (0, colors_1.compareColors)(item, color)) {
+                return item;
+            }
+        }
+        if (add) {
+            result.colors.push(color);
+            return color;
+        }
+        return null;
+    }
+    /**
+     * Add color to item and to results
+     */
+    function addColorToItem(prop, color, item) {
+        const addedColor = findColor(color, true);
+        if (item) {
+            const itemColors = item.colors || {};
+            if (!item.colors) {
+                item.colors = itemColors;
+            }
+            itemColors[prop] = addedColor;
+        }
+    }
+    /**
+     * Get element color
+     */
+    function getElementColor(prop, item) {
+        function find(prop) {
+            var _a;
+            let currentItem = item;
+            while (currentItem) {
+                const color = (_a = currentItem.colors) === null || _a === void 0 ? void 0 : _a[prop];
+                if (color !== void 0) {
+                    return color;
+                }
+                currentItem = currentItem.parents[0];
+            }
+            return attribs_1.defaultColorValues[prop];
+        }
+        let propColor = find(prop);
+        if (typeof propColor === 'object' &&
+            propColor.type === 'current' &&
+            prop !== 'color') {
+            // currentColor: get color
+            propColor = find('color');
+        }
+        return propColor;
+    }
+    /**
+     * Change color
+     */
+    async function checkColor(prop, value, item) {
+        // Ignore empty values
+        switch (value.trim().toLowerCase()) {
+            case '':
+            case 'inherit':
+                return;
+        }
+        // Resolve color
+        const color = (0, colors_1.stringToColor)(value);
+        const defaultValue = color || value;
+        // Check if callback exists
+        if (!options.callback) {
+            addColorToItem(prop, defaultValue, item);
+            return value;
+        }
+        // Call callback
+        let callbackResult = options.callback(prop, defaultValue, item === null || item === void 0 ? void 0 : item.tagName);
+        callbackResult =
+            callbackResult instanceof Promise
+                ? await callbackResult
+                : callbackResult;
+        // Remove entry
+        if (callbackResult === void 0) {
+            return callbackResult;
+        }
+        if (callbackResult === defaultValue) {
+            // Not changed
+            addColorToItem(prop, defaultValue, item);
+            return value;
+        }
+        if (typeof callbackResult === 'string') {
+            const newColor = (0, colors_1.stringToColor)(callbackResult);
+            addColorToItem(prop, newColor || callbackResult, item);
+            return callbackResult;
+        }
+        // Color
+        const newValue = (0, colors_1.colorToString)(callbackResult);
+        addColorToItem(prop, callbackResult, item);
+        return newValue;
+    }
+    // Parse colors in style
+    await (0, parse_style_1.parseSVGStyle)(svg, async (item) => {
+        const prop = item.prop;
+        const value = item.value;
+        if (propsToCheck.indexOf(prop) === -1) {
+            return value;
+        }
+        // Color
+        const attr = prop;
+        const newValue = checkColor(attr, value);
+        if (newValue === void 0) {
+            return newValue;
+        }
+        // Got color
+        if (item.type === 'global') {
+            result.hasGlobalStyle = true;
+        }
+        return newValue;
+    }, {
+        skipMasks: true,
+    });
+    // Parse colors in SVG
+    await (0, parse_1.parseSVG)(svg, async (item) => {
+        const tagName = item.tagName;
+        if (tags_1.maskAndSymbolTags.has(tagName)) {
+            // Ignore masks
+            item.testChildren = false;
+            return;
+        }
+        const $element = item.$element;
+        const attribs = item.element.attribs;
+        // Check common properties
+        for (let i = 0; i < propsToCheck.length; i++) {
+            const prop = propsToCheck[i];
+            if (prop === 'fill' && tags_1.animateTags.has(tagName)) {
+                // 'fill' has different meaning in animations
+                continue;
+            }
+            const value = attribs[prop];
+            if (value !== void 0) {
+                const newValue = await checkColor(prop, value, item);
+                if (newValue !== value) {
+                    if (newValue === void 0) {
+                        $element.removeAttr(prop);
+                    }
+                    else {
+                        $element.attr(prop, newValue);
+                    }
+                }
+            }
+        }
+        // Check animations
+        if (tags_1.animateTags.has(tagName)) {
+            const attr = attribs.attributeName;
+            if (propsToCheck.indexOf(attr) !== -1) {
+                // Valid property
+                for (let i = 0; i < animatePropsToCheck.length; i++) {
+                    const elementProp = animatePropsToCheck[i];
+                    const fullValue = attribs[elementProp];
+                    if (typeof fullValue !== 'string') {
+                        continue;
+                    }
+                    // Split values
+                    const splitValues = fullValue.split(';');
+                    let updatedValues = false;
+                    for (let j = 0; j < splitValues.length; j++) {
+                        const value = splitValues[j];
+                        if (value !== void 0) {
+                            const newValue = await checkColor(elementProp, value
+                            // Do not pass third parameter
+                            );
+                            if (newValue !== value) {
+                                updatedValues = true;
+                                splitValues[j] =
+                                    typeof newValue === 'string'
+                                        ? newValue
+                                        : '';
+                            }
+                        }
+                    }
+                    // Merge values back
+                    if (updatedValues) {
+                        $element.attr(elementProp, splitValues.join(';'));
+                    }
+                }
+            }
+        }
+        // Check shape for default colors
+        if (!result.hasGlobalStyle) {
+            // Get list of properties required to render element
+            let requiredProps;
+            if (tags_1.shapeTags.has(tagName)) {
+                requiredProps = attribs_1.shapeColorAttributes;
+            }
+            attribs_1.specialColorAttributes.forEach((attr) => {
+                var _a;
+                if ((_a = attributes_1.tagSpecificPresentationalAttributes[tagName]) === null || _a === void 0 ? void 0 : _a.has(attr)) {
+                    requiredProps = [attr];
+                }
+            });
+            // Check colors
+            if (requiredProps) {
+                const itemColors = item.colors || {};
+                if (!item.colors) {
+                    item.colors = itemColors;
+                }
+                for (let i = 0; i < requiredProps.length; i++) {
+                    const prop = requiredProps[i];
+                    const color = getElementColor(prop, item);
+                    if (color === attribs_1.defaultBlackColor) {
+                        // Default black color: change it
+                        result.hasUnsetColor = true;
+                        if (defaultColor) {
+                            // Add color to results and change attribute
+                            findColor(defaultColor, true);
+                            $element.attr(prop, (0, colors_1.colorToString)(defaultColor));
+                            itemColors[prop] = defaultColor;
+                        }
+                    }
+                }
+            }
+        }
+    });
+    return result;
+}
+exports.parseColors = parseColors;
+/**
+ * Check if color is empty, such as 'none' or 'transparent'
+ */
+function isEmptyColor(color) {
+    const type = color.type;
+    return type === 'none' || type === 'transparent';
+}
+exports.isEmptyColor = isEmptyColor;

package/lib/colors/parse.mjs

@@ -0,0 +1,212 @@
+// src/colors/parse.ts
+import {
+  compareColors,
+  stringToColor,
+  colorToString
+} from "@iconify/utils/lib/colors";
+import { parseSVG } from "../svg/parse.mjs";
+import { animateTags, maskAndSymbolTags, shapeTags } from "../svg/data/tags.mjs";
+import { parseSVGStyle } from "../svg/parse-style.mjs";
+import {
+  defaultBlackColor,
+  defaultColorValues,
+  shapeColorAttributes,
+  specialColorAttributes
+} from "./attribs.mjs";
+import { tagSpecificPresentationalAttributes } from "../svg/data/attributes.mjs";
+var propsToCheck = Object.keys(defaultColorValues);
+var animatePropsToCheck = ["from", "to", "values"];
+async function parseColors(svg, options = {}) {
+  const result = {
+    colors: [],
+    hasUnsetColor: false,
+    hasGlobalStyle: false
+  };
+  const defaultColor = typeof options.defaultColor === "string" ? stringToColor(options.defaultColor) : options.defaultColor;
+  function findColor(color, add = false) {
+    const isString = typeof color === "string";
+    for (let i = 0; i < result.colors.length; i++) {
+      const item = result.colors[i];
+      if (item === color) {
+        return item;
+      }
+      if (!isString && typeof item !== "string" && compareColors(item, color)) {
+        return item;
+      }
+    }
+    if (add) {
+      result.colors.push(color);
+      return color;
+    }
+    return null;
+  }
+  function addColorToItem(prop, color, item) {
+    const addedColor = findColor(color, true);
+    if (item) {
+      const itemColors = item.colors || {};
+      if (!item.colors) {
+        item.colors = itemColors;
+      }
+      itemColors[prop] = addedColor;
+    }
+  }
+  function getElementColor(prop, item) {
+    function find(prop2) {
+      var _a;
+      let currentItem = item;
+      while (currentItem) {
+        const color = (_a = currentItem.colors) == null ? void 0 : _a[prop2];
+        if (color !== void 0) {
+          return color;
+        }
+        currentItem = currentItem.parents[0];
+      }
+      return defaultColorValues[prop2];
+    }
+    let propColor = find(prop);
+    if (typeof propColor === "object" && propColor.type === "current" && prop !== "color") {
+      propColor = find("color");
+    }
+    return propColor;
+  }
+  async function checkColor(prop, value, item) {
+    switch (value.trim().toLowerCase()) {
+      case "":
+      case "inherit":
+        return;
+    }
+    const color = stringToColor(value);
+    const defaultValue = color || value;
+    if (!options.callback) {
+      addColorToItem(prop, defaultValue, item);
+      return value;
+    }
+    let callbackResult = options.callback(prop, defaultValue, item == null ? void 0 : item.tagName);
+    callbackResult = callbackResult instanceof Promise ? await callbackResult : callbackResult;
+    if (callbackResult === void 0) {
+      return callbackResult;
+    }
+    if (callbackResult === defaultValue) {
+      addColorToItem(prop, defaultValue, item);
+      return value;
+    }
+    if (typeof callbackResult === "string") {
+      const newColor = stringToColor(callbackResult);
+      addColorToItem(prop, newColor || callbackResult, item);
+      return callbackResult;
+    }
+    const newValue = colorToString(callbackResult);
+    addColorToItem(prop, callbackResult, item);
+    return newValue;
+  }
+  await parseSVGStyle(svg, async (item) => {
+    const prop = item.prop;
+    const value = item.value;
+    if (propsToCheck.indexOf(prop) === -1) {
+      return value;
+    }
+    const attr = prop;
+    const newValue = checkColor(attr, value);
+    if (newValue === void 0) {
+      return newValue;
+    }
+    if (item.type === "global") {
+      result.hasGlobalStyle = true;
+    }
+    return newValue;
+  }, {
+    skipMasks: true
+  });
+  await parseSVG(svg, async (item) => {
+    const tagName = item.tagName;
+    if (maskAndSymbolTags.has(tagName)) {
+      item.testChildren = false;
+      return;
+    }
+    const $element = item.$element;
+    const attribs = item.element.attribs;
+    for (let i = 0; i < propsToCheck.length; i++) {
+      const prop = propsToCheck[i];
+      if (prop === "fill" && animateTags.has(tagName)) {
+        continue;
+      }
+      const value = attribs[prop];
+      if (value !== void 0) {
+        const newValue = await checkColor(prop, value, item);
+        if (newValue !== value) {
+          if (newValue === void 0) {
+            $element.removeAttr(prop);
+          } else {
+            $element.attr(prop, newValue);
+          }
+        }
+      }
+    }
+    if (animateTags.has(tagName)) {
+      const attr = attribs.attributeName;
+      if (propsToCheck.indexOf(attr) !== -1) {
+        for (let i = 0; i < animatePropsToCheck.length; i++) {
+          const elementProp = animatePropsToCheck[i];
+          const fullValue = attribs[elementProp];
+          if (typeof fullValue !== "string") {
+            continue;
+          }
+          const splitValues = fullValue.split(";");
+          let updatedValues = false;
+          for (let j = 0; j < splitValues.length; j++) {
+            const value = splitValues[j];
+            if (value !== void 0) {
+              const newValue = await checkColor(elementProp, value);
+              if (newValue !== value) {
+                updatedValues = true;
+                splitValues[j] = typeof newValue === "string" ? newValue : "";
+              }
+            }
+          }
+          if (updatedValues) {
+            $element.attr(elementProp, splitValues.join(";"));
+          }
+        }
+      }
+    }
+    if (!result.hasGlobalStyle) {
+      let requiredProps;
+      if (shapeTags.has(tagName)) {
+        requiredProps = shapeColorAttributes;
+      }
+      specialColorAttributes.forEach((attr) => {
+        var _a;
+        if ((_a = tagSpecificPresentationalAttributes[tagName]) == null ? void 0 : _a.has(attr)) {
+          requiredProps = [attr];
+        }
+      });
+      if (requiredProps) {
+        const itemColors = item.colors || {};
+        if (!item.colors) {
+          item.colors = itemColors;
+        }
+        for (let i = 0; i < requiredProps.length; i++) {
+          const prop = requiredProps[i];
+          const color = getElementColor(prop, item);
+          if (color === defaultBlackColor) {
+            result.hasUnsetColor = true;
+            if (defaultColor) {
+              findColor(defaultColor, true);
+              $element.attr(prop, colorToString(defaultColor));
+              itemColors[prop] = defaultColor;
+            }
+          }
+        }
+      }
+    }
+  });
+  return result;
+}
+function isEmptyColor(color) {
+  const type = color.type;
+  return type === "none" || type === "transparent";
+}
+export {
+  isEmptyColor,
+  parseColors
+};

package/lib/css/parse.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Parse inline style
+ */
+export declare function parseInlineStyle(style: string): Record<string, string> | null;

package/lib/css/parse.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInlineStyle = void 0;
+const tokens_1 = require("./parser/tokens");
+/**
+ * Parse inline style
+ */
+function parseInlineStyle(style) {
+    const tokens = (0, tokens_1.getTokens)(style);
+    if (!(tokens instanceof Array)) {
+        return null;
+    }
+    const results = Object.create(null);
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.type !== 'rule') {
+            return null;
+        }
+        results[token.prop] = token.value;
+    }
+    return results;
+}
+exports.parseInlineStyle = parseInlineStyle;

package/lib/css/parse.mjs

@@ -0,0 +1,20 @@
+// src/css/parse.ts
+import { getTokens } from "./parser/tokens.mjs";
+function parseInlineStyle(style) {
+  const tokens = getTokens(style);
+  if (!(tokens instanceof Array)) {
+    return null;
+  }
+  const results = Object.create(null);
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.type !== "rule") {
+      return null;
+    }
+    results[token.prop] = token.value;
+  }
+  return results;
+}
+export {
+  parseInlineStyle
+};

package/lib/css/parser/error.d.ts

@@ -0,0 +1,11 @@
+export interface StyleParseError {
+    type: 'style-parse-error';
+    message: string;
+    code: string;
+    index?: number;
+    fullMessage: string;
+}
+/**
+ * Create error message
+ */
+export declare function styleParseError(message: string, code: string, index?: number): StyleParseError;

package/lib/css/parser/error.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.styleParseError = void 0;
+/**
+ * Create error message
+ */
+function styleParseError(message, code, index) {
+    let fullMessage = message;
+    if (typeof index === 'number' && index !== -1) {
+        const start = index;
+        // Check for space on left side of remaining code to calculate line start correctly
+        const remaining = code.slice(index) + '!';
+        const trimmed = remaining.trim();
+        const end = start + remaining.length - trimmed.length;
+        const code2 = code.slice(0, end);
+        const line = code2.length - code2.replace(/\n/g, '').length + 1;
+        fullMessage = message + ' on line ' + line;
+    }
+    return {
+        type: 'style-parse-error',
+        message,
+        code,
+        index,
+        fullMessage,
+    };
+}
+exports.styleParseError = styleParseError;