@iconify/tools 1.3.17 → 2.0.0-dev.2

package/lib/icon-set/match.mjs

@@ -0,0 +1,55 @@
+// src/icon-set/match.ts
+import { iconDefaults } from "@iconify/utils/lib/icon";
+var maxIteration = 5;
+function findMatchingIcon(iconSet, icon) {
+  const body = icon.body;
+  let hiddenMatch = null;
+  function isMatching(data) {
+    for (const key in iconDefaults) {
+      const attr = key;
+      if (data[attr] !== icon[attr]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  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;
+    }
+    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;
+  }
+  for (const key in iconSet.entries) {
+    const item = iconSet.entries[key];
+    if (item.type === "icon" && item.body === body) {
+      const result = test(key, 0);
+      if (typeof result === "string") {
+        return result;
+      }
+    }
+  }
+  return hiddenMatch;
+}
+export {
+  findMatchingIcon
+};

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

@@ -0,0 +1,5 @@
+import { IconSet } from '.';
+/**
+ * Merge icon sets
+ */
+export declare function mergeIconSets(oldIcons: IconSet, newIcons: IconSet): IconSet;

package/lib/icon-set/merge.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeIconSets = void 0;
+const _1 = require(".");
+const match_1 = require("./match");
+// eslint-disable-next-line @typescript-eslint/no-unused-vars-experimental, @typescript-eslint/no-unused-vars
+function assertNever(v) {
+    //
+}
+/**
+ * Merge icon sets
+ */
+function mergeIconSets(oldIcons, newIcons) {
+    const mergedIcons = new _1.IconSet(newIcons.export());
+    const oldEntries = oldIcons.entries;
+    const entries = mergedIcons.entries;
+    function add(name) {
+        if (entries[name]) {
+            // Already exists
+            return true;
+        }
+        const item = oldEntries[name];
+        switch (item.type) {
+            case 'icon': {
+                // Attempt to find matching icon
+                const fullIcon = oldIcons.resolve(name, true);
+                const parent = fullIcon
+                    ? (0, match_1.findMatchingIcon)(mergedIcons, fullIcon)
+                    : null;
+                if (parent !== null) {
+                    // Add as alias
+                    mergedIcons.setAlias(name, parent);
+                    return true;
+                }
+                // Add as is, duplicating props
+                const props = item.props;
+                mergedIcons.setItem(name, {
+                    ...item,
+                    props: {
+                        ...props,
+                        hidden: true,
+                    },
+                    categories: new Set(),
+                });
+                return true;
+            }
+            case 'variation':
+            case 'alias': {
+                // Add parent
+                let parent = item.parent;
+                if (!add(parent)) {
+                    return false;
+                }
+                const parentItem = entries[parent];
+                if (parentItem.type === 'alias') {
+                    // Alias of alias - use parent
+                    parent = parentItem.parent;
+                }
+                if (item.type === 'variation') {
+                    // Hide variation and copy props
+                    const props = item.props;
+                    mergedIcons.setItem(name, {
+                        ...item,
+                        parent,
+                        props: {
+                            ...props,
+                            hidden: true,
+                        },
+                        categories: new Set(),
+                    });
+                }
+                else {
+                    mergedIcons.setItem(name, {
+                        ...item,
+                        parent,
+                    });
+                }
+                return true;
+            }
+            default:
+                assertNever(item);
+                return false;
+        }
+    }
+    // Add old icons
+    for (const name in oldEntries) {
+        add(name);
+    }
+    return mergedIcons;
+}
+exports.mergeIconSets = mergeIconSets;

package/lib/icon-set/merge.mjs

@@ -0,0 +1,75 @@
+// src/icon-set/merge.ts
+import { IconSet } from "./index.mjs";
+import { findMatchingIcon } from "./match.mjs";
+function assertNever(v) {
+}
+function mergeIconSets(oldIcons, newIcons) {
+  const mergedIcons = new IconSet(newIcons.export());
+  const oldEntries = oldIcons.entries;
+  const entries = mergedIcons.entries;
+  function add(name) {
+    if (entries[name]) {
+      return true;
+    }
+    const item = oldEntries[name];
+    switch (item.type) {
+      case "icon": {
+        const fullIcon = oldIcons.resolve(name, true);
+        const parent = fullIcon ? findMatchingIcon(mergedIcons, fullIcon) : null;
+        if (parent !== null) {
+          mergedIcons.setAlias(name, parent);
+          return true;
+        }
+        const props = item.props;
+        mergedIcons.setItem(name, {
+          ...item,
+          props: {
+            ...props,
+            hidden: true
+          },
+          categories: new Set()
+        });
+        return true;
+      }
+      case "variation":
+      case "alias": {
+        let parent = item.parent;
+        if (!add(parent)) {
+          return false;
+        }
+        const parentItem = entries[parent];
+        if (parentItem.type === "alias") {
+          parent = parentItem.parent;
+        }
+        if (item.type === "variation") {
+          const props = item.props;
+          mergedIcons.setItem(name, {
+            ...item,
+            parent,
+            props: {
+              ...props,
+              hidden: true
+            },
+            categories: new Set()
+          });
+        } else {
+          mergedIcons.setItem(name, {
+            ...item,
+            parent
+          });
+        }
+        return true;
+      }
+      default:
+        assertNever(item);
+        return false;
+    }
+  }
+  for (const name in oldEntries) {
+    add(name);
+  }
+  return mergedIcons;
+}
+export {
+  mergeIconSets
+};

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

@@ -0,0 +1,10 @@
+import type { CommonIconProps, ExtraIconProps } from './types';
+/**
+ * Default properties
+ */
+export declare const extraDefaultProps: Required<ExtraIconProps>;
+export declare const defaultCommonProps: Required<CommonIconProps>;
+/**
+ * Filter icon props: copies properties, removing undefined and default entries
+ */
+export declare function filterProps(data: CommonIconProps): CommonIconProps;

package/lib/icon-set/props.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterProps = exports.defaultCommonProps = exports.extraDefaultProps = void 0;
+const icon_1 = require("@iconify/utils/lib/icon");
+/**
+ * Default properties
+ */
+exports.extraDefaultProps = {
+    hidden: false,
+};
+exports.defaultCommonProps = {
+    ...icon_1.iconDefaults,
+    ...exports.extraDefaultProps,
+};
+/**
+ * Properties to filter
+ */
+const props = Object.keys(exports.defaultCommonProps);
+/**
+ * Filter icon props: copies properties, removing undefined and default entries
+ */
+function filterProps(data) {
+    const result = {};
+    props.forEach((attr) => {
+        const value = data[attr];
+        if (value !== void 0 &&
+            value !== exports.defaultCommonProps[attr]) {
+            result[attr] = value;
+        }
+    });
+    return result;
+}
+exports.filterProps = filterProps;

package/lib/icon-set/props.mjs

@@ -0,0 +1,25 @@
+// src/icon-set/props.ts
+import { iconDefaults } from "@iconify/utils/lib/icon";
+var extraDefaultProps = {
+  hidden: false
+};
+var defaultCommonProps = {
+  ...iconDefaults,
+  ...extraDefaultProps
+};
+var props = Object.keys(defaultCommonProps);
+function filterProps(data) {
+  const result = {};
+  props.forEach((attr) => {
+    const value = data[attr];
+    if (value !== void 0 && value !== defaultCommonProps[attr]) {
+      result[attr] = value;
+    }
+  });
+  return result;
+}
+export {
+  defaultCommonProps,
+  extraDefaultProps,
+  filterProps
+};

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

@@ -0,0 +1,68 @@
+import type { IconifyIcon, ExtendedIconifyIcon, ExtendedIconifyAlias, IconifyOptional } from '@iconify/types';
+/**
+ * Category item
+ */
+export interface IconCategory {
+    title: string;
+    count: number;
+}
+/**
+ * Get common properties: IconifyOptional + APIIconAttributes
+ */
+declare type CommonProps<A, B> = {
+    [K in keyof A & keyof B]?: A[K] extends B[K] ? A[K] : never;
+};
+export declare type CommonIconProps = CommonProps<ExtendedIconifyIcon, ExtendedIconifyAlias>;
+/**
+ * Exclude IconifyOptional from CommonIconProps
+ */
+export declare type ExtraIconProps = Omit<CommonIconProps, keyof IconifyOptional>;
+/**
+ * Partials
+ */
+export interface IconWithPropsData {
+    props: CommonIconProps;
+    chars: Set<string>;
+    categories: Set<IconCategory>;
+}
+export interface IconParentData {
+    parent: string;
+}
+/**
+ * Icon types
+ */
+export interface IconSetIcon extends IconWithPropsData {
+    type: 'icon';
+    body: string;
+}
+export interface IconSetIconAlias extends IconParentData {
+    type: 'alias';
+}
+export interface IconSetIconVariation extends IconWithPropsData, IconParentData {
+    type: 'variation';
+}
+/**
+ * All icon types
+ */
+export declare type IconSetIconEntry = IconSetIcon | IconSetIconAlias | IconSetIconVariation;
+export declare type IconSetIconType = IconSetIconEntry['type'];
+/**
+ * Full icon with extra stuff
+ */
+export interface ResolvedIconifyIcon extends IconifyIcon, ExtraIconProps {
+}
+/**
+ * Result for checking theme: list of names for each theme
+ */
+export interface CheckThemeResult {
+    valid: Record<string, string[]>;
+    invalid: string[];
+}
+/**
+ * Callback for asyncForEach function
+ *
+ * Return false to stop loop
+ */
+declare type IconSetAsyncForEachCallbackResult = void | false;
+export declare type IconSetAsyncForEachCallback = (name: string, type: IconSetIconEntry['type']) => Promise<IconSetAsyncForEachCallbackResult> | IconSetAsyncForEachCallbackResult;
+export {};

package/lib/icon-set/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/import/directory.d.ts

@@ -0,0 +1,35 @@
+import { IconSet } from '../icon-set';
+/**
+ * Entry for file
+ */
+export interface ImportDirectpryFileEntry {
+    path: string;
+    subdir: string;
+    file: string;
+    ext: string;
+}
+/**
+ * Callback to get keyword for icon based on file name
+ *
+ * Returns:
+ * - string for new keyword
+ * - undefined to skip icon
+ *
+ * Callback can be asynchronous
+ */
+declare type ImportDirectoryKeywordCallbackResult = string | undefined;
+export declare type ImportDirectoryKeywordCallback = (file: ImportDirectpryFileEntry, defaultKeyword: string, iconSet: IconSet) => ImportDirectoryKeywordCallbackResult | Promise<ImportDirectoryKeywordCallbackResult>;
+/**
+ * Options
+ */
+interface ImportDirectoryOptions {
+    prefix?: string;
+    includeSubDirs?: boolean;
+    keyword?: ImportDirectoryKeywordCallback;
+    ignoreImportErrors?: boolean;
+}
+/**
+ * Import all icons from directory
+ */
+export declare function importDirectory(path: string, options?: ImportDirectoryOptions): Promise<IconSet>;
+export {};

package/lib/import/directory.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importDirectory = void 0;
+const fs_1 = require("fs");
+const icon_set_1 = require("../icon-set");
+const keyword_1 = require("../misc/keyword");
+const scan_1 = require("../misc/scan");
+const svg_1 = require("../svg");
+const cleanup_1 = require("../svg/cleanup");
+/**
+ * Import all icons from directory
+ */
+async function importDirectory(path, options = {}) {
+    // Find all files
+    const files = await (0, scan_1.scanDirectory)(path, (ext, file, subdir, path) => {
+        if (ext.toLowerCase() === '.svg') {
+            const result = {
+                file,
+                ext,
+                subdir,
+                path,
+            };
+            return result;
+        }
+        return false;
+    });
+    // Create blank icon set
+    const iconSet = (0, icon_set_1.blankIconSet)(options.prefix || '');
+    // Import all files
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        // Get keyword
+        const defaultKeyword = (0, keyword_1.cleanupIconKeyword)(file.file);
+        let keyword = options.keyword
+            ? options.keyword(file, defaultKeyword, iconSet)
+            : defaultKeyword;
+        if (keyword instanceof Promise) {
+            keyword = await keyword;
+        }
+        // Check it
+        if (typeof keyword !== 'string' || !keyword.length) {
+            continue;
+        }
+        // Import icon, clean it up
+        try {
+            const content = await fs_1.promises.readFile(file.path + file.subdir + file.file + file.ext, 'utf8');
+            const svg = new svg_1.SVG(content);
+            await (0, cleanup_1.cleanupSVG)(svg);
+            iconSet.fromSVG(keyword, svg);
+        }
+        catch (err) {
+            if (options.ignoreImportErrors !== false) {
+                throw err;
+            }
+        }
+    }
+    return iconSet;
+}
+exports.importDirectory = importDirectory;

