@iconify/tools 2.0.0-dev.3 → 2.0.2

package/lib/download/github/index.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadGitHubRepo = void 0;
+const fs_1 = require("fs");
+const prepare_1 = require("../../export/helpers/prepare");
+const hash_1 = require("./hash");
+const download_1 = require("../api/download");
+const unzip_1 = require("../helpers/unzip");
+/**
+ * Find matching directories
+ */
+async function findMatchingDirs(rootDir, hash) {
+    const matches = [];
+    const files = await fs_1.promises.readdir(rootDir);
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        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);
+        if (stat.isDirectory()) {
+            matches.push(file);
+        }
+    }
+    return matches;
+}
+async function downloadGitHubRepo(options) {
+    // Check for last commit
+    const hash = await (0, hash_1.getGitHubRepoHash)(options);
+    if (options.ifModifiedSince && hash === options.ifModifiedSince) {
+        return 'not_modified';
+    }
+    // Replace hash in target
+    options.target = options.target.replace('{hash}', hash);
+    // Prepare target directory
+    const rootDir = (options.target = await (0, prepare_1.prepareDirectoryForExport)(options));
+    // Archive name
+    const archiveTarget = rootDir + '/' + hash + '.zip';
+    // Check if archive exists
+    let exists = false;
+    try {
+        const stat = await fs_1.promises.lstat(archiveTarget);
+        exists = stat.isFile();
+    }
+    catch (err) {
+        //
+    }
+    // Download file
+    if (!exists) {
+        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,
+            headers: {
+                Accept: 'application/vnd.github.v3+json',
+                Authorization: 'token ' + options.token,
+            },
+        }, archiveTarget);
+    }
+    // Clean up old directories
+    const files = await fs_1.promises.readdir(rootDir);
+    const hashSearch = '-' + hash;
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        if (file === hash + '.zip') {
+            continue;
+        }
+        const filename = rootDir + '/' + files[i];
+        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 if directory and cleanupOldDirectories is not disabled
+            (isDir && options.cleanupOldDirectories !== false) ||
+            // Remove if file and cleanupOldFiles is enabled
+            (!isDir && options.cleanupOldFiles)) {
+            try {
+                await fs_1.promises.rm(filename, {
+                    force: true,
+                    recursive: true,
+                });
+            }
+            catch (err) {
+                //
+            }
+        }
+    }
+    // Unpack it
+    await (0, unzip_1.unzip)(archiveTarget, rootDir);
+    // Get actual dir
+    const matchingDirs = await findMatchingDirs(rootDir, hash);
+    if (matchingDirs.length !== 1) {
+        throw new Error(`Error unpacking ${hash}.zip`);
+    }
+    const actualDir = rootDir + '/' + matchingDirs[0];
+    return {
+        rootDir,
+        actualDir,
+        hash,
+    };
+}
+exports.downloadGitHubRepo = downloadGitHubRepo;

package/lib/download/github/index.mjs

@@ -0,0 +1,83 @@
+// src/download/github/index.ts
+import { promises as fs } from "fs";
+import {
+  prepareDirectoryForExport
+} from "../../export/helpers/prepare.mjs";
+import { getGitHubRepoHash } from "./hash.mjs";
+import { downloadFile } from "../api/download.mjs";
+import { unzip } from "../helpers/unzip.mjs";
+async function findMatchingDirs(rootDir, hash) {
+  const matches = [];
+  const files = await fs.readdir(rootDir);
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const lastChunk = file.split("-").pop();
+    if (lastChunk.length < 4 || lastChunk !== hash.slice(0, lastChunk.length)) {
+      continue;
+    }
+    const stat = await fs.lstat(rootDir + "/" + file);
+    if (stat.isDirectory()) {
+      matches.push(file);
+    }
+  }
+  return matches;
+}
+async function downloadGitHubRepo(options) {
+  const hash = await getGitHubRepoHash(options);
+  if (options.ifModifiedSince && hash === options.ifModifiedSince) {
+    return "not_modified";
+  }
+  options.target = options.target.replace("{hash}", hash);
+  const rootDir = options.target = await prepareDirectoryForExport(options);
+  const archiveTarget = rootDir + "/" + hash + ".zip";
+  let exists = false;
+  try {
+    const stat = await fs.lstat(archiveTarget);
+    exists = stat.isFile();
+  } catch (err) {
+  }
+  if (!exists) {
+    const uri = `https://api.github.com/repos/${options.user}/${options.repo}/zipball/${hash}`;
+    await downloadFile({
+      uri,
+      headers: {
+        Accept: "application/vnd.github.v3+json",
+        Authorization: "token " + options.token
+      }
+    }, archiveTarget);
+  }
+  const files = await fs.readdir(rootDir);
+  const hashSearch = "-" + hash;
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    if (file === hash + ".zip") {
+      continue;
+    }
+    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) {
+      try {
+        await fs.rm(filename, {
+          force: true,
+          recursive: true
+        });
+      } catch (err) {
+      }
+    }
+  }
+  await unzip(archiveTarget, rootDir);
+  const matchingDirs = await findMatchingDirs(rootDir, hash);
+  if (matchingDirs.length !== 1) {
+    throw new Error(`Error unpacking ${hash}.zip`);
+  }
+  const actualDir = rootDir + "/" + matchingDirs[0];
+  return {
+    rootDir,
+    actualDir,
+    hash
+  };
+}
+export {
+  downloadGitHubRepo
+};

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

