@iconify/tools 1.3.17 → 2.0.0-dev.2

package/lib/css/parser/tokens.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokens = void 0;
+const error_1 = require("./error");
+const strings_1 = require("./strings");
+const text_1 = require("./text");
+/**
+ * Find all tokens in css, sort by index
+ */
+function findTokens(code, tokens) {
+    const list = [];
+    const lc = code.toLowerCase();
+    tokens.forEach((token) => {
+        let index = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            index = lc.indexOf(token, index);
+            if (index === -1) {
+                return;
+            }
+            list.push({
+                token: token,
+                index: index,
+            });
+            index++;
+        }
+    });
+    list.sort((a, b) => a.index - b.index);
+    return list;
+}
+/**
+ * Get tokens
+ */
+function getTokens(css) {
+    const items = [];
+    let textQueue = [];
+    let start = 0;
+    let depth = 0;
+    try {
+        const checkRule = (text) => {
+            var _a;
+            if (!textQueue.length) {
+                return;
+            }
+            const item = (0, text_1.textTokensToRule)(textQueue);
+            if (item) {
+                items.push(item);
+                return;
+            }
+            const value = (0, text_1.mergeTextTokens)(textQueue) + text;
+            if (!value.length) {
+                return;
+            }
+            throw (0, error_1.styleParseError)('Invalid css rule', css, (_a = textQueue[0]) === null || _a === void 0 ? void 0 : _a.index);
+        };
+        findTokens(css, ['"', "'", '/*', '{', '}', ';', 'url(', '\\']).forEach((token) => {
+            if (token.index < start) {
+                return;
+            }
+            switch (token.token) {
+                case '/*': {
+                    // Skip to end of comment
+                    textQueue.push({
+                        type: 'chunk',
+                        text: css.slice(start, token.index),
+                        index: start,
+                    });
+                    start = token.index;
+                    const end = css.indexOf('*/', start + 2);
+                    if (end === -1) {
+                        // Invalid string
+                        throw (0, error_1.styleParseError)('Missing comment closing statement', css, start);
+                    }
+                    start = end + 2;
+                    break;
+                }
+                case '\\':
+                    // Escaped character, skip next character
+                    textQueue.push({
+                        type: 'chunk',
+                        text: css.slice(start, token.index + 2),
+                        index: start,
+                    });
+                    start = token.index + 2;
+                    break;
+                case 'url(': {
+                    textQueue.push({
+                        type: 'chunk',
+                        text: css.slice(start, token.index),
+                        index: start,
+                    });
+                    start = token.index;
+                    // Skip to end of URL
+                    const end = (0, strings_1.findEndOfURL)(css, start);
+                    if (typeof end !== 'number') {
+                        throw end;
+                    }
+                    textQueue.push({
+                        type: 'url',
+                        text: css.slice(start, end),
+                        index: start,
+                    });
+                    start = end;
+                    break;
+                }
+                case '"':
+                case "'": {
+                    textQueue.push({
+                        type: 'chunk',
+                        text: css.slice(start, token.index),
+                        index: start,
+                    });
+                    start = token.index;
+                    // Skip to end of quoted string
+                    const end = (0, strings_1.findEndOfQuotedString)(css, token.token, start);
+                    if (end === null) {
+                        throw (0, error_1.styleParseError)('Missing closing ' + token.token, css, start);
+                    }
+                    textQueue.push({
+                        type: 'quoted-string',
+                        text: css.slice(start, end),
+                        index: start,
+                    });
+                    start = end;
+                    break;
+                }
+                case ';': {
+                    textQueue.push({
+                        type: 'chunk',
+                        text: css.slice(start, token.index),
+                        index: start,
+                    });
+                    checkRule(token.token);
+                    start = token.index + 1;
+                    textQueue = [];
+                    break;
+                }
+                case '{': {
+                    // Get selector
+                    textQueue.push({
+                        type: 'chunk',
+                        text: css.slice(start, token.index),
+                        index: start,
+                    });
+                    const item = (0, text_1.textTokensToSelector)(textQueue);
+                    if (!item) {
+                        throw (0, error_1.styleParseError)('Invalid css rule', css, start);
+                    }
+                    items.push(item);
+                    start = token.index + 1;
+                    textQueue = [];
+                    depth++;
+                    break;
+                }
+                case '}': {
+                    // End of block
+                    textQueue.push({
+                        type: 'chunk',
+                        text: css.slice(start, token.index),
+                        index: start,
+                    });
+                    checkRule('');
+                    items.push({
+                        type: 'close',
+                        index: token.index,
+                    });
+                    if (!depth) {
+                        throw (0, error_1.styleParseError)('Unexpected }', css, token.index);
+                    }
+                    depth--;
+                    start = token.index + 1;
+                    textQueue = [];
+                    break;
+                }
+                default:
+                    throw new Error(`Forgot to parse token: ${token.token}`);
+            }
+        });
+        if (depth) {
+            return (0, error_1.styleParseError)('Missing }', css);
+        }
+        // Add remaining code
+        textQueue.push({
+            type: 'chunk',
+            text: css.slice(start),
+            index: start,
+        });
+        checkRule('');
+    }
+    catch (err) {
+        // Return error if it is StyleParseError object, re-throw if it is something else
+        if (typeof err === 'object' &&
+            err.type === 'style-parse-error') {
+            return err;
+        }
+        throw err;
+    }
+    return items;
+}
+exports.getTokens = getTokens;

