@iconify/tools 1.3.17 → 2.0.0-dev.2

package/lib/icon-set/index.js

@@ -0,0 +1,776 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blankIconSet = exports.IconSet = exports.sortThemeKeys = void 0;
+const icon_1 = require("@iconify/utils/lib/icon");
+const build_1 = require("@iconify/utils/lib/svg/build");
+const customisations_1 = require("@iconify/utils/lib/customisations");
+const minify_1 = require("@iconify/utils/lib/icon-set/minify");
+const convert_info_1 = require("@iconify/utils/lib/icon-set/convert-info");
+const props_1 = require("./props");
+const svg_1 = require("../svg");
+// eslint-disable-next-line @typescript-eslint/no-unused-vars-experimental, @typescript-eslint/no-unused-vars
+function assertNever(v) {
+    //
+}
+// Maximum depth for looking for parent icons
+// Must match depth limit in Iconify Utils (tested in unit tests by parsing same icon set with deep aliases)
+const maxIteration = 6;
+// Theme keys
+const themeKeys = ['prefixes', 'suffixes'];
+/**
+ * Sort theme keys: long keys first
+ *
+ * Applies changes to parameter, but also returns it
+ */
+function sortThemeKeys(keys) {
+    return keys.sort((a, b) => a.length === b.length ? a.localeCompare(b) : b.length - a.length);
+}
+exports.sortThemeKeys = sortThemeKeys;
+/**
+ * Export icon set
+ */
+class IconSet {
+    /**
+     * Load icon set
+     */
+    constructor(data) {
+        this.load(data);
+    }
+    /**
+     * Load icon set
+     */
+    load(data) {
+        this.prefix = data.prefix;
+        // Defaults
+        const defaultProps = (0, props_1.filterProps)(data);
+        // Add icons
+        this.entries = Object.create(null);
+        const entries = this.entries;
+        for (const name in data.icons) {
+            const item = data.icons[name];
+            const entry = {
+                type: 'icon',
+                body: item.body,
+                props: { ...defaultProps, ...(0, props_1.filterProps)(item) },
+                chars: new Set(),
+                categories: new Set(),
+            };
+            entries[name] = entry;
+        }
+        // Add aliases
+        if (data.aliases) {
+            for (const name in data.aliases) {
+                const item = data.aliases[name];
+                const parent = item.parent;
+                const props = (0, props_1.filterProps)(item);
+                if (Object.keys(props).length) {
+                    // Variation
+                    const entry = {
+                        type: 'variation',
+                        parent,
+                        props,
+                        chars: new Set(),
+                        categories: new Set(),
+                    };
+                    entries[name] = entry;
+                }
+                else {
+                    // Alias
+                    const entry = {
+                        type: 'alias',
+                        parent,
+                    };
+                    entries[name] = entry;
+                }
+            }
+        }
+        // Info
+        const info = data.info && (0, convert_info_1.convertIconSetInfo)(data.info);
+        this.info = info || void 0;
+        // Characters map
+        if (data.chars) {
+            for (const char in data.chars) {
+                const name = data.chars[char];
+                const icon = entries[name];
+                if (icon) {
+                    switch (icon.type) {
+                        case 'icon':
+                        case 'variation':
+                            icon.chars.add(char);
+                    }
+                }
+            }
+        }
+        // Categories
+        this.categories = new Set();
+        if (data.categories) {
+            for (const category in data.categories) {
+                const item = {
+                    title: category,
+                    count: 0,
+                };
+                data.categories[category].forEach((iconName) => {
+                    const icon = entries[iconName];
+                    switch (icon === null || icon === void 0 ? void 0 : icon.type) {
+                        case 'icon':
+                        case 'variation':
+                            icon.categories.add(item);
+                    }
+                });
+                this.categories.add(item);
+                this.listCategory(item);
+            }
+        }
+        // Themes
+        const prefixes = (this.prefixes = Object.create(null));
+        const suffixes = (this.suffixes = Object.create(null));
+        if (data.themes) {
+            // Import legacy format
+            for (const key in data.themes) {
+                const item = data.themes[key];
+                if (typeof item.prefix === 'string') {
+                    // Prefix ending with with '-'
+                    const prefix = item.prefix;
+                    if (prefix.slice(-1) === '-') {
+                        prefixes[prefix.slice(0, prefix.length - 1)] =
+                            item.title;
+                    }
+                }
+                if (typeof item.suffix === 'string') {
+                    // Suffix starting with with '-'
+                    const suffix = item.suffix;
+                    if (suffix.slice(0, 1) === '-') {
+                        suffixes[suffix.slice(1)] = item.title;
+                    }
+                }
+            }
+        }
+        themeKeys.forEach((prop) => {
+            // Copy data, overwriting imported legacy format
+            const items = data[prop];
+            if (items) {
+                this[prop] = Object.create(null);
+                for (const key in items) {
+                    this[prop][key] = items[key];
+                }
+            }
+        });
+    }
+    /**
+     * List icons
+     */
+    list(types = ['icon', 'variation']) {
+        return Object.keys(this.entries).filter((name) => {
+            const type = this.entries[name].type;
+            return types.indexOf(type) !== -1;
+        });
+    }
+    /**
+     * forEach function to loop through all entries.
+     * Supports asynchronous callbacks.
+     *
+     * Callback should return false to stop loop.
+     */
+    async forEach(callback, types = ['icon', 'variation', 'alias']) {
+        const names = this.list(types);
+        for (let i = 0; i < names.length; i++) {
+            const name = names[i];
+            const item = this.entries[name];
+            if (item) {
+                let result = callback(name, item.type);
+                if (result instanceof Promise) {
+                    result = await result;
+                }
+                if (result === false) {
+                    return;
+                }
+            }
+        }
+    }
+    resolve(name, full = false) {
+        const entries = this.entries;
+        function getIcon(name, iteration) {
+            if (entries[name] === void 0 || iteration > maxIteration) {
+                // Missing or loop is too deep
+                return null;
+            }
+            const item = entries[name];
+            switch (item.type) {
+                case 'icon': {
+                    const result = {
+                        body: item.body,
+                        ...item.props,
+                    };
+                    return result;
+                }
+                case 'alias':
+                    return getIcon(item.parent, iteration + 1);
+                case 'variation': {
+                    const parent = getIcon(item.parent, iteration + 1);
+                    if (!parent) {
+                        return null;
+                    }
+                    for (const key in item.props) {
+                        const attr = key;
+                        const value = item.props[attr];
+                        if (value) {
+                            if (parent[attr] === void 0) {
+                                parent[attr] = value;
+                            }
+                            else {
+                                // Merge props
+                                switch (attr) {
+                                    case 'rotate':
+                                        parent[attr] =
+                                            (parent[attr] +
+                                                value) %
+                                                4;
+                                        break;
+                                    case 'hFlip':
+                                    case 'vFlip':
+                                        parent[attr] = !parent[attr];
+                                        break;
+                                    default:
+                                        parent[attr] = value;
+                                        break;
+                                }
+                            }
+                        }
+                    }
+                    return parent;
+                }
+                default:
+                    assertNever(item);
+                    return null;
+            }
+        }
+        const result = getIcon(name, 0);
+        // Return icon
+        return result && full ? (0, icon_1.fullIcon)(result) : result;
+    }
+    /**
+     * Generate HTML
+     */
+    toString(name, custommisations = {
+        width: 'auto',
+        height: 'auto',
+    }) {
+        const item = this.resolve(name, true);
+        if (!item) {
+            return null;
+        }
+        const result = (0, build_1.iconToSVG)(item, {
+            ...customisations_1.defaults,
+            ...custommisations,
+        });
+        const attributes = Object.keys(result.attributes)
+            .map((key) => ` ${key}="${result.attributes[key]}"`)
+            .join('');
+        return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"${attributes}>${result.body}</svg>`;
+    }
+    /**
+     * Get SVG instance for icon
+     */
+    toSVG(name) {
+        const html = this.toString(name);
+        return html ? new svg_1.SVG(html) : null;
+    }
+    /**
+     * Export icon set
+     */
+    export(validate = true) {
+        const icons = Object.create(null);
+        const aliases = Object.create(null);
+        // Add icons
+        const names = Object.keys(this.entries);
+        names.sort((a, b) => a.localeCompare(b));
+        names.forEach((name) => {
+            const item = this.entries[name];
+            switch (item.type) {
+                case 'icon': {
+                    const icon = {
+                        body: item.body,
+                        ...item.props,
+                    };
+                    icons[name] = icon;
+                    break;
+                }
+                case 'alias':
+                case 'variation': {
+                    if (validate && !this.resolve(name)) {
+                        break;
+                    }
+                    const props = item.type === 'variation' ? item.props : {};
+                    const alias = {
+                        parent: item.parent,
+                        ...props,
+                    };
+                    aliases[name] = alias;
+                    break;
+                }
+                default: {
+                    assertNever(item);
+                }
+            }
+        });
+        // Add info
+        let info;
+        if (this.info) {
+            // Update icons count and clone object
+            this.info.total = this.count();
+            info = JSON.parse(JSON.stringify(this.info));
+        }
+        // Generate result
+        const result = {
+            prefix: this.prefix,
+        };
+        if (info) {
+            result.info = info;
+        }
+        result.icons = icons;
+        if (Object.keys(aliases).length) {
+            result.aliases = aliases;
+        }
+        // Add characters
+        const chars = this.chars(Object.keys(icons).concat(Object.keys(aliases)));
+        if (Object.keys(chars).length) {
+            result.chars = chars;
+        }
+        // Get categories
+        const categories = Object.create(null);
+        Array.from(this.categories)
+            // Sort
+            .sort((a, b) => a.title.localeCompare(b.title))
+            // Get list of icons
+            .forEach((item) => {
+            const names = this.listCategory(item);
+            if (names) {
+                categories[item.title] = names;
+            }
+        });
+        if (Object.keys(categories).length) {
+            result.categories = categories;
+        }
+        // Add themes
+        themeKeys.forEach((prop) => {
+            const items = this[prop];
+            const keys = Object.keys(items);
+            if (keys.length) {
+                // Sort theme and get matching icon names
+                sortThemeKeys(keys);
+                const sortedTheme = Object.create(null);
+                const tested = this.checkTheme(prop === 'prefixes');
+                // Add all themes that aren't empty
+                keys.forEach((key) => {
+                    if (tested.valid[key].length) {
+                        sortedTheme[key] = items[key];
+                    }
+                });
+                // Make sure themes do exist
+                if (Object.keys(sortedTheme).length) {
+                    result[prop] = sortedTheme;
+                }
+            }
+        });
+        // Minify icon set
+        (0, minify_1.minifyIconSet)(result);
+        return result;
+    }
+    /**
+     * Get characters map
+     */
+    chars(names) {
+        const chars = Object.create(null);
+        if (!names) {
+            names = Object.keys(this.entries);
+        }
+        for (let i = 0; i < names.length; i++) {
+            const name = names[i];
+            const item = this.entries[name];
+            switch (item.type) {
+                case 'icon':
+                case 'variation':
+                    item.chars.forEach((char) => {
+                        chars[char] = name;
+                    });
+            }
+        }
+        return chars;
+    }
+    /**
+     * Filter icons
+     */
+    _filter(callback) {
+        const names = [];
+        for (const key in this.entries) {
+            const item = this.entries[key];
+            switch (item.type) {
+                case 'icon': {
+                    if (callback(key, item)) {
+                        names.push(key);
+                    }
+                    break;
+                }
+                case 'variation':
+                case 'alias': {
+                    // Resolve alias to make sure parent icon is not hidden
+                    const icon = this.resolve(key);
+                    if (icon && callback(key, item, icon)) {
+                        names.push(key);
+                    }
+                    break;
+                }
+            }
+        }
+        return names;
+    }
+    /**
+     * Count icons
+     */
+    count() {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars-experimental
+        return this._filter((key, item, icon) => {
+            if (item.type === 'alias' || item.props.hidden || (icon === null || icon === void 0 ? void 0 : icon.hidden)) {
+                return false;
+            }
+            return true;
+        }).length;
+    }
+    /**
+     * Find category by title
+     */
+    _findCategory(title, add) {
+        const categoryItem = Array.from(this.categories).find((item) => item.title === title);
+        if (categoryItem) {
+            return categoryItem;
+        }
+        if (add) {
+            const newItem = {
+                title,
+                count: 0,
+            };
+            this.categories.add(newItem);
+            return newItem;
+        }
+        return null;
+    }
+    /**
+     * Count icons in category, remove category if empty
+     *
+     * Hidden icons and aliases do not count
+     */
+    listCategory(category) {
+        // Find item
+        const categoryItem = typeof category === 'string'
+            ? this._findCategory(category, false)
+            : category;
+        if (!categoryItem) {
+            return null;
+        }
+        // Find icons
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars-experimental
+        const icons = this._filter((key, item, icon) => {
+            if (item.type === 'alias' || item.props.hidden || (icon === null || icon === void 0 ? void 0 : icon.hidden)) {
+                return false;
+            }
+            return item.categories.has(categoryItem);
+        });
+        // Update count, remove category if empty
+        const count = icons.length;
+        categoryItem.count = count;
+        if (!count) {
+            this.categories.delete(categoryItem);
+            return null;
+        }
+        return icons;
+    }
+    /**
+     * Check if icon exists
+     */
+    exists(name) {
+        return !!this.entries[name];
+    }
+    /**
+     * Remove icons. Returns number of removed icons
+     *
+     * If removeDependencies is a string, it represents new parent for all aliases of removed icon.
+     */
+    remove(name, removeDependencies = true) {
+        const entries = this.entries;
+        const names = new Set();
+        // Check if new parent exists
+        if (typeof removeDependencies === 'string') {
+            if (name === removeDependencies || !entries[removeDependencies]) {
+                return 0;
+            }
+            names.add(removeDependencies);
+        }
+        function del(name, iteration) {
+            if (entries[name] === void 0 ||
+                iteration > maxIteration ||
+                names.has(name)) {
+                // Missing or loop is too deep
+                return false;
+            }
+            names.add(name);
+            if (removeDependencies === true ||
+                (!iteration && typeof removeDependencies === 'string')) {
+                // Find icons that have this icon as parent
+                for (const key in entries) {
+                    const item = entries[key];
+                    switch (item.type) {
+                        case 'icon':
+                            break;
+                        case 'alias':
+                        case 'variation':
+                            if (item.parent === name) {
+                                if (removeDependencies === true) {
+                                    if (!del(key, iteration + 1)) {
+                                        return false;
+                                    }
+                                    break;
+                                }
+                                // Change parent
+                                item.parent = removeDependencies;
+                            }
+                            break;
+                        default:
+                            assertNever(item);
+                    }
+                }
+            }
+            return true;
+        }
+        if (del(name, 0)) {
+            if (typeof removeDependencies === 'string') {
+                names.delete(removeDependencies);
+            }
+            names.forEach((name) => {
+                delete entries[name];
+            });
+            return names.size;
+        }
+        return 0;
+    }
+    /**
+     * Remove icon
+     */
+    rename(oldName, newName) {
+        const entries = this.entries;
+        // Remove existing item with new name
+        if (entries[newName]) {
+            if (!this.remove(newName)) {
+                return false;
+            }
+        }
+        // Rename icon
+        if (!entries[oldName]) {
+            return false;
+        }
+        entries[newName] = entries[oldName];
+        delete entries[oldName];
+        // Find aliases
+        for (const key in entries) {
+            const item = entries[key];
+            switch (item.type) {
+                case 'icon':
+                    break;
+                case 'alias':
+                case 'variation':
+                    if (item.parent === oldName) {
+                        item.parent = newName;
+                    }
+                    break;
+                default:
+                    assertNever(item);
+            }
+        }
+        return true;
+    }
+    /**
+     * Add/update item
+     */
+    setItem(name, item) {
+        switch (item.type) {
+            case 'alias':
+            case 'variation': {
+                if (!this.entries[item.parent]) {
+                    return false;
+                }
+            }
+        }
+        this.entries[name] = item;
+        return true;
+    }
+    /**
+     * Add/update icon
+     */
+    setIcon(name, icon) {
+        return this.setItem(name, {
+            type: 'icon',
+            body: icon.body,
+            props: (0, props_1.filterProps)(icon),
+            chars: new Set(),
+            categories: new Set(),
+        });
+    }
+    /**
+     * Add/update alias without props
+     */
+    setAlias(name, parent) {
+        return this.setItem(name, {
+            type: 'alias',
+            parent,
+        });
+    }
+    /**
+     * Add/update alias with props
+     */
+    setVariation(name, parent, props) {
+        // Copy categories
+        let categories;
+        while (!categories) {
+            const parentItem = this.entries[parent];
+            if (!parentItem) {
+                return false;
+            }
+            if (parentItem.type === 'alias') {
+                parent = parentItem.parent;
+            }
+            else {
+                categories = new Set(parentItem.categories);
+            }
+        }
+        return this.setItem(name, {
+            type: 'variation',
+            parent,
+            props,
+            chars: new Set(),
+            categories,
+        });
+    }
+    /**
+     * Icon from SVG. Updates old icon if it exists
+     */
+    fromSVG(name, svg) {
+        const props = svg.viewBox;
+        const body = svg.getBody();
+        const item = this.entries[name];
+        switch (item === null || item === void 0 ? void 0 : item.type) {
+            case 'icon':
+            case 'variation': {
+                // Copy extra properties
+                for (const key in props_1.extraDefaultProps) {
+                    const prop = key;
+                    if (item.props[prop]) {
+                        props[prop] = item.props[prop];
+                    }
+                }
+                // Set icon
+                return this.setItem(name, {
+                    type: 'icon',
+                    body,
+                    props,
+                    chars: item.chars,
+                    categories: item.categories,
+                });
+            }
+        }
+        // Create new entry
+        return this.setIcon(name, {
+            body,
+            ...props,
+        });
+    }
+    /**
+     * Add or remove character for icon
+     */
+    toggleCharacter(iconName, char, add) {
+        const item = this.entries[iconName];
+        if (!item) {
+            return false;
+        }
+        switch (item.type) {
+            case 'icon':
+            case 'variation':
+                if (item.chars.has(char) !== add) {
+                    item.chars[add ? 'add' : 'delete'](char);
+                    return true;
+                }
+        }
+        return false;
+    }
+    /**
+     * Add or remove category for icon
+     */
+    toggleCategory(iconName, category, add) {
+        const item = this.entries[iconName];
+        const categoryItem = this._findCategory(category, add);
+        if (!item || !categoryItem) {
+            return false;
+        }
+        switch (item.type) {
+            case 'icon':
+            case 'variation':
+                if (item.categories.has(categoryItem) !== add) {
+                    categoryItem.count += add ? 1 : -1;
+                    item.categories[add ? 'add' : 'delete'](categoryItem);
+                    return true;
+                }
+        }
+        return false;
+    }
+    /**
+     * Find icons that belong to theme
+     */
+    checkTheme(prefix) {
+        const themes = prefix ? this.prefixes : this.suffixes;
+        const keys = sortThemeKeys(Object.keys(themes));
+        const results = {
+            valid: Object.create(null),
+            invalid: [],
+        };
+        keys.forEach((key) => {
+            results.valid[key] = [];
+        });
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars-experimental
+        results.invalid = this._filter((name, item, icon) => {
+            if (item.type === 'alias' || item.props.hidden || (icon === null || icon === void 0 ? void 0 : icon.hidden)) {
+                return false;
+            }
+            // Check if icon belongs to theme
+            for (let i = 0; i < keys.length; i++) {
+                const search = keys[i];
+                if (search === '') {
+                    // Last item: matches all icons that do not belong to other themes
+                    results.valid[search].push(name);
+                    return false;
+                }
+                const match = prefix ? search + '-' : '-' + search;
+                const length = match.length;
+                const test = prefix
+                    ? name.slice(0, length)
+                    : name.slice(0 - length);
+                if (test === match) {
+                    // Icon belongs to theme
+                    results.valid[search].push(name);
+                    return false;
+                }
+            }
+            // Icon does not belong to any theme
+            return true;
+        });
+        return results;
+    }
+}
+exports.IconSet = IconSet;
+/**
+ * Create blank icon set
+ */
+function blankIconSet(prefix) {
+    return new IconSet({
+        prefix,
+        icons: {},
+    });
+}
+exports.blankIconSet = blankIconSet;