package/lib/import/directory.mjs

@@ -0,0 +1,47 @@
+// src/import/directory.ts
+import { promises as fs } from "fs";
+import { blankIconSet } from "../icon-set/index.mjs";
+import { cleanupIconKeyword } from "../misc/keyword.mjs";
+import { scanDirectory } from "../misc/scan.mjs";
+import { SVG } from "../svg/index.mjs";
+import { cleanupSVG } from "../svg/cleanup.mjs";
+async function importDirectory(path, options = {}) {
+  const files = await scanDirectory(path, (ext, file, subdir, path2) => {
+    if (ext.toLowerCase() === ".svg") {
+      const result = {
+        file,
+        ext,
+        subdir,
+        path: path2
+      };
+      return result;
+    }
+    return false;
+  });
+  const iconSet = blankIconSet(options.prefix || "");
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const defaultKeyword = cleanupIconKeyword(file.file);
+    let keyword = options.keyword ? options.keyword(file, defaultKeyword, iconSet) : defaultKeyword;
+    if (keyword instanceof Promise) {
+      keyword = await keyword;
+    }
+    if (typeof keyword !== "string" || !keyword.length) {
+      continue;
+    }
+    try {
+      const content = await fs.readFile(file.path + file.subdir + file.file + file.ext, "utf8");
+      const svg = new SVG(content);
+      await cleanupSVG(svg);
+      iconSet.fromSVG(keyword, svg);
+    } catch (err) {
+      if (options.ignoreImportErrors !== false) {
+        throw err;
+      }
+    }
+  }
+  return iconSet;
+}
+export {
+  importDirectory
+};

