@iconify/tools 2.0.14 → 2.0.15

package/lib/colors/parse.js

@@ -1,341 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyColor = exports.parseColors = void 0;
-const colors_1 = require("@iconify/utils/lib/colors");
-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");
-const analyse_1 = require("../svg/analyse");
-/**
- * Properties to check
- */
-const propsToCheck = Object.keys(attribs_1.defaultColorValues);
-const animatePropsToCheck = ['from', 'to', 'values'];
-/**
- * Find colors in icon
- *
- * Clean up icon before running this function to convert style to attributes using
- * cleanupInlineStyle() or cleanupSVG(), otherwise results might be inaccurate
- */
-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;
-    /**
-     * Find matching color in results
-     */
-    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, add = true) {
-        const addedColor = findColor(color, add !== false);
-        if (item) {
-            const itemColors = item._colors || (item._colors = {});
-            itemColors[prop] = addedColor === null ? color : addedColor;
-        }
-    }
-    /**
-     * Get element color
-     */
-    function getElementColor(prop, item, elements) {
-        function find(prop) {
-            var _a;
-            let currentItem = item;
-            while (currentItem) {
-                const element = elements.get(currentItem.index);
-                const color = (_a = element._colors) === null || _a === void 0 ? void 0 : _a[prop];
-                if (color !== void 0) {
-                    return color;
-                }
-                currentItem = currentItem.parent;
-                if (currentItem === null || currentItem === void 0 ? void 0 : currentItem.usedAsMask) {
-                    // Used as mask: color from parent item is irrelevant
-                    return attribs_1.defaultColorValues[prop];
-                }
-            }
-            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 parsedColor = (0, colors_1.stringToColor)(value);
-        const defaultValue = parsedColor || value;
-        // Ignore url()
-        if ((parsedColor === null || parsedColor === void 0 ? void 0 : parsedColor.type) === 'function' && parsedColor.func === 'url') {
-            // Add to item, so it won't be treated as missing, but do not add to results
-            addColorToItem(prop, defaultValue, item, false);
-            return value;
-        }
-        // Check if callback exists
-        if (!options.callback) {
-            addColorToItem(prop, defaultValue, item);
-            return value;
-        }
-        // Call callback
-        let callbackResult = options.callback(prop, value, parsedColor, item === null || item === void 0 ? void 0 : item.tagName, item);
-        callbackResult =
-            callbackResult instanceof Promise
-                ? await callbackResult
-                : callbackResult;
-        // Remove entry
-        switch (callbackResult) {
-            case 'remove': {
-                return item ? callbackResult : void 0;
-            }
-            case 'unset':
-                return;
-        }
-        if (callbackResult === value ||
-            (parsedColor && callbackResult === parsedColor)) {
-            // 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 = await checkColor(attr, value);
-        if (newValue === void 0) {
-            return newValue;
-        }
-        // Got color
-        if (item.type === 'global') {
-            result.hasGlobalStyle = true;
-        }
-        return newValue;
-    });
-    // Analyse SVG
-    const iconData = await (0, analyse_1.analyseSVGStructure)(svg, options);
-    const { elements, tree } = iconData;
-    const cheerio = svg.$svg;
-    const removedElements = new Set();
-    const parsedElements = new Set();
-    // Remove element
-    function removeElement(index, element) {
-        // Mark all children as removed (direct children as in DOM)
-        function removeChildren(element) {
-            element.children.forEach((item) => {
-                if (item.type !== 'tag') {
-                    return;
-                }
-                const element = item;
-                const index = element._index;
-                if (index && !removedElements.has(index)) {
-                    element._removed = true;
-                    removedElements.add(index);
-                    removeChildren(element);
-                }
-            });
-        }
-        // Remove element
-        element._removed = true;
-        removedElements.add(index);
-        removeChildren(element);
-        cheerio(element).remove();
-    }
-    // Parse tree item
-    async function parseTreeItem(item) {
-        const index = item.index;
-        if (removedElements.has(index) || parsedElements.has(index)) {
-            return;
-        }
-        parsedElements.add(index);
-        const element = elements.get(index);
-        if (element._removed) {
-            return;
-        }
-        const { tagName, attribs } = element;
-        // Copy colors from parent item
-        if (item.parent) {
-            const parentIndex = item.parent.index;
-            const parentElement = elements.get(parentIndex);
-            if (parentElement._colors) {
-                element._colors = {
-                    ...parentElement._colors,
-                };
-            }
-        }
-        // 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, element);
-                if (newValue !== value) {
-                    if (newValue === void 0) {
-                        // Unset
-                        cheerio(element).removeAttr(prop);
-                        if (element._colors) {
-                            delete element._colors[prop];
-                        }
-                    }
-                    else if (newValue === 'remove') {
-                        // Remove element
-                        removeElement(index, element);
-                        return;
-                    }
-                    else {
-                        // Change attribute
-                        // Value in element._colors is changed in checkColor()
-                        cheerio(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) {
-                        cheerio(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 = element._colors || (element._colors = {});
-                for (let i = 0; i < requiredProps.length; i++) {
-                    const prop = requiredProps[i];
-                    const color = getElementColor(prop, item, elements);
-                    if (color === attribs_1.defaultBlackColor) {
-                        // Default black color: change it
-                        if (defaultColor) {
-                            const defaultColorValue = typeof defaultColor === 'function'
-                                ? defaultColor(prop, element, item, iconData)
-                                : defaultColor;
-                            // Add color to results and change attribute
-                            findColor(defaultColorValue, true);
-                            cheerio(element).attr(prop, (0, colors_1.colorToString)(defaultColorValue));
-                            itemColors[prop] = defaultColorValue;
-                        }
-                        else {
-                            result.hasUnsetColor = true;
-                        }
-                    }
-                }
-            }
-        }
-        // Parse child elements
-        for (let i = 0; i < item.children.length; i++) {
-            const childItem = item.children[i];
-            if (!childItem.usedAsMask) {
-                await parseTreeItem(childItem);
-            }
-        }
-    }
-    // Parse tree, starting with <svg>
-    await parseTreeItem(tree);
-    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/validate.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateColors = void 0;
-const colors_1 = require("@iconify/utils/lib/colors");
-const parse_1 = require("./parse");
-/**
- * Validate colors in icon
- *
- * If icon is monotone,
- *
- * Throws exception on error
- */
-async function validateColors(svg, expectMonotone, options) {
-    // Parse colors
-    const palette = await (0, parse_1.parseColors)(svg, options);
-    // Check palette
-    palette.colors.forEach((color) => {
-        if (typeof color === 'string') {
-            throw new Error('Unexpected color: ' + color);
-        }
-        switch (color.type) {
-            case 'none':
-            case 'transparent':
-                return;
-            // Monotone
-            case 'current':
-                if (!expectMonotone) {
-                    throw new Error('Unexpected color: ' + (0, colors_1.colorToString)(color));
-                }
-                return;
-            // Palette
-            case 'rgb':
-            case 'hsl':
-                if (expectMonotone) {
-                    throw new Error('Unexpected color: ' + (0, colors_1.colorToString)(color));
-                }
-                return;
-            default:
-                // Allow url()
-                if (color.type !== 'function' || color.func !== 'url') {
-                    // Do not allow other colors
-                    throw new Error('Unexpected color: ' + (0, colors_1.colorToString)(color));
-                }
-        }
-    });
-    return palette;
-}
-exports.validateColors = validateColors;

package/lib/css/parse.js

@@ -1,23 +0,0 @@
-"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/parser/error.js

@@ -1,27 +0,0 @@
-"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;

package/lib/css/parser/export.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tokensToString = void 0;
-const tab = '\t';
-const nl = '\n';
-/**
- * Convert tokens tree to string
- */
-function tokensToString(tree) {
-    let compact = true;
-    for (let i = 0; i < tree.length; i++) {
-        if (tree[i].type !== 'rule') {
-            compact = false;
-            break;
-        }
-    }
-    return tree
-        .map((token) => {
-        return parseToken(token, compact, 0);
-    })
-        .join('');
-}
-exports.tokensToString = tokensToString;
-/**
- * Old code
- */
-function parseToken(token, compact, depth) {
-    let content;
-    switch (token.type) {
-        case 'rule': {
-            return ((compact ? '' : tab.repeat(depth)) +
-                token.prop +
-                (compact ? ':' : ': ') +
-                token.value +
-                ';' +
-                (compact ? '' : nl));
-        }
-        case 'at-rule': {
-            content =
-                '@' + token.atRule + joinAtValues(token.atValues, compact);
-            break;
-        }
-        case 'selector': {
-            content = token.selectors.join(compact ? ',' : ', ');
-        }
-    }
-    const children = token.children.map((item) => {
-        return parseToken(item, compact, depth + 1);
-    });
-    return ((compact ? '' : tab.repeat(depth)) +
-        content +
-        (compact ? '{' : ' {' + nl) +
-        children.join('') +
-        (compact ? '}' : tab.repeat(depth) + '}' + nl));
-}
-/**
- * Join at-rule values
- */
-function joinAtValues(values, compact) {
-    return values
-        .map((item) => {
-        const value = typeof item === 'string' ? item : joinAtValues(item, compact);
-        if (value.slice(0, 1) === '(' || value.slice(-1) === ')') {
-            return value;
-        }
-        return '(' + value + ')';
-    })
-        .join(compact ? ',' : ', ');
-}

package/lib/css/parser/strings.js

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findEndOfURL = exports.findEndOfQuotedString = void 0;
-const error_1 = require("./error");
-/**
- * Find end of quoted string
- *
- * Returns index of character after quote
- */
-function findEndOfQuotedString(code, quote, start) {
-    let nextEscape = code.indexOf('\\', start + 1);
-    let end = code.indexOf(quote, start + 1);
-    if (end === -1) {
-        // Invalid string
-        return null;
-    }
-    while (nextEscape !== -1 && nextEscape < end) {
-        if (end === nextEscape + 1) {
-            end = code.indexOf(quote, end + 1);
-            if (end === -1) {
-                // Invalid string
-                return null;
-            }
-        }
-        nextEscape = code.indexOf('\\', nextEscape + 2);
-    }
-    return end + 1;
-}
-exports.findEndOfQuotedString = findEndOfQuotedString;
-/**
- * Find end of url
- *
- * Returns index of character after end of URL
- */
-function findEndOfURL(code, start) {
-    let index = (start || 0) + 4;
-    const length = code.length;
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        if (index >= length) {
-            return (0, error_1.styleParseError)('Cannot find end of URL', code, start);
-        }
-        let next = code.charAt(index);
-        switch (next) {
-            case '"':
-            case "'": {
-                // quoted url
-                let end = findEndOfQuotedString(code, next, index);
-                if (end === null) {
-                    return (0, error_1.styleParseError)('Incomplete string', code, index);
-                }
-                end = code.indexOf(')', end);
-                return end === -1
-                    ? (0, error_1.styleParseError)('Cannot find end of URL', code, start)
-                    : end + 1;
-            }
-            case ' ':
-            case '\t':
-            case '\r':
-            case '\n':
-                // skip whitespace
-                index++;
-                break;
-            default:
-                // unquoted url
-                // eslint-disable-next-line no-constant-condition
-                while (true) {
-                    switch (next) {
-                        case ')':
-                            return index + 1;
-                        case '"':
-                        case "'":
-                        case '(':
-                        case ' ':
-                        case '\t':
-                        case '\r':
-                        case '\n':
-                            return (0, error_1.styleParseError)('Invalid URL', code, start);
-                        default:
-                            if (code.charCodeAt(index) < 32) {
-                                return (0, error_1.styleParseError)('Invalid URL', code, start);
-                            }
-                    }
-                    index++;
-                    if (index >= length) {
-                        return (0, error_1.styleParseError)('Cannot find end of URL', code, start);
-                    }
-                    next = code.charAt(index);
-                }
-        }
-    }
-}
-exports.findEndOfURL = findEndOfURL;