@kingironman2011/license-checker 1.0.1 → 1.1.0

package/README.md

@@ -0,0 +1,90 @@
+# License Checker
+
+Scan a Node.js project’s production and development dependencies, print their license information, and copy discovered license files into an output directory.
+
+## Requirements
+
+- Node.js 24 or newer
+- A project with dependencies installed
+
+## Install
+
+Run the CLI directly with pnpm:
+
+```sh
+pnpm dlx @kingironman2011/license-checker
+```
+
+Or install it in a project:
+
+```sh
+pnpm add -D @kingironman2011/license-checker
+```
+
+Then run:
+
+```sh
+pnpm exec license-checker
+```
+
+The command scans the current directory by default. Pass a project directory to scan another project:
+
+```sh
+pnpm exec license-checker ./path/to/project
+```
+
+## CLI options
+
+```text
+Usage: license-checker [project-directory] [options]
+
+Options:
+  --check               List dependencies with no license metadata or license file
+  --silent, -s          Do not print the license report
+  --extract, --files <dir> Copy license files into <dir>
+  --production, --prod  Scan production dependencies only
+  --development, --dev  Scan development dependencies only
+  --all                 Scan both dependency scopes (default)
+  --help, -h            Show this help
+```
+
+Examples:
+
+```sh
+# Check production dependencies in the current directory
+pnpm exec license-checker --production
+
+# Find dependencies without license metadata or a license file (exits nonzero if any are found)
+pnpm exec license-checker --check
+
+# Copy discovered license files to ./licenses
+pnpm exec license-checker --extract ./licenses
+```
+
+When `--check` finds dependencies whose license is unknown and which have no license files, it lists them and exits with status 1. Otherwise it reports that all dependencies have license metadata or license files. `--silent` suppresses report output; it does not change the exit status.
+
+## Library API
+
+The package also exports `runLicenseCheck` for use from JavaScript or TypeScript:
+
+```ts
+import { runLicenseCheck } from "@kingironman2011/license-checker";
+
+const dependencies = await runLicenseCheck({
+  start: process.cwd(),
+  production: true,
+});
+
+console.log(dependencies);
+```
+
+Options include `start` (project directory), `production`, `development`, and `files` (directory for extracted license files). With neither scope selected, both production and development dependencies are scanned. Each result includes the package name, version, license, license file paths, and dependency scope.
+
+## Development
+
+```sh
+pnpm install
+pnpm build
+pnpm lint
+pnpm format:check
+```

package/dist/cli/options.d.ts

@@ -1,4 +1,60 @@
-import type { LicenseCheckOptions } from "../types.js";
-export interface CliOptions extends LicenseCheckOptions {
-}
-export declare function getNormalizedArguments(args: string[]): CliOptions;
+import path from "node:path";
+import type { NormalizedArguments, ParsedArguments } from "../types.js";
+export declare const knownOptions: {
+    angularCli: BooleanConstructor;
+    clarificationsFile: typeof path;
+    clarificationsMatchAll: BooleanConstructor;
+    color: BooleanConstructor;
+    csv: BooleanConstructor;
+    csvComponentPrefix: StringConstructor;
+    customPath: typeof path;
+    depth: NumberConstructor;
+    development: BooleanConstructor;
+    direct: (StringConstructor | null)[];
+    excludeLicenses: StringConstructor;
+    excludePackages: StringConstructor;
+    excludePackagesStartingWith: StringConstructor;
+    excludePrivatePackages: BooleanConstructor;
+    failOn: StringConstructor;
+    files: typeof path;
+    help: BooleanConstructor;
+    includeLicenses: StringConstructor;
+    includePackages: StringConstructor;
+    json: BooleanConstructor;
+    limitAttributes: StringConstructor;
+    markdown: BooleanConstructor;
+    nopeer: BooleanConstructor;
+    onlyAllow: StringConstructor;
+    onlyunknown: BooleanConstructor;
+    out: typeof path;
+    plainVertical: BooleanConstructor;
+    production: BooleanConstructor;
+    relativeLicensePath: BooleanConstructor;
+    relativeModulePath: BooleanConstructor;
+    start: StringConstructor;
+    summary: BooleanConstructor;
+    unknown: BooleanConstructor;
+    version: BooleanConstructor;
+};
+export declare const shortHands: {
+    h: string[];
+    v: string[];
+};
+/**
+ * @typedef {ParsedArguments & {
+ *   color: boolean,
+ *   direct: number,
+ *   relativeLicensePath: boolean,
+ *   relativeModulePath: boolean,
+ *   start: string,
+ *   depth: number
+ * }} ArgumentsWithDefaults Parsed command-line arguments with defaults applied.
+ */
+/**
+ * Applies default values to parsed command-line arguments.
+ *
+ * @param {ParsedArguments} parsedArguments Parsed command-line arguments.
+ * @returns {ArgumentsWithDefaults} Parsed command-line arguments with defaults applied.
+ */
+export declare function setDefaultArguments(parsedArguments?: ParsedArguments): NormalizedArguments;
+export declare function getNormalizedArguments(args?: string[]): NormalizedArguments;