package/lib/misc/keyword.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Clean up keyword
+ */
+export declare function cleanupIconKeyword(keyword: string, convertCamelCase?: boolean): string;

package/lib/misc/keyword.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupIconKeyword = void 0;
+/**
+ * Clean up keyword
+ */
+function cleanupIconKeyword(keyword, convertCamelCase = false) {
+    // Convert camelCase to dash-case
+    if (convertCamelCase) {
+        keyword = keyword.replace(/[A-Z]+/g, (chars) => '_' + chars.toLowerCase());
+    }
+    // Replace stuff
+    keyword = keyword
+        .toLowerCase()
+        .trim()
+        // Replace few characters with dash
+        .replace(/[_.:]/g, '-')
+        // Remove bad characters
+        .replace(/[^a-z0-9-]/g, '')
+        // Replace repeating dash
+        .replace(/[-]+/g, '-');
+    // Remove '-' at start and end
+    if (keyword.slice(0, 1) === '-') {
+        keyword = keyword.slice(1);
+    }
+    if (keyword.slice(-1) === '-') {
+        keyword = keyword.slice(0, keyword.length - 1);
+    }
+    return keyword;
+}
+exports.cleanupIconKeyword = cleanupIconKeyword;

package/lib/misc/keyword.mjs

@@ -0,0 +1,17 @@
+// src/misc/keyword.ts
+function cleanupIconKeyword(keyword, convertCamelCase = false) {
+  if (convertCamelCase) {
+    keyword = keyword.replace(/[A-Z]+/g, (chars) => "_" + chars.toLowerCase());
+  }
+  keyword = keyword.toLowerCase().trim().replace(/[_.:]/g, "-").replace(/[^a-z0-9-]/g, "").replace(/[-]+/g, "-");
+  if (keyword.slice(0, 1) === "-") {
+    keyword = keyword.slice(1);
+  }
+  if (keyword.slice(-1) === "-") {
+    keyword = keyword.slice(0, keyword.length - 1);
+  }
+  return keyword;
+}
+export {
+  cleanupIconKeyword
+};

