@iconify/tools 4.2.0 → 5.0.0-beta.2

package/lib/download/helpers/untar.js

@@ -0,0 +1,13 @@
+import { unpackTar } from "modern-tar/fs";
+import { createReadStream } from "node:fs";
+import { createGunzip } from "node:zlib";
+import { pipeline } from "node:stream/promises";
+
+/**
+* Unpack .tgz archive
+*/
+async function untar(file, path) {
+	await pipeline(createReadStream(file, { highWaterMark: 256 * 1024 }), createGunzip(), unpackTar(path));
+}
+
+export { untar };

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

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

package/lib/download/helpers/unzip.js

@@ -0,0 +1,39 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, normalize } from "pathe";
+import { unzip as unzip$1 } from "fflate";
+
+/**
+* Unzip archive
+*/
+async function unzip(source, path) {
+	const dir = normalize(path);
+	const data = await readFile(source);
+	async function writeFiles(data$1) {
+		const createdDirs = /* @__PURE__ */ new Set();
+		for (const name in data$1) {
+			const filePath = normalize(join(dir, name));
+			if (filePath.startsWith("/") || filePath.includes("..") || filePath.includes(":")) throw new Error("Invalid file path in zip: " + filePath);
+			if (filePath.includes("/._")) continue;
+			const isDir = filePath.endsWith("/");
+			const fileDir = isDir ? filePath.slice(0, filePath.length - 1) : dirname(filePath);
+			if (!createdDirs.has(fileDir)) {
+				createdDirs.add(fileDir);
+				try {
+					await mkdir(fileDir, { recursive: true });
+				} catch {}
+			}
+			if (!isDir) await writeFile(filePath, data$1[name]);
+		}
+	}
+	return new Promise((resolve$1, reject) => {
+		unzip$1(data, (err, unzipped) => {
+			if (err) {
+				reject(err);
+				return;
+			}
+			writeFiles(unzipped).then(() => resolve$1()).catch((err$1) => reject(err$1));
+		});
+	});
+}
+
+export { unzip };

package/lib/download/index.d.ts

