feat(napi): expose cloneWithOptions and clearCache methods (#40)

* feat(napi): expose `cloneWithOptions` and `clearCache` methods

Author: Boshen

napi/Cargo.lock

@@ -19,11 +19,11 @@ export interface NapiResolveOptions {
   tsconfig?: TsconfigOptions
   /**
    * Alias for [ResolveOptions::alias] and [ResolveOptions::fallback].
+   *
    * For the second value of the tuple, `None -> AliasValue::Ignore`, Some(String) ->
    * AliasValue::Path(String)`
    * Create aliases to import or require certain modules more easily.
    * A trailing $ can also be added to the given object's keys to signify an exact match.
-   *
    */
   alias?: Record<string, Array<string | undefined | null>>
   /**
@@ -199,7 +199,11 @@ export interface ResolveResult {
 }
 export function sync(path: string, request: string): ResolveResult
 export class ResolverFactory {
-  constructor(op: NapiResolveOptions)
+  constructor(options: NapiResolveOptions)
   static default(): ResolverFactory
+  /** Clone the resolver using the same underlying cache. */
+  cloneWithOptions(options: NapiResolveOptions): ResolverFactory
+  /** Clear the underlying cache. */
+  clearCache(): void
   sync(path: string, request: string): ResolveResult
 }

napi/index.d.ts

@@ -252,8 +252,8 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { EnforceExtension, ResolverFactory, sync } = nativeBinding
+const { EnforceExtension, sync, ResolverFactory } = nativeBinding
 
 module.exports.EnforceExtension = EnforceExtension
-module.exports.ResolverFactory = ResolverFactory
 module.exports.sync = sync
+module.exports.ResolverFactory = ResolverFactory

napi/index.js

@@ -17,6 +17,24 @@ pub struct ResolveResult {
     pub error: Option<String>,
 }
 
+fn resolve(resolver: &Resolver, path: &Path, request: &str) -> ResolveResult {
+    match resolver.resolve(path, request) {
+        Ok(resolution) => ResolveResult {
+            path: Some(resolution.full_path().to_string_lossy().to_string()),
+            error: None,
+        },
+        Err(err) => ResolveResult { path: None, error: Some(err.to_string()) },
+    }
+}
+
+#[allow(clippy::needless_pass_by_value)]
+#[napi]
+pub fn sync(path: String, request: String) -> ResolveResult {
+    let path = PathBuf::from(path);
+    let resolver = Resolver::new(ResolveOptions::default());
+    resolve(&resolver, &path, &request)
+}
+
 #[napi]
 pub struct ResolverFactory {
     resolver: Resolver,
@@ -25,10 +43,39 @@ pub struct ResolverFactory {
 #[napi]
 impl ResolverFactory {
     #[napi(constructor)]
-    pub fn new(op: NapiResolveOptions) -> Self {
+    pub fn new(options: NapiResolveOptions) -> Self {
+        Self { resolver: Resolver::new(Self::normalize_options(options)) }
+    }
+
+    #[napi]
+    pub fn default() -> Self {
         let default_options = ResolveOptions::default();
+        Self { resolver: Resolver::new(default_options) }
+    }
+
+    /// Clone the resolver using the same underlying cache.
+    #[napi]
+    pub fn clone_with_options(&self, options: NapiResolveOptions) -> Self {
+        Self { resolver: self.resolver.clone_with_options(Self::normalize_options(options)) }
+    }
+
+    /// Clear the underlying cache.
+    #[napi]
+    pub fn clear_cache(&self) {
+        self.resolver.clear_cache();
+    }
+
+    #[allow(clippy::needless_pass_by_value)]
+    #[napi]
+    pub fn sync(&self, path: String, request: String) -> ResolveResult {
+        let path = PathBuf::from(path);
+        resolve(&self.resolver, &path, &request)
+    }
+
+    fn normalize_options(op: NapiResolveOptions) -> ResolveOptions {
+        let default = ResolveOptions::default();
         // merging options
-        let finalize_options = ResolveOptions {
+        ResolveOptions {
             tsconfig: op.tsconfig.map(|tsconfig| tsconfig.into()),
             alias: op
                 .alias
@@ -47,26 +94,26 @@ impl ResolverFactory {
                         })
                         .collect::<Vec<_>>()
                 })
-                .unwrap_or(default_options.alias),
+                .unwrap_or(default.alias),
             alias_fields: op
                 .alias_fields
                 .map(|o| o.into_iter().map(|x| StrOrStrList(x).into()).collect::<Vec<_>>())
-                .unwrap_or(default_options.alias_fields),
-            condition_names: op.condition_names.unwrap_or(default_options.condition_names),
-            description_files: op.description_files.unwrap_or(default_options.description_files),
+                .unwrap_or(default.alias_fields),
+            condition_names: op.condition_names.unwrap_or(default.condition_names),
+            description_files: op.description_files.unwrap_or(default.description_files),
             enforce_extension: op
                 .enforce_extension
                 .map(|enforce_extension| enforce_extension.into())
-                .unwrap_or(default_options.enforce_extension),
+                .unwrap_or(default.enforce_extension),
             exports_fields: op
                 .exports_fields
                 .map(|o| o.into_iter().map(|x| StrOrStrList(x).into()).collect::<Vec<_>>())
-                .unwrap_or(default_options.exports_fields),
+                .unwrap_or(default.exports_fields),
             extension_alias: op
                 .extension_alias
                 .map(|extension_alias| extension_alias.into_iter().collect::<Vec<_>>())
-                .unwrap_or(default_options.extension_alias),
-            extensions: op.extensions.unwrap_or(default_options.extensions),
+                .unwrap_or(default.extension_alias),
+            extensions: op.extensions.unwrap_or(default.extensions),
             fallback: op
                 .fallback
                 .map(|fallback| {
@@ -84,17 +131,17 @@ impl ResolverFactory {
                         })
                         .collect::<Vec<_>>()
                 })
-                .unwrap_or(default_options.fallback),
-            fully_specified: op.fully_specified.unwrap_or(default_options.fully_specified),
+                .unwrap_or(default.fallback),
+            fully_specified: op.fully_specified.unwrap_or(default.fully_specified),
             main_fields: op
                 .main_fields
                 .map(|o| StrOrStrList(o).into())
-                .unwrap_or(default_options.main_fields),
-            main_files: op.main_files.unwrap_or(default_options.main_files),
-            modules: op.modules.map(|o| StrOrStrList(o).into()).unwrap_or(default_options.modules),
-            resolve_to_context: op.resolve_to_context.unwrap_or(default_options.resolve_to_context),
-            prefer_relative: op.prefer_relative.unwrap_or(default_options.prefer_relative),
-            prefer_absolute: op.prefer_absolute.unwrap_or(default_options.prefer_absolute),
+                .unwrap_or(default.main_fields),
+            main_files: op.main_files.unwrap_or(default.main_files),
+            modules: op.modules.map(|o| StrOrStrList(o).into()).unwrap_or(default.modules),
+            resolve_to_context: op.resolve_to_context.unwrap_or(default.resolve_to_context),
+            prefer_relative: op.prefer_relative.unwrap_or(default.prefer_relative),
+            prefer_absolute: op.prefer_absolute.unwrap_or(default.prefer_absolute),
             restrictions: op
                 .restrictions
                 .map(|restrictions| {
@@ -103,44 +150,13 @@ impl ResolverFactory {
                         .map(|restriction| restriction.into())
                         .collect::<Vec<_>>()
                 })
-                .unwrap_or(default_options.restrictions),
+                .unwrap_or(default.restrictions),
             roots: op
                 .roots
                 .map(|roots| roots.into_iter().map(PathBuf::from).collect::<Vec<_>>())
-                .unwrap_or(default_options.roots),
-            symlinks: op.symlinks.unwrap_or(default_options.symlinks),
-            builtin_modules: op.builtin_modules.unwrap_or(default_options.builtin_modules),
-        };
-        Self { resolver: Resolver::new(finalize_options) }
-    }
-    #[napi]
-    pub fn default() -> Self {
-        let default_options = ResolveOptions::default();
-        Self { resolver: Resolver::new(default_options) }
-    }
-
-    #[allow(clippy::needless_pass_by_value)]
-    #[napi]
-    pub fn sync(&self, path: String, request: String) -> ResolveResult {
-        let path = PathBuf::from(path);
-        resolve(&self.resolver, &path, &request)
-    }
-}
-
-fn resolve(resolver: &Resolver, path: &Path, request: &str) -> ResolveResult {
-    match resolver.resolve(path, request) {
-        Ok(resolution) => ResolveResult {
-            path: Some(resolution.full_path().to_string_lossy().to_string()),
-            error: None,
-        },
-        Err(err) => ResolveResult { path: None, error: Some(err.to_string()) },
+                .unwrap_or(default.roots),
+            symlinks: op.symlinks.unwrap_or(default.symlinks),
+            builtin_modules: op.builtin_modules.unwrap_or(default.builtin_modules),
+        }
     }
 }
-
-#[allow(clippy::needless_pass_by_value)]
-#[napi]
-pub fn sync(path: String, request: String) -> ResolveResult {
-    let path = PathBuf::from(path);
-    let resolver = Resolver::new(ResolveOptions::default());
-    resolve(&resolver, &path, &request)
-}

napi/src/lib.rs

@@ -15,6 +15,9 @@ assert.deepStrictEqual(resolver.sync(cwd, "./index.js").path, path.join(cwd, 'in
 
 assert.strict(resolver.sync(cwd, "./ts").error.length > 0);
 
+const newResolver = resolver.cloneWithOptions({});
+newResolver.clearCache();
+
 
 // custom constructor
 const resolver2 = new ResolverFactory(

napi/test.mjs

@@ -147,6 +147,7 @@ impl<Fs: FileSystem + Default> ResolverGeneric<Fs> {
         Self { cache: Arc::new(Cache::new(file_system)), ..Self::new(options) }
     }
 
+    /// Clone the resolver using the same underlying cache.
     #[must_use]
     pub fn clone_with_options(&self, options: ResolveOptions) -> Self {
         Self { options: options.sanitize(), cache: Arc::clone(&self.cache) }