@@ -0,0 +1,9 @@
+/**
+ * API options
+ */
+export interface GitHubAPIOptions {
+    token: string;
+    user: string;
+    repo: string;
+    branch: string;
+}

package/lib/download/github/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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/helpers/unzip.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unzip archive
+ */
+export declare function unzip(source: string, path: string): Promise<void>;

package/lib/download/helpers/unzip.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unzip = void 0;
+const extract_zip_1 = __importDefault(require("extract-zip"));
+const fs_1 = require("fs");
+/**
+ * Unzip archive
+ */
+async function unzip(source, path) {
+    const dir = await fs_1.promises.realpath(path);
+    await (0, extract_zip_1.default)(source, {
+        dir,
+    });
+}
+exports.unzip = unzip;

package/lib/download/helpers/unzip.mjs

@@ -0,0 +1,12 @@
+// src/download/helpers/unzip.ts
+import extract from "extract-zip";
+import { promises as fs } from "fs";
+async function unzip(source, path) {
+  const dir = await fs.realpath(path);
+  await extract(source, {
+    dir
+  });
+}
+export {
+  unzip
+};

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

@@ -0,0 +1,27 @@
+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, Partial<IfModifiedSinceOption> {
+    package: string;
+    tag?: string;
+    log?: boolean;
+}
+/**
+ * Result
+ */
+export interface DownloadNPMPackageResult {
+    rootDir: string;
+    actualDir: string;
+    version: string;
+}
+/**
+ * Download NPM package
+ */
+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

@@ -0,0 +1,73 @@
+"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 download_1 = require("../api/download");
+const untar_1 = require("../helpers/untar");
+const version_1 = require("./version");
+async function downloadNPMPackage(options) {
+    const rootDir = (options.target = (0, prepare_1.normalizeDir)(options.target));
+    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;
+            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';
+    // Prepare target directory
+    await (0, prepare_1.prepareDirectoryForExport)(options);
+    // 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(`Unpacking ${archiveTarget}`);
+    }
+    await (0, untar_1.untar)(archiveTarget, rootDir);
+    return {
+        rootDir,
+        actualDir,
+        version,
+    };
+}
+exports.downloadNPMPackage = downloadNPMPackage;

package/lib/download/npm/index.mjs

