@iconify/tools 1.3.17 → 2.0.0-dev.2

package/lib/icon-set/index.mjs

@@ -0,0 +1,617 @@
+// src/icon-set/index.ts
+import { fullIcon } from "@iconify/utils/lib/icon";
+import { iconToSVG } from "@iconify/utils/lib/svg/build";
+import {
+  defaults
+} from "@iconify/utils/lib/customisations";
+import { minifyIconSet } from "@iconify/utils/lib/icon-set/minify";
+import { convertIconSetInfo } from "@iconify/utils/lib/icon-set/convert-info";
+import { extraDefaultProps, filterProps } from "./props.mjs";
+import { SVG } from "../svg/index.mjs";
+function assertNever(v) {
+}
+var maxIteration = 6;
+var themeKeys = ["prefixes", "suffixes"];
+function sortThemeKeys(keys) {
+  return keys.sort((a, b) => a.length === b.length ? a.localeCompare(b) : b.length - a.length);
+}
+var IconSet = class {
+  constructor(data) {
+    this.load(data);
+  }
+  load(data) {
+    this.prefix = data.prefix;
+    const defaultProps = filterProps(data);
+    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, ...filterProps(item) },
+        chars: new Set(),
+        categories: 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 = filterProps(item);
+        if (Object.keys(props).length) {
+          const entry = {
+            type: "variation",
+            parent,
+            props,
+            chars: new Set(),
+            categories: new Set()
+          };
+          entries[name] = entry;
+        } else {
+          const entry = {
+            type: "alias",
+            parent
+          };
+          entries[name] = entry;
+        }
+      }
+    }
+    const info = data.info && 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) {
+          switch (icon.type) {
+            case "icon":
+            case "variation":
+              icon.chars.add(char);
+          }
+        }
+      }
+    }
+    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 ? void 0 : icon.type) {
+            case "icon":
+            case "variation":
+              icon.categories.add(item);
+          }
+        });
+        this.categories.add(item);
+        this.listCategory(item);
+      }
+    }
+    const prefixes = this.prefixes = Object.create(null);
+    const suffixes = this.suffixes = 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, prefix.length - 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] = 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:
+          assertNever(item);
+          return null;
+      }
+    }
+    const result = getIcon(name, 0);
+    return result && full ? fullIcon(result) : result;
+  }
+  toString(name, custommisations = {
+    width: "auto",
+    height: "auto"
+  }) {
+    const item = this.resolve(name, true);
+    if (!item) {
+      return null;
+    }
+    const result = iconToSVG(item, {
+      ...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(html) : null;
+  }
+  export(validate = true) {
+    const icons = Object.create(null);
+    const aliases = 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;
+        }
+        default: {
+          assertNever(item);
+        }
+      }
+    });
+    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 = Object.create(null);
+    Array.from(this.categories).sort((a, b) => a.title.localeCompare(b.title)).forEach((item) => {
+      const names2 = this.listCategory(item);
+      if (names2) {
+        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 = 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;
+        }
+      }
+    });
+    minifyIconSet(result);
+    return result;
+  }
+  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(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 == null ? void 0 : 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, icon) => {
+      if (item.type === "alias" || item.props.hidden || (icon == null ? void 0 : icon.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 = 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;
+            default:
+              assertNever(item);
+          }
+        }
+      }
+      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;
+        default:
+          assertNever(item);
+      }
+    }
+    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: filterProps(icon),
+      chars: new Set(),
+      categories: new Set()
+    });
+  }
+  setAlias(name, parent) {
+    return this.setItem(name, {
+      type: "alias",
+      parent
+    });
+  }
+  setVariation(name, parent, props) {
+    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
+    });
+  }
+  fromSVG(name, svg) {
+    const props = svg.viewBox;
+    const body = svg.getBody();
+    const item = this.entries[name];
+    switch (item == null ? void 0 : item.type) {
+      case "icon":
+      case "variation": {
+        for (const key in 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.categories
+        });
+      }
+    }
+    return this.setIcon(name, {
+      body,
+      ...props
+    });
+  }
+  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;
+  }
+  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;
+  }
+  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] = [];
+    });
+    results.invalid = this._filter((name, item, icon) => {
+      if (item.type === "alias" || item.props.hidden || (icon == null ? void 0 : 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: {}
+  });
+}
+export {
+  IconSet,
+  blankIconSet,
+  sortThemeKeys
+};

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

@@ -0,0 +1,6 @@
+import type { FullIconifyIcon } from '@iconify/utils/lib/icon';
+import type { IconSet } from '.';
+/**
+ * Find matching icon in icon set
+ */
+export declare function findMatchingIcon(iconSet: IconSet, icon: FullIconifyIcon): string | null;

package/lib/icon-set/match.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMatchingIcon = void 0;
+const icon_1 = require("@iconify/utils/lib/icon");
+// Maximum depth for looking for parent icons
+const maxIteration = 5;
+/**
+ * Find matching icon in icon set
+ */
+function findMatchingIcon(iconSet, icon) {
+    const body = icon.body;
+    let hiddenMatch = null;
+    function isMatching(data) {
+        for (const key in icon_1.iconDefaults) {
+            const attr = key;
+            if (data[attr] !== icon[attr]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if icon matches
+     */
+    function test(name, iteration) {
+        const data = iconSet.resolve(name, true);
+        if (!data) {
+            return null;
+        }
+        if (isMatching(data)) {
+            if (data.hidden) {
+                hiddenMatch = name;
+            }
+            else {
+                return name;
+            }
+        }
+        if (iteration > maxIteration) {
+            return null;
+        }
+        // Check aliases
+        for (const key in iconSet.entries) {
+            const item = iconSet.entries[key];
+            if (item.type === 'variation' && item.parent === name) {
+                const result = test(key, iteration + 1);
+                if (typeof result === 'string') {
+                    return result;
+                }
+            }
+        }
+        return null;
+    }
+    // Find icons that match
+    for (const key in iconSet.entries) {
+        const item = iconSet.entries[key];
+        if (item.type === 'icon' && item.body === body) {
+            // Possible match
+            const result = test(key, 0);
+            if (typeof result === 'string') {
+                return result;
+            }
+        }
+    }
+    return hiddenMatch;
+}
+exports.findMatchingIcon = findMatchingIcon;