resolve-everything 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License Copyright (c) 2023 Lily Skye
+
+Permission is hereby granted, free of
+charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice
+(including the next paragraph) shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+# resolve-everything
+
+`resolve-everything` is a tool which walks through the module dependency tree of a JavaScript/TypeScript project and gives you data about all the relationships.
+
+## Usage
+
+### Command-Line Interface (CLI)
+
+```sh
+$ npx resolve-everything --entrypoint ./some-file.js
+```
+
+which outputs JSON shaped like:
+
+```jsonc
+{
+  "<full-path-to-some-file.js>": {
+    "id": "<full-path-to-some-file.js>",
+    "requests": {
+      // key is "require/import string that appeared in the source code"
+      // value is "full path to the file that refers to"
+      "./something": "<full-path-to-something>",
+      "react": "<full-path-to-react>",
+      "../somewhere/yeah": "<full-path-to-yeah>",
+    },
+    "dependencies": [
+      "<full-path-to-something>",
+      "<full-path-to-react>",
+      "<full-path-to-yeah>",
+    ]
+  },
+  "<full-path-to-something>": { ... },
+  "<full-path-to-yeah>": { ... },
+  ...
+}
+```
+
+#### Options:
+
+- `--entrypoint` (path): The place to start walking the module graph. This is the only required option.
+
+- `--skip` (RegExp|"none"): Which files not to parse and find requires/imports in. Defaults to `/node_modules/`. Specify "none" to parse everything.
+
+- `--json` (boolean): whether to output json or human-readable data. default value varies depending on if stdout is a tty.
+
+- `--only-entrypoint` (boolean): if true, only the imports/requires in the entrypoint file will be resolved, and no other files will be walked over.
+
+- `--resolver` (path): module which exports a JS function that locates modules. Uses the same resolver format as [kame](https://github.com/suchipi/kame#config-hell).
+
+- `--full-errors` (boolean): If reading, parsing, traversal, or resolution errors occur, print as much error information as possible.
+
+### Node API
+
+```ts
+import { walk } from "resolve-everything";
+
+const entrypoint = "/home/someone/some-file.js";
+const { errors, modules } = walk(entrypoint /* , options */);
+
+// modules is a Map<string, { id: string, requests: Map<string, string> }>
+```
+
+#### Options
+
+```ts
+export type WalkOptions = {
+  /**
+   * Which files not to parse and find requires/imports in.
+   *
+   * Defaults to `/node_modules/`.
+   * Specify `null` to include node_modules.
+   */
+  skip?: RegExp | null;
+
+  /**
+   * If true, only the imports/requires in the entrypoint file will be
+   * resolved, and no other files will be walked over.
+   */
+  onlyEntrypoint?: boolean;
+
+  /**
+   * A function which translates the string-part of an import/require into the
+   * absolute path to the file on disk, OR, if there is no file for that module
+   * (ie. it's a node builtin), a string starting with "external:".
+   */
+  resolver?: (id: string, fromFilePath: string) => string;
+};
+```
+
+See the included TypeScript types for more information.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_util_1 = __importDefault(require("node:util"));
+const clefairy_1 = require("clefairy");
+const _1 = require(".");
+(0, clefairy_1.run)({
+    entrypoint: clefairy_1.optionalPath,
+    resolver: clefairy_1.optionalPath,
+    fullErrors: clefairy_1.optionalBoolean,
+    skip: clefairy_1.optionalString,
+    json: clefairy_1.optionalBoolean,
+    onlyEntrypoint: clefairy_1.optionalBoolean,
+    help: clefairy_1.optionalBoolean,
+    h: clefairy_1.optionalBoolean,
+}, async ({ entrypoint, resolver, fullErrors, skip, json, onlyEntrypoint, help, h, }) => {
+    if (help || h) {
+        const helpText = require("./help-text").default;
+        console.log(helpText);
+        return;
+    }
+    if (entrypoint == null) {
+        throw new Error(`You must specify an --entrypoint. Run with --help for more info.`);
+    }
+    if (!node_fs_1.default.existsSync(entrypoint)) {
+        throw new Error("No such file: " + entrypoint);
+    }
+    const walkOptions = {
+        onError: (err) => {
+            if (!fullErrors && /node_modules/.test(err.filename || "")) {
+                // Don't report resolution errors under node_modules dirs because
+                // they're usually not actionable.
+                return;
+            }
+            let message = `Failed to ${err.stage} `;
+            if (err.request) {
+                message += JSON.stringify(err.request) + " ";
+            }
+            message += `for ${JSON.stringify(err.filename)}`;
+            console.warn(message);
+            if (fullErrors) {
+                console.error(err.error);
+            }
+        },
+    };
+    if (skip) {
+        if (skip === "none") {
+            walkOptions.skip = null;
+        }
+        else {
+            const mightBeRegExpLiteral = /^\/.*\/[gimsuy]?$/.test(skip);
+            if (mightBeRegExpLiteral) {
+                try {
+                    walkOptions.skip = eval(skip);
+                }
+                catch (err) {
+                    walkOptions.skip = new RegExp(skip, "gu");
+                }
+            }
+            else {
+                walkOptions.skip = new RegExp(skip, "gu");
+            }
+        }
+    }
+    if (resolver) {
+        const exps = require(resolver);
+        if (typeof exps === "function") {
+            walkOptions.resolver = exps;
+        }
+        else if (typeof exps === "object" && exps != null) {
+            if (typeof exps.resolve === "function") {
+                walkOptions.resolver = exps.resolve;
+            }
+            else if (typeof exps.default === "function") {
+                walkOptions.resolver = exps.default;
+            }
+            else {
+                throw new Error(`Resolver at ${JSON.stringify(resolver)} didn't export a 'resolve' function.`);
+            }
+        }
+        else {
+            throw new Error(`Resolver at ${JSON.stringify(resolver)} didn't export a 'resolve' function.`);
+        }
+    }
+    const result = (0, _1.walk)(entrypoint, walkOptions);
+    let toPrint = (0, _1.serialize)(result.modules);
+    if (onlyEntrypoint) {
+        toPrint = toPrint[entrypoint];
+    }
+    if (json === undefined && !process.stdout.isTTY) {
+        json = true;
+    }
+    if (json) {
+        console.log(JSON.stringify(toPrint, null, 2));
+    }
+    else {
+        console.log(node_util_1.default.inspect(toPrint, { depth: 4, colors: true }));
+    }
+});

package/dist/debug-logger.d.ts

@@ -0,0 +1,9 @@
+import makeDebug from "debug";
+export declare const debugLogger: {
+    summary: makeDebug.Debugger;
+    fileContent: makeDebug.Debugger;
+    ast: makeDebug.Debugger;
+    traverse: makeDebug.Debugger;
+    args: makeDebug.Debugger;
+    returns: makeDebug.Debugger;
+};

package/dist/debug-logger.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugLogger = void 0;
+const debug_1 = __importDefault(require("debug"));
+exports.debugLogger = {
+    summary: (0, debug_1.default)("resolve-everything:summary"),
+    fileContent: (0, debug_1.default)("resolve-everything:noisy:file-content"),
+    ast: (0, debug_1.default)("resolve-everything:noisy:ast"),
+    traverse: (0, debug_1.default)("resolve-everything:noisy:traverse"),
+    args: (0, debug_1.default)("resolve-everything:noisy:args"),
+    returns: (0, debug_1.default)("resolve-everything:noisy:returns"),
+};

package/dist/default-resolver.d.ts

@@ -0,0 +1 @@
+export declare function defaultResolver(id: string, fromFilePath: string): string;

package/dist/default-resolver.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultResolver = void 0;
+const node_module_1 = __importDefault(require("node:module"));
+const node_path_1 = __importDefault(require("node:path"));
+const resolve_1 = __importDefault(require("resolve"));
+if (!Array.isArray(node_module_1.default.builtinModules)) {
+    throw new Error("your node version seriously way too old bruh");
+}
+const allBuiltins = new Set(node_module_1.default.builtinModules);
+// This is (more or less) a direct copy-paste of kame's default resolver.
+// We copy-paste instead of depending on it directly, though, because kame has a LOT of deps and we just need this piece
+//
+// // https://github.com/suchipi/kame/blob/ae317caf325d5cbe4925fe30273159b6c04651a6/src/default-resolver.ts#L10
+function defaultResolver(id, fromFilePath) {
+    if (id.includes(":") && !id.startsWith("file:")) {
+        return "external:" + id;
+    }
+    if (allBuiltins.has(id.split("/")[0])) {
+        return "external:" + id;
+    }
+    const result = resolve_1.default.sync(id, {
+        basedir: node_path_1.default.dirname(fromFilePath),
+        preserveSymlinks: false,
+        extensions: [
+            ".js",
+            ".json",
+            ".mjs",
+            ".jsx",
+            ".ts",
+            ".tsx",
+            ".node",
+            ".wasm",
+        ],
+    });
+    if (result.endsWith(".node") || result.endsWith(".wasm")) {
+        return "external:" + result;
+    }
+    return result;
+}
+exports.defaultResolver = defaultResolver;

package/dist/help-text.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/dist/help-text.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const kleur_1 = __importDefault(require("kleur"));
+const h1 = kleur_1.default.bgBlue;
+const h2 = kleur_1.default.blue().bold;
+const opt = kleur_1.default.green;
+const jsonSample = `{
+  "<full-path-to-some-file.js>": {
+    "id": "<full-path-to-some-file.js>",
+    "requests": {
+      // key is require/import string that appeared in the source code
+      // value is full path to the file that refers to
+      "./something": "<full-path-to-something>",
+      "react": "<full-path-to-react>",
+      "../somewhere/yeah": "<full-path-to-yeah>",
+    },
+    "dependencies": [
+      "<full-path-to-something>",
+      "<full-path-to-react>",
+      "<full-path-to-yeah>",
+    ]
+  },
+  "<full-path-to-something>": { ... },
+  "<full-path-to-yeah>": { ... },
+  ...
+}`
+    .replaceAll(/\[\]\{\}/g, (str) => kleur_1.default.bold(str))
+    .replaceAll(/<[^>]+>/g, (str) => kleur_1.default.magenta(str))
+    .replaceAll(/"([^"]+)"/g, (str, contents) => kleur_1.default.green(`"` + kleur_1.default.bold(contents) + `"`))
+    .replaceAll(/\/\/.*\n/g, (str) => kleur_1.default.dim(str))
+    .replaceAll("...", kleur_1.default.dim("..."));
+exports.default = `
+${h1("# resolve-everything")}
+
+resolve-everything is a tool which walks through the module dependency tree of
+a JavaScript/TypeScript project and gives you data about all the relationships.
+
+${h2("## Usage")}
+
+$ resolve-everything --entrypoint ./some-file.js
+
+${h2("## Options")}
+
+${opt("--entrypoint")} (path):
+  The place to start walking the module graph.
+  This is the only required option.
+
+${opt("--skip")} (RegExp|"none"):
+  Which files not to parse and find requires/imports in.
+  Defaults to /node_modules/. Specify "none" to parse everything.
+
+${opt("--json")} (boolean):
+  Whether to output json or human-readable data.
+  Default value varies depending on if stdout is a tty.
+
+${opt("--only-entrypoint")} (boolean):
+  If true, only the imports/requires in the entrypoint file will be resolved,
+  and no other files will be walked over.
+
+${opt("--resolver")} (path):
+  Module which exports a JS function that locates modules. Uses the same
+  resolver format as https://github.com/suchipi/kame, namely:
+
+  export function resolve(id: string, fromFilePath: string): string;
+
+${opt("--full-errors")} (boolean):
+  If reading, parsing, traversal, or resolution errors occur, print as much
+  error information as possible.
+
+${h2("## Output")}
+
+The program prints JSON shaped like:
+
+${jsonSample}
+
+${kleur_1.default.bold("resolve-everything")} was made with ${kleur_1.default.red("<3")} by Lily Skye. Though it likely can't resolve
+*${kleur_1.default.italic("all")}* of your problems, maybe it can resolve one of them.
+`.trim();

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { walk, type WalkOptions } from "./walk";
+export type { ErrorReport as ReportedError, ResolverFunction } from "./types";
+export { defaultResolver } from "./default-resolver";
+export { Walker, type WalkerOptions } from "./walker";
+export { Module } from "./module";
+export { serialize, type SerializedModules as SerializeResult, } from "./serialize";

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialize = exports.Module = exports.Walker = exports.defaultResolver = exports.walk = void 0;
+var walk_1 = require("./walk");
+Object.defineProperty(exports, "walk", { enumerable: true, get: function () { return walk_1.walk; } });
+var default_resolver_1 = require("./default-resolver");
+Object.defineProperty(exports, "defaultResolver", { enumerable: true, get: function () { return default_resolver_1.defaultResolver; } });
+var walker_1 = require("./walker");
+Object.defineProperty(exports, "Walker", { enumerable: true, get: function () { return walker_1.Walker; } });
+var module_1 = require("./module");
+Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return module_1.Module; } });
+var serialize_1 = require("./serialize");
+Object.defineProperty(exports, "serialize", { enumerable: true, get: function () { return serialize_1.serialize; } });

