@kingironman2011/license-checker 1.0.2 → 1.1.0

package/dist/dependencies/read-installed-packages.js

@@ -1,66 +1,188 @@
-import { readFile, realpath } from "node:fs/promises";
+import fs from "node:fs/promises";
 import path from "node:path";
-async function resolveDependency(parentDir, name) {
-    let currentDir = parentDir;
-    while (true) {
-        const candidate = path.join(currentDir, "node_modules", name, "package.json");
+const clonePackageJson = (packageJson) => JSON.parse(JSON.stringify(packageJson ?? {}));
+const readPackageJsonFromDisk = async (packagePath) => {
+    try {
+        const content = await fs.readFile(path.join(packagePath, "package.json"), "utf8");
+        return clonePackageJson(JSON.parse(content));
+    }
+    catch {
+        try {
+            const source = await fs.readFile(path.join(packagePath, "index.js"), "utf8");
+            const manifest = /\/\*\*package(?:\s|$)([\s\S]*?)\*\*\//m.exec(source)?.[1];
+            if (!manifest)
+                return {};
+            const json = manifest.replace(/^\s*\*/gm, "");
+            return clonePackageJson(JSON.parse(json));
+        }
+        catch {
+            return {};
+        }
+    }
+};
+const getDependencySpecs = (packageJson) => ({
+    ...packageJson.dependencies,
+    ...packageJson.optionalDependencies,
+});
+const getRootDependencySpecs = (packageJson) => ({
+    ...getDependencySpecs(packageJson),
+});
+async function packageDirectories(directory) {
+    let entries;
+    try {
+        entries = await fs.readdir(directory, {
+            withFileTypes: true,
+            encoding: "utf8",
+        });
+    }
+    catch {
+        return [];
+    }
+    const packages = [];
+    for (const entry of entries) {
+        if (entry.name.startsWith("."))
+            continue;
+        if (entry.name.startsWith("@")) {
+            packages.push(...(await packageDirectories(path.join(directory, entry.name))));
+            continue;
+        }
+        const packagePath = path.join(directory, entry.name);
         try {
-            await readFile(candidate, "utf8");
-            return path.dirname(candidate);
+            if ((await fs.stat(packagePath)).isDirectory())
+                packages.push(packagePath);
         }
         catch {
-            const parent = path.dirname(currentDir);
-            if (parent === currentDir)
-                return undefined;
-            currentDir = parent;
+            // Broken symlinks are not installed packages.
         }
     }
+    return packages;
 }
-export async function readInstalledPackages(projectDir, scope) {
-    const root = JSON.parse(await readFile(path.join(projectDir, "package.json"), "utf8"));
-    const roots = scope === "production"
-        ? { ...root.dependencies, ...root.optionalDependencies }
-        : (root.devDependencies ?? {});
-    const found = new Map();
-    const visited = new Set();
-    async function visit(packagePath, dependencyName) {
-        let realPackagePath;
+async function resolveInstalledPackage(fromPath, dependencyName) {
+    let directory = fromPath;
+    while (true) {
+        const candidate = path.join(directory, "node_modules", dependencyName);
         try {
-            realPackagePath = await realpath(packagePath);
+            if ((await fs.stat(candidate)).isDirectory())
+                return candidate;
         }
         catch {
-            return;
+            // Keep searching through parent node_modules directories.
         }
-        if (visited.has(realPackagePath))
-            return;
-        visited.add(realPackagePath);
-        const pkg = JSON.parse(await readFile(path.join(packagePath, "package.json"), "utf8"));
-        const name = pkg.name ?? dependencyName;
-        const version = pkg.version ?? "unknown";
-        const key = `${name}@${version}`;
-        found.set(key, {
-            name,
-            version,
-            license: pkg.license && typeof pkg.license === "string"
-                ? pkg.license
-                : ((typeof pkg.license === "object" ? pkg.license.type : undefined) ??
-                    pkg.licenses?.map(({ type }) => type ?? "Unknown").join(" OR ") ??
-                    "Unknown"),
-            scope,
-            packagePath,
-            licenseFiles: [],
-        });
-        const dependencies = { ...pkg.dependencies, ...pkg.optionalDependencies };
-        for (const childName of Object.keys(dependencies).toSorted()) {
-            const childPath = await resolveDependency(packagePath, childName);
-            if (childPath)
-                await visit(childPath, childName);
+        const parent = path.dirname(directory);
+        if (parent === directory)
+            return undefined;
+        directory = parent;
+    }
+}
+const findDependency = (packageJson, dependencyName) => {
+    let currentPackageJson = packageJson;
+    while (currentPackageJson) {
+        const dependency = currentPackageJson.dependencies?.[dependencyName];
+        if (dependency && typeof dependency === "object") {
+            return dependency;
         }
+        if (currentPackageJson.realName === dependencyName) {
+            return currentPackageJson;
+        }
+        currentPackageJson = currentPackageJson.link
+            ? null
+            : (currentPackageJson.parent ?? null);
     }
-    for (const name of Object.keys(roots).toSorted()) {
-        const packagePath = await resolveDependency(projectDir, name);
-        if (packagePath)
-            await visit(packagePath, name);
+};
+const unmarkExtraneous = (packageJson, options) => {
+    packageJson.extraneous = false;
+    const dependencies = packageJson["_dependencies"] ?? {};
+    if (options.dev &&
+        packageJson.devDependencies &&
+        (packageJson.root || packageJson.link)) {
+        Object.keys(packageJson.devDependencies).forEach((dependencyName) => {
+            dependencies[dependencyName] = String(packageJson.devDependencies?.[dependencyName]);
+        });
     }
-    return [...found.values()];
-}
+    if (!options.nopeer && packageJson.peerDependencies) {
+        Object.keys(packageJson.peerDependencies).forEach((dependencyName) => {
+            dependencies[dependencyName] = String(packageJson.peerDependencies?.[dependencyName]);
+        });
+    }
+    Object.keys(dependencies).forEach((dependencyName) => {
+        const dependency = findDependency(packageJson, dependencyName);
+        if (dependency?.extraneous) {
+            unmarkExtraneous(dependency, options);
+        }
+    });
+};
+const readInstalledPackages = async (folder, options = {}) => {
+    const rootPath = path.resolve(folder);
+    const convertedNodes = new Map();
+    const convertNode = async (installedPath, parent = null, depth = 0, dependencyName) => {
+        const existing = convertedNodes.get(installedPath);
+        if (existing)
+            return existing;
+        const realPath = await fs
+            .realpath(installedPath)
+            .catch(() => installedPath);
+        const packageJson = {
+            ...clonePackageJson(await readPackageJsonFromDisk(realPath)),
+        };
+        const isRoot = installedPath === rootPath;
+        const dependencySpecs = isRoot
+            ? getRootDependencySpecs(packageJson)
+            : getDependencySpecs(packageJson);
+        const node = {
+            ...packageJson,
+            name: packageJson.name ?? dependencyName ?? path.basename(installedPath),
+            version: packageJson.version,
+            path: installedPath,
+            realPath,
+            realName: dependencyName ?? packageJson.name ?? path.basename(installedPath),
+            _dependencies: Object.fromEntries(Object.entries(dependencySpecs).map(([key, value]) => [
+                key,
+                String(value),
+            ])),
+            dependencies: {},
+            extraneous: true,
+            depth,
+        };
+        if (realPath !== installedPath)
+            node.link = realPath;
+        if (node.realName && node.name !== node.realName)
+            node.invalid = true;
+        if (parent && !node.link)
+            node.parent = parent;
+        convertedNodes.set(installedPath, node);
+        const convertedDependencies = (node.dependencies ??= {});
+        for (const childPath of await packageDirectories(path.join(installedPath, "node_modules"))) {
+            const childName = path
+                .relative(path.join(installedPath, "node_modules"), childPath)
+                .split(path.sep)
+                .join("/");
+            convertedDependencies[childName] = await convertNode(childPath, node, depth + 1, childName);
+        }
+        const specs = { ...dependencySpecs };
+        if (options.dev && (isRoot || node.link)) {
+            Object.assign(specs, packageJson.devDependencies);
+        }
+        if (!options.nopeer)
+            Object.assign(specs, packageJson.peerDependencies);
+        for (const [name, spec] of Object.entries(specs)) {
+            if (options.nopeer &&
+                packageJson.peerDependencies?.[name] !== undefined) {
+                continue;
+            }
+            const installed = await resolveInstalledPackage(installedPath, name);
+            if (!installed) {
+                if (packageJson.optionalDependencies?.[name] === undefined) {
+                    convertedDependencies[name] = String(spec);
+                }
+                continue;
+            }
+            convertedDependencies[name] = await convertNode(installed, node, depth + 1, name);
+        }
+        return node;
+    };
+    const convertedRoot = await convertNode(rootPath);
+    convertedRoot.root = true;
+    unmarkExtraneous(convertedRoot, options);
+    return convertedRoot;
+};
+export default readInstalledPackages;

package/dist/dependencies/walk-dependency-tree.d.ts

@@ -0,0 +1,19 @@
+import type { DependencyPackage } from "../types.js";
+/**
+ * Walks a dependency tree depth-first and calls `visit` for every accepted node.
+ *
+ * A maxDepth of 0 still visits direct dependencies, matching the license checker's historic `direct: 0` behavior.
+ *
+ * @param {DependencyTreeNode} rootDependency
+ * @param {{
+ *   maxDepth?: number | boolean | string | null,
+ *   shouldVisit?: (dependency: DependencyTreeNode, currentDepth: number) => boolean,
+ *   visit: (dependency: DependencyTreeNode, currentDepth: number) => void | boolean
+ * }} options
+ * @returns {void}
+ */
+export declare function walkDependencyTree(rootDependency: DependencyPackage, { maxDepth, shouldVisit, visit, }: {
+    maxDepth?: number | boolean | string | null;
+    shouldVisit?: (dependency: DependencyPackage, currentDepth: number) => boolean;
+    visit: (dependency: DependencyPackage, currentDepth: number) => void | boolean;
+}): void;

package/dist/dependencies/walk-dependency-tree.js

@@ -0,0 +1,38 @@
+/**
+ * Walks a dependency tree depth-first and calls `visit` for every accepted node.
+ *
+ * A maxDepth of 0 still visits direct dependencies, matching the license checker's historic `direct: 0` behavior.
+ *
+ * @param {DependencyTreeNode} rootDependency
+ * @param {{
+ *   maxDepth?: number | boolean | string | null,
+ *   shouldVisit?: (dependency: DependencyTreeNode, currentDepth: number) => boolean,
+ *   visit: (dependency: DependencyTreeNode, currentDepth: number) => void | boolean
+ * }} options
+ * @returns {void}
+ */
+export function walkDependencyTree(rootDependency, { maxDepth = Number.POSITIVE_INFINITY, shouldVisit = () => true, visit, }) {
+    const depthLimit = typeof maxDepth === "boolean"
+        ? maxDepth
+            ? Number.POSITIVE_INFINITY
+            : 0
+        : typeof maxDepth === "string"
+            ? Number(maxDepth)
+            : (maxDepth ?? Number.POSITIVE_INFINITY);
+    const walk = (dependency, currentDepth) => {
+        if (typeof dependency === "string")
+            return;
+        if (!dependency || !shouldVisit(dependency, currentDepth)) {
+            return;
+        }
+        const visitResult = visit(dependency, currentDepth);
+        const dependencies = dependency.dependencies;
+        if (visitResult === false || currentDepth > depthLimit || !dependencies) {
+            return;
+        }
+        Object.keys(dependencies).forEach((dependencyName) => {
+            walk(dependencies[dependencyName], currentDepth + 1);
+        });
+    };
+    walk(rootDependency, 0);
+}

package/dist/files/read-json.d.ts

@@ -0,0 +1 @@
+export declare const readJson: <T = Record<string, unknown>>(jsonPath: string) => T;

package/dist/files/read-json.js

@@ -0,0 +1,8 @@
+import fs from "node:fs";
+export const readJson = (jsonPath) => {
+    if (typeof jsonPath !== "string") {
+        throw new Error("The path was not specified for the JSON file to parse.");
+    }
+    const jsonFileContents = fs.readFileSync(jsonPath, { encoding: "utf8" });
+    return JSON.parse(jsonFileContents);
+};

package/dist/index.d.ts

@@ -1,3 +1,88 @@
-import type { DependencyLicense, LicenseCheckOptions } from "./types.js";
-export type { DependencyLicense, DependencyScope, LicenseCheckOptions, } from "./types.js";
-export declare function runLicenseCheck(options?: LicenseCheckOptions): Promise<DependencyLicense[]>;
+import type { LicenseCheckOptions, ModuleInfos } from "./types.js";
+/**
+ * Custom output field default value or toggle.
+ *
+ * For CSV output, custom format keys define the output columns after module_name.
+ * For JSON output, custom format keys add or populate fields in addition to the usual result fields.
+ * A value of false disables optional population for that field where supported, but does not remove core fields such as
+ * licenses.
+ *
+ * Use limitAttributes to restrict formatted JSON output to a specific set of fields.
+ *
+ * @typedef {(string | boolean | undefined)} CustomFormatValue
+ */
+/**
+ * @typedef {Record<string, CustomFormatValue>} CustomFormat
+ */
+/**
+ * @typedef {Object} LicenseCheckOptions Options struct for the init() and runLicenseCheck() functions.
+ * @property {string} start Path to start checking dependencies from.
+ * @property {boolean=} production Only show production dependencies.
+ * @property {boolean=} development Only show development dependencies.
+ * @property {boolean=} unknown Report guessed licenses as unknown licenses.
+ * @property {boolean=} onlyunknown Only list packages with unknown or guessed licenses.
+ * @property {boolean=} json Output in JSON format.
+ * @property {boolean=} csv Output in CSV format.
+ * @property {string=} csvComponentPrefix Prefix column for component in CSV format.
+ * @property {string=} out Write the data to a specific file.
+ * @property {string=} customPath Path to a JSON file that defines a custom output format.
+ * @property {string=} excludeLicenses Exclude modules which licenses are in the comma-separated list from the output.
+ * @property {boolean=} relativeLicensePath Output the location of the license files as relative paths.
+ * @property {boolean=} relativeModulePath Output module locations as relative paths.
+ * @property {boolean=} summary Output a summary of the license usage.
+ * @property {string=} failOn Fail (exit with code 1) on the first occurrence of the licenses of the semicolon-separated list.
+ * @property {string=} onlyAllow Fail (exit with code 1) on the first occurrence of the licenses not in the semicolon-separated list.
+ * @property {string=} includePackages Restrict output to the packages (package@version) in the semicolon-separated list.
+ * @property {string=} excludePackages Restrict output to the packages (package@version) not in the semicolon-separated list.
+ * @property {boolean=} excludePrivatePackages Restrict output to not include any package marked as private.
+ * @property {string=} excludePackagesStartingWith Exclude modules starting with a specific string.
+ * @property {(boolean | number)=} direct Look for direct dependencies only.
+ * @property {number=} depth Recurse dependencies up to a specific depth, overrides "direct".
+ * @property {boolean=} color Colorize output.
+ * @property {CustomFormat=} customFormat Custom output fields and default values.
+ * @property {boolean=} nopeer Ignore peerDependencies.
+ * @property {string=} clarificationsFile A file that contains license clarifications for malformed or non-standard packages.
+ * @property {boolean=} clarificationsMatchAll Require every clarification to match a package.
+ * @property {string=} includeLicenses Include modules which licenses are in the comma-separated list in the output.
+ * @property {string=} files Path to write output files to.
+ */
+/**
+ * @typedef {Object} KnownModuleInfo Information about one dependency.
+ * @property {string=} name Module name.
+ * @property {string=} version Module version.
+ * @property {string=} description Module description.
+ * @property {string=} repository Repository URL.
+ * @property {string=} publisher Publisher name.
+ * @property {string=} email Publisher e-mail.
+ * @property {string=} url Publisher URL.
+ * @property {(string | string[])=} licenses Detected license(s).
+ * @property {string=} licenseFile Path to license file, if available.
+ * @property {string=} licenseText Contents of the license.
+ * @property {string=} licenseModified Whether the license is modified.
+ * @property {boolean=} private Private module.
+ * @property {string=} path Path to module.
+ * @property {boolean=} relativeModulePath Output module locations as relative paths.
+ * @property {string=} copyright Copyright statements.
+ * @property {string=} noticeFile Path of NOTICE file.
+ */
+/**
+ * @typedef {KnownModuleInfo & Record<string, string | string[] | boolean | undefined>} ModuleInfo
+ */
+/**
+ * @typedef {Record<string, ModuleInfo>} ModuleInfos
+ */
+/**
+ * Checks licenses based on the given options.
+ *
+ * @param {LicenseCheckOptions} options Controls the license checker's behavior.
+ * @returns {Promise<ModuleInfos>} All information on dependencies found by the license checker.
+ */
+export declare const runLicenseCheck: (options: LicenseCheckOptions) => Promise<ModuleInfos>;
+/**
+ * Runs the license check for the given args.
+ *
+ * @param {LicenseCheckOptions} args Specifies the path to the module to check dependencies of.
+ * @param {(err: Error | null, ret: ModuleInfos) => void} callback Called after the checker finished.
+ * @deprecated Will be removed in a future version. Please switch to {@link runLicenseCheck} instead.
+ */
+export declare const init: (args: LicenseCheckOptions, callback: (error: Error | null, results: ModuleInfos) => void) => void;