@@ -1,31 +1,27 @@
-import { DownloadGitHubRepoOptions, DownloadGitHubRepoResult } from './github/index.js';
-import { DownloadGitRepoOptions, DownloadGitRepoResult } from './git/index.js';
-import { DownloadNPMPackageOptions, DownloadNPMPackageResult } from './npm/index.js';
-import { DocumentNotModified } from './types/modified.js';
-import { DownloadSourceType, DownloadSourceMixin } from './types/sources.js';
-import { DownloadGitLabRepoOptions, DownloadGitLabRepoResult } from './gitlab/index.js';
-import '../export/helpers/prepare.js';
-import './github/types.js';
-import './gitlab/types.js';
-
+import { DocumentNotModified } from "./types/modified.js";
+import { DownloadSourceMixin, DownloadSourceType } from "./types/sources.js";
+import { DownloadGitRepoOptions, DownloadGitRepoResult } from "./git/index.js";
+import { DownloadGitHubRepoOptions, DownloadGitHubRepoResult } from "./github/index.js";
+import { DownloadGitLabRepoOptions, DownloadGitLabRepoResult } from "./gitlab/index.js";
+import { DownloadNPMPackageOptions, DownloadNPMPackageResult } from "./npm/index.js";
 /**
  * Options and result combinations
  */
 interface DownloadGitRepo {
-    options: DownloadGitRepoOptions & DownloadSourceMixin<'git'>;
-    result: DownloadGitRepoResult;
+  options: DownloadGitRepoOptions & DownloadSourceMixin<'git'>;
+  result: DownloadGitRepoResult;
 }
 interface DownloadGitHubRepo {
-    options: DownloadGitHubRepoOptions & DownloadSourceMixin<'github'>;
-    result: DownloadGitHubRepoResult;
+  options: DownloadGitHubRepoOptions & DownloadSourceMixin<'github'>;
+  result: DownloadGitHubRepoResult;
 }
 interface DownloadGitLabRepo {
-    options: DownloadGitLabRepoOptions & DownloadSourceMixin<'gitlab'>;
-    result: DownloadGitLabRepoResult;
+  options: DownloadGitLabRepoOptions & DownloadSourceMixin<'gitlab'>;
+  result: DownloadGitLabRepoResult;
 }
 interface DownloadNPMPackage {
-    options: DownloadNPMPackageOptions & DownloadSourceMixin<'npm'>;
-    result: DownloadNPMPackageResult;
+  options: DownloadNPMPackageOptions & DownloadSourceMixin<'npm'>;
+  result: DownloadNPMPackageResult;
 }
 /**
  * Combinations based on type
@@ -44,5 +40,4 @@ declare function downloadPackage<T extends 'git'>(options: DownloadOptions<T>):
 declare function downloadPackage<T extends 'github'>(options: DownloadOptions<T>): DownloadResult<T>;
 declare function downloadPackage<T extends 'gitlab'>(options: DownloadOptions<T>): DownloadResult<T>;
 declare function downloadPackage<T extends 'npm'>(options: DownloadOptions<T>): DownloadResult<T>;
-
-export { type DownloadParams, type DownloadParamsMixin, downloadPackage };
+export { DownloadParams, DownloadParamsMixin, downloadPackage };

package/lib/download/index.js

@@ -0,0 +1,19 @@
+import { downloadGitRepo } from "./git/index.js";
+import { downloadGitHubRepo } from "./github/index.js";
+import { downloadGitLabRepo } from "./gitlab/index.js";
+import { downloadNPMPackage } from "./npm/index.js";
+
+function assertNever(v) {}
+function downloadPackage(options) {
+	switch (options.downloadType) {
+		case "git": return downloadGitRepo(options);
+		case "github": return downloadGitHubRepo(options);
+		case "gitlab": return downloadGitLabRepo(options);
+		case "npm": return downloadNPMPackage(options);
+		default:
+			assertNever(options);
+			throw new Error(`Invalid download type: ${options.downloadType}`);
+	}
+}
+
+export { downloadPackage };

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

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

package/lib/download/npm/index.js

@@ -0,0 +1,51 @@
+import { normalizeDir, prepareDirectoryForExport } from "../../export/helpers/prepare.js";
+import { downloadFile } from "../api/download.js";
+import { untar } from "../helpers/untar.js";
+import { getNPMVersion, getPackageVersion } from "./version.js";
+import { promises } from "fs";
+
+async function downloadNPMPackage(options) {
+	const rootDir = options.target = normalizeDir(options.target);
+	const contentsDir = rootDir + "/package";
+	const versionInfo = await getNPMVersion(options);
+	const version = versionInfo.version;
+	const ifModifiedSince = options.ifModifiedSince;
+	if (ifModifiedSince) try {
+		let expectedVersion;
+		if (typeof ifModifiedSince === "object") if (ifModifiedSince.downloadType === "npm" && ifModifiedSince.rootDir === rootDir && ifModifiedSince.contentsDir === contentsDir) expectedVersion = ifModifiedSince.version;
+		else expectedVersion = null;
+		else expectedVersion = ifModifiedSince === true ? await getPackageVersion(contentsDir) : ifModifiedSince;
+		if (version === expectedVersion) return "not_modified";
+	} catch (err) {
+		options.cleanup = true;
+	}
+	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 {
+		archiveExists = (await promises.stat(archiveTarget)).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: contentsDir,
+		cleanup: true
+	});
+	if (options.log) console.log(`Unpacking ${archiveTarget}`);
+	await untar(archiveTarget, rootDir);
+	return {
+		downloadType: "npm",
+		rootDir,
+		contentsDir,
+		version
+	};
+}
+
+export { downloadNPMPackage };

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

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

package/lib/download/npm/types.js

@@ -0,0 +1 @@
+export {  };

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

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

package/lib/download/npm/version.js

@@ -0,0 +1,23 @@
+import { execAsync } from "../../misc/exec.js";
+import { promises } from "fs";
+
+/**
+* Get version of package from NPM registry
+*/
+async function getNPMVersion(options) {
+	const tag = options.tag || "latest";
+	const result = await execAsync(`npm view ${options.package}@${tag} --json`, { maxBuffer: 1024 * 1024 * 8 });
+	const data = JSON.parse(result.stdout);
+	return {
+		version: data.version,
+		file: data.dist?.tarball
+	};
+}
+/**
+* Get version of package from filename
+*/
+async function getPackageVersion(target) {
+	return JSON.parse(await promises.readFile(target + "/package.json", "utf8")).version;
+}
+
+export { getNPMVersion, getPackageVersion };

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

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

package/lib/download/types/modified.js

@@ -0,0 +1 @@
+export {  };

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

@@ -6,7 +6,6 @@ type DownloadSourceType = 'git' | 'github' | 'gitlab' | 'npm';
  * Type in other objects
  */
 interface DownloadSourceMixin<T extends DownloadSourceType> {
-    downloadType: T;
+  downloadType: T;
 }