package/dist/module.d.ts

@@ -0,0 +1,11 @@
+import * as ee from "equivalent-exchange";
+import type { ResolverFunction } from "./types";
+export declare class Module {
+    id: string;
+    requests: Map<string, string>;
+    constructor(id: string);
+    read(): string | null;
+    parse(code: string): ee.types.File;
+    getRequests(ast: ee.types.File): Array<string>;
+    resolve(request: string, resolver: ResolverFunction): string;
+}

package/dist/module.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const fs = __importStar(require("node:fs"));
+const ee = __importStar(require("equivalent-exchange"));
+const debug_logger_1 = require("./debug-logger");
+let formatAst;
+if (debug_logger_1.debugLogger.ast.enabled) {
+    formatAst = require("pretty-print-ast");
+}
+else {
+    formatAst = () => "";
+}
+class Module {
+    constructor(id) {
+        this.requests = new Map();
+        this.id = id;
+    }
+    read() {
+        debug_logger_1.debugLogger.summary("Module.read", this.id);
+        if (!/\.[cm]?[tj]sx?$/.test(this.id)) {
+            debug_logger_1.debugLogger.summary("doesn't appear to be js/ts:", this.id);
+            debug_logger_1.debugLogger.returns("Module.read -> null");
+            return null;
+        }
+        const code = fs.readFileSync(this.id, "utf-8");
+        debug_logger_1.debugLogger.fileContent(code);
+        debug_logger_1.debugLogger.returns("Module.read ->", code);
+        return code;
+    }
+    parse(code) {
+        debug_logger_1.debugLogger.summary("Module.parse", this.id);
+        debug_logger_1.debugLogger.args("Module.parse", code);
+        const ast = ee.codeToAst(code, { fileName: this.id });
+        debug_logger_1.debugLogger.ast(formatAst(ast, { color: true }));
+        debug_logger_1.debugLogger.returns("Module.parse ->", ast);
+        return ast;
+    }
+    getRequests(ast) {
+        debug_logger_1.debugLogger.summary("Module.getRequests", this.id);
+        debug_logger_1.debugLogger.args("Module.getRequests", ast);
+        const requests = [];
+        ee.traverse(ast, {
+            ImportDeclaration(nodePath) {
+                debug_logger_1.debugLogger.traverse("found ImportDeclaration", nodePath.node);
+                requests.push(nodePath.node.source.value);
+            },
+            ExportAllDeclaration(nodePath) {
+                debug_logger_1.debugLogger.traverse("found ExportAllDeclaration", nodePath.node);
+                requests.push(nodePath.node.source.value);
+            },
+            ExportNamedDeclaration(nodePath) {
+                debug_logger_1.debugLogger.traverse("found ExportNamedDeclaration", nodePath.node);
+                const source = nodePath.node.source;
+                if (source != null) {
+                    debug_logger_1.debugLogger.traverse("previously-mentioned ExportNamedDeclaration had a source!");
+                    requests.push(source.value);
+                }
+            },
+            CallExpression(nodePath) {
+                const node = nodePath.node;
+                if (ee.hasShape(node, {
+                    callee: {
+                        type: "Identifier",
+                        name: "require",
+                    },
+                    arguments: {
+                        0: {
+                            type: "StringLiteral",
+                        },
+                    },
+                })) {
+                    debug_logger_1.debugLogger.traverse("found require", node);
+                    requests.push(node.arguments[0].value);
+                }
+                if (ee.hasShape(node, {
+                    callee: {
+                        type: "Import",
+                    },
+                    arguments: {
+                        0: {
+                            type: "StringLiteral",
+                        },
+                    },
+                })) {
+                    debug_logger_1.debugLogger.traverse("found dynamic import", node);
+                    requests.push(node.arguments[0].value);
+                }
+            },
+        });
+        debug_logger_1.debugLogger.returns("Module.getRequests ->", requests);
+        return requests;
+    }
+    resolve(request, resolver) {
+        debug_logger_1.debugLogger.summary("Module.resolve", this.id, request);
+        debug_logger_1.debugLogger.args("Module.resolve", request, resolver);
+        const resolved = resolver(request, this.id);
+        this.requests.set(request, resolved);
+        debug_logger_1.debugLogger.returns("Module.resolve ->", resolved);
+        return resolved;
+    }
+}
+exports.Module = Module;