package/lib/css/parser/tokens.mjs

@@ -0,0 +1,186 @@
+// src/css/parser/tokens.ts
+import { styleParseError } from "./error.mjs";
+import { findEndOfQuotedString, findEndOfURL } from "./strings.mjs";
+import {
+  mergeTextTokens,
+  textTokensToRule,
+  textTokensToSelector
+} from "./text.mjs";
+function findTokens(code, tokens) {
+  const list = [];
+  const lc = code.toLowerCase();
+  tokens.forEach((token) => {
+    let index = 0;
+    while (true) {
+      index = lc.indexOf(token, index);
+      if (index === -1) {
+        return;
+      }
+      list.push({
+        token,
+        index
+      });
+      index++;
+    }
+  });
+  list.sort((a, b) => a.index - b.index);
+  return list;
+}
+function getTokens(css) {
+  const items = [];
+  let textQueue = [];
+  let start = 0;
+  let depth = 0;
+  try {
+    const checkRule = (text) => {
+      var _a;
+      if (!textQueue.length) {
+        return;
+      }
+      const item = textTokensToRule(textQueue);
+      if (item) {
+        items.push(item);
+        return;
+      }
+      const value = mergeTextTokens(textQueue) + text;
+      if (!value.length) {
+        return;
+      }
+      throw styleParseError("Invalid css rule", css, (_a = textQueue[0]) == null ? void 0 : _a.index);
+    };
+    findTokens(css, ['"', "'", "/*", "{", "}", ";", "url(", "\\"]).forEach((token) => {
+      if (token.index < start) {
+        return;
+      }
+      switch (token.token) {
+        case "/*": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          start = token.index;
+          const end = css.indexOf("*/", start + 2);
+          if (end === -1) {
+            throw styleParseError("Missing comment closing statement", css, start);
+          }
+          start = end + 2;
+          break;
+        }
+        case "\\":
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index + 2),
+            index: start
+          });
+          start = token.index + 2;
+          break;
+        case "url(": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          start = token.index;
+          const end = findEndOfURL(css, start);
+          if (typeof end !== "number") {
+            throw end;
+          }
+          textQueue.push({
+            type: "url",
+            text: css.slice(start, end),
+            index: start
+          });
+          start = end;
+          break;
+        }
+        case '"':
+        case "'": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          start = token.index;
+          const end = findEndOfQuotedString(css, token.token, start);
+          if (end === null) {
+            throw styleParseError("Missing closing " + token.token, css, start);
+          }
+          textQueue.push({
+            type: "quoted-string",
+            text: css.slice(start, end),
+            index: start
+          });
+          start = end;
+          break;
+        }
+        case ";": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          checkRule(token.token);
+          start = token.index + 1;
+          textQueue = [];
+          break;
+        }
+        case "{": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          const item = textTokensToSelector(textQueue);
+          if (!item) {
+            throw styleParseError("Invalid css rule", css, start);
+          }
+          items.push(item);
+          start = token.index + 1;
+          textQueue = [];
+          depth++;
+          break;
+        }
+        case "}": {
+          textQueue.push({
+            type: "chunk",
+            text: css.slice(start, token.index),
+            index: start
+          });
+          checkRule("");
+          items.push({
+            type: "close",
+            index: token.index
+          });
+          if (!depth) {
+            throw styleParseError("Unexpected }", css, token.index);
+          }
+          depth--;
+          start = token.index + 1;
+          textQueue = [];
+          break;
+        }
+        default:
+          throw new Error(`Forgot to parse token: ${token.token}`);
+      }
+    });
+    if (depth) {
+      return styleParseError("Missing }", css);
+    }
+    textQueue.push({
+      type: "chunk",
+      text: css.slice(start),
+      index: start
+    });
+    checkRule("");
+  } catch (err) {
+    if (typeof err === "object" && err.type === "style-parse-error") {
+      return err;
+    }
+    throw err;
+  }
+  return items;
+}
+export {
+  getTokens
+};

