@iconify/tools 4.2.0 → 5.0.0-beta.2

package/lib/css/parser/text.js

@@ -0,0 +1,103 @@
+/**
+* Merge text tokens to string
+*/
+function mergeTextTokens(tokens) {
+	return tokens.map((token) => token.text).join("").trim();
+}
+/**
+* Get list of selectors from list of words
+*/
+function getSelectors(tokens) {
+	const selectors = [];
+	let selector = "";
+	tokens.forEach((token) => {
+		if (token.type !== "chunk") {
+			selector += token.text;
+			return;
+		}
+		const list = token.text.split(",");
+		selector += list.shift();
+		while (list.length > 0) {
+			selectors.push(selector.trim());
+			selector = list.shift();
+		}
+	});
+	selectors.push(selector.trim());
+	return selectors.filter((item) => item.length > 0);
+}
+/**
+* Convert text token to rule
+*/
+function textTokensToRule(tokens) {
+	let prop = "";
+	let value = "";
+	let isProp = true;
+	let error = false;
+	tokens.forEach((token) => {
+		if (error) return;
+		if (token.type !== "chunk") {
+			if (isProp) error = true;
+			else value += token.text;
+			return;
+		}
+		const pairs = token.text.split(":");
+		if (pairs.length > 2) {
+			error = true;
+			return;
+		}
+		if (pairs.length === 2) {
+			if (!isProp) {
+				error = true;
+				return;
+			}
+			prop += pairs[0];
+			value = pairs[1];
+			isProp = false;
+			return;
+		}
+		if (isProp) prop += token.text;
+		else value += token.text;
+	});
+	if (error || isProp) return null;
+	prop = prop.trim();
+	value = value.trim();
+	if (!prop.length || !value.length) return null;
+	const result = {
+		type: "rule",
+		prop: prop.toLowerCase(),
+		value,
+		index: tokens[0].index
+	};
+	["important"].forEach((word) => {
+		if (result.value.slice(-1 - word.length).toLowerCase() === "!" + word) {
+			result[word] = true;
+			result.value = result.value.slice(0, -1 - word.length).trim();
+		}
+	});
+	return result.value.length ? result : null;
+}
+/**
+* Create at-rule or selector token from text tokens
+*/
+function textTokensToSelector(tokens) {
+	const selectors = getSelectors(tokens);
+	const code = mergeTextTokens(tokens);
+	const index = tokens[0].index;
+	if (!selectors.length) return null;
+	if (code.charAt(0) === "@") {
+		const parts = code.split(/\s+/);
+		return {
+			type: "at-rule",
+			index,
+			rule: parts.shift().slice(1),
+			value: parts.join(" ").trim()
+		};
+	} else return {
+		type: "selector",
+		code,
+		index,
+		selectors
+	};
+}
+
+export { getSelectors, mergeTextTokens, textTokensToRule, textTokensToSelector };

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

@@ -1,9 +1,7 @@
-import { StyleParseError } from './error.js';
-import { CSSToken } from './types.js';
-
+import { StyleParseError } from "./error.js";
+import { CSSToken } from "./types.js";
 /**
  * Get tokens
  */
 declare function getTokens(css: string): CSSToken[] | StyleParseError;
-
-export { getTokens };
+export { getTokens };

package/lib/css/parser/tokens.js