package/dist/cli/options.js

@@ -1,56 +1,246 @@
 import path from "node:path";
-export function getNormalizedArguments(args) {
-    const options = {
-        start: process.cwd(),
-        silent: false,
-    };
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--silent" || arg === "-s")
-            options.silent = true;
-        else if (arg === "--check")
-            options.check = true;
-        else if (arg === "--production" || arg === "--prod") {
-            options.production = true;
-            options.development = false;
+import { supportsBasicColor } from "../output/ansi.js";
+export const knownOptions = {
+    angularCli: Boolean,
+    clarificationsFile: path,
+    clarificationsMatchAll: Boolean,
+    color: Boolean,
+    csv: Boolean,
+    csvComponentPrefix: String,
+    customPath: path,
+    depth: Number, // Meant to replace the misleading "--direct" option
+    development: Boolean,
+    direct: [String, null],
+    excludeLicenses: String,
+    excludePackages: String,
+    excludePackagesStartingWith: String,
+    excludePrivatePackages: Boolean,
+    failOn: String,
+    files: path,
+    help: Boolean,
+    includeLicenses: String,
+    includePackages: String,
+    json: Boolean,
+    limitAttributes: String,
+    markdown: Boolean,
+    nopeer: Boolean,
+    onlyAllow: String,
+    onlyunknown: Boolean,
+    out: path,
+    plainVertical: Boolean,
+    production: Boolean,
+    relativeLicensePath: Boolean,
+    relativeModulePath: Boolean,
+    start: String,
+    summary: Boolean,
+    unknown: Boolean,
+    version: Boolean,
+};
+export const shortHands = {
+    h: ["--help"],
+    v: ["--version"],
+};
+/**
+ * @typedef {Object} ParsedArguments Parsed command-line arguments.
+ * @property {boolean=} angularCli Output in Angular CLI-compatible plain vertical format.
+ * @property {string=} clarificationsFile Path to a license clarifications file.
+ * @property {boolean=} clarificationsMatchAll Require every clarification to match a package.
+ * @property {(boolean | null)=} color Colorize output.
+ * @property {boolean=} csv Output in CSV format.
+ * @property {string=} csvComponentPrefix Prefix column for component in CSV format.
+ * @property {string=} customPath Path to a JSON file that defines a custom output format.
+ * @property {(string | number)=} depth Recurse dependencies up to a specific depth.
+ * @property {boolean=} development Only show development dependencies.
+ * @property {(string | boolean | number | null)=} direct Look for direct dependencies only.
+ * @property {string=} excludeLicenses Exclude modules which licenses are in the comma-separated list from the output.
+ * @property {string=} excludePackages Restrict output to the packages not in the semicolon-separated list.
+ * @property {string=} excludePackagesStartingWith Exclude modules starting with a specific string.
+ * @property {boolean=} excludePrivatePackages Restrict output to not include any package marked as private.
+ * @property {string=} failOn Fail on the first occurrence of a license in the semicolon-separated list.
+ * @property {string=} files Path to write output files to.
+ * @property {boolean=} help Show help output.
+ * @property {string=} includeLicenses Include modules which licenses are in the comma-separated list in the output.
+ * @property {string=} includePackages Restrict output to the packages in the semicolon-separated list.
+ * @property {boolean=} json Output in JSON format.
+ * @property {string=} limitAttributes Restrict formatted JSON output to a specific set of fields.
+ * @property {boolean=} markdown Output in Markdown format.
+ * @property {boolean=} nopeer Ignore peerDependencies.
+ * @property {string=} onlyAllow Fail on the first occurrence of a license not in the semicolon-separated list.
+ * @property {boolean=} onlyunknown Only list packages with unknown or guessed licenses.
+ * @property {string=} out Write the data to a specific file.
+ * @property {boolean=} plainVertical Output in plain vertical format.
+ * @property {boolean=} production Only show production dependencies.
+ * @property {boolean=} relativeLicensePath Output license file locations as relative paths.
+ * @property {boolean=} relativeModulePath Output module locations as relative paths.
+ * @property {string=} start Path to start checking dependencies from.
+ * @property {boolean=} summary Output a summary of the license usage.
+ * @property {boolean=} unknown Report guessed licenses as unknown licenses.
+ * @property {boolean=} version Show version output.
+ */
+function normalizeArgv(args = process.argv) {
+    if (Array.isArray(args) && (args.length === 0 || args[0]?.startsWith("-"))) {
+        return [process.execPath, "license-checker-rseidelsohn", ...args];
+    }
+    return args;
+}
+/**
+ * Parses command-line arguments.
+ *
+ * @param {string[]} [args] Command-line arguments to parse.
+ * @returns {ParsedArguments} Parsed command-line arguments.
+ */
+function parseArguments(args = process.argv) {
+    const argv = normalizeArgv(args).slice(2);
+    const parsedArguments = {};
+    const optionNames = Object.keys(knownOptions);
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (!argument?.startsWith("-"))
+            continue;
+        if (/^-{2,}$/.test(argument))
+            break;
+        const equalIndex = argument.indexOf("=");
+        const hasEquals = equalIndex >= 0;
+        let name = argument.replace(/^-+/, "");
+        let valueFromEquals;
+        if (hasEquals) {
+            valueFromEquals = name.slice(name.indexOf("=") + 1);
+            name = name.slice(0, name.indexOf("="));
         }
-        else if (arg === "--development" || arg === "--dev") {
-            options.production = false;
-            options.development = true;
+        if (name === "h" || name === "v")
+            name = name === "h" ? "help" : "version";
+        else if (name.length > 1 && !optionNames.includes(name)) {
+            const matches = optionNames.filter((option) => option.startsWith(name));
+            if (matches.length === 1)
+                name = matches[0];
         }
-        else if (arg === "--all") {
-            options.production = false;
-            options.development = false;
+        let negated = false;
+        while (name.toLowerCase().startsWith("no-")) {
+            negated = !negated;
+            name = name.slice(3);
         }
-        else if (arg === "--extract" || arg === "-o" || arg === "--files") {
-            const value = args[index + 1];
-            if (!value || value.startsWith("-"))
-                throw new Error(`${arg} requires a directory`);
-            options.files = path.resolve(value);
-            index += 1;
+        const kind = knownOptions[name];
+        const isBoolean = kind === Boolean;
+        let value;
+        if (isBoolean || negated) {
+            value = !negated;
+            const next = argv[index + 1];
+            if (!hasEquals && (next === "true" || next === "false")) {
+                value = next === "true";
+                index += 1;
+            }
+            if (hasEquals) {
+                value = !(valueFromEquals === "false" ||
+                    valueFromEquals === "0" ||
+                    valueFromEquals === "null");
+            }
+            if (negated && Array.isArray(kind) && kind.includes(null))
+                value = null;
         }
-        else if (arg === "--help" || arg === "-h") {
-            printHelp();
-            process.exit(0);
+        else {
+            const next = hasEquals ? valueFromEquals : argv[index + 1];
+            if (next === undefined || next.startsWith("-")) {
+                value = kind === String ? "" : true;
+            }
+            else {
+                value = next;
+                index += 1;
+            }
+            if (kind === Number && !Number.isNaN(Number(value)))
+                value = Number(value);
+            if (kind === path && value !== true)
+                value = path.resolve(String(value));
+            if (kind === path && value === true)
+                continue;
         }
-        else if (arg.startsWith("-")) {
-            throw new Error(`Unknown option: ${arg}`);
+        if (kind === Number &&
+            typeof value === "string" &&
+            Number.isNaN(Number(value)))
+            continue;
+        parsedArguments[name] = value;
+    }
+    return parsedArguments;
+}
+/**
+ * Converts a value for the "--direct" option into a number.
+ *
+ * The "--direct" option is meant to accept either a Boolean or a Number. Either of those values will then be taken for
+ * determining the depth:
+ * - Passing in no value or leaving the parameter off will be interpreted as Infinity
+ * - Passing in true will be interpreted as Infinity
+ * - Passing in false will be interpreted as 0
+ * - Passing in a number will be interpreted as that number
+ * - Passing in any other value that can't be recognized as a number will be interpreted as Infinity
+ *
+ * @param {boolean | number | string | undefined} value
+ * @returns number
+ */
+function toDepthNumber(value = Number.POSITIVE_INFINITY) {
+    switch (typeof value) {
+        case "string":
+            return depthStringToNumber(value);
+        case "boolean":
+            return value ? Number.POSITIVE_INFINITY : 0;
+        case "number":
+            return Math.max(0, value);
+        default:
+            return Number.POSITIVE_INFINITY;
+    }
+}
+function depthStringToNumber(depthString) {
+    const lowered = depthString.toLowerCase();
+    let numberValue;
+    if (lowered === "true") {
+        numberValue = Number.POSITIVE_INFINITY;
+    }
+    else if (lowered === "false") {
+        numberValue = 0;
+    }
+    else {
+        numberValue = Number.parseInt(lowered, 10);
+        if (Number.isNaN(numberValue)) {
+            numberValue = Number.POSITIVE_INFINITY;
         }
         else {
-            options.start = path.resolve(arg);
+            numberValue = Math.max(0, numberValue);
         }
     }
-    return options;
+    return numberValue;
+}
+/**
+ * @typedef {ParsedArguments & {
+ *   color: boolean,
+ *   direct: number,
+ *   relativeLicensePath: boolean,
+ *   relativeModulePath: boolean,
+ *   start: string,
+ *   depth: number
+ * }} ArgumentsWithDefaults Parsed command-line arguments with defaults applied.
+ */
+/**
+ * Applies default values to parsed command-line arguments.
+ *
+ * @param {ParsedArguments} parsedArguments Parsed command-line arguments.
+ * @returns {ArgumentsWithDefaults} Parsed command-line arguments with defaults applied.
+ */
+export function setDefaultArguments(parsedArguments = {}) {
+    const argumentsWithDefaults = { ...parsedArguments };
+    if (argumentsWithDefaults.color === null ||
+        argumentsWithDefaults.color === undefined) {
+        argumentsWithDefaults.color = supportsBasicColor();
+    }
+    if (argumentsWithDefaults.json ||
+        argumentsWithDefaults.markdown ||
+        argumentsWithDefaults.csv) {
+        argumentsWithDefaults.color = false;
+    }
+    argumentsWithDefaults.start = argumentsWithDefaults.start ?? process.cwd();
+    argumentsWithDefaults.relativeLicensePath = Boolean(argumentsWithDefaults.relativeLicensePath);
+    argumentsWithDefaults.relativeModulePath = Boolean(argumentsWithDefaults.relativeModulePath);
+    // "--depth" should replace "--direct", as it is better understandable:
+    argumentsWithDefaults.direct = toDepthNumber(argumentsWithDefaults.depth ?? argumentsWithDefaults.direct);
+    return argumentsWithDefaults;
 }
-function printHelp() {
-    console.log(`Usage: license-checker [project-directory] [options]
-
-Options:
-  --check               List dependencies with no license metadata or license file
-  --silent, -s          Do not print the license report
-  --extract, --files <dir> Copy license files into <dir>
-  --production, --prod  Scan production dependencies only
-  --development, --dev  Scan development dependencies only
-  --all                 Scan both dependency scopes (default)
-  --help, -h            Show this help`);
+export function getNormalizedArguments(args = process.argv) {
+    return setDefaultArguments(parseArguments(args));
 }

package/dist/cli/preflight.d.ts

@@ -0,0 +1,8 @@
+import type { NormalizedArguments } from "../types.js";
+export declare const exitProcessOrWarnIfNeeded: ({ unknownArgs, parsedArgs, }: {
+    unknownArgs: string[];
+    parsedArgs: NormalizedArguments & {
+        help?: boolean;
+        version?: boolean;
+    };
+}) => void;

package/dist/cli/preflight.js

@@ -0,0 +1,32 @@
+import packageJson from "../../package.json" with { type: "json" };
+import { usageMessage } from "./usage.js";
+const version = packageJson.version;
+export const exitProcessOrWarnIfNeeded = ({ unknownArgs, parsedArgs, }) => {
+    if (unknownArgs.length) {
+        console.error(`license-checker-rseidelsohn@${version}`, "\n");
+        console.error(`Error: Unknown option${unknownArgs.length > 1 ? "s" : ""}: ${unknownArgs
+            .map((unknownArg) => `'${unknownArg}'`)
+            .join(", ")}`);
+        console.error("       Possibly a typo?", "\n");
+        console.error(usageMessage, "\n");
+        process.exit(1);
+    }
+    if (parsedArgs.help) {
+        console.log(`license-checker-rseidelsohn@${version}`);
+        console.log(usageMessage, "\n");
+        process.exit(0);
+    }
+    if (parsedArgs.version) {
+        console.error(version);
+        process.exit(1);
+    }
+    if (parsedArgs.failOn && parsedArgs.onlyAllow) {
+        console.error("Error: --failOn and --onlyAllow can not be used at the same time. Choose one or the other.");
+        process.exit(1);
+    }
+    const hasFailArgs = parsedArgs.failOn ?? parsedArgs.onlyAllow;
+    if (hasFailArgs && hasFailArgs.indexOf(",") >= 0) {
+        const argName = parsedArgs.failOn ? "failOn" : "onlyAllow";
+        console.warn(`Warning: The --${argName} argument takes semicolons as delimeters instead of commas (some license names can contain commas)`);
+    }
+};

package/dist/cli/usage.d.ts

@@ -0,0 +1 @@
+export declare const usageMessage: string;

package/dist/cli/usage.js

@@ -0,0 +1,39 @@
+export const usageMessage = [
+    "All CLI options in alphabetical order:",
+    "",
+    "   --angularCli: is just a synonym for --plainVertical",
+    "   --clarificationsFile [filepath]: A file that describe the license clarifications for each package, see clarificationExample.json, any field available to the customFormat option can be clarified. Can also be used to specify a subregion of a package's license file (instead reading the entire file)",
+    "   --clarificationsMatchAll: fail if any clarification entry was not used",
+    "   --color: colorize terminal tree output",
+    "   --csv: output in csv format",
+    "   --csvComponentPrefix: column prefix for components in csv file",
+    "   --customPath: to add a custom Format file in JSON",
+    '   --depth [number]: look for "number" of levels of dependencies - overrides the ambiguously named "--direct" option',
+    "   --development: only show development dependencies",
+    '   --direct [boolean|number]: look for direct dependencies only if "true" or look for "number" of levels of dependencies',
+    "   --excludeLicenses [list]: exclude modules which licenses are in the comma-separated list from the output",
+    '   --excludePackages [list]: restrict output to the packages (either "package@fullversion" or "package@majorversion" or only "package") NOT in the semicolon-seperated list',
+    "   --excludePackagesStartingWith [list]: excludes packages starting with anything in the semicolon-separated list",
+    "   --excludePrivatePackages: restrict output to not include any package marked as private",
+    "   --failOn [list]: fail (exit with code 1) on the first occurrence of the licenses of the semicolon-separated list",
+    "   --files [path]: copy all license files to path and rename them to `module-name`@`version`-LICENSE.txt",
+    "   --help (-h): The text you are reading right now :)",
+    "   --includeLicenses [list]: restrict output to the packages of which the licenses are included in the comma-separated list from the output",
+    '   --includePackages [list]: restrict output to the packages (either "package@fullversion" or "package@majorversion" or only "package") in the semicolon-seperated list',
+    "   --json: output in json format",
+    "   --limitAttributes [list]: limit the attributes to be output",
+    "   --markdown: output in markdown format",
+    "   --nopeer: skip peer dependencies in output",
+    "   --onlyAllow [list]: fail (exit with code 1) on the first occurrence of the licenses not in the semicolon-seperated list",
+    "   --onlyunknown: only list packages with unknown or guessed licenses",
+    "   --out [filepath]: write the data to a specific file",
+    "   --plainVertical: output in plain vertical format like [Angular CLI does](https://angular.io/3rdpartylicenses.txt)",
+    "   --production: only show production dependencies",
+    "   --relativeLicensePath: output the location of the license files as relative paths",
+    "   --relativeModulePath: output the location of the module files as relative paths",
+    "   --start [filepath]: path of the initial json to look for",
+    "   --summary: output a summary of the license usage",
+    "   --unknown: report guessed licenses as unknown licenses",
+    "   --version (-v): The current version",
+    "",
+].join("\n");

package/dist/cli.js

@@ -1,39 +1,23 @@
 #!/usr/bin/env node
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { getNormalizedArguments } from "./cli/options.js";
+import { getNormalizedArguments, knownOptions } from "./cli/options.js";
+import { exitProcessOrWarnIfNeeded } from "./cli/preflight.js";
 import { runLicenseCheck } from "./index.js";
-async function main() {
-    const options = getNormalizedArguments(process.argv.slice(2));
-    const items = await runLicenseCheck(options);
-    const missing = options.check
-        ? items.filter((item) => item.license.toLowerCase() === "unknown" && item.licenseFiles.length === 0)
-        : [];
-    if (options.check && missing.length > 0)
-        process.exitCode = 1;
-    if (options.silent)
-        return;
-    if (options.check) {
-        if (missing.length > 0) {
-            console.log(`Found ${missing.length} dependencies with missing licenses:\n`);
-            for (const item of missing)
-                console.log(`${item.name}@${item.version}`);
+import { colorizeOutput, getFormattedOutput, shouldColorizeOutput, } from "./output/format-output.js";
+const parsedArgs = getNormalizedArguments();
+const known = Object.keys(knownOptions);
+const unknownArgs = Object.keys(parsedArgs).filter((arg) => !known.includes(arg));
+exitProcessOrWarnIfNeeded({ unknownArgs, parsedArgs });
+try {
+    const foundLicensesJson = await runLicenseCheck(parsedArgs);
+    if (!parsedArgs.out) {
+        if (shouldColorizeOutput(parsedArgs)) {
+            colorizeOutput(foundLicensesJson);
         }
-        else {
-            console.log(`All ${items.length} dependencies have license metadata or license files.`);
-        }
-        return;
+        const formattedOutput = getFormattedOutput(foundLicensesJson, parsedArgs);
+        console.log(formattedOutput);
     }
-    console.log(`Found ${items.length} dependencies:\n`);
-    for (const item of items)
-        console.log(`${item.name}@${item.version}  ${item.license}`);
-    if (options.files)
-        console.log(`\nLicense files copied to ${options.files}`);
 }
-const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : "";
-if (invokedPath === fileURLToPath(import.meta.url)) {
-    main().catch((error) => {
-        console.error(error instanceof Error ? error.message : error);
-        process.exitCode = 1;
-    });
+catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    process.exitCode = 1;
 }

package/dist/dependencies/direct-dependencies.d.ts

@@ -0,0 +1,10 @@
+import type { DependencyPackage, LicenseCheckOptions } from "../types.js";
+/**
+ * This function has a wanted side effect, as it modifies the package tree that is passed by reference.
+ *
+ * The depth attribute set in the options parameter here - which is defined by setting the `--direct` flag - is of
+ * no use with npm < 3, as the older npm versions flattened all dependencies into one single directory. So in
+ * order to make `--direct` work with older versions of npm, we need to filter out all non-dependencies from
+ * the result.
+ */
+export declare function deleteNonDirectDependencies({ _dependencies: directDependencies, dependencies: allDependencies, devDependencies, }: DependencyPackage, options: Pick<LicenseCheckOptions, "production" | "development">): void;

package/dist/dependencies/direct-dependencies.js

@@ -0,0 +1,28 @@
+/**
+ * This function has a wanted side effect, as it modifies the package tree that is passed by reference.
+ *
+ * The depth attribute set in the options parameter here - which is defined by setting the `--direct` flag - is of
+ * no use with npm < 3, as the older npm versions flattened all dependencies into one single directory. So in
+ * order to make `--direct` work with older versions of npm, we need to filter out all non-dependencies from
+ * the result.
+ */
+export function deleteNonDirectDependencies({ _dependencies: directDependencies = {}, dependencies: allDependencies = {}, devDependencies = {}, }, options) {
+    const allDependenciesArray = Object.keys(allDependencies);
+    const directDependenciesArray = Object.keys(directDependencies);
+    const devDependenciesArray = Object.keys(devDependencies);
+    let wantedDependenciesArray = [];
+    if (options.production && !options.development) {
+        wantedDependenciesArray = directDependenciesArray.filter((directDependency) => !devDependenciesArray.includes(directDependency));
+    }
+    else if (!options.production && options.development) {
+        wantedDependenciesArray = devDependenciesArray;
+    }
+    else {
+        wantedDependenciesArray = directDependenciesArray;
+    }
+    allDependenciesArray.forEach((currentDependency) => {
+        if (!wantedDependenciesArray.includes(currentDependency)) {
+            delete allDependencies[currentDependency];
+        }
+    });
+}

package/dist/dependencies/read-installed-packages.d.ts

@@ -1,2 +1,9 @@
-import type { DependencyLicense, DependencyScope } from "../types.js";
-export declare function readInstalledPackages(projectDir: string, scope: Exclude<DependencyScope, "both">): Promise<DependencyLicense[]>;
+import type { DependencyPackage } from "../types.js";
+interface ReadOptions {
+    depth?: number | boolean;
+    dev?: boolean;
+    nopeer?: boolean;
+    log?: (...args: unknown[]) => void;
+}
+declare const readInstalledPackages: (folder: string, options?: ReadOptions) => Promise<DependencyPackage>;
+export default readInstalledPackages;