-
-export type { DownloadSourceMixin, DownloadSourceType };
+export { DownloadSourceMixin, DownloadSourceType };

package/lib/download/types/sources.js

@@ -0,0 +1 @@
+export {  };

package/lib/export/directory.d.ts

@@ -1,20 +1,13 @@
-import { IconSet } from '../icon-set/index.js';
-import { ExportTargetOptions } from './helpers/prepare.js';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../icon-set/types.js';
-import '../svg/index.js';
-import 'cheerio';
-import '@iconify/utils/lib/icon-set/tree';
-
+import { IconSet } from "../icon-set/index.js";
+import { ExportTargetOptions } from "./helpers/prepare.js";
 /**
  * Options
  */
 interface ExportToDirectoryOptions extends ExportTargetOptions {
-    autoHeight?: boolean;
-    includeAliases?: boolean;
-    includeChars?: boolean;
-    log?: boolean;
+  autoHeight?: boolean;
+  includeAliases?: boolean;
+  includeChars?: boolean;
+  log?: boolean;
 }
 /**
  * Export icon set to directory
@@ -22,5 +15,4 @@ interface ExportToDirectoryOptions extends ExportTargetOptions {
  * Returns list of stored files
  */
 declare function exportToDirectory(iconSet: IconSet, options: ExportToDirectoryOptions): Promise<string[]>;
-
-export { type ExportToDirectoryOptions, exportToDirectory };
+export { ExportToDirectoryOptions, exportToDirectory };

package/lib/export/directory.js

@@ -0,0 +1,37 @@
+import { prepareDirectoryForExport } from "./helpers/prepare.js";
+import { promises } from "fs";
+
+/**
+* Export icon set to directory
+*
+* Returns list of stored files
+*/
+async function exportToDirectory(iconSet, options) {
+	const dir = await 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 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);
+}
+
+export { exportToDirectory };

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

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

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

@@ -0,0 +1,23 @@
+import { writeJSONFile } from "../../misc/write-json.js";
+import { promises } from "fs";
+
+/**
+* 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) {
+			try {
+				await promises.unlink(dir + "/" + filename);
+			} catch (err) {}
+			continue;
+		}
+		if (typeof content === "string") await promises.writeFile(dir + "/" + filename, content, "utf8");
+		else if (typeof content === "object") await writeJSONFile(dir + "/" + filename, content);
+		result?.add(filename);
+	}
+}
+
+export { exportCustomFiles };

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

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

package/lib/export/helpers/prepare.js

@@ -0,0 +1,31 @@
+import { mkdir, rm } from "node:fs/promises";
+import { normalize } from "pathe";
+
+/**
+* Normalize directory
+*/
+function normalizeDir(dir) {
+	dir = normalize(dir);
+	if (dir.slice(-1) === "/") dir = dir.slice(0, -1);
+	return dir;
+}
+/**
+* Prepare directory for export
+*
+* Also normalizes directory and returns normalized value
+*/
+async function prepareDirectoryForExport(options) {
+	const dir = normalizeDir(options.target);
+	if (options.cleanup) try {
+		await rm(dir, {
+			recursive: true,
+			force: true
+		});
+	} catch {}
+	try {
+		await mkdir(dir, { recursive: true });
+	} catch {}
+	return dir;
+}
+
+export { normalizeDir, prepareDirectoryForExport };

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

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

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

@@ -0,0 +1,19 @@
+import { uniquePromise } from "@cyberalien/svg-utils";
+import { readFile } from "node:fs/promises";
+
+let cache;
+async function getVersion() {
+	const packageName = "@iconify/types/package.json";
+	return cache = (await uniquePromise(packageName, async () => {
+		const filename = import.meta.resolve(packageName);
+		return JSON.parse(await readFile(filename.replace("file://", ""), "utf8"));
+	})).version;
+}
+/**
+* Get current version of Iconify Types package
+*/
+async function getTypesVersion() {
+	return cache || await getVersion();
+}
+
+export { getTypesVersion };

package/lib/export/icon-package.d.ts