package/lib/css/parser/tree.d.ts

@@ -0,0 +1,5 @@
+import type { CSSToken, CSSTreeToken } from './types';
+/**
+ * Convert tokens list to tree
+ */
+export declare function tokensTree(tokens: CSSToken[]): CSSTreeToken[];

package/lib/css/parser/tree.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokensTree = void 0;
+/**
+ * Convert tokens list to tree
+ */
+function tokensTree(tokens) {
+    const result = [];
+    let index = 0;
+    function parse(target) {
+        while (index < tokens.length) {
+            const token = tokens[index];
+            index++;
+            switch (token.type) {
+                case 'close':
+                    return;
+                case 'selector':
+                case 'at-rule': {
+                    const newItem = {
+                        ...token,
+                        children: [],
+                    };
+                    target.push(newItem);
+                    parse(newItem.children);
+                    // Remove token without children
+                    if (!newItem.children.length) {
+                        const index = target.indexOf(newItem);
+                        if (index !== -1) {
+                            target.splice(index, 1);
+                        }
+                    }
+                    break;
+                }
+                default:
+                    target.push(token);
+            }
+        }
+    }
+    while (index < tokens.length) {
+        parse(result);
+    }
+    return result;
+}
+exports.tokensTree = tokensTree;

package/lib/css/parser/tree.mjs

@@ -0,0 +1,40 @@
+// src/css/parser/tree.ts
+function tokensTree(tokens) {
+  const result = [];
+  let index = 0;
+  function parse(target) {
+    while (index < tokens.length) {
+      const token = tokens[index];
+      index++;
+      switch (token.type) {
+        case "close":
+          return;
+        case "selector":
+        case "at-rule": {
+          const newItem = {
+            ...token,
+            children: []
+          };
+          target.push(newItem);
+          parse(newItem.children);
+          if (!newItem.children.length) {
+            const index2 = target.indexOf(newItem);
+            if (index2 !== -1) {
+              target.splice(index2, 1);
+            }
+          }
+          break;
+        }
+        default:
+          target.push(token);
+      }
+    }
+  }
+  while (index < tokens.length) {
+    parse(result);
+  }
+  return result;
+}
+export {
+  tokensTree
+};

package/lib/css/parser/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Text tokens, to be split combined into correct tokens later
+ */
+export interface TextToken {
+    type: 'chunk' | 'url' | 'quoted-string';
+    index: number;
+    text: string;
+}
+/**
+ * Values
+ */
+export declare type CSSATValue = string | string[];
+/**
+ * Tokens
+ */
+export interface CSSRuleToken {
+    type: 'rule';
+    index: number;
+    prop: string;
+    value: string;
+    important?: boolean;
+}
+export interface CSSSelectorToken {
+    type: 'selector';
+    index: number;
+    code: string;
+    selectors: string[];
+}
+export interface CSSAtRuleToken {
+    type: 'at-rule';
+    index: number;
+    code: string;
+    atRule: string;
+    atValues: CSSATValue[];
+}
+export interface CSSCloseToken {
+    type: 'close';
+    index: number;
+}
+export declare type CSSTokenWithSelector = CSSSelectorToken | CSSAtRuleToken;
+export declare type CSSToken = CSSRuleToken | CSSSelectorToken | CSSAtRuleToken | CSSCloseToken;
+/**
+ * Tree tokens
+ */
+export interface CSSSelectorTreeToken extends CSSSelectorToken {
+    children: CSSTreeToken[];
+}
+export interface CSSAtRuleTreeToken extends CSSAtRuleToken {
+    children: CSSTreeToken[];
+}
+export declare type CSSTreeToken = CSSRuleToken | CSSSelectorTreeToken | CSSAtRuleTreeToken;

