@iconify/tools 2.0.14 → 2.0.15

package/lib/css/parser/tokens.mjs

@@ -1,11 +1,7 @@
-// src/css/parser/tokens.ts
-import { styleParseError } from "./error.mjs";
-import { findEndOfQuotedString, findEndOfURL } from "./strings.mjs";
-import {
-  mergeTextTokens,
-  textTokensToRule,
-  textTokensToSelector
-} from "./text.mjs";
+import { styleParseError } from './error.mjs';
+import { findEndOfQuotedString, findEndOfURL } from './strings.mjs';
+import { textTokensToRule, mergeTextTokens, textTokensToSelector } from './text.mjs';
+
 function findTokens(code, tokens) {
   const list = [];
   const lc = code.toLowerCase();
@@ -33,7 +29,6 @@ function getTokens(css) {
   let depth = 0;
   try {
     const checkRule = (text) => {
-      var _a;
       if (!textQueue.length) {
         return;
       }
@@ -46,7 +41,7 @@ function getTokens(css) {
       if (!value.length) {
         return;
       }
-      throw styleParseError("Invalid css rule", css, (_a = textQueue[0]) == null ? void 0 : _a.index);
+      throw styleParseError("Invalid css rule", css, textQueue[0]?.index);
     };
     findTokens(css, ['"', "'", "/*", "{", "}", ";", "url(", "\\"]).forEach((token) => {
       if (token.index < start) {
@@ -181,6 +176,5 @@ function getTokens(css) {
   }
   return items;
 }
-export {
-  getTokens
-};
+
+export { getTokens };

package/lib/css/parser/tree.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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;
+}
+
+exports.tokensTree = tokensTree;

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

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

package/lib/css/parser/tree.mjs

@@ -1,4 +1,3 @@
-// src/css/parser/tree.ts
 function tokensTree(tokens) {
   const result = [];
   let index = 0;
@@ -35,6 +34,5 @@ function tokensTree(tokens) {
   }
   return result;
 }
-export {
-  tokensTree
-};
+
+export { tokensTree };

package/lib/css/parser/types.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

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

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

package/lib/css/parser/types.mjs

@@ -0,0 +1 @@
+

package/lib/download/api/cache.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fs = require('fs');
+const crypto = require('crypto');
+const misc_scan = require('../../misc/scan.cjs');
+
+const cacheVersion = 1;
+const storedFiles = /* @__PURE__ */ Object.create(null);
+function apiCacheKey(query) {
+  const item = JSON.stringify({
+    uri: query.uri,
+    params: query.params?.toString(),
+    headers: query.headers
+  });
+  return crypto.createHash("md5").update(item).digest("hex");
+}
+async function storeAPICache(options, key, data) {
+  const expires = Date.now() + options.ttl * 1e3;
+  const filename = options.dir + "/" + key + "." + expires + ".json";
+  if (!storedFiles[options.dir]) {
+    await getStoredFiles(options.dir);
+  }
+  await fs.promises.writeFile(filename, JSON.stringify({
+    version: cacheVersion,
+    expires,
+    data
+  }, null, 4), "utf8");
+  storedFiles[options.dir][key] = {
+    filename,
+    expires
+  };
+}
+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 fs.promises.readFile(item.filename, "utf8"));
+    return content.version === cacheVersion && content.expires > time ? content.data : null;
+  } catch (err) {
+    return null;
+  }
+}
+function clearAPICache(dir) {
+  return getStoredFiles(dir, true);
+}
+async function getStoredFiles(dir, clear = false) {
+  const storage = !clear && storedFiles[dir] || /* @__PURE__ */ Object.create(null);
+  const time = Date.now();
+  storedFiles[dir] = storage;
+  try {
+    await fs.promises.mkdir(dir, {
+      recursive: true
+    });
+  } catch (err) {
+  }
+  await misc_scan.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 fs.promises.unlink(filename);
+      return false;
+    }
+    const cacheKey = parts[0];
+    storage[cacheKey] = {
+      filename,
+      expires
+    };
+  }, false);
+}
+
+exports.apiCacheKey = apiCacheKey;
+exports.clearAPICache = clearAPICache;
+exports.getAPICache = getAPICache;
+exports.storeAPICache = storeAPICache;

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

@@ -1,17 +1,20 @@
-import type { APICacheOptions, APIQueryParams } from './types';
+import { APIQueryParams, APICacheOptions } from './types.js';
+
 /**
  * Unique key
  */
-export declare function apiCacheKey(query: APIQueryParams): string;
+declare function apiCacheKey(query: APIQueryParams): string;
 /**
  * Store cache
  */
-export declare function storeAPICache(options: APICacheOptions, key: string, data: string): Promise<void>;
+declare function storeAPICache(options: APICacheOptions, key: string, data: string): Promise<void>;
 /**
  * Get item from cache
  */
-export declare function getAPICache(dir: string, key: string): Promise<string | null>;
+declare function getAPICache(dir: string, key: string): Promise<string | null>;
 /**
  * Clear cache
  */
