@iconify/tools 2.0.14 → 2.0.15

package/lib/icon-set/index.cjs

@@ -0,0 +1,589 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const icon = require('@iconify/utils/lib/icon');
+const build = require('@iconify/utils/lib/svg/build');
+const customisations = require('@iconify/utils/lib/customisations');
+const minify = require('@iconify/utils/lib/icon-set/minify');
+const convertInfo = require('@iconify/utils/lib/icon-set/convert-info');
+const iconSet_props = require('./props.cjs');
+const svg_index = require('../svg/index.cjs');
+require('cheerio');
+require('@iconify/utils');
+
+const maxIteration = 6;
+const themeKeys = ["prefixes", "suffixes"];
+function sortThemeKeys(keys) {
+  return keys.sort((a, b) => a.length === b.length ? a.localeCompare(b) : b.length - a.length);
+}
+class IconSet {
+  constructor(data) {
+    this.load(data);
+  }
+  load(data) {
+    this.prefix = data.prefix;
+    const defaultProps = iconSet_props.filterProps(data, true);
+    this.entries = /* @__PURE__ */ 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: iconSet_props.filterProps({
+          ...defaultProps,
+          ...item
+        }, true),
+        chars: /* @__PURE__ */ new Set(),
+        categories: /* @__PURE__ */ new Set()
+      };
+      entries[name] = entry;
+    }
+    if (data.aliases) {
+      for (const name in data.aliases) {
+        const item = data.aliases[name];
+        const parent = item.parent;
+        const props = iconSet_props.filterProps(item, false);
+        const chars = /* @__PURE__ */ new Set();
+        if (Object.keys(props).length) {
+          const entry = {
+            type: "variation",
+            parent,
+            props,
+            chars
+          };
+          entries[name] = entry;
+        } else {
+          const entry = {
+            type: "alias",
+            parent,
+            chars
+          };
+          entries[name] = entry;
+        }
+      }
+    }
+    const info = data.info && convertInfo.convertIconSetInfo(data.info);
+    this.info = info || void 0;
+    if (data.chars) {
+      for (const char in data.chars) {
+        const name = data.chars[char];
+        const icon = entries[name];
+        if (icon) {
+          icon.chars.add(char);
+        }
+      }
+    }
+    this.categories = /* @__PURE__ */ 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?.type) {
+            case "icon":
+              icon.categories.add(item);
+          }
+        });
+        this.categories.add(item);
+        this.listCategory(item);
+      }
+    }
+    const prefixes = this.prefixes = /* @__PURE__ */ Object.create(null);
+    const suffixes = this.suffixes = /* @__PURE__ */ Object.create(null);
+    if (data.themes) {
+      for (const key in data.themes) {
+        const item = data.themes[key];
+        if (typeof item.prefix === "string") {
+          const prefix = item.prefix;
+          if (prefix.slice(-1) === "-") {
+            prefixes[prefix.slice(0, -1)] = item.title;
+          }
+        }
+        if (typeof item.suffix === "string") {
+          const suffix = item.suffix;
+          if (suffix.slice(0, 1) === "-") {
+            suffixes[suffix.slice(1)] = item.title;
+          }
+        }
+      }
+    }
+    themeKeys.forEach((prop) => {
+      const items = data[prop];
+      if (items) {
+        this[prop] = /* @__PURE__ */ Object.create(null);
+        for (const key in items) {
+          this[prop][key] = items[key];
+        }
+      }
+    });
+  }
+  list(types = ["icon", "variation"]) {
+    return Object.keys(this.entries).filter((name) => {
+      const type = this.entries[name].type;
+      return types.indexOf(type) !== -1;
+    });
+  }
+  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(name2, iteration) {
+      if (entries[name2] === void 0 || iteration > maxIteration) {
+        return null;
+      }
+      const item = entries[name2];
+      switch (item.type) {
+        case "icon": {
+          const result2 = {
+            body: item.body,
+            ...item.props
+          };
+          return result2;
+        }
+        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 {
+                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:
+          return null;
+      }
+    }
+    const result = getIcon(name, 0);
+    return result && full ? icon.fullIcon(result) : result;
+  }
+  toString(name, custommisations = {
+    width: "auto",
+    height: "auto"
+  }) {
+    const item = this.resolve(name, true);
+    if (!item) {
+      return null;
+    }
+    const result = build.iconToSVG(item, {
+      ...customisations.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>`;
+  }
+  toSVG(name) {
+    const html = this.toString(name);
+    return html ? new svg_index.SVG(html) : null;
+  }
+  export(validate = true) {
+    const icons = /* @__PURE__ */ Object.create(null);
+    const aliases = /* @__PURE__ */ Object.create(null);
+    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;
+        }
+      }
+    });
+    let info;
+    if (this.info) {
+      this.info.total = this.count();
+      info = JSON.parse(JSON.stringify(this.info));
+    }
+    const result = {
+      prefix: this.prefix
+    };
+    if (info) {
+      result.info = info;
+    }
+    result.icons = icons;
+    if (Object.keys(aliases).length) {
+      result.aliases = aliases;
+    }
+    const chars = this.chars(Object.keys(icons).concat(Object.keys(aliases)));
+    if (Object.keys(chars).length) {
+      result.chars = chars;
+    }
+    const categories = /* @__PURE__ */ Object.create(null);
+    Array.from(this.categories).sort((a, b) => a.title.localeCompare(b.title)).forEach((item) => {
+      const names2 = this.listCategory(item);
+      if (names2) {
+        names2.sort((a, b) => a.localeCompare(b));
+        categories[item.title] = names2;
+      }
+    });
+    if (Object.keys(categories).length) {
+      result.categories = categories;
+    }
+    themeKeys.forEach((prop) => {
+      const items = this[prop];
+      const keys = Object.keys(items);
+      if (keys.length) {
+        sortThemeKeys(keys);
+        const sortedTheme = /* @__PURE__ */ Object.create(null);
+        const tested = this.checkTheme(prop === "prefixes");
+        keys.forEach((key) => {
+          if (tested.valid[key].length) {
+            sortedTheme[key] = items[key];
+          }
+        });
+        if (Object.keys(sortedTheme).length) {
+          result[prop] = sortedTheme;
+        }
+      }
+    });
+    minify.minifyIconSet(result);
+    return result;
+  }
+  chars(names) {
+    const chars = /* @__PURE__ */ 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];
+      item.chars.forEach((char) => {
+        chars[char] = name;
+      });
+    }
+    return chars;
+  }
+  _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": {
+          const icon = this.resolve(key);
+          if (icon && callback(key, item, icon)) {
+            names.push(key);
+          }
+          break;
+        }
+      }
+    }
+    return names;
+  }
+  count() {
+    return this._filter((_key, item, icon) => {
+      if (item.type === "alias" || item.props.hidden || icon?.hidden) {
+        return false;
+      }
+      return true;
+    }).length;
+  }
+  _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;
+  }
+  listCategory(category) {
+    const categoryItem = typeof category === "string" ? this._findCategory(category, false) : category;
+    if (!categoryItem) {
+      return null;
+    }
+    const icons = this._filter((_key, item) => {
+      if (item.type !== "icon" || item.props.hidden) {
+        return false;
+      }
+      return item.categories.has(categoryItem);
+    });
+    const count = icons.length;
+    categoryItem.count = count;
+    if (!count) {
+      this.categories.delete(categoryItem);
+      return null;
+    }
+    return icons;
+  }
+  exists(name) {
+    return !!this.entries[name];
+  }
+  remove(name, removeDependencies = true) {
+    const entries = this.entries;
+    const names = /* @__PURE__ */ new Set();
+    if (typeof removeDependencies === "string") {
+      if (name === removeDependencies || !entries[removeDependencies]) {
+        return 0;
+      }
+      names.add(removeDependencies);
+    }
+    function del(name2, iteration) {
+      if (entries[name2] === void 0 || iteration > maxIteration || names.has(name2)) {
+        return false;
+      }
+      names.add(name2);
+      if (removeDependencies === true || !iteration && typeof removeDependencies === "string") {
+        for (const key in entries) {
+          const item = entries[key];
+          switch (item.type) {
+            case "icon":
+              break;
+            case "alias":
+            case "variation":
+              if (item.parent === name2) {
+                if (removeDependencies === true) {
+                  if (!del(key, iteration + 1)) {
+                    return false;
+                  }
+                  break;
+                }
+                item.parent = removeDependencies;
+              }
+              break;
+          }
+        }
+      }
+      return true;
+    }
+    if (del(name, 0)) {
+      if (typeof removeDependencies === "string") {
+        names.delete(removeDependencies);
+      }
+      names.forEach((name2) => {
+        delete entries[name2];
+      });
+      return names.size;
+    }
+    return 0;
+  }
+  rename(oldName, newName) {
+    const entries = this.entries;
+    if (entries[newName]) {
+      if (!this.remove(newName)) {
+        return false;
+      }
+    }
+    if (!entries[oldName]) {
+      return false;
+    }
+    entries[newName] = entries[oldName];
+    delete entries[oldName];
+    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;
+      }
+    }
+    return true;
+  }
+  setItem(name, item) {
+    switch (item.type) {
+      case "alias":
+      case "variation": {
+        if (!this.entries[item.parent]) {
+          return false;
+        }
+      }
+    }
+    this.entries[name] = item;
+    return true;
+  }
+  setIcon(name, icon) {
+    return this.setItem(name, {
+      type: "icon",
+      body: icon.body,
+      props: iconSet_props.filterProps(icon, true),
+      chars: /* @__PURE__ */ new Set(),
+      categories: /* @__PURE__ */ new Set()
+    });
+  }
+  setAlias(name, parent) {
+    return this.setItem(name, {
+      type: "alias",
+      parent,
+      chars: /* @__PURE__ */ new Set()
+    });
+  }
+  setVariation(name, parent, props) {
+    return this.setItem(name, {
+      type: "variation",
+      parent,
+      props,
+      chars: /* @__PURE__ */ new Set()
+    });
+  }
+  fromSVG(name, svg) {
+    const props = svg.viewBox;
+    const body = svg.getBody();
+    const item = this.entries[name];
+    switch (item?.type) {
+      case "icon":
+      case "variation": {
+        for (const key in iconSet_props.extraDefaultProps) {
+          const prop = key;
+          if (item.props[prop]) {
+            props[prop] = item.props[prop];
+          }
+        }
+        return this.setItem(name, {
+          type: "icon",
+          body,
+          props,
+          chars: item.chars,
+          categories: item.type === "icon" ? item.categories : /* @__PURE__ */ new Set()
+        });
+      }
+    }
+    return this.setIcon(name, {
+      body,
+      ...props
+    });
+  }
+  toggleCharacter(iconName, char, add) {
+    const item = this.entries[iconName];
+    if (!item) {
+      return false;
+    }
+    if (item.chars.has(char) !== add) {
+      item.chars[add ? "add" : "delete"](char);
+      return true;
+    }
+    return false;
+  }
+  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":
+        if (item.categories.has(categoryItem) !== add) {
+          categoryItem.count += add ? 1 : -1;
+          item.categories[add ? "add" : "delete"](categoryItem);
+          return true;
+        }
+    }
+    return false;
+  }
+  checkTheme(prefix) {
+    const themes = prefix ? this.prefixes : this.suffixes;
+    const keys = sortThemeKeys(Object.keys(themes));
+    const results = {
+      valid: /* @__PURE__ */ Object.create(null),
+      invalid: []
+    };
+    keys.forEach((key) => {
+      results.valid[key] = [];
+    });
+    results.invalid = this._filter((name, item, icon) => {
+      if (item.type === "alias" || item.props.hidden || icon?.hidden) {
+        return false;
+      }
+      for (let i = 0; i < keys.length; i++) {
+        const search = keys[i];
+        if (search === "") {
+          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) {
+          results.valid[search].push(name);
+          return false;
+        }
+      }
+      return true;
+    });
+    return results;
+  }
+}
+function blankIconSet(prefix) {
+  return new IconSet({
+    prefix,
+    icons: {}
+  });
+}
+
+exports.IconSet = IconSet;
+exports.blankIconSet = blankIconSet;
+exports.sortThemeKeys = sortThemeKeys;

package/lib/icon-set/index.d.ts

@@ -1,17 +1,18 @@
-import type { IconifyJSON, IconifyInfo } from '@iconify/types';
+import { IconifyInfo, IconifyJSON } from '@iconify/types';
 import { IconifyIconCustomisations } from '@iconify/utils/lib/customisations';
-import type { CheckThemeResult, CommonIconProps, IconCategory, IconSetAsyncForEachCallback, IconSetIconEntry, IconSetIconType, ResolvedIconifyIcon } from './types';
-import { SVG } from '../svg';
+import { IconSetIconEntry, IconCategory, IconSetIconType, IconSetAsyncForEachCallback, ResolvedIconifyIcon, CommonIconProps, CheckThemeResult } from './types.js';
+import { SVG } from '../svg/index.js';
+
 /**
  * Sort theme keys: long keys first
  *
  * Applies changes to parameter, but also returns it
  */
-export declare function sortThemeKeys(keys: string[]): string[];
+declare function sortThemeKeys(keys: string[]): string[];
 /**
  * Export icon set
  */
-export declare class IconSet {
+declare class IconSet {
     /**
      * Properties. You can write directly to almost any property, but avoid writing to
      * 'entries' and 'categories' properties, there are functions for that.
@@ -131,4 +132,6 @@ export declare class IconSet {
 /**
  * Create blank icon set
  */
-export declare function blankIconSet(prefix: string): IconSet;
+declare function blankIconSet(prefix: string): IconSet;
+
+export { IconSet, blankIconSet, sortThemeKeys };