@@ -0,0 +1,169 @@
+import { styleParseError } from "./error.js";
+import { findEndOfQuotedString, findEndOfURL } from "./strings.js";
+import { mergeTextTokens, textTokensToRule, textTokensToSelector } from "./text.js";
+
+/**
+* Find all tokens in css, sort by index
+*/
+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;
+}
+/**
+* Get tokens
+*/
+function getTokens(css) {
+	const items = [];
+	let textQueue = [];
+	let start = 0;
+	let depth = 0;
+	try {
+		const checkRule = (text) => {
+			if (!textQueue.length) return;
+			const item = textTokensToRule(textQueue);
+			if (item) {
+				items.push(item);
+				return;
+			}
+			if (!(mergeTextTokens(textQueue) + text).length) return;
+			throw styleParseError("Invalid css rule", css, textQueue[0]?.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

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

package/lib/css/parser/tree.js

@@ -0,0 +1,35 @@
+/**
+* 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);
+					if (!newItem.children.length) {
+						const index$1 = target.indexOf(newItem);
+						if (index$1 !== -1) target.splice(index$1, 1);
+					}
+					break;
+				}
+				default: target.push(token);
+			}
+		}
+	}
+	while (index < tokens.length) parse(result);
+	return result;
+}
+
+export { tokensTree };

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

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

package/lib/css/parser/types.js

@@ -0,0 +1 @@
+export {  };

package/lib/download/api/cache.d.ts

@@ -1,5 +1,4 @@
-import { APIQueryParams, APICacheOptions } from './types.js';
-
+import { APICacheOptions, APIQueryParams } from "./types.js";
 /**
  * Unique key
  */
@@ -16,5 +15,4 @@ declare function getAPICache(dir: string, key: string): Promise<string | null>;
  * Clear cache
  */
 declare function clearAPICache(dir: string): Promise<void>;
-
-export { apiCacheKey, clearAPICache, getAPICache, storeAPICache };
+export { apiCacheKey, clearAPICache, getAPICache, storeAPICache };

package/lib/download/api/cache.js

@@ -0,0 +1,84 @@
+import { scanDirectory } from "../../misc/scan.js";
+import { promises } from "fs";
+import { createHash } from "crypto";
+
+const cacheVersion = 1;
+const storedFiles = Object.create(null);
+/**
+* Unique key
+*/
+function apiCacheKey(query) {
+	const item = JSON.stringify({
+		uri: query.uri,
+		params: query.params?.toString(),
+		headers: query.headers
+	});
+	return createHash("md5").update(item).digest("hex");
+}
+/**
+* Store cache
+*/
+async function storeAPICache(options, key, data) {
+	const expires = Date.now() + options.ttl * 1e3;
+	const filename = options.dir + "/" + key + "." + expires.toString() + ".json";
+	if (!storedFiles[options.dir]) await getStoredFiles(options.dir);
+	const content = {
+		version: cacheVersion,
+		expires,
+		data
+	};
+	await promises.writeFile(filename, JSON.stringify(content, null, 4), "utf8");
+	storedFiles[options.dir][key] = {
+		filename,
+		expires
+	};
+}
+/**
+* Get item from cache
+*/
+async function getAPICache(dir, key) {
+	if (!storedFiles[dir]) await getStoredFiles(dir);
+	const item = storedFiles[dir][key];
+	if (!item) return null;
+	const time = Date.now();
+	try {
+		const content = JSON.parse(await promises.readFile(item.filename, "utf8"));
+		return content.version === cacheVersion && content.expires > time ? content.data : null;
+	} catch (err) {
+		return null;
+	}
+}
+/**
+* Clear cache
+*/
+function clearAPICache(dir) {
+	return getStoredFiles(dir, true);
+}
+/**
+* Find all stored files
+*/
+async function getStoredFiles(dir, clear = false) {
+	const storage = !clear && storedFiles[dir] || Object.create(null);
+	const time = Date.now();
+	storedFiles[dir] = storage;
+	try {
+		await promises.mkdir(dir, { recursive: true });
+	} catch (err) {}
+	await scanDirectory(dir, async (ext, file, subdir, path) => {
+		if (ext !== ".json") return false;
+		const filename = path + subdir + file + ext;
+		const parts = file.split(".");
+		const expires = parseInt(parts.pop());
+		if (clear || expires < time || parts.length !== 1) {
+			await promises.unlink(filename);
+			return false;
+		}
+		const cacheKey = parts[0];
+		storage[cacheKey] = {
+			filename,
+			expires
+		};
+	}, false);
+}
+
+export { apiCacheKey, clearAPICache, getAPICache, storeAPICache };

package/lib/download/api/config.d.ts

@@ -1,18 +1,16 @@
-import { RequestOptions } from 'node:http';
-import { APIQueryParams } from './types.js';
-
+import { APIQueryParams } from "./types.js";
+import { RequestOptions } from "node:http";
 /**
  * Axios config, customisable
  */
 declare const axiosConfig: Omit<RequestOptions, 'headers' | 'responseType' | 'url' | 'method' | 'data'>;
 interface AxiosCallbacks {
-    onStart?: (url: string, params: APIQueryParams) => void;
-    onSuccess?: (url: string, params: APIQueryParams) => void;
-    onError?: (url: string, params: APIQueryParams, errorCode?: number) => void;
+  onStart?: (url: string, params: APIQueryParams) => void;
+  onSuccess?: (url: string, params: APIQueryParams) => void;
+  onError?: (url: string, params: APIQueryParams, errorCode?: number) => void;
 }
 /**
  * Customisable callbacks, used for logging
  */
 declare const fetchCallbacks: AxiosCallbacks;
-
-export { axiosConfig, fetchCallbacks };
+export { axiosConfig, fetchCallbacks };

package/lib/download/api/config.js

@@ -0,0 +1,10 @@
+/**
+* Axios config, customisable
+*/
+const axiosConfig = {};
+/**
+* Customisable callbacks, used for logging
+*/
+const fetchCallbacks = { onStart: (url) => console.log("Fetching:", url) };
+
+export { axiosConfig, fetchCallbacks };

package/lib/download/api/download.d.ts

@@ -1,8 +1,6 @@
-import { APIQueryParams } from './types.js';
-
+import { APIQueryParams } from "./types.js";
 /**
  * Download file
  */
 declare function downloadFile(query: APIQueryParams, target: string): Promise<void>;
-
-export { downloadFile };
+export { downloadFile };

package/lib/download/api/download.js

@@ -0,0 +1,26 @@
+import { axiosConfig, fetchCallbacks } from "./config.js";
+import { getFetch } from "./fetch.js";
+import { writeFile } from "fs/promises";
+
+/**
+* Download file
+*/
+async function downloadFile(query, target) {
+	const params = query.params ? query.params.toString() : "";
+	const url = query.uri + (params ? "?" + params : "");
+	const headers = query.headers;
+	fetchCallbacks.onStart?.(url, query);
+	const response = await getFetch()(url, {
+		...axiosConfig,
+		headers
+	});
+	if (response.status !== 200) {
+		fetchCallbacks.onError?.(url, query, response.status);
+		throw new Error(`Error downloading ${url}: ${response.status}`);
+	}
+	const data = await response.arrayBuffer();
+	fetchCallbacks.onSuccess?.(url, query);
+	await writeFile(target, Buffer.from(data));
+}
+
+export { downloadFile };

package/lib/download/api/fetch.d.ts

@@ -6,5 +6,4 @@ declare function setFetch(fetchFunction: typeof fetch): void;
  * Get fetch function
  */
 declare function getFetch(): typeof fetch;
-
-export { getFetch, setFetch };
+export { getFetch, setFetch };

package/lib/download/api/fetch.js

@@ -0,0 +1,15 @@
+let customFetch = fetch;
+/**
+* Set custom fetch function
+*/
+function setFetch(fetchFunction) {
+	customFetch = fetchFunction;
+}
+/**
+* Get fetch function
+*/
+function getFetch() {
+	return customFetch;
+}
+
+export { getFetch, setFetch };

package/lib/download/api/index.d.ts

@@ -1,8 +1,6 @@
-import { APIQueryParams, APICacheOptions } from './types.js';
-
+import { APICacheOptions, APIQueryParams } from "./types.js";
 /**
  * Send API query
  */
 declare function sendAPIQuery(query: APIQueryParams, cache?: APICacheOptions): Promise<number | string>;
-
-export { sendAPIQuery };
+export { sendAPIQuery };

package/lib/download/api/index.js

@@ -0,0 +1,50 @@
+import { apiCacheKey, getAPICache, storeAPICache } from "./cache.js";
+import { axiosConfig, fetchCallbacks } from "./config.js";
+import { getFetch } from "./fetch.js";
+
+/**
+* Send API query
+*/
+async function sendAPIQuery(query, cache) {
+	const cacheKey = cache ? apiCacheKey(query) : "";
+	if (cache) {
+		const cached = await getAPICache(cache.dir, cacheKey);
+		if (cached) return cached;
+	}
+	const result = await sendQuery(query);
+	if (cache && typeof result !== "number") try {
+		await storeAPICache(cache, cacheKey, result);
+	} catch (err) {
+		console.error("Error writing API cache");
+	}
+	return result;
+}
+/**
+* Send query
+*/
+async function sendQuery(query) {
+	const params = query.params ? query.params.toString() : "";
+	const url = query.uri + (params ? "?" + params : "");
+	const headers = query.headers;
+	fetchCallbacks.onStart?.(url, query);
+	function fail(value) {
+		fetchCallbacks.onError?.(url, query, value);
+		return value ?? 404;
+	}
+	const fetch = getFetch();
+	try {
+		const response = await fetch(url, {
+			...axiosConfig,
+			headers
+		});
+		if (response.status !== 200) return fail(response.status);
+		const data = await response.text();
+		if (typeof data !== "string") return fail();
+		fetchCallbacks.onSuccess?.(url, query);
+		return data;
+	} catch (err) {
+		return fail();
+	}
+}
+
+export { sendAPIQuery };