@@ -1,20 +1,14 @@
-import { IconSet } from '../icon-set/index.js';
-import { ExportTargetOptions } from './helpers/prepare.js';
-import { ExportOptionsWithCustomFiles } from './helpers/custom-files.js';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../icon-set/types.js';
-import '../svg/index.js';
-import 'cheerio';
-import '@iconify/utils/lib/icon-set/tree';
-
+import { IconSet } from "../icon-set/index.js";
+import { ExportTargetOptions } from "./helpers/prepare.js";
+import { ExportOptionsWithCustomFiles } from "./helpers/custom-files.js";
 /**
  * Options
  */
 interface ExportIconPackageOptions extends ExportTargetOptions, ExportOptionsWithCustomFiles {
-    package?: Record<string, unknown>;
-    module?: boolean;
-    typesContent?: string;
+  package?: Record<string, unknown>;
+  module?: boolean;
+  typesContent?: string;
+  wildcardTypesVersion?: boolean;
 }
 /**
  * Export icon set as single icon packages
@@ -22,5 +16,4 @@ interface ExportIconPackageOptions extends ExportTargetOptions, ExportOptionsWit
  * Was used for exporting `@iconify-icons/{prefix}` packages
  */
 declare function exportIconPackage(iconSet: IconSet, options: ExportIconPackageOptions): Promise<string[]>;
-
-export { type ExportIconPackageOptions, exportIconPackage };
+export { ExportIconPackageOptions, exportIconPackage };

package/lib/export/icon-package.js

@@ -0,0 +1,55 @@
+import { prepareDirectoryForExport } from "./helpers/prepare.js";
+import { writeJSONFile } from "../misc/write-json.js";
+import { exportCustomFiles } from "./helpers/custom-files.js";
+import { getTypesVersion } from "./helpers/types-version.js";
+import { promises } from "fs";
+
+/**
+* Content for .d.ts files
+*/
+const defaultTypesContent = `import type { IconifyIcon } from '@iconify/types';
+declare const data: IconifyIcon;
+export default data;
+`;
+/**
+* Export icon set as single icon packages
+*
+* Was used for exporting `@iconify-icons/{prefix}` packages
+*/
+async function exportIconPackage(iconSet, options) {
+	const files = /* @__PURE__ */ new Set();
+	const esm = options.module !== false;
+	const dir = await prepareDirectoryForExport(options);
+	const typesContent = options.typesContent || defaultTypesContent;
+	await iconSet.forEach(async (name$1) => {
+		const data = iconSet.resolve(name$1, false);
+		if (!data) return;
+		const typesFilename = name$1 + ".d.ts";
+		await 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 = name$1 + ".js";
+		await promises.writeFile(`${dir}/${contentFilename}`, content, "utf8");
+		files.add(contentFilename);
+	});
+	await exportCustomFiles(dir, options, files);
+	const typesVersion = options.wildcardTypesVersion === false ? "^" + await getTypesVersion() : "*";
+	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": typesVersion }
+	};
+	await writeJSONFile(dir + "/package.json", packageJSON);
+	files.add("package.json");
+	return Array.from(files);
+}
+
+export { exportIconPackage };

package/lib/export/json-package.d.ts

@@ -1,19 +1,13 @@
-import { IconSet } from '../icon-set/index.js';
-import { ExportTargetOptions } from './helpers/prepare.js';
-import { ExportOptionsWithCustomFiles } from './helpers/custom-files.js';
-import '@iconify/types';
-import '@iconify/utils/lib/customisations/defaults';
-import '../icon-set/types.js';
-import '../svg/index.js';
-import 'cheerio';
-import '@iconify/utils/lib/icon-set/tree';
-
+import { IconSet } from "../icon-set/index.js";
+import { ExportTargetOptions } from "./helpers/prepare.js";
+import { ExportOptionsWithCustomFiles } from "./helpers/custom-files.js";
 /**
  * Options
  */
 interface ExportJSONPackageOptions extends ExportTargetOptions, ExportOptionsWithCustomFiles {
-    package?: Record<string, unknown>;
-    customisePackage?: (contents: Record<string, unknown>) => void;
+  package?: Record<string, unknown>;
+  customisePackage?: (contents: Record<string, unknown>) => void;
+  wildcardTypesVersion?: boolean;
 }
 /**
  * Export icon set as JSON package
@@ -21,5 +15,4 @@ interface ExportJSONPackageOptions extends ExportTargetOptions, ExportOptionsWit
  * Used for exporting `@iconify-json/{prefix}` packages
  */
 declare function exportJSONPackage(iconSet: IconSet, options: ExportJSONPackageOptions): Promise<string[]>;
-
-export { type ExportJSONPackageOptions, exportJSONPackage };
+export { ExportJSONPackageOptions, exportJSONPackage };