package/lib/misc/scan.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Callback
+ *
+ * Extension starts with '.' (can be empty)
+ * File does not include extension
+ * Subdir ends with '/' (can be empty)
+ *
+ * Should return:
+ * - false, null or undefined to skip file
+ * - true to include file (subdir + file + extension)
+ * - string to include custom string (such as file without extension)
+ * - custom object to return custom object
+ */
+declare type ScanDirectoryCallbackFalseResult = boolean | null | undefined;
+declare type ScanDirectoryCallbackStringResult = ScanDirectoryCallbackFalseResult | string;
+declare type ScanDirectoryCallbackAsString = (ext: string, file: string, subdir: string, path: string) => ScanDirectoryCallbackStringResult | Promise<ScanDirectoryCallbackStringResult>;
+declare type ScanDirectoryCallbackAsCustom<T> = (ext: string, file: string, subdir: string, path: string) => T | ScanDirectoryCallbackFalseResult | Promise<T | ScanDirectoryCallbackFalseResult>;
+export declare type ScanDirectoryCallback = ScanDirectoryCallbackAsCustom<unknown> | ScanDirectoryCallbackAsString;
+/**
+ * Find all files in directory
+ */
+export declare function scanDirectory(path: string, callback: ScanDirectoryCallbackAsString, subdirs?: boolean): Promise<string[]>;
+export declare function scanDirectory<T>(path: string, callback: ScanDirectoryCallbackAsCustom<T>, subdirs?: boolean): Promise<T[]>;
+export {};