-export declare function clearAPICache(dir: string): Promise<void>;
+declare function clearAPICache(dir: string): Promise<void>;
+
+export { apiCacheKey, clearAPICache, getAPICache, storeAPICache };

package/lib/download/api/cache.mjs

@@ -1,14 +1,13 @@
-// src/download/api/cache.ts
-import { promises as fs } from "fs";
-import { createHash } from "crypto";
-import { scanDirectory } from "../../misc/scan.mjs";
-var cacheVersion = 1;
-var storedFiles = Object.create(null);
+import { promises } from 'fs';
+import { createHash } from 'crypto';
+import { scanDirectory } from '../../misc/scan.mjs';
+
+const cacheVersion = 1;
+const storedFiles = /* @__PURE__ */ Object.create(null);
 function apiCacheKey(query) {
-  var _a;
   const item = JSON.stringify({
     uri: query.uri,
-    params: (_a = query.params) == null ? void 0 : _a.toString(),
+    params: query.params?.toString(),
     headers: query.headers
   });
   return createHash("md5").update(item).digest("hex");
@@ -19,7 +18,7 @@ async function storeAPICache(options, key, data) {
   if (!storedFiles[options.dir]) {
     await getStoredFiles(options.dir);
   }
-  await fs.writeFile(filename, JSON.stringify({
+  await promises.writeFile(filename, JSON.stringify({
     version: cacheVersion,
     expires,
     data
@@ -39,7 +38,7 @@ async function getAPICache(dir, key) {
   }
   const time = Date.now();
   try {
-    const content = JSON.parse(await fs.readFile(item.filename, "utf8"));
+    const content = JSON.parse(await promises.readFile(item.filename, "utf8"));
     return content.version === cacheVersion && content.expires > time ? content.data : null;
   } catch (err) {
     return null;
@@ -49,11 +48,11 @@ function clearAPICache(dir) {
   return getStoredFiles(dir, true);
 }
 async function getStoredFiles(dir, clear = false) {
-  const storage = !clear && storedFiles[dir] || Object.create(null);
+  const storage = !clear && storedFiles[dir] || /* @__PURE__ */ Object.create(null);
   const time = Date.now();
   storedFiles[dir] = storage;
   try {
-    await fs.mkdir(dir, {
+    await promises.mkdir(dir, {
       recursive: true
     });
   } catch (err) {
@@ -66,7 +65,7 @@ async function getStoredFiles(dir, clear = false) {
     const parts = file.split(".");
     const expires = parseInt(parts.pop());
     if (clear || expires < time || parts.length !== 1) {
-      await fs.unlink(filename);
+      await promises.unlink(filename);
       return false;
     }
     const cacheKey = parts[0];
@@ -76,9 +75,5 @@ async function getStoredFiles(dir, clear = false) {
     };
   }, false);
 }
-export {
-  apiCacheKey,
-  clearAPICache,
-  getAPICache,
-  storeAPICache
-};
+
+export { apiCacheKey, clearAPICache, getAPICache, storeAPICache };

package/lib/download/api/download.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fetch = require('node-fetch');
+const util = require('util');
+const stream = require('stream');
+const fs = require('fs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+const fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
+
+const streamPipeline = util.promisify(stream.pipeline);
+async function downloadFile(query, target) {
+  const params = query.params ? query.params.toString() : "";
+  const url = query.uri + (params ? "?" + params : "");
+  const headers = query.headers;
+  const response = await fetch__default(url, {
+    headers
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(`Error downloading ${url}: ${response.status}`);
+  }
+  await streamPipeline(response.body, fs.createWriteStream(target));
+}
+
+exports.downloadFile = downloadFile;

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

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

package/lib/download/api/download.mjs

@@ -1,9 +1,9 @@
-// src/download/api/download.ts
-import fetch from "node-fetch";
-import { promisify } from "util";
-import { pipeline } from "stream";
-import { createWriteStream } from "fs";
-var streamPipeline = promisify(pipeline);
+import fetch from 'node-fetch';
+import { promisify } from 'util';
+import { pipeline } from 'stream';
+import { createWriteStream } from 'fs';
+
+const streamPipeline = promisify(pipeline);
 async function downloadFile(query, target) {
   const params = query.params ? query.params.toString() : "";
   const url = query.uri + (params ? "?" + params : "");
@@ -16,6 +16,5 @@ async function downloadFile(query, target) {
   }
   await streamPipeline(response.body, createWriteStream(target));
 }
-export {
-  downloadFile
-};
+
+export { downloadFile };

package/lib/download/api/index.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fetch = require('node-fetch');
+const download_api_cache = require('./cache.cjs');
+require('fs');
+require('crypto');
+require('../../misc/scan.cjs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }
+
+const fetch__default = /*#__PURE__*/_interopDefaultLegacy(fetch);
+
+async function sendAPIQuery(query, cache) {
+  const cacheKey = cache ? download_api_cache.apiCacheKey(query) : "";
+  if (cache) {
+    const cached = await download_api_cache.getAPICache(cache.dir, cacheKey);
+    if (cached) {
+      return cached;
+    }
+  }
+  const result = await sendQuery(query);
+  if (cache && typeof result !== "number") {
+    try {
+      await download_api_cache.storeAPICache(cache, cacheKey, result);
+    } catch (err) {
+      console.error("Error writing API cache");
+    }
+  }
+  return result;
+}
+async function sendQuery(query) {
+  const params = query.params ? query.params.toString() : "";
+  const url = query.uri + (params ? "?" + params : "");
+  console.log("Fetch:", url);
+  const headers = query.headers;
+  try {
+    const response = await fetch__default(url, {
+      headers
+    });
+    if (response.status >= 400) {
+      return response.status;
+    }
+    return await response.text();
+  } catch (err) {
+    return 404;
+  }
+}
+
+exports.sendAPIQuery = sendAPIQuery;

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

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

package/lib/download/api/index.mjs

@@ -1,6 +1,9 @@
-// src/download/api/index.ts
-import fetch from "node-fetch";
-import { apiCacheKey, getAPICache, storeAPICache } from "./cache.mjs";
+import fetch from 'node-fetch';
+import { apiCacheKey, getAPICache, storeAPICache } from './cache.mjs';
+import 'fs';
+import 'crypto';
+import '../../misc/scan.mjs';
+
 async function sendAPIQuery(query, cache) {
   const cacheKey = cache ? apiCacheKey(query) : "";
   if (cache) {
@@ -36,6 +39,5 @@ async function sendQuery(query) {
     return 404;
   }
 }
-export {
-  sendAPIQuery
-};
+
+export { sendAPIQuery };

package/lib/download/api/types.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

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

@@ -1,15 +1,17 @@
 /**
  * API Cache
  */
-export interface APICacheOptions {
+interface APICacheOptions {
     dir: string;
     ttl: number;
 }
 /**
  * Params
  */
-export interface APIQueryParams {
+interface APIQueryParams {
     uri: string;
     params?: URLSearchParams;
     headers?: Record<string, string>;
 }
+
+export { APICacheOptions, APIQueryParams };

package/lib/download/api/types.mjs

@@ -0,0 +1 @@
+

package/lib/download/git/branch.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const misc_exec = require('../../misc/exec.cjs');
+require('child_process');
+
+async function getGitRepoBranch(options, checkout) {
+  const result = await misc_exec.execAsync("git branch --show-current", {
+    cwd: options.target
+  });
+  const branch = result.stdout.trim();
+  if (typeof checkout === "string" && branch !== checkout) {
+    await misc_exec.execAsync(`git checkout ${checkout}`, {
+      cwd: options.target
+    });
+    return await getGitRepoBranch(options);
+  }
+  return branch;
+}
+
+exports.getGitRepoBranch = getGitRepoBranch;

package/lib/download/git/branch.d.ts

@@ -1,5 +1,8 @@
-import type { ExportTargetOptions } from '../../export/helpers/prepare';
+import { ExportTargetOptions } from '../../export/helpers/prepare.js';
+
 /**
  * Get current branch from cloned git repo
  */
-export declare function getGitRepoBranch(options: ExportTargetOptions, checkout?: string): Promise<string>;
+declare function getGitRepoBranch(options: ExportTargetOptions, checkout?: string): Promise<string>;
+
+export { getGitRepoBranch };

package/lib/download/git/branch.mjs

@@ -1,5 +1,6 @@
-// src/download/git/branch.ts
-import { execAsync } from "../../misc/exec.mjs";
+import { execAsync } from '../../misc/exec.mjs';
+import 'child_process';
+
 async function getGitRepoBranch(options, checkout) {
   const result = await execAsync("git branch --show-current", {
     cwd: options.target
@@ -13,6 +14,5 @@ async function getGitRepoBranch(options, checkout) {
   }
   return branch;
 }
-export {
-  getGitRepoBranch
-};
+
+export { getGitRepoBranch };

package/lib/download/git/hash.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const misc_exec = require('../../misc/exec.cjs');
+require('child_process');
+
+async function getGitRepoHash(options) {
+  const result = await misc_exec.execAsync("git rev-parse HEAD", {
+    cwd: options.target
+  });
+  return result.stdout.trim();
+}
+
+exports.getGitRepoHash = getGitRepoHash;

package/lib/download/git/hash.d.ts

@@ -1,5 +1,8 @@
-import type { ExportTargetOptions } from '../../export/helpers/prepare';
+import { ExportTargetOptions } from '../../export/helpers/prepare.js';
+
 /**
  * Get latest hash from cloned git repo
  */
-export declare function getGitRepoHash(options: ExportTargetOptions): Promise<string>;
+declare function getGitRepoHash(options: ExportTargetOptions): Promise<string>;
+
+export { getGitRepoHash };

package/lib/download/git/hash.mjs

@@ -1,11 +1,11 @@
-// src/download/git/hash.ts
-import { execAsync } from "../../misc/exec.mjs";
+import { execAsync } from '../../misc/exec.mjs';
+import 'child_process';
+
 async function getGitRepoHash(options) {
   const result = await execAsync("git rev-parse HEAD", {
     cwd: options.target
   });
   return result.stdout.trim();
 }
-export {
-  getGitRepoHash
-};
+
+export { getGitRepoHash };