package/lib/css/parser/types.js

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

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

@@ -0,0 +1,134 @@
+import type { IconifyJSON, IconifyInfo } 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';
+/**
+ * Sort theme keys: long keys first
+ *
+ * Applies changes to parameter, but also returns it
+ */
+export declare function sortThemeKeys(keys: string[]): string[];
+/**
+ * Export icon set
+ */
+export 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.
+     */
+    prefix: string;
+    entries: Record<string, IconSetIconEntry>;
+    info: IconifyInfo | undefined;
+    categories: Set<IconCategory>;
+    prefixes: Record<string, string>;
+    suffixes: Record<string, string>;
+    /**
+     * Load icon set
+     */
+    constructor(data: IconifyJSON);
+    /**
+     * Load icon set
+     */
+    load(data: IconifyJSON): void;
+    /**
+     * List icons
+     */
+    list(types?: IconSetIconType[]): string[];
+    /**
+     * forEach function to loop through all entries.
+     * Supports asynchronous callbacks.
+     *
+     * Callback should return false to stop loop.
+     */
+    forEach(callback: IconSetAsyncForEachCallback, types?: IconSetIconType[]): Promise<void>;
+    /**
+     * Resolve icon
+     */
+    resolve(name: string, full: false): ResolvedIconifyIcon | null;
+    resolve(name: string): ResolvedIconifyIcon | null;
+    resolve(name: string, full: true): Required<ResolvedIconifyIcon> | null;
+    /**
+     * Generate HTML
+     */
+    toString(name: string, custommisations?: IconifyIconCustomisations): string | null;
+    /**
+     * Get SVG instance for icon
+     */
+    toSVG(name: string): SVG | null;
+    /**
+     * Export icon set
+     */
+    export(validate?: boolean): IconifyJSON;
+    /**
+     * Get characters map
+     */
+    chars(names?: string[]): Record<string, string>;
+    /**
+     * Filter icons
+     */
+    _filter(callback: (name: string, item: IconSetIconEntry, icon?: ResolvedIconifyIcon) => boolean): string[];
+    /**
+     * Count icons
+     */
+    count(): number;
+    /**
+     * Find category by title
+     */
+    _findCategory(title: string, add: boolean): IconCategory | null;
+    /**
+     * Count icons in category, remove category if empty
+     *
+     * Hidden icons and aliases do not count
+     */
+    listCategory(category: IconCategory | string): string[] | null;
+    /**
+     * Check if icon exists
+     */
+    exists(name: string): boolean;
+    /**
+     * Remove icons. Returns number of removed icons
+     *
+     * If removeDependencies is a string, it represents new parent for all aliases of removed icon.
+     */
+    remove(name: string, removeDependencies?: boolean | string): number;
+    /**
+     * Remove icon
+     */
+    rename(oldName: string, newName: string): boolean;
+    /**
+     * Add/update item
+     */
+    setItem(name: string, item: IconSetIconEntry): boolean;
+    /**
+     * Add/update icon
+     */
+    setIcon(name: string, icon: ResolvedIconifyIcon): boolean;
+    /**
+     * Add/update alias without props
+     */
+    setAlias(name: string, parent: string): boolean;
+    /**
+     * Add/update alias with props
+     */
+    setVariation(name: string, parent: string, props: CommonIconProps): boolean;
+    /**
+     * Icon from SVG. Updates old icon if it exists
+     */
+    fromSVG(name: string, svg: SVG): boolean;
+    /**
+     * Add or remove character for icon
+     */
+    toggleCharacter(iconName: string, char: string, add: boolean): boolean;
+    /**
+     * Add or remove category for icon
+     */
+    toggleCategory(iconName: string, category: string, add: boolean): boolean;
+    /**
+     * Find icons that belong to theme
+     */
+    checkTheme(prefix: boolean): CheckThemeResult;
+}
+/**
+ * Create blank icon set
+ */
+export declare function blankIconSet(prefix: string): IconSet;