Expand plugin traits and plugin config (#9744)

* Expand plugin traits and plugin config

* Use trait objects

* Use Rc

crates/parcel_core/Cargo.toml

@@ -8,6 +8,7 @@ description = "Core logic for the parcel bundler"
 default = []
 
 [dependencies]
+parcel_filesystem = { path = "../parcel_filesystem" }
 parcel-resolver = { path = "../../packages/utils/node-resolver-rs" }
 
 ahash = "0.8.11"

crates/parcel_core/src/bundle_graph.rs

@@ -0,0 +1 @@
+pub struct BundleGraph {}

crates/parcel_core/src/lib.rs

@@ -1,6 +1,7 @@
 #![deny(unused_crate_dependencies)]
 //! Core re-implementation in Rust
 
+pub mod bundle_graph;
 pub mod hash;
 pub mod plugin;
 pub mod request_tracker;

crates/parcel_core/src/plugin.rs

@@ -1,4 +1,5 @@
 mod bundler;
+
 pub use bundler::*;
 
 mod compressor;
@@ -13,6 +14,9 @@ pub use optimizer::*;
 mod packager;
 pub use packager::*;
 
+mod plugin_config;
+pub use plugin_config::*;
+
 mod reporter;
 pub use reporter::*;
 
@@ -28,11 +32,14 @@ pub use transformer::*;
 mod validator;
 pub use validator::*;
 
+#[derive(Default)]
 pub struct PluginContext {
  pub options: PluginOptions,
  pub logger: PluginLogger,
 }
 
+#[derive(Default)]
 pub struct PluginLogger {}
 
+#[derive(Default)]
 pub struct PluginOptions {}

crates/parcel_core/src/plugin/bundler.rs

@@ -1,8 +1,49 @@
+use super::PluginConfig;
+use crate::bundle_graph::BundleGraph;
+
 /// Converts an asset graph into a BundleGraph
 ///
 /// Bundlers accept the entire asset graph and modify it to add bundle nodes that group the assets
 /// into output bundles.
 ///
 /// Bundle and optimize run in series and are functionally identitical.
 ///
-pub trait BundlerPlugin {}
+pub trait BundlerPlugin {
+ /// A hook designed to load config necessary for the bundler to operate
+ ///
+ /// This function will run once, shortly after the plugin is initialised.
+ ///
+ fn load_config(&mut self, config: &PluginConfig) -> Result<(), anyhow::Error>;
+
+ // TODO: Should BundleGraph be AssetGraph or something that contains AssetGraph in the name?
+ fn bundle(&self, bundle_graph: &mut BundleGraph) -> Result<(), anyhow::Error>;
+
+ fn optimize(&self, bundle_graph: &mut BundleGraph) -> Result<(), anyhow::Error>;
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[derive(Debug)]
+ struct TestBundlerPlugin {}
+
+ impl BundlerPlugin for TestBundlerPlugin {
+ fn load_config(&mut self, _config: &PluginConfig) -> Result<(), anyhow::Error> {
+ todo!()
+ }
+
+ fn bundle(&self, _bundle_graph: &mut BundleGraph) -> Result<(), anyhow::Error> {
+ todo!()
+ }
+
+ fn optimize(&self, _bundle_graph: &mut BundleGraph) -> Result<(), anyhow::Error> {
+ todo!()
+ }
+ }
+
+ #[test]
+ fn can_be_dyn() {
+ let _bundler: Box<dyn BundlerPlugin> = Box::new(TestBundlerPlugin {});
+ }
+}

crates/parcel_core/src/plugin/compressor.rs

@@ -1,2 +1,44 @@
+use std::fs::File;
+
+pub struct CompressedFile {
+ /// An optional file extension appended to the output file
+ ///
+ /// When no extension is returned, then the returned stream replaces the original file.
+ ///
+ pub extension: Option<String>,
+
+ /// The compressed file
+ pub file: File,
+}
+
 /// Compresses the input file stream
-pub trait CompressorPlugin {}
+pub trait CompressorPlugin {
+ /// Compress the given file
+ ///
+ /// The file contains the final contents of bundles and sourcemaps as they are being written.
+ /// A new stream can be returned, or None to forward compression onto the next plugin.
+ ///
+ fn compress(&self, file: &File) -> Result<Option<CompressedFile>, String>;
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ struct TestCompressorPlugin {}
+
+ impl CompressorPlugin for TestCompressorPlugin {
+ fn compress(&self, _file: &File) -> Result<Option<CompressedFile>, String> {
+ todo!()
+ }
+ }
+
+ #[test]
+ fn can_be_defined_in_dyn_vec() {
+ let mut compressors = Vec::<Box<dyn CompressorPlugin>>::new();
+
+ compressors.push(Box::new(TestCompressorPlugin {}));
+
+ assert_eq!(compressors.len(), 1);
+ }
+}

crates/parcel_core/src/plugin/namer.rs

@@ -1,5 +1,60 @@
+use std::path::PathBuf;
+
+use super::PluginConfig;
+use crate::bundle_graph::BundleGraph;
+use crate::types::Bundle;
+
 /// Determines the output filename for a bundle
 ///
 /// Namers run in a pipeline until one returns a result.
 ///
-pub trait NamerPlugin {}
+pub trait NamerPlugin {
+ /// A hook designed to setup config needed for naming bundles
+ ///
+ /// This function will run once, shortly after the plugin is initialised.
+ ///
+ fn load_config(&mut self, config: &PluginConfig) -> Result<(), anyhow::Error>;
+
+ /// Names the given bundle
+ ///
+ /// The returned file path should be relative to the target dist directory, and will be used to
+ /// name the bundle. Naming can be forwarded onto the next plugin by returning None.
+ ///
+ fn name(
+ &mut self,
+ config: &PluginConfig,
+ bundle: &Bundle,
+ bundle_graph: &BundleGraph,
+ ) -> Result<Option<PathBuf>, anyhow::Error>;
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ struct TestNamerPlugin {}
+
+ impl NamerPlugin for TestNamerPlugin {
+ fn load_config(&mut self, _config: &PluginConfig) -> Result<(), anyhow::Error> {
+ todo!()
+ }
+
+ fn name(
+ &mut self,
+ _config: &PluginConfig,
+ _bundle: &Bundle,
+ _bundle_graph: &BundleGraph,
+ ) -> Result<Option<PathBuf>, anyhow::Error> {
+ todo!()
+ }
+ }
+
+ #[test]
+ fn can_be_defined_in_dyn_vec() {
+ let mut namers = Vec::<Box<dyn NamerPlugin>>::new();
+
+ namers.push(Box::new(TestNamerPlugin {}));
+
+ assert_eq!(namers.len(), 1);
+ }
+}

crates/parcel_core/src/plugin/optimizer.rs

@@ -1,3 +1,23 @@
+use std::fs::File;
+
+use super::PluginConfig;
+use crate::bundle_graph::BundleGraph;
+use crate::types::Bundle;
+use crate::types::SourceMap;
+
+pub struct OptimizeContext<'a> {
+ pub bundle: &'a Bundle,
+ pub bundle_graph: &'a BundleGraph,
+ pub contents: &'a File, // TODO We may want this to be a String or File later
+ pub map: Option<&'a SourceMap>,
+ // TODO getSourceMapReference?
+}
+
+pub struct OptimizedBundle {
+ pub contents: File,
+ // TODO ast, map, type
+}
+
 /// Optimises a bundle
 ///
 /// Optimizers are commonly used to implement minification, tree shaking, dead code elimination,
