[Feature]: support conditionally running loaders based on module contents

[mjames-c]

What problem does this feature solve?

My company, Canva, currently has an expensive Babel loader with many custom Babel plugins. These plugins only need to run against a subset of source code and so we have a quick check on the JS side which acts as a pass through for files which do NOT need to be babel transformed.

Being able to move this check to the Rust side would speed things up as we avoid message passing back and worth between the Rust and JS side.

What does the proposed API of configuration look like?

open to suggestions but something like rules[].contentInclude

type ContentInclude = Array<{
  id: string;
  condition: Condition;
}>

If one or more conditions match the loader is invoked. If a loader is invoked the ids of the matching conditions are passed to it so it can make decisions based on them.

https://rspack.rs/config/module-rules#condition

[hardfist]

@mjames-c Could you share the snippet from your loader so we can better understand your feature request?

[mjames-c]

@hardfist sure thing, here's a pseudo code example:

  const plugins: babel.PluginItem[] = [
    // ...
  ]
    .filter(plugin => plugin.quickTest(content))
    .map(plugin => plugin.createPlugin());

  if (!plugins.length) {
    // do nothing
    callback(null, content, map, extra);
    return;
  }

  // ... do expensive babel parse and transform ...

an example quickTest looks like:

export const myCustomConditionalBabelPlugin = {
  quickTest(src: string) {
    return src.includes('some needle');
  },
  createPlugin(): babel.PluginItem { ... } 
}

No pressure to implement this if you decide it's not worth it, we've been able to build this ourselves by writing our own native loader using Rspack's Rust based api bindings plugin system:

#[cacheable]
#[derive(Debug)]
struct ShouldRun {
    id: String,
    condition: ShouldRunCondition,
}

#[cacheable]
#[derive(Debug)]
enum ShouldRunCondition {
    String(String),
    Regex(RspackRegex),
}

#[cacheable]
#[derive(Debug)]
pub struct CanvaMaybeJsTransformLoader {
    should_run: Vec<ShouldRun>,
    transformer: Arc<JsTransformerLoader>,
    options_fingerprint: u64,
}

impl MaybeJsTransformLoader {
    fn matched_condition_ids<'a>(&'a self, source: &str) -> Vec<&'a str> {
        self.should_run
            .iter()
            .filter(|should_run| should_run.condition.matches(source))
            .map(|should_run| should_run.id.as_str())
            .collect()
    }

    fn run_with_context<Context>(&self, loader_context: &mut LoaderContext<Context>) -> Result<()>
    where
        Context: Send,
        JsTransformerLoader: Loader<Context>,
    {
        let matched_condition_ids = loader_context
            .content()
            .map(|content| self.matched_condition_ids(&String::from_utf8_lossy(content.as_bytes())))
            .unwrap_or_default();

        let loader_result = loader_context.take_all();
        if !matched_condition_ids.is_empty() {
            let loader_index = usize::try_from(loader_context.loader_index)
                .expect("the current loader index should not be negative");
            let transformer: Arc<dyn Loader<Context>> = self.transformer.clone();
            loader_context.loader_items[loader_index] = transformer.into();
            loader_context.loader_items[loader_index].set_data(serde_json::json!({
                "matchedConditionIds": matched_condition_ids,
            }));
        }

        // Preserve source maps and additional loader data both when passing through and while
        // handing execution to the JavaScript transformer.
        loader_context.finish_with(loader_result);
        Ok(())
    }
}