package/dist/serialize.d.ts

@@ -0,0 +1,11 @@
+import type { Module } from "./module";
+export type SerializedModules = {
+    [filename: string]: {
+        id: string;
+        requests: {
+            [request: string]: string;
+        };
+        dependencies: Array<string>;
+    };
+};
+export declare function serialize(modules: Map<string, Module>): SerializedModules;

package/dist/serialize.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialize = void 0;
+function serialize(modules) {
+    const result = {};
+    for (const [id, mod] of modules) {
+        result[id] = {
+            id,
+            requests: {},
+            dependencies: [],
+        };
+        for (const [request, resolved] of mod.requests) {
+            result[id].requests[request] = resolved;
+            result[id].dependencies.push(resolved);
+        }
+    }
+    return result;
+}
+exports.serialize = serialize;

package/dist/test-helpers.d.ts

@@ -0,0 +1,6 @@
+import type { RunContext } from "first-base";
+export declare const rootDir: import("path-less-traveled").PathMarker;
+export declare const cliPath: string;
+export declare function cleanString(str: string): string;
+export declare function inspectAndClean(value: any): string;
+export declare function cleanRunResult(result: RunContext["result"]): RunContext["result"];

package/dist/test-helpers.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanRunResult = exports.inspectAndClean = exports.cleanString = exports.cliPath = exports.rootDir = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = __importDefault(require("node:util"));
+const path_less_traveled_1 = require("path-less-traveled");
+exports.rootDir = (0, path_less_traveled_1.pathMarker)(node_path_1.default.resolve(__dirname, ".."));
+exports.cliPath = (0, exports.rootDir)("dist/cli.js");
+function cleanString(str) {
+    return str.replaceAll((0, exports.rootDir)(), "<rootDir>");
+}
+exports.cleanString = cleanString;
+function inspectAndClean(value) {
+    return cleanString(node_util_1.default.inspect(value, { depth: Infinity }));
+}
+exports.inspectAndClean = inspectAndClean;
+function cleanRunResult(result) {
+    return {
+        ...result,
+        stdout: cleanString(result.stdout),
+        stderr: cleanString(result.stderr),
+    };
+}
+exports.cleanRunResult = cleanRunResult;

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+export type ErrorReport = {
+    filename?: string;
+    request?: string;
+    stage: "read" | "parse" | "getRequests" | "resolve";
+    error: Error;
+};
+export type ResolverFunction = (id: string, fromFilePath: string) => string;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/walk.d.ts

