@iconify/tools 2.0.1 → 2.0.5

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,24 +10,22 @@ 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);
+        const stat = await fs_1.promises.stat(rootDir + '/' + file);
         if (stat.isDirectory()) {
             matches.push(file);
         }
     }
     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.stat(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);
@@ -68,8 +71,10 @@ async function downloadGitHubRepo(options) {
         const stat = await fs_1.promises.lstat(filename);
         const isDir = stat.isDirectory();
         if (
-        // Remove if directory matches hash to avoid errors extracting zip
-        (isDir && filename.slice(0 - hashSearch.length) === hashSearch) ||
+        // Remove symbolic links
+        stat.isSymbolicLink() ||
+            // Remove if directory matches hash to avoid errors extracting zip
+            (isDir && filename.slice(0 - hashSearch.length) === hashSearch) ||
             // Remove if directory and cleanupOldDirectories is not disabled
             (isDir && options.cleanupOldDirectories !== false) ||
             // Remove if file and cleanupOldFiles is enabled
@@ -86,7 +91,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,15 +7,15 @@ 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);
+    const stat = await fs.stat(rootDir + "/" + file);
     if (stat.isDirectory()) {
       matches.push(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.stat(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;
@@ -52,7 +56,7 @@ async function downloadGitHubRepo(options) {
     const filename = rootDir + "/" + files[i];
     const stat = await fs.lstat(filename);
     const isDir = stat.isDirectory();
-    if (isDir && filename.slice(0 - hashSearch.length) === hashSearch || isDir && options.cleanupOldDirectories !== false || !isDir && options.cleanupOldFiles) {
+    if (stat.isSymbolicLink() || isDir && filename.slice(0 - hashSearch.length) === hashSearch || isDir && options.cleanupOldDirectories !== false || !isDir && options.cleanupOldFiles) {
       try {
         await fs.rm(filename, {
           force: true,
@@ -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.stat(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.stat(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.mjs

@@ -1,76 +1,37 @@
-var __defProp = Object.defineProperty;
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  __markAsModule(target);
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 
 // ../../node_modules/@iconify/types/package.json
-var package_exports = {};
-__export(package_exports, {
-  author: () => author,
-  bugs: () => bugs,
-  default: () => package_default,
-  description: () => description,
-  devDependencies: () => devDependencies,
-  homepage: () => homepage,
-  license: () => license,
-  main: () => main,
-  name: () => name,
-  repository: () => repository,
-  scripts: () => scripts,
-  type: () => type,
-  types: () => types,
-  version: () => version
-});
-var name, description, version, author, license, main, type, types, scripts, bugs, homepage, repository, devDependencies, package_default;
-var init_package = __esm({
-  "../../node_modules/@iconify/types/package.json"() {
-    name = "@iconify/types";
-    description = "Types for Iconify data";
-    version = "1.0.10";
-    author = "Vjacheslav Trushkin";
-    license = "(Apache-2.0 OR GPL-2.0)";
-    main = "./index.js";
-    type = "module";
-    types = "./types.ts";
-    scripts = {
-      test: "tsc --noEmit --strict --typeRoots '[]' types.ts"
-    };
-    bugs = "https://github.com/iconify/iconify/issues";
-    homepage = "https://github.com/iconify/iconify";
-    repository = {
-      type: "git",
-      url: "https://github.com/iconify/iconify.git",
-      directory: "packages/types"
-    };
-    devDependencies = {
-      typescript: "^4.4.3"
-    };
-    package_default = {
-      name,
-      description,
-      version,
-      author,
-      license,
-      main,
-      type,
-      types,
-      scripts,
-      bugs,
-      homepage,
-      repository,
-      devDependencies
+var require_package = __commonJS({
+  "../../node_modules/@iconify/types/package.json"(exports, module) {
+    module.exports = {
+      name: "@iconify/types",
+      description: "Types for Iconify data",
+      version: "1.0.12",
+      author: "Vjacheslav Trushkin",
+      license: "(Apache-2.0 OR GPL-2.0)",
+      main: "./index.js",
+      types: "./types.ts",
+      scripts: {
+        test: "tsc --noEmit --strict --typeRoots '[]' types.ts"
+      },
+      bugs: "https://github.com/iconify/iconify/issues",
+      homepage: "https://github.com/iconify/iconify",
+      repository: {
+        type: "git",
+        url: "https://github.com/iconify/iconify.git",
+        directory: "packages/types"
+      },
+      devDependencies: {
+        typescript: "^4.4.3"
+      }
     };
   }
 });
 
 // src/export/helpers/types-version.ts
-var pkg = (init_package(), package_exports);
+var pkg = require_package();
 function getTypesVersion() {
   return pkg.version;
 }