@iconify/tools 2.0.0-dev.3 → 2.0.2

package/README.md

@@ -0,0 +1,90 @@
+# Iconify Tools
+
+This library is a collection of tools for importing, exporting and processing SVG images.
+
+Its main purpose is to convert icon sets and fonts to Iconify JSON collections, but it can be used for other purposes.
+
+## Installation
+
+First install it by running this command:
+
+```
+npm install @iconify/tools --save
+```
+
+## Example
+
+The following code example does the following:
+
+-   Imports set of SVG from directory.
+-   Cleans up all icons.
+-   Changes colors in all icons to `currentColor`.
+-   Optimises icons.
+-   Exports icons as `IconifyJSON` icon set.
+
+```js
+import { promises as fs } from 'fs';
+import { importDirectory } from '@iconify/tools/lib/import/directory';
+import { cleanupSVG } from '@iconify/tools/lib/svg/cleanup';
+import { runSVGO } from '@iconify/tools/lib/optimise/svgo';
+import { parseColors, isEmptyColor } from '@iconify/tools/lib/colors/parse';
+
+(async () => {
+	// Import icons
+	const iconSet = await importDirectory('svg/test', {
+		prefix: 'test',
+	});
+
+	// Validate, clean up, fix palette and optimise
+	await iconSet.forEach(async (name, type) => {
+		if (type !== 'icon') {
+			return;
+		}
+
+		const svg = iconSet.toSVG(name);
+		if (!svg) {
+			// Invalid icon
+			iconSet.remove(name);
+			return;
+		}
+
+		// Clean up and optimise icons
+		try {
+			await cleanupSVG(svg);
+			await parseColors(svg, {
+				defaultColor: 'currentColor',
+				callback: (attr, colorStr, color) => {
+					return !color || isEmptyColor(color)
+						? colorStr
+						: 'currentColor';
+				},
+			});
+			await runSVGO(svg);
+		} catch (err) {
+			// Invalid icon
+			console.error(`Error parsing ${name}:`, err);
+			iconSet.remove(name);
+			return;
+		}
+
+		// Update icon
+		iconSet.fromSVG(name, svg);
+	});
+
+	// Export as IconifyJSON
+	const exported = JSON.stringify(iconSet.export(), null, '\t') + '\n';
+
+	// Save to file
+	await fs.writeFile(`output/${iconSet.prefix}.json`, exported, 'utf8');
+})();
+```
+
+## Documentation
+
+Full documentation is too big for simple README file. See [Iconify Tools documentation](https://docs.iconify.design/tools/tools2/) for detailed documentation with code samples.
+
+## License
+
+Library is released with MIT license.
+
+© 2021 Vjacheslav Trushkin

package/lib/colors/parse.d.ts

@@ -4,7 +4,7 @@ import { ColorAttributes } from './attribs';
 /**
  * Result
  */
-interface FindColorsResult {
+export interface FindColorsResult {
     colors: (Color | string)[];
     hasUnsetColor: boolean;
     hasGlobalStyle: boolean;

package/lib/colors/parse.js

@@ -245,13 +245,15 @@ async function parseColors(svg, options = {}) {
                     const color = getElementColor(prop, item);
                     if (color === attribs_1.defaultBlackColor) {
                         // Default black color: change it
-                        result.hasUnsetColor = true;
                         if (defaultColor) {
                             // Add color to results and change attribute
                             findColor(defaultColor, true);
                             $element.attr(prop, (0, colors_1.colorToString)(defaultColor));
                             itemColors[prop] = defaultColor;
                         }
+                        else {
+                            result.hasUnsetColor = true;
+                        }
                     }
                 }
             }

package/lib/colors/parse.mjs

@@ -197,11 +197,12 @@ async function parseColors(svg, options = {}) {
           const prop = requiredProps[i];
           const color = getElementColor(prop, item);
           if (color === defaultBlackColor) {
-            result.hasUnsetColor = true;
             if (defaultColor) {
               findColor(defaultColor, true);
               $element.attr(prop, colorToString(defaultColor));
               itemColors[prop] = defaultColor;
+            } else {
+              result.hasUnsetColor = true;
             }
           }
         }

package/lib/colors/validate.d.ts

@@ -0,0 +1,11 @@
+import type { SVG } from '../svg/index';
+import { ParseColorsOptions } from './parse';
+import type { FindColorsResult } from './parse';
+/**
+ * Validate colors in icon
+ *
+ * If icon is monotone,
+ *
+ * Throws exception on error
+ */
+export declare function validateColors(svg: SVG, expectMonotone: boolean, options?: ParseColorsOptions): Promise<FindColorsResult>;

package/lib/colors/validate.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateColors = void 0;
+const colors_1 = require("@iconify/utils/lib/colors");
+const parse_1 = require("./parse");
+/**
+ * Validate colors in icon
+ *
+ * If icon is monotone,
+ *
+ * Throws exception on error
+ */
+async function validateColors(svg, expectMonotone, options) {
+    // Parse colors
+    const palette = await (0, parse_1.parseColors)(svg, options);
+    // Check palette
+    palette.colors.forEach((color) => {
+        if (typeof color === 'string') {
+            throw new Error('Unexpected color: ' + color);
+        }
+        switch (color.type) {
+            case 'none':
+            case 'transparent':
+                return;
+            // Monotone
+            case 'current':
+                if (!expectMonotone) {
+                    throw new Error('Unexpected color: ' + (0, colors_1.colorToString)(color));
+                }
+                return;
+            // Palette
+            case 'rgb':
+            case 'hsl':
+                if (expectMonotone) {
+                    throw new Error('Unexpected color: ' + (0, colors_1.colorToString)(color));
+                }
+                return;
+            // Do not allow other colors
+            default:
+                throw new Error('Unexpected color: ' + (0, colors_1.colorToString)(color));
+        }
+    });
+    return palette;
+}
+exports.validateColors = validateColors;

package/lib/colors/validate.mjs

@@ -0,0 +1,33 @@
+// src/colors/validate.ts
+import { colorToString } from "@iconify/utils/lib/colors";
+import { parseColors } from "./parse.mjs";
+async function validateColors(svg, expectMonotone, options) {
+  const palette = await parseColors(svg, options);
+  palette.colors.forEach((color) => {
+    if (typeof color === "string") {
+      throw new Error("Unexpected color: " + color);
+    }
+    switch (color.type) {
+      case "none":
+      case "transparent":
+        return;
+      case "current":
+        if (!expectMonotone) {
+          throw new Error("Unexpected color: " + colorToString(color));
+        }
+        return;
+      case "rgb":
+      case "hsl":
+        if (expectMonotone) {
+          throw new Error("Unexpected color: " + colorToString(color));
+        }
+        return;
+      default:
+        throw new Error("Unexpected color: " + colorToString(color));
+    }
+  });
+  return palette;
+}
+export {
+  validateColors
+};

package/lib/css/parser/text.js

@@ -103,12 +103,9 @@ function textTokensToRule(tokens) {
     };
     // Check for !important (with possibility to support other stuff like !default in future)
     ['important'].forEach((word) => {
-        if (result.value.slice(0 - word.length - 1).toLowerCase() ===
-            '!' + word) {
+        if (result.value.slice(-1 - word.length).toLowerCase() === '!' + word) {
             result[word] = true;
-            result.value = result.value
-                .slice(0, result.value.length - word.length - 1)
-                .trim();
+            result.value = result.value.slice(0, -1 - word.length).trim();
         }
     });
     // Value cannot be empty
@@ -140,7 +137,7 @@ function textTokensToSelector(tokens) {
                     return;
                 }
                 const list = item
-                    .slice(1, item.length - 1)
+                    .slice(1, -1)
                     .split(/\)\s?and\s?\(/i)
                     .map((item) => item.trim());
                 let match = true;

package/lib/css/parser/text.mjs

@@ -73,9 +73,9 @@ function textTokensToRule(tokens) {
     index: tokens[0].index
   };
   ["important"].forEach((word) => {
-    if (result.value.slice(0 - word.length - 1).toLowerCase() === "!" + word) {
+    if (result.value.slice(-1 - word.length).toLowerCase() === "!" + word) {
       result[word] = true;
-      result.value = result.value.slice(0, result.value.length - word.length - 1).trim();
+      result.value = result.value.slice(0, -1 - word.length).trim();
     }
   });
   return result.value.length ? result : null;
@@ -97,7 +97,7 @@ function textTokensToSelector(tokens) {
         if (typeof item !== "string" || item.charAt(0) !== "(" || item.charAt(item.length - 1) !== ")") {
           return;
         }
-        const list = item.slice(1, item.length - 1).split(/\)\s?and\s?\(/i).map((item2) => item2.trim());
+        const list = item.slice(1, -1).split(/\)\s?and\s?\(/i).map((item2) => item2.trim());
         let match = true;
         list.forEach((item2) => {
           if (item2.indexOf("(") !== -1 || item2.indexOf(")") !== -1) {

package/lib/{api → download/api}/cache.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.clearAPICache = exports.getAPICache = exports.storeAPICache = exports.apiCacheKey = void 0;
 const fs_1 = require("fs");
 const crypto_1 = require("crypto");
-const scan_1 = require("../misc/scan");
+const scan_1 = require("../../misc/scan");
 const cacheVersion = 1;
 const storedFiles = Object.create(null);
 /**

package/lib/{api → download/api}/cache.mjs

@@ -1,7 +1,7 @@
-// src/api/cache.ts
+// src/download/api/cache.ts
 import { promises as fs } from "fs";
 import { createHash } from "crypto";
-import { scanDirectory } from "../misc/scan.mjs";
+import { scanDirectory } from "../../misc/scan.mjs";
 var cacheVersion = 1;
 var storedFiles = Object.create(null);
 function apiCacheKey(query) {

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

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

package/lib/download/api/download.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const util_1 = require("util");
+const stream_1 = require("stream");
+const fs_1 = require("fs");
+const streamPipeline = (0, util_1.promisify)(stream_1.pipeline);
+/**
+ * Download file
+ */
+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 (0, node_fetch_1.default)(url, {
+        headers,
+    });
+    if (!response.ok || !response.body) {
+        throw new Error(`Error downloading ${url}: ${response.status}`);
+    }
+    await streamPipeline(response.body, (0, fs_1.createWriteStream)(target));
+}
+exports.downloadFile = downloadFile;

package/lib/download/api/download.mjs

@@ -0,0 +1,21 @@
+// 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);
+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(url, {
+    headers
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(`Error downloading ${url}: ${response.status}`);
+  }
+  await streamPipeline(response.body, createWriteStream(target));
+}
+export {
+  downloadFile
+};

package/lib/{api → download/api}/index.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendAPIQuery = void 0;
-const cross_fetch_1 = __importDefault(require("cross-fetch"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
 const cache_1 = require("./cache");
 /**
  * Send API query
@@ -38,7 +38,7 @@ async function sendQuery(query) {
     console.log('Fetch:', url);
     const headers = query.headers;
     try {
-        const response = await (0, cross_fetch_1.default)(url, {
+        const response = await (0, node_fetch_1.default)(url, {
             headers,
         });
         if (response.status >= 400) {

package/lib/{api → download/api}/index.mjs

@@ -1,5 +1,5 @@
-// src/api/index.ts
-import crossFetch from "cross-fetch";
+// src/download/api/index.ts
+import fetch from "node-fetch";
 import { apiCacheKey, getAPICache, storeAPICache } from "./cache.mjs";
 async function sendAPIQuery(query, cache) {
   const cacheKey = cache ? apiCacheKey(query) : "";
@@ -25,7 +25,7 @@ async function sendQuery(query) {
   console.log("Fetch:", url);
   const headers = query.headers;
   try {
-    const response = await crossFetch(url, {
+    const response = await fetch(url, {
       headers
     });
     if (response.status >= 400) {

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

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

package/lib/download/git/hash.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitRepoHash = void 0;
+const exec_1 = require("../../misc/exec");
+/**
+ * Get latest hash from cloned git repo
+ */
+async function getGitRepoHash(options) {
+    const result = await (0, exec_1.execAsync)('git rev-parse HEAD', {
+        cwd: options.target,
+    });
+    return result.stdout.trim();
+}
+exports.getGitRepoHash = getGitRepoHash;

package/lib/download/git/hash.mjs

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

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

@@ -0,0 +1,26 @@
+import { ExportTargetOptions } from '../../export/helpers/prepare';
+import type { DocumentNotModified } from '../types/modified';
+interface IfModifiedSinceOption {
+    ifModifiedSince: string | true;
+}
+/**
+ * Options for downloadGitRepo()
+ */
+export interface DownloadGitRepoOptions extends ExportTargetOptions, Partial<IfModifiedSinceOption> {
+    remote: string;
+    branch: string;
+    log?: boolean;
+}
+/**
+ * Result
+ */
+export interface DownloadGitRepoResult {
+    target: string;
+    hash: string;
+}
+/**
+ * Download Git repo
+ */
+export declare function downloadGitRepo<T extends IfModifiedSinceOption & DownloadGitRepoOptions>(options: T): Promise<DownloadGitRepoResult | DocumentNotModified>;
+export declare function downloadGitRepo(options: DownloadGitRepoOptions): Promise<DownloadGitRepoResult>;
+export {};

package/lib/download/git/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadGitRepo = void 0;
+const fs_1 = require("fs");
+const prepare_1 = require("../../export/helpers/prepare");
+const exec_1 = require("../../misc/exec");
+const hash_1 = require("./hash");
+async function downloadGitRepo(options) {
+    const { remote, branch } = options;
+    // Check for last commit
+    const hasHashInTarget = options.target.indexOf('{hash}') !== -1;
+    if (options.ifModifiedSince || hasHashInTarget) {
+        // Get actual hash
+        const result = await (0, exec_1.execAsync)(`git ls-remote ${remote} --branch ${branch}`);
+        const parts = result.stdout.split(/\s/);
+        const latestHash = parts.shift();
+        if (hasHashInTarget) {
+            options.target = options.target.replace('{hash}', latestHash);
+        }
+        if (options.ifModifiedSince) {
+            try {
+                // Get expected hash
+                const expectedHash = options.ifModifiedSince === true
+                    ? await (0, hash_1.getGitRepoHash)(options)
+                    : options.ifModifiedSince;
+                if (latestHash === expectedHash) {
+                    return 'not_modified';
+                }
+            }
+            catch (err) {
+                //
+            }
+        }
+    }
+    // Prepare target directory
+    const target = (options.target = await (0, prepare_1.prepareDirectoryForExport)(options));
+    // Check if directory is empty if directory wasn't cleaned up
+    const files = options.cleanup ? [] : await fs_1.promises.readdir(target);
+    if (!files.length) {
+        if (options.log) {
+            console.log(`Cloning ${remote}#${branch} to ${target}`);
+        }
+        await (0, exec_1.execAsync)(`git clone --branch ${branch} --no-tags --depth 1 ${remote} "${target}"`);
+    }
+    // Get latest hash
+    const hash = await (0, hash_1.getGitRepoHash)(options);
+    return {
+        target,
+        hash,
+    };
+}
+exports.downloadGitRepo = downloadGitRepo;

package/lib/download/git/index.mjs

@@ -0,0 +1,44 @@
+// src/download/git/index.ts
+import { promises as fs } from "fs";
+import {
+  prepareDirectoryForExport
+} from "../../export/helpers/prepare.mjs";
+import { execAsync } from "../../misc/exec.mjs";
+import { getGitRepoHash } from "./hash.mjs";
+async function downloadGitRepo(options) {
+  const { remote, branch } = options;
+  const hasHashInTarget = options.target.indexOf("{hash}") !== -1;
+  if (options.ifModifiedSince || hasHashInTarget) {
+    const result = await execAsync(`git ls-remote ${remote} --branch ${branch}`);
+    const parts = result.stdout.split(/\s/);
+    const latestHash = parts.shift();
+    if (hasHashInTarget) {
+      options.target = options.target.replace("{hash}", latestHash);
+    }
+    if (options.ifModifiedSince) {
+      try {
+        const expectedHash = options.ifModifiedSince === true ? await getGitRepoHash(options) : options.ifModifiedSince;
+        if (latestHash === expectedHash) {
+          return "not_modified";
+        }
+      } catch (err) {
+      }
+    }
+  }
+  const target = options.target = await prepareDirectoryForExport(options);
+  const files = options.cleanup ? [] : await fs.readdir(target);
+  if (!files.length) {
+    if (options.log) {
+      console.log(`Cloning ${remote}#${branch} to ${target}`);
+    }
+    await execAsync(`git clone --branch ${branch} --no-tags --depth 1 ${remote} "${target}"`);
+  }
+  const hash = await getGitRepoHash(options);
+  return {
+    target,
+    hash
+  };
+}
+export {
+  downloadGitRepo
+};

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

@@ -0,0 +1,5 @@
+import type { GitHubAPIOptions } from './types';
+/**
+ * Get latest hash from GitHub using API
+ */
+export declare function getGitHubRepoHash(options: GitHubAPIOptions): Promise<string>;

package/lib/download/github/hash.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitHubRepoHash = void 0;
+const api_1 = require("../api");
+/**
+ * Get latest hash from GitHub using API
+ */
+async function getGitHubRepoHash(options) {
+    var _a;
+    const uri = `https://api.github.com/repos/${options.user}/${options.repo}/branches/${options.branch}`;
+    const data = await (0, api_1.sendAPIQuery)({
+        uri,
+        headers: {
+            Accept: 'application/vnd.github.v3+json',
+            Authorization: 'token ' + options.token,
+        },
+    });
+    if (typeof data !== 'string') {
+        throw new Error(`Error downloading data from GitHub API: ${data}`);
+    }
+    const content = JSON.parse(data);
+    const hash = (_a = content === null || content === void 0 ? void 0 : content.commit) === null || _a === void 0 ? void 0 : _a.sha;
+    if (typeof hash !== 'string') {
+        throw new Error('Error parsing GitHub API response');
+    }
+    return hash;
+}
+exports.getGitHubRepoHash = getGitHubRepoHash;

package/lib/download/github/hash.mjs

@@ -0,0 +1,25 @@
+// src/download/github/hash.ts
+import { sendAPIQuery } from "../api/index.mjs";
+async function getGitHubRepoHash(options) {
+  var _a;
+  const uri = `https://api.github.com/repos/${options.user}/${options.repo}/branches/${options.branch}`;
+  const data = await sendAPIQuery({
+    uri,
+    headers: {
+      Accept: "application/vnd.github.v3+json",
+      Authorization: "token " + options.token
+    }
+  });
+  if (typeof data !== "string") {
+    throw new Error(`Error downloading data from GitHub API: ${data}`);
+  }
+  const content = JSON.parse(data);
+  const hash = (_a = content == null ? void 0 : content.commit) == null ? void 0 : _a.sha;
+  if (typeof hash !== "string") {
+    throw new Error("Error parsing GitHub API response");
+  }
+  return hash;
+}
+export {
+  getGitHubRepoHash
+};

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

@@ -0,0 +1,28 @@
+import { ExportTargetOptions } from '../../export/helpers/prepare';
+import type { DocumentNotModified } from '../types/modified';
+import type { GitHubAPIOptions } from './types';
+interface IfModifiedSinceOption {
+    ifModifiedSince: string;
+}
+/**
+ * Options for downloadGitRepo()
+ */
+export interface DownloadGitHubRepoOptions extends ExportTargetOptions, GitHubAPIOptions, Partial<IfModifiedSinceOption> {
+    cleanupOldFiles?: boolean;
+    cleanupOldDirectories?: boolean;
+    log?: boolean;
+}
+/**
+ * Result
+ */
+export interface DownloadGitHubRepoResult {
+    rootDir: string;
+    actualDir: string;
+    hash: string;
+}
+/**
+ * Download GitHub repo using API
+ */
+export declare function downloadGitHubRepo<T extends IfModifiedSinceOption & DownloadGitHubRepoOptions>(options: T): Promise<DownloadGitHubRepoResult | DocumentNotModified>;
+export declare function downloadGitHubRepo(options: DownloadGitHubRepoOptions): Promise<DownloadGitHubRepoResult>;
+export {};