@@ -0,0 +1,12 @@
+import type { Module } from "./module";
+import type { ErrorReport, ResolverFunction } from "./types";
+export type WalkOptions = {
+    onError?: (error: ErrorReport) => void;
+    resolver?: ResolverFunction;
+    skip?: RegExp | null;
+    onlyEntrypoint?: boolean;
+};
+export declare function walk(entrypoint: string, options?: WalkOptions): {
+    errors: ErrorReport[];
+    modules: Map<string, Module>;
+};

package/dist/walk.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walk = void 0;
+const path = __importStar(require("node:path"));
+const walker_1 = require("./walker");
+const debug_logger_1 = require("./debug-logger");
+const default_resolver_1 = require("./default-resolver");
+function walk(entrypoint, options) {
+    debug_logger_1.debugLogger.summary("walk", entrypoint);
+    debug_logger_1.debugLogger.args("walk", entrypoint, options);
+    if (!path.isAbsolute(entrypoint)) {
+        throw new Error(`entrypoint must be an absolute path. received: ${entrypoint}`);
+    }
+    const resolver = options?.resolver ?? default_resolver_1.defaultResolver;
+    const skip = typeof options?.skip === "undefined" ? /node_modules/ : options?.skip;
+    const onlyEntrypoint = options?.onlyEntrypoint ?? false;
+    const walker = new walker_1.Walker(entrypoint, {
+        resolver,
+        skip,
+        onlyEntrypoint,
+    });
+    if (options?.onError) {
+        walker.on("error", options.onError);
+    }
+    const { errors } = walker.walk();
+    const modules = walker.modules;
+    const ret = {
+        errors,
+        modules,
+    };
+    debug_logger_1.debugLogger.returns("walk ->", ret);
+    return ret;
+}
+exports.walk = walk;