@@ -0,0 +1,63 @@
+// src/download/npm/index.ts
+import { promises as fs } from "fs";
+import {
+  normalizeDir,
+  prepareDirectoryForExport
+} from "../../export/helpers/prepare.mjs";
+import { downloadFile } from "../api/download.mjs";
+import { untar } from "../helpers/untar.mjs";
+import { getNPMVersion, getPackageVersion } from "./version.mjs";
+async function downloadNPMPackage(options) {
+  const rootDir = options.target = normalizeDir(options.target);
+  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;
+      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(`Unpacking ${archiveTarget}`);
+  }
+  await untar(archiveTarget, rootDir);
+  return {
+    rootDir,
+    actualDir,
+    version
+  };
+}
+export {
+  downloadNPMPackage
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Package options
+ */
+export interface NPMPackageOptions {
+    package: string;
+    tag?: string;
+}

package/lib/download/npm/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,13 @@
+import type { NPMPackageOptions } from './types';
+export interface GetNPMVersionResult {
+    version: string;
+    file?: string;
+}
+/**
+ * Get version of package from NPM registry
+ */
+export declare function getNPMVersion(options: NPMPackageOptions): Promise<GetNPMVersionResult>;
+/**
+ * Get version of package from filename
+ */
+export declare function getPackageVersion(target: string): Promise<string>;

package/lib/download/npm/version.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = exports.getNPMVersion = void 0;
+const fs_1 = require("fs");
+const exec_1 = require("../../misc/exec");
+/**
+ * Get version of package from NPM registry
+ */
+async function getNPMVersion(options) {
+    var _a;
+    const tag = options.tag || 'latest';
+    const result = await (0, exec_1.execAsync)(`npm view ${options.package}@${tag} --json`);
+    const data = JSON.parse(result.stdout);
+    return {
+        version: data.version,
+        file: (_a = data.dist) === null || _a === void 0 ? void 0 : _a.tarball,
+    };
+}
+exports.getNPMVersion = getNPMVersion;
+/**
+ * Get version of package from filename
+ */
+async function getPackageVersion(target) {
+    return JSON.parse(await fs_1.promises.readFile(target + '/package.json', 'utf8'))
+        .version;
+}
+exports.getPackageVersion = getPackageVersion;

package/lib/download/npm/version.mjs

@@ -0,0 +1,20 @@
+// src/download/npm/version.ts
+import { promises as fs } from "fs";
+import { execAsync } from "../../misc/exec.mjs";
+async function getNPMVersion(options) {
+  var _a;
+  const tag = options.tag || "latest";
+  const result = await execAsync(`npm view ${options.package}@${tag} --json`);
+  const data = JSON.parse(result.stdout);
+  return {
+    version: data.version,
+    file: (_a = data.dist) == null ? void 0 : _a.tarball
+  };
+}
+async function getPackageVersion(target) {
+  return JSON.parse(await fs.readFile(target + "/package.json", "utf8")).version;
+}
+export {
+  getNPMVersion,
+  getPackageVersion
+};

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

@@ -0,0 +1,4 @@
+/**
+ * Document wasn't modified
+ */
+export declare type DocumentNotModified = 'not_modified';

package/lib/download/types/modified.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/export/directory.d.ts

@@ -1,5 +1,5 @@
 import type { IconSet } from '../icon-set';
-import type { ExportTargetOptions } from './prepare';
+import type { ExportTargetOptions } from './helpers/prepare';
 /**
  * Options
  */
@@ -14,4 +14,4 @@ export interface ExportToDirectoryOptions extends ExportTargetOptions {
  *
  * Returns list of stored files
  */
-export declare function exportToDirectory(iconSet: IconSet, options: ExportToDirectoryOptions): Promise<Set<string>>;
+export declare function exportToDirectory(iconSet: IconSet, options: ExportToDirectoryOptions): Promise<string[]>;

package/lib/export/directory.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exportToDirectory = void 0;
 const fs_1 = require("fs");
-const prepare_1 = require("./prepare");
+const prepare_1 = require("./helpers/prepare");
 /**
  * Export icon set to directory
  *
@@ -47,6 +47,6 @@ async function exportToDirectory(iconSet, options) {
         }
         await store(name, `${dir}/${name}.svg`);
     });
-    return storedFiles;
+    return Array.from(storedFiles);
 }
 exports.exportToDirectory = exportToDirectory;

package/lib/export/directory.mjs

@@ -1,6 +1,6 @@
 // src/export/directory.ts
 import { promises as fs } from "fs";
-import { prepareDirectoryForExport } from "./prepare.mjs";
+import { prepareDirectoryForExport } from "./helpers/prepare.mjs";
 async function exportToDirectory(iconSet, options) {
   const dir = await prepareDirectoryForExport(options);
   const storedFiles = new Set();
@@ -34,7 +34,7 @@ async function exportToDirectory(iconSet, options) {
     }
     await store(name, `${dir}/${name}.svg`);
   });
-  return storedFiles;
+  return Array.from(storedFiles);
 }
 export {
   exportToDirectory

package/lib/export/helpers/custom-files.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Options
+ */
+export interface ExportOptionsWithCustomFiles {
+    customFiles?: Record<string, string | Record<string, unknown> | null>;
+}
+/**
+ * Write custom files
+ */
+export declare function exportCustomFiles(dir: string, options: ExportOptionsWithCustomFiles, result?: Set<string>): Promise<void>;

package/lib/export/helpers/custom-files.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportCustomFiles = void 0;
+const fs_1 = require("fs");
+const write_json_1 = require("../../misc/write-json");
+/**
+ * Write custom files
+ */
+async function exportCustomFiles(dir, options, result) {
+    const customFiles = options.customFiles || {};
+    for (const filename in customFiles) {
+        const content = customFiles[filename];
+        if (content === null) {
+            // Delete file, if exists
+            try {
+                await fs_1.promises.unlink(dir + '/' + filename);
+            }
+            catch (err) {
+                //
+            }
+            continue;
+        }
+        if (typeof content === 'string') {
+            await fs_1.promises.writeFile(dir + '/' + filename, content, 'utf8');
+        }
+        else if (typeof content === 'object') {
+            await (0, write_json_1.writeJSONFile)(dir + '/' + filename, content);
+        }
+        result === null || result === void 0 ? void 0 : result.add(filename);
+    }
+}
+exports.exportCustomFiles = exportCustomFiles;

package/lib/export/helpers/custom-files.mjs

@@ -0,0 +1,25 @@
+// src/export/helpers/custom-files.ts
+import { promises as fs } from "fs";
+import { writeJSONFile } from "../../misc/write-json.mjs";
+async function exportCustomFiles(dir, options, result) {
+  const customFiles = options.customFiles || {};
+  for (const filename in customFiles) {
+    const content = customFiles[filename];
+    if (content === null) {
+      try {
+        await fs.unlink(dir + "/" + filename);
+      } catch (err) {
+      }
+      continue;
+    }
+    if (typeof content === "string") {
+      await fs.writeFile(dir + "/" + filename, content, "utf8");
+    } else if (typeof content === "object") {
+      await writeJSONFile(dir + "/" + filename, content);
+    }
+    result == null ? void 0 : result.add(filename);
+  }
+}
+export {
+  exportCustomFiles
+};

package/lib/export/{prepare.d.ts → helpers/prepare.d.ts}

@@ -5,6 +5,10 @@ export interface ExportTargetOptions {
     target: string;
     cleanup?: boolean;
 }
+/**
+ * Normalize directory
+ */
+export declare function normalizeDir(dir: string): string;
 /**
  * Prepare directory for export
  *