@badisi/latest-version 8.0.5 → 9.0.0

package/index.mjs

@@ -0,0 +1,201 @@
+import { npm, yarn } from "global-dirs";
+import { readFile } from "node:fs/promises";
+import { dirname, join, parse, resolve } from "node:path";
+import gt from "semver/functions/gt.js";
+import maxSatisfying from "semver/ranges/max-satisfying.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { get } from "node:http";
+import { get as get$1 } from "node:https";
+import { URL } from "node:url";
+import registryAuthToken from "registry-auth-token";
+import getRegistryUrl from "registry-auth-token/registry-url.js";
+//#region src/cache.ts
+const ONE_DAY = 1e3 * 60 * 60 * 24;
+const getCacheDir = (name = "@badisi/latest-version") => {
+	const homeDir = homedir();
+	switch (process.platform) {
+		case "darwin": return join(homeDir, "Library", "Caches", name);
+		case "win32": return join(process.env["LOCALAPPDATA"] ?? join(homeDir, "AppData", "Local"), name, "Cache");
+		default: return join(process.env["XDG_CACHE_HOME"] ?? join(homeDir, ".cache"), name);
+	}
+};
+const saveMetadataToCache = (pkg) => {
+	const filePath = join(getCacheDir(), `${pkg.name}.json`);
+	if (!existsSync(dirname(filePath))) mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, JSON.stringify(pkg));
+};
+const getMetadataFromCache = (pkgName, options) => {
+	const maxAge = options?.cacheMaxAge ?? 864e5;
+	if (maxAge !== 0) {
+		const pkgCacheFilePath = join(getCacheDir(), `${pkgName}.json`);
+		if (existsSync(pkgCacheFilePath)) {
+			const pkg = JSON.parse(readFileSync(pkgCacheFilePath).toString());
+			if (Date.now() - pkg.lastUpdateDate < maxAge) return pkg;
+		}
+	}
+};
+//#endregion
+//#region src/metadata.ts
+const downloadMetadata = (pkgName, options) => new Promise((resolve, reject) => {
+	const i = pkgName.indexOf("/");
+	const pkgScope = i !== -1 ? pkgName.slice(0, i) : "";
+	const registryUrl = options?.registryUrl ?? getRegistryUrl(pkgScope);
+	const pkgUrl = new URL(encodeURIComponent(pkgName).replace(/^%40/, "@"), registryUrl);
+	let requestOptions = {
+		headers: { accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*" },
+		host: pkgUrl.hostname,
+		path: pkgUrl.pathname,
+		port: pkgUrl.port
+	};
+	const authInfo = registryAuthToken(pkgUrl.toString(), { recursive: true });
+	if (authInfo && requestOptions.headers) requestOptions.headers.authorization = `${authInfo.type} ${authInfo.token}`;
+	if (options?.requestOptions) requestOptions = {
+		...requestOptions,
+		...options.requestOptions
+	};
+	const request = (pkgUrl.protocol === "https:" ? get$1 : get)(requestOptions, (res) => {
+		if (res.statusCode === 200) {
+			let rawData = "";
+			res.setEncoding("utf8");
+			res.on("data", (chunk) => rawData += chunk);
+			res.once("error", (err) => {
+				res.removeAllListeners();
+				reject(/* @__PURE__ */ new Error(`Request error (${err.message}): ${pkgUrl.toString()}`));
+			});
+			res.once("end", () => {
+				res.removeAllListeners();
+				try {
+					const pkgMetadata = JSON.parse(rawData);
+					resolve({
+						name: pkgName,
+						lastUpdateDate: Date.now(),
+						versions: Object.keys(pkgMetadata["versions"]),
+						distTags: pkgMetadata["dist-tags"]
+					});
+					return;
+				} catch (error) {
+					if (typeof error === "string") reject(new Error(error));
+					else if (error instanceof Error) reject(error);
+					else reject(/* @__PURE__ */ new Error("Metadata extraction error"));
+					return;
+				}
+			});
+		} else {
+			res.removeAllListeners();
+			res.resume();
+			reject(/* @__PURE__ */ new Error(`Request error (${res.statusCode ?? "unknown"}): ${pkgUrl.toString()}`));
+			return;
+		}
+	});
+	const abort = (error) => {
+		request.destroy();
+		reject(typeof error === "string" ? new Error(error) : error);
+	};
+	request.once("timeout", () => {
+		abort(`Request timed out: ${pkgUrl.toString()}`);
+	});
+	request.once("error", (err) => {
+		abort(err);
+	});
+	request.once("close", () => {
+		request.removeAllListeners();
+	});
+});
+//#endregion
+//#region src/index.ts
+const isPackageJson = (obj) => obj.dependencies !== void 0 || obj.devDependencies !== void 0 || obj.peerDependencies !== void 0;
+const getRegistryVersions = async (pkgName, tagOrRange, options) => {
+	let pkgMetadata;
+	if (pkgName.length && options?.useCache) {
+		pkgMetadata = getMetadataFromCache(pkgName, options);
+		if (!pkgMetadata) {
+			pkgMetadata = await downloadMetadata(pkgName, options);
+			saveMetadataToCache(pkgMetadata);
+		}
+	} else if (pkgName.length) pkgMetadata = await downloadMetadata(pkgName, options);
+	const versions = {
+		latest: pkgMetadata?.distTags["latest"],
+		next: pkgMetadata?.distTags["next"]
+	};
+	if (tagOrRange && pkgMetadata?.distTags[tagOrRange]) versions.wanted = pkgMetadata.distTags[tagOrRange];
+	else if (tagOrRange && pkgMetadata?.versions.length) versions.wanted = maxSatisfying(pkgMetadata.versions, tagOrRange) ?? void 0;
+	return versions;
+};
+const getInstalledVersion = async (pkgName, location = "local") => {
+	try {
+		const readPackageJson = async (path) => JSON.parse(await readFile(path, "utf8"));
+		if (location === "globalNpm") return (await readPackageJson(join(npm.packages, pkgName, "package.json"))).version;
+		else if (location === "globalYarn") {
+			if (!(pkgName in (await readPackageJson(resolve(yarn.packages, "..", "package.json"))).dependencies)) return;
+			return (await readPackageJson(join(yarn.packages, pkgName, "package.json"))).version;
+		} else {
+			/**
+			* Compute the local paths manually as require.resolve() and require.resolve.paths()
+			* cannot be trusted anymore.
+			* @see https://github.com/nodejs/node/issues/33460
+			* @see https://github.com/nodejs/loaders/issues/26
+			*/
+			const startPath = process.cwd();
+			const { root } = parse(startPath);
+			const findPackageVersion = async (path, rootPath, name) => {
+				const pkgPath = join(path, "node_modules", name, "package.json");
+				try {
+					return (await readPackageJson(pkgPath)).version;
+				} catch {}
+				if (path === rootPath) return;
+				return await findPackageVersion(dirname(path), rootPath, name);
+			};
+			return await findPackageVersion(startPath, root, pkgName);
+		}
+	} catch {
+		return;
+	}
+};
+const getInfo = async (pkg, options) => {
+	const i = pkg.lastIndexOf("@");
+	let pkgInfo = {
+		name: i > 1 ? pkg.slice(0, i) : pkg,
+		wantedTagOrRange: i > 1 ? pkg.slice(i + 1) : "latest",
+		updatesAvailable: false
+	};
+	try {
+		pkgInfo = {
+			...pkgInfo,
+			local: await getInstalledVersion(pkgInfo.name, "local"),
+			globalNpm: await getInstalledVersion(pkgInfo.name, "globalNpm"),
+			globalYarn: await getInstalledVersion(pkgInfo.name, "globalYarn"),
+			...await getRegistryVersions(pkgInfo.name, pkgInfo.wantedTagOrRange, options)
+		};
+		const local = pkgInfo.local && pkgInfo.wanted ? gt(pkgInfo.wanted, pkgInfo.local) ? pkgInfo.wanted : false : false;
+		const globalNpm = pkgInfo.globalNpm && pkgInfo.wanted ? gt(pkgInfo.wanted, pkgInfo.globalNpm) ? pkgInfo.wanted : false : false;
+		const globalYarn = pkgInfo.globalYarn && pkgInfo.wanted ? gt(pkgInfo.wanted, pkgInfo.globalYarn) ? pkgInfo.wanted : false : false;
+		pkgInfo.updatesAvailable = local || globalNpm || globalYarn ? {
+			local,
+			globalNpm,
+			globalYarn
+		} : false;
+	} catch (err) {
+		if (typeof err === "string") pkgInfo.error = new Error(err);
+		else if (err instanceof Error) pkgInfo.error = err;
+		else pkgInfo.error = /* @__PURE__ */ new Error("Unknown error");
+	}
+	return pkgInfo;
+};
+const latestVersion = async (arg, options) => {
+	const pkgs = [];
+	if (typeof arg === "string") pkgs.push(arg);
+	else if (Array.isArray(arg)) pkgs.push(...arg);
+	else if (isPackageJson(arg)) {
+		const addDeps = (deps) => {
+			if (deps) pkgs.push(...Object.keys(deps).map((key) => `${key}@${deps[key]}`));
+		};
+		addDeps(arg.dependencies);
+		addDeps(arg.devDependencies);
+		addDeps(arg.peerDependencies);
+	}
+	const results = (await Promise.allSettled(pkgs.map((pkg) => getInfo(pkg, options)))).map((jobResult) => jobResult.value);
+	return typeof arg === "string" ? results[0] : results;
+};
+//#endregion
+export { ONE_DAY, latestVersion };

package/package.json

@@ -1,27 +1,29 @@
 {
     "name": "@badisi/latest-version",
-    "version": "8.0.5",
+    "version": "9.0.0",
     "description": "Get latest versions of packages",
     "homepage": "https://github.com/Badisi/latest-version",
     "license": "MIT",
     "author": {
         "name": "Badisi"
     },
-    "type": "commonjs",
-    "main": "index.js",
-    "typings": "index.d.ts",
+    "type": "module",
+    "main": "./index.cjs",
+    "module": "./index.mjs",
+    "types": "./index.d.mts",
     "exports": {
         ".": {
-            "require": "./index.js",
-            "types": "./index.d.ts",
-            "default": "./index.js"
+            "import": {
+                "types": "./index.d.mts",
+                "default": "./index.mjs"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
         },
         "./package.json": "./package.json"
     },
-    "bin": {
-        "latest-version": "bin/latest-version",
-        "lv": "bin/latest-version"
-    },
     "repository": {
         "type": "git",
         "url": "https://github.com/Badisi/latest-version"
@@ -33,6 +35,7 @@
         "latest",
         "current",
         "next",
+        "outdated",
         "version",
         "pkg",
         "package",
@@ -44,9 +47,12 @@
         "node": ">= 20.12.0"
     },
     "dependencies": {
-        "global-dirs": "3.0.1",
-        "ora": "^9.3.0",
+        "global-dirs": "^3.0.1",
         "registry-auth-token": "^5.1.1",
-        "semver": "^7.7.4"
+        "semver": "^7.8.5"
+    },
+    "allowScripts": {
+        "@hug/eslint-config@26.0.0": true,
+        "fsevents@2.3.3": true
     }
 }

package/bin/latest-version

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-'use strict';
-
-require('../cli.js');

package/cli.d.ts

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

package/cli.js

@@ -1,239 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/cli.ts
-var import_node_util = require("node:util");
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
-var import_major = __toESM(require("semver/functions/major"));
-var import_diff = __toESM(require("semver/functions/diff"));
-var import_index = __toESM(require("./index"));
-var colorizeDiff = (from, to) => {
-  const toParts = to.split(".");
-  const diffIndex = from.split(".").findIndex((part, i) => part !== toParts[i]);
-  if (diffIndex !== -1) {
-    let color = "magenta";
-    if (toParts[0] !== "0") {
-      color = diffIndex === 0 ? "red" : diffIndex === 1 ? "cyan" : "green";
-    }
-    const start = toParts.slice(0, diffIndex).join(".");
-    const mid = diffIndex === 0 ? "" : ".";
-    const end = (0, import_node_util.styleText)(color, toParts.slice(diffIndex).join("."));
-    return `${start}${mid}${end}`;
-  }
-  return to;
-};
-var columnCellRenderer = (column, row) => {
-  let text = row[column.attrName];
-  const gap = text.length < column.maxLength ? " ".repeat(column.maxLength - text.length) : "";
-  switch (column.attrName) {
-    case "name":
-      text = (0, import_node_util.styleText)("yellow", text);
-      break;
-    case "installed":
-    case "separator":
-      text = (0, import_node_util.styleText)("blue", text);
-      break;
-    case "location":
-    case "tagOrRange":
-      text = (0, import_node_util.styleText)("gray", text);
-      break;
-    case "wanted":
-      text = colorizeDiff(row.installed, text);
-      break;
-    case "latest":
-      if (text !== row.wanted) {
-        text = colorizeDiff(row.installed, text);
-      }
-      break;
-    default:
-      break;
-  }
-  return column.align === "right" ? `${gap}${text}` : `${text}${gap}`;
-};
-var columnHeaderRenderer = (column) => {
-  const text = column.label;
-  const gap = text.length < column.maxLength ? " ".repeat(column.maxLength - text.length) : "";
-  return column.align === "right" ? `${gap}${(0, import_node_util.styleText)("underline", text)}` : `${(0, import_node_util.styleText)("underline", text)}${gap}`;
-};
-var drawBox = (lines, color = "yellow", horizontalPadding = 3) => {
-  const maxLineWidth = lines.reduce((max, row) => Math.max(max, (0, import_node_util.stripVTControlCharacters)(row).length), 0);
-  console.log((0, import_node_util.styleText)(color, `\u250C${"\u2500".repeat(maxLineWidth + horizontalPadding * 2)}\u2510`));
-  lines.forEach((row) => {
-    const padding = " ".repeat(horizontalPadding);
-    const fullRow = `${row}${" ".repeat(maxLineWidth - (0, import_node_util.stripVTControlCharacters)(row).length)}`;
-    console.log(`${(0, import_node_util.styleText)(color, "\u2502")}${padding}${fullRow}${padding}${(0, import_node_util.styleText)(color, "\u2502")}`);
-  });
-  console.log((0, import_node_util.styleText)(color, `\u2514${"\u2500".repeat(maxLineWidth + horizontalPadding * 2)}\u2518`));
-};
-var getTableColumns = (rows) => {
-  const columns = [
-    { label: "Package", attrName: "name", align: "left", maxLength: 0, items: [] },
-    { label: "Location", attrName: "location", align: "left", maxLength: 0, items: [] },
-    { label: "Installed", attrName: "installed", align: "right", maxLength: 0, items: [] },
-    { label: "", attrName: "separator", align: "center", maxLength: 0, items: [] },
-    { label: "Range", attrName: "tagOrRange", align: "right", maxLength: 0, items: [] },
-    { label: "", attrName: "separator", align: "center", maxLength: 0, items: [] },
-    { label: "Wanted", attrName: "wanted", align: "right", maxLength: 0, items: [] },
-    { label: "Latest", attrName: "latest", align: "right", maxLength: 0, items: [] }
-  ];
-  rows.forEach((row) => {
-    columns.forEach((column) => {
-      column.maxLength = Math.max(column.label.length, column.maxLength, row[column.attrName].length || 0);
-    });
-  });
-  return columns;
-};
-var getTableRows = (updates) => {
-  return updates.reduce((all, pkg) => {
-    const { name, latest, local, globalNpm, globalYarn, wantedTagOrRange, updatesAvailable } = pkg;
-    const getGroup = (a, b) => {
-      if (b && (0, import_major.default)(b) === 0) {
-        return "majorVersionZero";
-      } else if (a && b) {
-        const releaseType = (0, import_diff.default)(a, b) ?? "";
-        if (["major", "premajor", "prerelease"].includes(releaseType)) {
-          return "major";
-        } else if (["minor", "preminor"].includes(releaseType)) {
-          return "minor";
-        } else if (["patch", "prepatch"].includes(releaseType)) {
-          return "patch";
-        }
-      }
-      return "unknown";
-    };
-    const add = (group, location, installed, wanted) => all.push({
-      name: " " + name,
-      location,
-      installed: installed ?? "unknown",
-      latest: latest ?? "unknown",
-      tagOrRange: wantedTagOrRange ?? "unknown",
-      separator: "\u2192",
-      wanted: wanted ?? "unknown",
-      group
-    });
-    if (updatesAvailable) {
-      if (updatesAvailable.local) {
-        add(getGroup(local, updatesAvailable.local), "local", local, updatesAvailable.local);
-      }
-      if (updatesAvailable.globalNpm) {
-        add(getGroup(globalNpm, updatesAvailable.globalNpm), "NPM global", globalNpm, updatesAvailable.globalNpm);
-      }
-      if (updatesAvailable.globalYarn) {
-        add(getGroup(globalYarn, updatesAvailable.globalYarn), "YARN global", globalYarn, updatesAvailable.globalYarn);
-      }
-    } else {
-      if (local && local !== latest) {
-        add(getGroup(local, latest), "local", local, pkg.wanted);
-      }
-      if (globalNpm && globalNpm !== latest) {
-        add(getGroup(globalNpm, latest), "NPM global", globalNpm, pkg.wanted);
-      }
-      if (globalYarn && globalYarn !== latest) {
-        add(getGroup(globalYarn, latest), "YARN global", globalYarn, pkg.wanted);
-      }
-      if (!local && !globalNpm && !globalYarn) {
-        add("unknown", "unknown", "unknown", pkg.wanted);
-      }
-    }
-    return all;
-  }, []);
-};
-var displayTable = (latestVersionPackages) => {
-  const updates = latestVersionPackages.filter((pkg) => pkg.updatesAvailable);
-  if (updates.length) {
-    const rows = getTableRows(updates);
-    const hasUpdates = rows.some((row) => row.installed !== "unknown");
-    const columns = getTableColumns(rows);
-    const columnGap = 2;
-    const getGroupLines = (groupType, color, title, description) => {
-      const items = rows.filter((row) => row.group === groupType).sort((a, b) => a.name > b.name ? 1 : -1);
-      return !items.length ? [] : [
-        "",
-        (0, import_node_util.styleText)(color, `${(0, import_node_util.styleText)("bold", title)} ${(0, import_node_util.styleText)("italic", `(${description})`)}`),
-        ...items.map((row) => columns.map((column) => columnCellRenderer(column, row)).join(" ".repeat(columnGap)))
-      ];
-    };
-    drawBox([
-      "",
-      hasUpdates ? (0, import_node_util.styleText)("yellow", "Important updates are available.") : void 0,
-      hasUpdates ? "" : void 0,
-      columns.map(columnHeaderRenderer).join(" ".repeat(columnGap)),
-      ...getGroupLines("patch", "green", "Patch", "backwards-compatible bug fixes"),
-      ...getGroupLines("minor", "cyan", "Minor", "backwards-compatible features"),
-      ...getGroupLines("major", "red", "Major", "potentially breaking API changes"),
-      ...getGroupLines("majorVersionZero", "magenta", "Major version zero", "not stable, anything may change"),
-      ...getGroupLines("unknown", "blue", "Missing", "not installed"),
-      ""
-    ].filter((line) => line !== void 0));
-  } else {
-    console.log((0, import_node_util.styleText)("green", "\u{1F389} Packages are up-to-date"));
-  }
-};
-var checkVersions = async (packages, skipMissing, options = { useCache: true }) => {
-  const ora = (await import("ora")).default;
-  const spinner = ora({ text: (0, import_node_util.styleText)("cyan", "Checking versions...") });
-  spinner.start();
-  let latestVersionPackages = await (0, import_index.default)(packages, options);
-  if (skipMissing) {
-    latestVersionPackages = latestVersionPackages.filter((pkg) => pkg.local ?? pkg.globalNpm ?? pkg.globalYarn);
-  }
-  spinner.stop();
-  displayTable(latestVersionPackages);
-};
-void (async () => {
-  let args = process.argv.slice(2);
-  const skipMissing = args.includes("--skip-missing");
-  args = args.filter((arg) => !arg.startsWith("-"));
-  if (args.length === 1 && args[0].endsWith("package.json")) {
-    if ((0, import_node_fs.existsSync)(args[0])) {
-      process.chdir((0, import_node_path.dirname)(args[0]));
-      await checkVersions(JSON.parse((0, import_node_fs.readFileSync)(args[0]).toString()), skipMissing);
-    } else {
-      console.log((0, import_node_util.styleText)("cyan", "No package.json file were found"));
-    }
-  } else {
-    let localPkgJson;
-    if ((0, import_node_fs.existsSync)("package.json")) {
-      localPkgJson = JSON.parse((0, import_node_fs.readFileSync)("package.json").toString());
-    }
-    if (args.length) {
-      args = args.map((arg) => {
-        if (localPkgJson?.dependencies?.[arg]) {
-          return `${arg}@${localPkgJson.dependencies?.[arg]}`;
-        } else if (localPkgJson?.devDependencies?.[arg]) {
-          return `${arg}@${localPkgJson.devDependencies?.[arg]}`;
-        } else if (localPkgJson?.peerDependencies?.[arg]) {
-          return `${arg}@${localPkgJson.peerDependencies?.[arg]}`;
-        }
-        return arg;
-      });
-      await checkVersions(args, skipMissing);
-    } else if (localPkgJson) {
-      await checkVersions(localPkgJson, skipMissing);
-    } else {
-      console.log((0, import_node_util.styleText)("cyan", "No packages were found"));
-    }
-  }
-})();

package/index.d.ts

@@ -1,146 +0,0 @@
-import type { Agent } from 'http';
-interface RegistryVersions {
-    /**
-     * The latest version of the package found on the registry (if found).
-     */
-    latest?: string;
-    /**
-     * The next version of the package found on the registry (if found).
-     */
-    next?: string;
-    /**
-     * The latest version of the package found on the registry and satisfied by the wanted tag or version range.
-     */
-    wanted?: string;
-}
-interface InstalledVersions {
-    /**
-     * The current local installed version of the package (if installed).
-     */
-    local?: string;
-    /**
-     * The current npm global installed version of the package (if installed).
-     */
-    globalNpm?: string;
-    /**
-     * The current yarn global installed version of the package (if installed).
-     */
-    globalYarn?: string;
-}
-interface LatestVersionPackage extends InstalledVersions, RegistryVersions {
-    /**
-     * The name of the package.
-     */
-    name: string;
-    /**
-     * The tag or version range that was provided (if provided).
-     * @default "latest"
-     */
-    wantedTagOrRange?: string;
-    /**
-     * Whether the local or global installed versions (if any) could be upgraded or not, based on the wanted version.
-     */
-    updatesAvailable: {
-        local: string | false;
-        globalNpm: string | false;
-        globalYarn: string | false;
-    } | false;
-    /**
-     * Any error that might have occurred during the process.
-     */
-    error?: Error;
-}
-interface RequestOptions {
-    readonly ca?: string | Buffer | Array<string | Buffer>;
-    readonly rejectUnauthorized?: boolean;
-    readonly agent?: Agent | boolean;
-    readonly timeout?: number;
-}
-interface LatestVersionOptions {
-    /**
-     * Awaiting the api to return might take time, depending on the network, and might impact your package loading performance.
-     * You can use the cache mechanism to improve load performance and reduce unnecessary network requests.
-     * If `useCache` is not supplied, the api will always check for updates and wait for every requests to return before returning itself.
-     * If `useCache` is used, the api will always returned immediately, with either (for each provided packages):
-     * 1) a latest/next version available if a cache was found
-     * 2) no latest/next version available if no cache was found - in such case updates will be fetched in the background and a cache will
-     * be created for each provided packages and made available for the next call to the api.
-     * @default false
-     */
-    readonly useCache?: boolean;
-    /**
-     * How long the cache for the provided packages should be used before being refreshed (in milliseconds).
-     * If `useCache` is not supplied, this option has no effect.
-     * If `0` is used, this will force the cache to refresh immediately:
-     * 1) The api will returned immediately (without any latest nor next version available for the provided packages)
-     * 2) New updates will be fetched in the background
-     * 3) The cache for each provided packages will be refreshed and made available for the next call to the api
-     * @default ONE_DAY
-     */
-    readonly cacheMaxAge?: number;
-    /**
-     * A JavaScript package registry url that implements the CommonJS Package Registry specification.
-     * @default "Looks at any registry urls in the .npmrc file or fallback to the default npm registry instead"
-     * @example <caption>.npmrc</caption>
-     * registry = 'https://custom-registry.com/'
-     * @pkgscope:registry = 'https://custom-registry.com/'
-     */
-    readonly registryUrl?: string;
-    /**
-     * Set of options to be passed down to Node.js http/https request.
-     * @example <caption>Behind a proxy with self-signed certificate</caption>
-     * { ca: [ fs.readFileSync('proxy-cert.pem') ] }
-     * @example <caption>Bypassing certificate validation</caption>
-     * { rejectUnauthorized: false }
-     */
-    readonly requestOptions?: RequestOptions;
-}
-interface LatestVersion {
-    /**
-     * Get latest versions of packages from of a package json like object.
-     * @param {PackageJson} item - A package json like object (with dependencies, devDependencies and peerDependencies attributes).
-     * @example { dependencies: { 'npm': 'latest' }, devDependencies: { 'npm': '1.3.2' }, peerDependencies: { '@scope/name': '^5.0.2' } }
-     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
-     * If `useCache` is not supplied, the default of `false` is used.
-     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
-     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the `npm registry url` instead.
-     * @returns {Promise<LatestVersionPackage[]>}
-     */
-    (item: PackageJson, options?: LatestVersionOptions): Promise<LatestVersionPackage[]>;
-    /**
-     * Get latest version of a single package.
-     * @param {Package} item - A single package object (represented by a string that should match the following format: `${'@' | ''}${string}@${string}`)
-     * @example 'npm', 'npm@1.3.2', '@scope/name@^5.0.2'
-     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
-     * If `useCache` is not supplied, the default of `false` is used.
-     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
-     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the npm registry url instead.
-     * @returns {Promise<LatestVersionPackage>}
-     */
-    (item: Package, options?: LatestVersionOptions): Promise<LatestVersionPackage>;
-    /**
-     * Get latest versions of a collection of packages.
-     * @param {Package[]} items - A collection of package object (represented by a string that should match the following format: `${'@' | ''}${string}@${string}`)
-     * @example ['npm', 'npm@1.3.2', '@scope/name@^5.0.2']
-     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
-     * If `useCache` is not supplied, the default of `false` is used.
-     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
-     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the npm registry url instead.
-     * @returns {Promise<LatestVersionPackage[]>}
-     */
-    (items: Package[], options?: LatestVersionOptions): Promise<LatestVersionPackage[]>;
-}
-type PackageRange = `${'@' | ''}${string}@${string}`;
-type Package = PackageRange | string;
-type PackageJsonDependencies = Record<string, string>;
-type PackageJson = Record<string, any> & ({
-    dependencies: PackageJsonDependencies;
-} | {
-    devDependencies: PackageJsonDependencies;
-} | {
-    peerDependencies: PackageJsonDependencies;
-});
-export declare const ONE_DAY: number;
-declare const latestVersion: LatestVersion;
-export type { LatestVersion, Package, PackageRange, PackageJson, PackageJsonDependencies, RegistryVersions, LatestVersionPackage, RequestOptions, LatestVersionOptions };
-export default latestVersion;