@iconify/tools 2.0.0-dev.4 → 2.0.3

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/download/git/index.d.ts

@@ -1,12 +1,14 @@
 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 {
+export interface DownloadGitRepoOptions extends ExportTargetOptions, Partial<IfModifiedSinceOption> {
     remote: string;
     branch: string;
-    ifModifiedSince?: string | true;
     log?: boolean;
 }
 /**
@@ -19,4 +21,6 @@ export interface DownloadGitRepoResult {
 /**
  * Download Git repo
  */
-export declare function downloadGitRepo(options: DownloadGitRepoOptions): Promise<DownloadGitRepoResult | DocumentNotModified>;
+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

@@ -5,9 +5,6 @@ const fs_1 = require("fs");
 const prepare_1 = require("../../export/helpers/prepare");
 const exec_1 = require("../../misc/exec");
 const hash_1 = require("./hash");
-/**
- * Download Git repo
- */
 async function downloadGitRepo(options) {
     const { remote, branch } = options;
     // Check for last commit

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

@@ -1,11 +1,13 @@
 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 {
-    ifModifiedSince?: string;
+export interface DownloadGitHubRepoOptions extends ExportTargetOptions, GitHubAPIOptions, Partial<IfModifiedSinceOption> {
     cleanupOldFiles?: boolean;
     cleanupOldDirectories?: boolean;
     log?: boolean;
@@ -21,4 +23,6 @@ export interface DownloadGitHubRepoResult {
 /**
  * Download GitHub repo using API
  */
-export declare function downloadGitHubRepo(options: DownloadGitHubRepoOptions): Promise<DownloadGitHubRepoResult | DocumentNotModified>;
+export declare function downloadGitHubRepo<T extends IfModifiedSinceOption & DownloadGitHubRepoOptions>(options: T): Promise<DownloadGitHubRepoResult | DocumentNotModified>;
+export declare function downloadGitHubRepo(options: DownloadGitHubRepoOptions): Promise<DownloadGitHubRepoResult>;
+export {};

package/lib/download/github/index.js

@@ -10,12 +10,13 @@ const unzip_1 = require("../helpers/unzip");
  * Find matching directories
  */
 async function findMatchingDirs(rootDir, hash) {
-    const search = '-' + hash;
     const matches = [];
     const files = await fs_1.promises.readdir(rootDir);
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
-        if (file.slice(0 - search.length) !== search) {
+        const lastChunk = file.split('-').pop();
+        if (lastChunk.length < 4 ||
+            lastChunk !== hash.slice(0, lastChunk.length)) {
             continue;
         }
         const stat = await fs_1.promises.lstat(rootDir + '/' + file);
@@ -25,9 +26,6 @@ async function findMatchingDirs(rootDir, hash) {
     }
     return matches;
 }
-/**
- * Download GitHub repo using API
- */
 async function downloadGitHubRepo(options) {
     // Check for last commit
     const hash = await (0, hash_1.getGitHubRepoHash)(options);
@@ -39,11 +37,11 @@ async function downloadGitHubRepo(options) {
     // Prepare target directory
     const rootDir = (options.target = await (0, prepare_1.prepareDirectoryForExport)(options));
     // Archive name
-    const zipTarget = rootDir + '/' + hash + '.zip';
+    const archiveTarget = rootDir + '/' + hash + '.zip';
     // Check if archive exists
     let exists = false;
     try {
-        const stat = await fs_1.promises.lstat(zipTarget);
+        const stat = await fs_1.promises.lstat(archiveTarget);
         exists = stat.isFile();
     }
     catch (err) {
@@ -51,10 +49,15 @@ async function downloadGitHubRepo(options) {
     }
     // Download file
     if (!exists) {
-        const uri = `https://codeload.github.com/${options.user}/${options.repo}/zip/${hash}`;
+        const uri = `https://api.github.com/repos/${options.user}/${options.repo}/zipball/${hash}`;
+        // const uri = `https://codeload.github.com/${options.user}/${options.repo}/zip/${hash}`;
         await (0, download_1.downloadFile)({
             uri,
-        }, zipTarget);
+            headers: {
+                Accept: 'application/vnd.github.v3+json',
+                Authorization: 'token ' + options.token,
+            },
+        }, archiveTarget);
     }
     // Clean up old directories
     const files = await fs_1.promises.readdir(rootDir);
@@ -86,7 +89,7 @@ async function downloadGitHubRepo(options) {
         }
     }
     // Unpack it
-    await (0, unzip_1.unzip)(zipTarget, rootDir);
+    await (0, unzip_1.unzip)(archiveTarget, rootDir);
     // Get actual dir
     const matchingDirs = await findMatchingDirs(rootDir, hash);
     if (matchingDirs.length !== 1) {

package/lib/download/github/index.mjs

@@ -7,12 +7,12 @@ import { getGitHubRepoHash } from "./hash.mjs";
 import { downloadFile } from "../api/download.mjs";
 import { unzip } from "../helpers/unzip.mjs";
 async function findMatchingDirs(rootDir, hash) {
-  const search = "-" + hash;
   const matches = [];
   const files = await fs.readdir(rootDir);
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    if (file.slice(0 - search.length) !== search) {
+    const lastChunk = file.split("-").pop();
+    if (lastChunk.length < 4 || lastChunk !== hash.slice(0, lastChunk.length)) {
       continue;
     }
     const stat = await fs.lstat(rootDir + "/" + file);
@@ -29,18 +29,22 @@ async function downloadGitHubRepo(options) {
   }
   options.target = options.target.replace("{hash}", hash);
   const rootDir = options.target = await prepareDirectoryForExport(options);
-  const zipTarget = rootDir + "/" + hash + ".zip";
+  const archiveTarget = rootDir + "/" + hash + ".zip";
   let exists = false;
   try {
-    const stat = await fs.lstat(zipTarget);
+    const stat = await fs.lstat(archiveTarget);
     exists = stat.isFile();
   } catch (err) {
   }
   if (!exists) {
-    const uri = `https://codeload.github.com/${options.user}/${options.repo}/zip/${hash}`;
+    const uri = `https://api.github.com/repos/${options.user}/${options.repo}/zipball/${hash}`;
     await downloadFile({
-      uri
-    }, zipTarget);
+      uri,
+      headers: {
+        Accept: "application/vnd.github.v3+json",
+        Authorization: "token " + options.token
+      }
+    }, archiveTarget);
   }
   const files = await fs.readdir(rootDir);
   const hashSearch = "-" + hash;
@@ -62,7 +66,7 @@ async function downloadGitHubRepo(options) {
       }
     }
   }
-  await unzip(zipTarget, rootDir);
+  await unzip(archiveTarget, rootDir);
   const matchingDirs = await findMatchingDirs(rootDir, hash);
   if (matchingDirs.length !== 1) {
     throw new Error(`Error unpacking ${hash}.zip`);

package/lib/download/helpers/untar.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unpack .tgz archive
+ */
+export declare function untar(file: string, path: string): Promise<void>;

package/lib/download/helpers/untar.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.untar = void 0;
+const tar_1 = require("tar");
+/**
+ * Unpack .tgz archive
+ */
+async function untar(file, path) {
+    await (0, tar_1.x)({
+        file,
+        C: path,
+    });
+}
+exports.untar = untar;

package/lib/download/helpers/untar.mjs

@@ -0,0 +1,11 @@
+// src/download/helpers/untar.ts
+import { x } from "tar";
+async function untar(file, path) {
+  await x({
+    file,
+    C: path
+  });
+}
+export {
+  untar
+};

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

@@ -1,12 +1,14 @@
 import { ExportTargetOptions } from '../../export/helpers/prepare';
 import type { DocumentNotModified } from '../types/modified';
+interface IfModifiedSinceOption {
+    ifModifiedSince: string | true;
+}
 /**
  * Options for downloadNPMPackage()
  */
-export interface DownloadNPMPackageOptions extends ExportTargetOptions {
+export interface DownloadNPMPackageOptions extends ExportTargetOptions, Partial<IfModifiedSinceOption> {
     package: string;
     tag?: string;
-    ifModifiedSince?: string | true;
     log?: boolean;
 }
 /**
@@ -20,4 +22,6 @@ export interface DownloadNPMPackageResult {
 /**
  * Download NPM package
  */
-export declare function downloadNPMPackage(options: DownloadNPMPackageOptions): Promise<DownloadNPMPackageResult | DocumentNotModified>;
+export declare function downloadNPMPackage<T extends IfModifiedSinceOption & DownloadNPMPackageOptions>(options: T): Promise<DownloadNPMPackageResult | DocumentNotModified>;
+export declare function downloadNPMPackage(options: DownloadNPMPackageOptions): Promise<DownloadNPMPackageResult>;
+export {};

package/lib/download/npm/index.js

@@ -1,25 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadNPMPackage = void 0;
+const fs_1 = require("fs");
 const prepare_1 = require("../../export/helpers/prepare");
-const exec_1 = require("../../misc/exec");
+const download_1 = require("../api/download");
+const untar_1 = require("../helpers/untar");
 const version_1 = require("./version");
-/**
- * Download NPM package
- */
 async function downloadNPMPackage(options) {
-    const packageName = options.package;
-    const tag = options.tag || 'latest';
     const rootDir = (options.target = (0, prepare_1.normalizeDir)(options.target));
-    const actualDir = rootDir + '/node_modules/' + packageName;
-    // Check for version
+    const actualDir = rootDir + '/package';
+    // Get latest location
+    const versionInfo = await (0, version_1.getNPMVersion)(options);
+    const version = versionInfo.version;
+    // Check downloaded copy
     if (options.ifModifiedSince) {
         try {
             const expectedVersion = options.ifModifiedSince === true
                 ? await (0, version_1.getPackageVersion)(actualDir)
                 : options.ifModifiedSince;
-            const latestVersion = (await (0, version_1.getNPMVersion)(options)).version;
-            if (latestVersion === expectedVersion) {
+            if (version === expectedVersion) {
                 return 'not_modified';
             }
         }
@@ -27,15 +26,44 @@ async function downloadNPMPackage(options) {
             //
         }
     }
+    const archiveURL = versionInfo.file;
+    if (!archiveURL) {
+        throw new Error(`NPM registry did not provide link to package archive.`);
+    }
+    const archiveTarget = rootDir + '/' + version + '.tgz';
     // Prepare target directory
     await (0, prepare_1.prepareDirectoryForExport)(options);
-    // Check if directory is empty if directory wasn't cleaned up
+    // Check if archive exists
+    let archiveExists = false;
+    try {
+        const stat = await fs_1.promises.lstat(archiveTarget);
+        archiveExists = stat.isFile();
+    }
+    catch (err) {
+        //
+    }
+    // Download file
+    if (!archiveExists) {
+        if (options.log) {
+            console.log(`Downloading ${archiveURL}`);
+        }
+        await (0, download_1.downloadFile)({
+            uri: archiveURL,
+            headers: {
+                Accept: 'application/tar+gzip',
+            },
+        }, archiveTarget);
+    }
+    // Remove old unpacked file
+    await (0, prepare_1.prepareDirectoryForExport)({
+        target: actualDir,
+        cleanup: true,
+    });
+    // Unpack file
     if (options.log) {
-        console.log(`Installing ${packageName}@${tag} to ${rootDir}`);
+        console.log(`Unpacking ${archiveTarget}`);
     }
-    await (0, exec_1.execAsync)(`npm install --prefix "${rootDir}" ${packageName}@${tag} --no-audit --ignore-scripts --no-save --omit dev --no-bin-links`);
-    // Get latest version
-    const version = await (0, version_1.getPackageVersion)(actualDir);
+    await (0, untar_1.untar)(archiveTarget, rootDir);
     return {
         rootDir,
         actualDir,

package/lib/download/npm/index.mjs

@@ -1,31 +1,57 @@
 // src/download/npm/index.ts
+import { promises as fs } from "fs";
 import {
   normalizeDir,
   prepareDirectoryForExport
 } from "../../export/helpers/prepare.mjs";
-import { execAsync } from "../../misc/exec.mjs";
+import { downloadFile } from "../api/download.mjs";
+import { untar } from "../helpers/untar.mjs";
 import { getNPMVersion, getPackageVersion } from "./version.mjs";
 async function downloadNPMPackage(options) {
-  const packageName = options.package;
-  const tag = options.tag || "latest";
   const rootDir = options.target = normalizeDir(options.target);
-  const actualDir = rootDir + "/node_modules/" + packageName;
+  const actualDir = rootDir + "/package";
+  const versionInfo = await getNPMVersion(options);
+  const version = versionInfo.version;
   if (options.ifModifiedSince) {
     try {
       const expectedVersion = options.ifModifiedSince === true ? await getPackageVersion(actualDir) : options.ifModifiedSince;
-      const latestVersion = (await getNPMVersion(options)).version;
-      if (latestVersion === expectedVersion) {
+      if (version === expectedVersion) {
         return "not_modified";
       }
     } catch (err) {
     }
   }
+  const archiveURL = versionInfo.file;
+  if (!archiveURL) {
+    throw new Error(`NPM registry did not provide link to package archive.`);
+  }
+  const archiveTarget = rootDir + "/" + version + ".tgz";
   await prepareDirectoryForExport(options);
+  let archiveExists = false;
+  try {
+    const stat = await fs.lstat(archiveTarget);
+    archiveExists = stat.isFile();
+  } catch (err) {
+  }
+  if (!archiveExists) {
+    if (options.log) {
+      console.log(`Downloading ${archiveURL}`);
+    }
+    await downloadFile({
+      uri: archiveURL,
+      headers: {
+        Accept: "application/tar+gzip"
+      }
+    }, archiveTarget);
+  }
+  await prepareDirectoryForExport({
+    target: actualDir,
+    cleanup: true
+  });
   if (options.log) {
-    console.log(`Installing ${packageName}@${tag} to ${rootDir}`);
+    console.log(`Unpacking ${archiveTarget}`);
   }
-  await execAsync(`npm install --prefix "${rootDir}" ${packageName}@${tag} --no-audit --ignore-scripts --no-save --omit dev --no-bin-links`);
-  const version = await getPackageVersion(actualDir);
+  await untar(archiveTarget, rootDir);
   return {
     rootDir,
     actualDir,

package/lib/export/helpers/types-version.js

@@ -1,14 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTypesVersion = void 0;
-const package_json_1 = __importDefault(require("@iconify/types/package.json"));
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const pkg = require('@iconify/types/package.json');
 /**
  * Get current version of Iconify Types package
  */
 function getTypesVersion() {
-    return package_json_1.default.version;
+    return pkg.version;
 }
 exports.getTypesVersion = getTypesVersion;