package/lib/misc/scan.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanDirectory = void 0;
+const fs_1 = require("fs");
+async function scanDirectory(path, callback, subdirs = true) {
+    const results = [];
+    if (path.length && path.slice(-1) !== '/') {
+        path += '/';
+    }
+    async function scan(subdir) {
+        const files = await fs_1.promises.readdir(path + subdir);
+        for (let i = 0; i < files.length; i++) {
+            const filename = files[i];
+            if (filename.slice(0, 1) === '.') {
+                continue;
+            }
+            const stat = await fs_1.promises.lstat(path + subdir + filename);
+            if (stat.isDirectory()) {
+                if (subdirs) {
+                    await scan(subdir + filename + '/');
+                }
+                continue;
+            }
+            if (!stat.isFile()) {
+                continue;
+            }
+            const parts = filename.split('.');
+            const ext = parts.length > 1 ? '.' + parts.pop() : '';
+            const file = parts.join('.');
+            // Callback
+            let callbackResult = callback(ext, file, subdir, path);
+            if (callbackResult instanceof Promise) {
+                callbackResult = await callbackResult;
+            }
+            if (callbackResult === void 0 ||
+                callbackResult === false ||
+                callbackResult === null) {
+                // Skip file
+                continue;
+            }
+            // Add item
+            results.push(callbackResult === true ? subdir + filename : callbackResult);
+        }
+    }
+    await scan('');
+    return results;
+}
+exports.scanDirectory = scanDirectory;