package/dist/walker.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { EventEmitter } from "node:events";
+import { Module } from "./module";
+import type { ErrorReport, ResolverFunction } from "./types";
+export type WalkerOptions = {
+    resolver: ResolverFunction;
+    skip: RegExp | null;
+    onlyEntrypoint: boolean;
+};
+export declare class Walker extends EventEmitter {
+    entrypoint: string;
+    modules: Map<string, Module>;
+    private _options;
+    constructor(entrypoint: string, options: WalkerOptions);
+    walk(): {
+        errors: Array<ErrorReport>;
+    };
+}

package/dist/walker.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Walker = void 0;
+const path = __importStar(require("node:path"));
+const node_events_1 = require("node:events");
+const module_1 = require("./module");
+const debug_logger_1 = require("./debug-logger");
+class Walker extends node_events_1.EventEmitter {
+    constructor(entrypoint, options) {
+        super();
+        this._options = options;
+        if (!path.isAbsolute(entrypoint)) {
+            throw Object.assign(new Error(`Entrypoint must be an absolute path. received: ${entrypoint}`), { entrypoint });
+        }
+        this.entrypoint = entrypoint;
+        this.modules = new Map();
+    }
+    walk() {
+        debug_logger_1.debugLogger.summary("Walker.walk");
+        const filesToProcess = [this.entrypoint];
+        let filename;
+        const errors = [];
+        let errorStage = "read";
+        let errorRequest = undefined;
+        const reportError = (error) => {
+            const report = {
+                filename,
+                stage: errorStage,
+                request: errorRequest,
+                error,
+            };
+            debug_logger_1.debugLogger.summary("error reported:", report);
+            this.emit("error", report);
+            errors.push(report);
+        };
+        while ((filename = filesToProcess.shift())) {
+            debug_logger_1.debugLogger.summary("Walker.walk -> processing", filename);
+            this.emit("processing", filename);
+            if (this.modules.has(filename)) {
+                // already processed
+                continue;
+            }
+            const mod = new module_1.Module(filename);
+            this.modules.set(filename, mod);
+            try {
+                const code = mod.read();
+                if (code == null) {
+                    // not a js/ts file
+                    continue;
+                }
+                errorStage = "parse";
+                const ast = mod.parse(code);
+                errorStage = "getRequests";
+                const requests = mod.getRequests(ast);
+                errorStage = "resolve";
+                errorRequest = undefined;
+                for (const request of requests) {
+                    errorRequest = request;
+                    try {
+                        const target = mod.resolve(request, this._options.resolver);
+                        if (target.startsWith("external:")) {
+                            continue;
+                        }
+                        if (this._options.skip != null && this._options.skip.test(target)) {
+                            continue;
+                        }
+                        if (!this.modules.has(target)) {
+                            debug_logger_1.debugLogger.summary("Walker.walk -> queueing", target);
+                            this.emit("queueing", target);
+                            filesToProcess.push(target);
+                        }
+                    }
+                    catch (error) {
+                        reportError(error);
+                    }
+                }
+                errorRequest = undefined;
+            }
+            catch (error) {
+                reportError(error);
+            }
+            if (this._options.onlyEntrypoint) {
+                break;
+            }
+        }
+        const ret = { errors };
+        debug_logger_1.debugLogger.returns("Walker.walk ->", ret);
+        return ret;
+    }
+}
+exports.Walker = Walker;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "resolve-everything",
+  "version": "0.1.0",
+  "description": "walk your project's import/require tree and print all the relationships",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "resolve-everything": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "rm -rf dist && bunx --bun tsc && chmod +x dist/cli.js",
+    "test": "vitest",
+    "cli": "bun src/cli.ts"
+  },
+  "keywords": [],
+  "author": "Lily Skye <me@suchipi.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/debug": "^4.1.10",
+    "@types/resolve": "^1.20.4",
+    "path-less-traveled": "^2.0.0",
+    "prettier": "^3.0.3",
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.6"
+  },
+  "prettier": {},
+  "dependencies": {
+    "clefairy": "^0.4.0",
+    "debug": "^4.3.4",
+    "equivalent-exchange": "^1.10.0",
+    "first-base": "^1.3.0",
+    "kleur": "^4.1.5",
+    "pretty-print-ast": "^1.0.1",
+    "resolve": "^1.22.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/suchipi/resolve-everything.git"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "include": ["./src/**/*.ts"],
+
+  "compilerOptions": {
+    "lib": ["es2021"],
+    "target": "es2020",
+    "module": "CommonJS",
+    "outDir": "./dist",
+    "declaration": true,
+    "skipLibCheck": true,
+
+    "strict": true,
+    "noImplicitAny": false,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "downlevelIteration": false,
+
+    "moduleResolution": "node",
+    "esModuleInterop": true
+  }
+}