@@ -8,4 +28,47 @@
 /// Multiple optimizer plugins may run in series, and the result of each optimizer is passed to
 /// the next.
 ///
-pub trait OptimizerPlugin: Send + Sync {}
+pub trait OptimizerPlugin: Send + Sync {
+ /// A hook designed to setup config needed for optimizing bundles
+ ///
+ /// This function will run once, shortly after the plugin is initialised.
+ ///
+ fn load_config(&mut self, config: &PluginConfig) -> Result<(), anyhow::Error>;
+
+ /// Transforms the contents of a bundle and its source map
+ fn optimize(
+ &mut self,
+ config: &PluginConfig,
+ ctx: OptimizeContext,
+ ) -> Result<OptimizedBundle, anyhow::Error>;
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ struct TestOptimizerPlugin {}
+
+ impl OptimizerPlugin for TestOptimizerPlugin {
+ fn load_config(&mut self, _config: &PluginConfig) -> Result<(), anyhow::Error> {
+ todo!()
+ }
+
+ fn optimize(
+ &mut self,
+ _config: &PluginConfig,
+ _ctx: OptimizeContext,
+ ) -> Result<OptimizedBundle, anyhow::Error> {
+ todo!()
+ }
+ }
+
+ #[test]
+ fn can_be_defined_in_dyn_vec() {
+ let mut optimizers = Vec::<Box<dyn OptimizerPlugin>>::new();
+
+ optimizers.push(Box::new(TestOptimizerPlugin {}));
+
+ assert_eq!(optimizers.len(), 1);
+ }
+}

crates/parcel_core/src/plugin/packager.rs

@@ -1,6 +1,65 @@
+use std::fs::File;
+
+use super::PluginConfig;
+use crate::bundle_graph::BundleGraph;
+use crate::types::Bundle;
+use crate::types::SourceMap;
+
+pub struct PackageContext<'a> {
+ pub bundle: &'a Bundle,
+ pub bundle_graph: &'a BundleGraph,
+ pub contents: &'a File, // TODO We may want this to be a String or File later
+ pub map: Option<&'a SourceMap>,
+ // TODO getSourceMapReference?
+}
+
+pub struct PackagedBundle {
+ pub contents: File,
+ // TODO ast, map, type
+}
+
 /// Combines all the assets in a bundle together into an output file
 ///
 /// Packagers are also responsible for resolving URL references, bundle inlining, and generating
 /// source maps.
 ///
-pub trait PackagerPlugin: Send + Sync {}
+pub trait PackagerPlugin: Send + Sync {
+ /// A hook designed to setup config needed for packaging
+ ///
+ /// This function will run once, shortly after the plugin is initialised.
+ ///
+ fn load_config(&mut self, config: &PluginConfig) -> Result<(), anyhow::Error>;
+
+ /// Combines assets in a bundle
+ fn package(
+ &mut self,
+ config: &PluginConfig,
+ ctx: PackageContext,
+ ) -> Result<PackagedBundle, anyhow::Error>;
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ struct TestPackagerPlugin {}
+
+ impl PackagerPlugin for TestPackagerPlugin {
+ fn load_config(&mut self, _config: &PluginConfig) -> Result<(), anyhow::Error> {
+ todo!()
+ }
+
+ fn package(
+ &mut self,
+ _config: &PluginConfig,
+ _ctx: PackageContext,
+ ) -> Result<PackagedBundle, anyhow::Error> {
+ todo!()
+ }
+ }
+
+ #[test]
+ fn can_be_dyn() {
+ let _packager: Box<dyn PackagerPlugin> = Box::new(TestPackagerPlugin {});
+ }
+}