libyear/src/libyear.js

A simple measure of software dependency freshness

import { availableParallelism } from "node:os";
import { orderBy } from "lodash-es";
import pLimit from "p-limit";
import { compare, sort, valid } from "semver";
import { calculateDrift, calculatePulse } from "./date.js";
import { getDependencies } from "./fetch/dependencies.js";
import { getPackageInfo } from "./fetch/package-info.js";
import { getReleasesByType, getSanitisedReleases, getStableReleases, } from "./versions.js";
const limit = pLimit(availableParallelism());
export const libyear = async (packageManager, flags) => Promise.all(Object.entries(await getDependencies(packageManager, flags)).map(([dependency, currentVersion]) => limit(() => getPackageInfo(packageManager, dependency).then(({ deprecated, versions = {} }) => {
    const allVersionsMap = getSanitisedReleases(versions, currentVersion);
    const stableVersionsMap = getStableReleases(allVersionsMap);
    const allVersions = Object.keys(allVersionsMap);
    const stableVersions = Object.keys(stableVersionsMap);
    const latestAllVersion = sort(allVersions).at(-1) ?? "";
    const latestStableVersion = sort(stableVersions).at(-1) ?? "";
    const diffAllVersions = allVersions.slice(allVersions.findIndex((version) => version === currentVersion) +
        1, allVersions.findIndex((version) => version === latestStableVersion) + 1);
    const diffStableVersions = diffAllVersions.filter((version) => stableVersions.includes(version));
    const drift = calculateDrift(allVersionsMap[currentVersion], allVersionsMap[latestStableVersion]);
    const pulse = calculatePulse(Object.values(allVersionsMap).sort().at(-1));
    const releases = diffStableVersions.length;
    const { major, minor, patch } = getReleasesByType([
        currentVersion,
        ...diffStableVersions,
    ]);
    const latest = [
        latestStableVersion,
        flags?.preReleases ? latestAllVersion : "",
    ]
        .filter((version) => valid(version))
        .find((version) => compare(currentVersion, version) < 0);
    if (flags?.quiet && drift <= 0) {
        return null;
    }
    return {
        dependency,
        deprecated: deprecated ?? versions[currentVersion]?.deprecated,
        drift,
        pulse,
        releases,
        major,
        minor,
        patch,
        latest,
    };
}))))
    .then((dependencies) => dependencies.filter((dependency) => dependency != null))
    .then((dependencies) => flags?.sort != null
    ? orderBy(dependencies, flags.sort, "desc")
    : dependencies);