@iconify/tools 2.0.14 → 2.0.15

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

@@ -1,13 +1,14 @@
-import { ExportTargetOptions } from '../../export/helpers/prepare';
-import type { DocumentNotModified } from '../types/modified';
-import type { DownloadSourceMixin } from '../types/sources';
+import { ExportTargetOptions } from '../../export/helpers/prepare.js';
+import { DocumentNotModified } from '../types/modified.js';
+import { DownloadSourceMixin } from '../types/sources.js';
+
 interface IfModifiedSinceOption {
     ifModifiedSince: string | true | DownloadNPMPackageResult;
 }
 /**
  * Options for downloadNPMPackage()
  */
-export interface DownloadNPMPackageOptions extends ExportTargetOptions, Partial<IfModifiedSinceOption> {
+interface DownloadNPMPackageOptions extends ExportTargetOptions, Partial<IfModifiedSinceOption> {
     package: string;
     tag?: string;
     log?: boolean;
@@ -15,7 +16,7 @@ export interface DownloadNPMPackageOptions extends ExportTargetOptions, Partial<
 /**
  * Result
  */
-export interface DownloadNPMPackageResult extends DownloadSourceMixin<'npm'> {
+interface DownloadNPMPackageResult extends DownloadSourceMixin<'npm'> {
     rootDir: string;
     contentsDir: string;
     version: string;
@@ -23,6 +24,7 @@ export interface DownloadNPMPackageResult extends DownloadSourceMixin<'npm'> {
 /**
  * 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 {};
+declare function downloadNPMPackage<T extends IfModifiedSinceOption & DownloadNPMPackageOptions>(options: T): Promise<DownloadNPMPackageResult | DocumentNotModified>;
+declare function downloadNPMPackage(options: DownloadNPMPackageOptions): Promise<DownloadNPMPackageResult>;
+
+export { DownloadNPMPackageOptions, DownloadNPMPackageResult, downloadNPMPackage };

package/lib/download/npm/index.mjs

@@ -1,12 +1,16 @@
-// 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";
+import { promises } 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';
+import 'pathe';
+import 'node-fetch';
+import 'util';
+import 'stream';
+import 'tar';
+import '../../misc/exec.mjs';
+import 'child_process';
+
 async function downloadNPMPackage(options) {
   const rootDir = options.target = normalizeDir(options.target);
   const contentsDir = rootDir + "/package";
@@ -40,7 +44,7 @@ async function downloadNPMPackage(options) {
   await prepareDirectoryForExport(options);
   let archiveExists = false;
   try {
-    const stat = await fs.stat(archiveTarget);
+    const stat = await promises.stat(archiveTarget);
     archiveExists = stat.isFile();
   } catch (err) {
   }
@@ -70,6 +74,5 @@ async function downloadNPMPackage(options) {
     version
   };
 }
-export {
-  downloadNPMPackage
-};
+
+export { downloadNPMPackage };

package/lib/download/npm/types.cjs

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

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

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

package/lib/download/npm/types.mjs

@@ -0,0 +1 @@
+

package/lib/download/npm/version.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fs = require('fs');
+const misc_exec = require('../../misc/exec.cjs');
+require('child_process');
+
+async function getNPMVersion(options) {
+  const tag = options.tag || "latest";
+  const result = await misc_exec.execAsync(`npm view ${options.package}@${tag} --json`);
+  const data = JSON.parse(result.stdout);
+  return {
+    version: data.version,
+    file: data.dist?.tarball
+  };
+}
+async function getPackageVersion(target) {
+  return JSON.parse(await fs.promises.readFile(target + "/package.json", "utf8")).version;
+}
+
+exports.getNPMVersion = getNPMVersion;
+exports.getPackageVersion = getPackageVersion;

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

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

package/lib/download/npm/version.mjs

@@ -1,20 +1,18 @@
-// src/download/npm/version.ts
-import { promises as fs } from "fs";
-import { execAsync } from "../../misc/exec.mjs";
+import { promises } from 'fs';
+import { execAsync } from '../../misc/exec.mjs';
+import 'child_process';
+
 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
+    file: data.dist?.tarball
   };
 }
 async function getPackageVersion(target) {
-  return JSON.parse(await fs.readFile(target + "/package.json", "utf8")).version;
+  return JSON.parse(await promises.readFile(target + "/package.json", "utf8")).version;
 }
-export {
-  getNPMVersion,
-  getPackageVersion
-};
+
+export { getNPMVersion, getPackageVersion };

package/lib/download/types/modified.cjs

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

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

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

package/lib/download/types/modified.mjs

@@ -0,0 +1 @@
+

package/lib/download/types/sources.cjs

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

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

@@ -1,10 +1,12 @@
 /**
  * Download types
  */
-export declare type DownloadSourceType = 'git' | 'github' | 'gitlab' | 'npm';
+declare type DownloadSourceType = 'git' | 'github' | 'gitlab' | 'npm';
 /**
  * Type in other objects
  */
-export interface DownloadSourceMixin<T extends DownloadSourceType> {
+interface DownloadSourceMixin<T extends DownloadSourceType> {
     downloadType: T;
 }
+
+export { DownloadSourceMixin, DownloadSourceType };

package/lib/download/types/sources.mjs

@@ -0,0 +1 @@
+

package/lib/export/directory.cjs

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fs = require('fs');
+const export_helpers_prepare = require('./helpers/prepare.cjs');
+require('pathe');
+
+async function exportToDirectory(iconSet, options) {
+  const dir = await export_helpers_prepare.prepareDirectoryForExport(options);
+  const storedFiles = /* @__PURE__ */ new Set();
+  const customisations = options.autoHeight === false ? {
+    height: "1em"
+  } : {
+    width: "auto",
+    height: "auto"
+  };
+  const store = async (name, target) => {
+    const svg = iconSet.toString(name, customisations);
+    if (!svg) {
+      return;
+    }
+    await fs.promises.writeFile(target, svg, "utf8");
+    storedFiles.add(target);
+    if (options.log) {
+      console.log(`Saved ${target} (${svg.length} bytes)`);
+    }
+  };
+  if (options.includeChars) {
+    const chars = iconSet.chars();
+    for (const char in chars) {
+      const name = chars[char];
+      await store(name, `${dir}/${char}.svg`);
+    }
+  }
+  await iconSet.forEach(async (name, type) => {
+    if (type === "alias" && options.includeAliases === false) {
+      return;
+    }
+    await store(name, `${dir}/${name}.svg`);
+  });
+  return Array.from(storedFiles);
+}
+
+exports.exportToDirectory = exportToDirectory;

package/lib/export/directory.d.ts

@@ -1,9 +1,14 @@
-import type { IconSet } from '../icon-set';
-import type { ExportTargetOptions } from './helpers/prepare';
+import { IconSet } from '../icon-set/index.js';
+import { ExportTargetOptions } from './helpers/prepare.js';
+import '@iconify/types';
+import '@iconify/utils/lib/customisations';
+import '../icon-set/types.js';
+import '../svg/index.js';
+
 /**
  * Options
  */
-export interface ExportToDirectoryOptions extends ExportTargetOptions {
+interface ExportToDirectoryOptions extends ExportTargetOptions {
     autoHeight?: boolean;
     includeAliases?: boolean;
     includeChars?: boolean;
@@ -14,4 +19,6 @@ export interface ExportToDirectoryOptions extends ExportTargetOptions {
  *
  * Returns list of stored files
  */
-export declare function exportToDirectory(iconSet: IconSet, options: ExportToDirectoryOptions): Promise<string[]>;
+declare function exportToDirectory(iconSet: IconSet, options: ExportToDirectoryOptions): Promise<string[]>;
+
+export { ExportToDirectoryOptions, exportToDirectory };

package/lib/export/directory.mjs

@@ -1,9 +1,10 @@
-// src/export/directory.ts
-import { promises as fs } from "fs";
-import { prepareDirectoryForExport } from "./helpers/prepare.mjs";
+import { promises } from 'fs';
+import { prepareDirectoryForExport } from './helpers/prepare.mjs';
+import 'pathe';
+
 async function exportToDirectory(iconSet, options) {
   const dir = await prepareDirectoryForExport(options);
-  const storedFiles = new Set();
+  const storedFiles = /* @__PURE__ */ new Set();
   const customisations = options.autoHeight === false ? {
     height: "1em"
   } : {
@@ -15,7 +16,7 @@ async function exportToDirectory(iconSet, options) {
     if (!svg) {
       return;
     }
-    await fs.writeFile(target, svg, "utf8");
+    await promises.writeFile(target, svg, "utf8");
     storedFiles.add(target);
     if (options.log) {
       console.log(`Saved ${target} (${svg.length} bytes)`);
@@ -36,6 +37,5 @@ async function exportToDirectory(iconSet, options) {
   });
   return Array.from(storedFiles);
 }
-export {
-  exportToDirectory
-};
+
+export { exportToDirectory };

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

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fs = require('fs');
+const misc_writeJson = require('../../misc/write-json.cjs');
+
+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.promises.unlink(dir + "/" + filename);
+      } catch (err) {
+      }
+      continue;
+    }
+    if (typeof content === "string") {
+      await fs.promises.writeFile(dir + "/" + filename, content, "utf8");
+    } else if (typeof content === "object") {
+      await misc_writeJson.writeJSONFile(dir + "/" + filename, content);
+    }
+    result?.add(filename);
+  }
+}
+
+exports.exportCustomFiles = exportCustomFiles;

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

@@ -1,10 +1,12 @@
 /**
  * Options
  */
-export interface ExportOptionsWithCustomFiles {
+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>;
+declare function exportCustomFiles(dir: string, options: ExportOptionsWithCustomFiles, result?: Set<string>): Promise<void>;
+
+export { ExportOptionsWithCustomFiles, exportCustomFiles };

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

@@ -1,25 +1,24 @@
-// src/export/helpers/custom-files.ts
-import { promises as fs } from "fs";
-import { writeJSONFile } from "../../misc/write-json.mjs";
+import { promises } 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);
+        await promises.unlink(dir + "/" + filename);
       } catch (err) {
       }
       continue;
     }
     if (typeof content === "string") {
-      await fs.writeFile(dir + "/" + filename, content, "utf8");
+      await promises.writeFile(dir + "/" + filename, content, "utf8");
     } else if (typeof content === "object") {
       await writeJSONFile(dir + "/" + filename, content);
     }
-    result == null ? void 0 : result.add(filename);
+    result?.add(filename);
   }
 }
-export {
-  exportCustomFiles
-};
+
+export { exportCustomFiles };

package/lib/export/helpers/prepare.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fs = require('fs');
+const pathe = require('pathe');
+
+function normalizeDir(dir) {
+  dir = pathe.normalize(dir);
+  if (dir.slice(-1) === "/") {
+    dir = dir.slice(0, -1);
+  }
+  return dir;
+}
+async function prepareDirectoryForExport(options) {
+  const dir = normalizeDir(options.target);
+  if (options.cleanup) {
+    try {
+      await fs.promises.rm(dir, {
+        recursive: true,
+        force: true
+      });
+    } catch (err) {
+    }
+  }
+  try {
+    await fs.promises.mkdir(dir, {
+      recursive: true
+    });
+  } catch (err) {
+  }
+  return dir;
+}
+
+exports.normalizeDir = normalizeDir;
+exports.prepareDirectoryForExport = prepareDirectoryForExport;

package/lib/export/helpers/prepare.d.ts

@@ -1,17 +1,19 @@
 /**
  * Common options for all functions that export to directory
  */
-export interface ExportTargetOptions {
+interface ExportTargetOptions {
     target: string;
     cleanup?: boolean;
 }
 /**
  * Normalize directory
  */
-export declare function normalizeDir(dir: string): string;
+declare function normalizeDir(dir: string): string;
 /**
  * Prepare directory for export
  *
  * Also normalizes directory and returns normalized value
  */
-export declare function prepareDirectoryForExport(options: ExportTargetOptions): Promise<string>;
+declare function prepareDirectoryForExport(options: ExportTargetOptions): Promise<string>;
+
+export { ExportTargetOptions, normalizeDir, prepareDirectoryForExport };

package/lib/export/helpers/prepare.mjs

@@ -1,6 +1,6 @@
-// src/export/helpers/prepare.ts
-import { promises as fs } from "fs";
-import { normalize } from "pathe";
+import { promises } from 'fs';
+import { normalize } from 'pathe';
+
 function normalizeDir(dir) {
   dir = normalize(dir);
   if (dir.slice(-1) === "/") {
@@ -12,7 +12,7 @@ async function prepareDirectoryForExport(options) {
   const dir = normalizeDir(options.target);
   if (options.cleanup) {
     try {
-      await fs.rm(dir, {
+      await promises.rm(dir, {
         recursive: true,
         force: true
       });
@@ -20,14 +20,12 @@ async function prepareDirectoryForExport(options) {
     }
   }
   try {
-    await fs.mkdir(dir, {
+    await promises.mkdir(dir, {
       recursive: true
     });
   } catch (err) {
   }
   return dir;
 }
-export {
-  normalizeDir,
-  prepareDirectoryForExport
-};
+
+export { normalizeDir, prepareDirectoryForExport };

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

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const localPkg = require('local-pkg');
+const fs = require('fs');
+
+let cache;
+async function getVersion() {
+  const packageName = "@iconify/types/package.json";
+  const filename = localPkg.resolveModule(packageName);
+  if (!filename) {
+    throw new Error(`Cannot resolve ${packageName}`);
+  }
+  const content = JSON.parse(await fs.promises.readFile(filename, "utf8"));
+  return cache = content.version;
+}
+async function getTypesVersion() {
+  return cache || await getVersion();
+}
+
+exports.getTypesVersion = getTypesVersion;

package/lib/export/helpers/types-version.d.ts

@@ -1,4 +1,6 @@
 /**
  * Get current version of Iconify Types package
  */
-export declare function getTypesVersion(): string;
+declare function getTypesVersion(): Promise<string>;
+
+export { getTypesVersion };

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

@@ -1,40 +1,18 @@
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
+import { resolveModule } from 'local-pkg';
+import { promises } from 'fs';
 
-// ../../node_modules/@iconify/types/package.json
-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"
-      }
-    };
+let cache;
+async function getVersion() {
+  const packageName = "@iconify/types/package.json";
+  const filename = resolveModule(packageName);
+  if (!filename) {
+    throw new Error(`Cannot resolve ${packageName}`);
   }
-});
-
-// src/export/helpers/types-version.ts
-var pkg = require_package();
-function getTypesVersion() {
-  return pkg.version;
+  const content = JSON.parse(await promises.readFile(filename, "utf8"));
+  return cache = content.version;
+}
+async function getTypesVersion() {
+  return cache || await getVersion();
 }
-export {
-  getTypesVersion
-};
+
+export { getTypesVersion };

package/lib/export/icon-package.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const fs = require('fs');
+const export_helpers_prepare = require('./helpers/prepare.cjs');
+const misc_writeJson = require('../misc/write-json.cjs');
+const export_helpers_typesVersion = require('./helpers/types-version.cjs');
+const export_helpers_customFiles = require('./helpers/custom-files.cjs');
+require('pathe');
+require('local-pkg');
+
+const defaultTypesContent = `import type { IconifyIcon } from '@iconify/types';
+declare const data: IconifyIcon;
+export default data;
+`;
+async function exportIconPackage(iconSet, options) {
+  const files = /* @__PURE__ */ new Set();
+  const esm = options.module !== false;
+  const dir = await export_helpers_prepare.prepareDirectoryForExport(options);
+  const typesContent = options.typesContent || defaultTypesContent;
+  await iconSet.forEach(async (name2) => {
+    const data = iconSet.resolve(name2, false);
+    if (!data) {
+      return;
+    }
+    const typesFilename = name2 + ".d.ts";
+    await fs.promises.writeFile(`${dir}/${typesFilename}`, typesContent, "utf8");
+    files.add(typesFilename);
+    let content = `const data = ` + JSON.stringify(data, null, "	") + ";\n";
+    if (!esm) {
+      content += "exports.__esModule = true;\nexports.default = data;\n";
+    } else {
+      content += "export default data;\n";
+    }
+    const contentFilename = name2 + ".js";
+    await fs.promises.writeFile(`${dir}/${contentFilename}`, content, "utf8");
+    files.add(contentFilename);
+  });
+  await export_helpers_customFiles.exportCustomFiles(dir, options, files);
+  const info = iconSet.info;
+  const { name, description, version, dependencies, ...customPackageProps } = options.package || {};
+  const packageJSON = {
+    name: name || (esm ? `@iconify-icons/${iconSet.prefix}` : `@iconify/icons-${iconSet.prefix}`),
+    description: description || `Iconify icon components for ${info ? info.name : iconSet.prefix}`,
+    version,
+    type: esm ? "module" : void 0,
+    iconSetInfo: info,
+    ...customPackageProps,
+    dependencies: dependencies || {
+      "@iconify/types": "^" + await export_helpers_typesVersion.getTypesVersion()
+    }
+  };
+  await misc_writeJson.writeJSONFile(dir + "/package.json", packageJSON);
+  files.add("package.json");
+  return Array.from(files);
+}
+
+exports.exportIconPackage = exportIconPackage;