npm-dependency-tree/dependency-tree.ts

import yargs from "yargs/yargs";
import path from "path";

import { hideBin } from "yargs/helpers";



type FormatValue = "tree" | "csv";
type Format = { header: string, apply: (node: PackageLockTree, parents: string[]) => string }
type FilterValue = "none" | "oracle";

const args = yargs(hideBin(process.argv))
    .option("package", {
        type: "string",
        describe: "The full or relative path to the package.json file",
        require: true
    })
    .option("format", {
        describe: "Possible values are 'tree' and 'csv'",
        default: "tree",
        coerce: (value: FormatValue): Format =>
            value === "tree"
                ? {
                    header: "",
                    apply: (node: PackageLockTree, parents: string[]) =>
                        `${"  ".repeat(parents.length)}${node.value.name}@${node.value.version}${node.value.dev ? " (dev)" : ""}`
                }
                : {
                    header: "name,version,root,parent,type",
                    apply: (node: PackageLockTree, parents: string[]) =>
                        `${node.value.name},${node.value.version},${parents[0] ?? ""},${parents[parents.length - 1] ?? ""},${node.value.dev ? "devDependency" : "dependency"}`
                }
    })
    .option("filter", {
        describe: "Possible values are 'none' and 'oracle'",
        default: "none",
        coerce: (value: FilterValue) =>
            value === "oracle"
                ? (node: PackageLockTree, parents: string[]) => (parents.length === 0 && !node.value.name.startsWith("@os")) || (!node.value.name.startsWith("@o") && parents.length > 1 && parents.every(p => p.startsWith("@os")))
                : (node: PackageLockTree, parents: string[]) => true
    })
    .help()
    .argv;



interface Dictionary<T> {
    [index: string]: T
}

interface Package {
    dependencies: Dictionary<string>;
    devDependencies?: Dictionary<string>;
}

type PackageLockDependencies = Dictionary<{
    version: string;
    dev: boolean;
    requires?: Dictionary<string>;
    dependencies?: PackageLockDependencies;
}>

interface PackageLock {
    dependencies: PackageLockDependencies;
}



type Tree<T> = Leaf<T> | Node<T>;

type Node<T> = {
    type: "node";
    value: T;
    children: Tree<T>[];
}

type Leaf<T> = {
    type: "leaf";
    value: T;
}

type PackageLockTree = Tree<{ name: string, version: string, dev: boolean }>;



const constructDepTree = (packageName: string, context: PackageLockDependencies, stack: string[] = []): PackageLockTree => {
    const dependency = context[packageName];
    const value = { name: packageName, version: dependency.version, dev: dependency.dev };
    if (!dependency.requires) {
        return { type: "leaf", value };
    }
    return {
        type: "node",
        value,
        children: Object.keys(dependency.requires).filter(k => stack.every(s => s !== k))
            .map(requiredDepName => constructDepTree(requiredDepName, { ...context, ...dependency.dependencies }, [...stack, packageName]))
    };
}

const displayDepTree = (format: Format) => {
    console.log(format.header);
    return (filter: (node: PackageLockTree, parents: string[]) => boolean) =>
        (tree: PackageLockTree) => {
            const iter = (tree: PackageLockTree, stack: string[] = []) => {
                if (filter(tree, stack)) {
                    console.log(format.apply(tree, stack));
                }
                if (tree.type === "node") {
                    tree.children.forEach(t => iter(t, [...stack, `${tree.value.name}@${tree.value.version}`]))
                }
            }
            iter(tree);
        };
}



Promise.all<Package, PackageLock>([
    import(args.package),
    import(`${path.dirname(args.package)}/package-lock.json`)
])
    .then(([json, jsonLock]) => {
        const dependencyTree = Object.keys(json.dependencies)
            .concat(Object.keys(json.devDependencies ?? {}))
            .map(depName => constructDepTree(depName, jsonLock.dependencies));
        const display = displayDepTree(args.format)(args.filter);
        dependencyTree.forEach(t => display(t));
    })
    .catch(reson => {
        console.error(reson);
    });