https://docs.rs/canonical-path/latest/canonical_path/

The current codebase does not distinguish canonical paths, which makes refactoring very tedious.

need to port https://github.com/webpack/enhanced-resolve/blob/main/lib/util/path.js#L195

Might be worth adding —

https://github.com/parcel-bundler/parcel/tree/db3bcae10497fa6a712fd9a135f93f26c5745454/packages/utils/node-resolver-core

to the resolver benchmarks — this is implemented in rustland as well so the comparison is more apples to apples.

package.json:

{
    "name": "commonjs",
    "exports": {
        "./a/b/*": "./dist/hello.js",
        "./a/*/c": null
    }
}

output:

thread '' panicked at 'internal error: entered unreachable code', /Users/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/nodejs-resolver-0.0.34/src/map.rs:135:18
note: run with RUST_BACKTRACE=1 environment variable to display a backtrace
fatal runtime error: failed to initiate panic, error 5
[1] 8437 abort node apps/commonjs-app/index.js

enhanced-resolve used by webpack works:

The current code bases does not utilize the fact that, a lot of the paths result unchanged after transformation, which should benefit from Cow<Path>

API: https://webpack.js.org/configuration/resolve/#resolveextensionalias

Requested by:

• web-infra-dev/rspack#2993

Both std::fs::canonicalize and std::fs::metadata are slow syscalls as they need to follow and resolve symlinks.

We can probably avoid a lot of these calls by normalizing and caching as much as possible.

For example, std::fs::metadata is currently being called with such paths:

"/benchcases/three/src/copy1/./math/Color.js"
"/benchcases/three/src/copy1/core/../math/Color.js"
"/benchcases/three/src/copy1/extras/core/../../math/Color.js"
"/benchcases/three/src/copy1/helpers/../math/Color.js"
"/benchcases/three/src/copy1/lights/../math/Color.js"
"/benchcases/three/src/copy1/loaders/../math/Color.js"
"/benchcases/three/src/copy1/materials/../math/Color.js"
"/benchcases/three/src/copy1/renderers/shaders/../../math/Color.js"
"/benchcases/three/src/copy1/renderers/webgl/../../math/Color.js"
"/benchcases/three/src/copy1/scenes/../math/Color.js"

But only 1 call should exist because we can normalize and cache these paths prior to the call.

std::fs::canonicalize will be harder to cache and normalize, but should be doable ;-)

Found via dhat

From web-infra-dev/rspack#2914

[questionAbsolutePath]: path.resolve(__dirname, "./src/question.prod.js"),

It return false for PathBuf::from("/a/b/c") == PathBuf::from("/a/b/../b/c"), we should ensure it return true.

I am working on a bundler which is written using Rust and using nodejs_resolver to resolve dependencies. When running dev, all files will be resolved by nodejs_resolver. During dev, if there is a missing dependency, nodejs_resolver will cache that the dependency is None. When the missing dependency is added and using the original resolver to resolve this dependency, the cache None will return and cannot get the right result.

At first sight, I think there should be a method clear_entry which is single entry version of clear_entries:

    // src/entry.rs
    pub fn delete_cache_entry(&self, path: &Path) {
        self.cache.entries.remove(path);
    }

    // TODO: should put entries as a parament.
    pub fn clear_entries(&self) {
        self.cache.entries.clear();
    }

But, the param path should be a path which has been dealt with be ParsePlugin etc rather than the resolve param request, caller cannot the right path in a direct way.

There is a convenient way to resolve request without cache? If not, is there a proper method nodejs_resolver can provide to do that? If has, I can PR.

• Turn on clippy pedantic and nursery - for better code quality
• Fix the benchmark bot, it's still broken
• Have a clear boundary / api between public and private structs, make all public fields private and add accessors and setters.
• Especially for the return type Info, it should be replaced with a API struct
• Add a NormalizedPath newtype for the return types of normalize.rs trait, to make the code super clear where normalized paths are
• Make tracing an optional dependency?

We currently save all raw values, they become quite large when we get 1000+ dependencies, it's best to remove the raw values and save what is necessary.

The current codebase is pretty hard to navigate due to the mixed style of JavaScript + Rust, I'll refactor this codebase a bit to make it more idiomatic.

Currently, many errors happen during the resolve will yield the absolute path, this is pretty annoying when you want to copy the error message, the user needs to convert it to the relative path by hand.

fs::read_to_string uses another path.metadata() stat call which is not needed.

Reading package.json is currently done inside load_entry, it should be moved to a plugin.

And while we are at it, we should look into reducing stat calls inside this plugin.