Rename crate

Author: Sytten

Cargo.toml

@@ -1,8 +1,11 @@
 [package]
-name = "rquickjs-moduledef-ext"
+name = "rquickjs-module"
 version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-rquickjs = { version = "*", features = ["full-async", "parallel", "macro"] }
+rquickjs = { version = "0.8.1", features = ["loader"] }
+
+[dev-dependencies]
+rquickjs = { version = "0.8.1", features = ["futures", "macro"] }
 tokio = { version = "1", features = ["full"] }

README.md

@@ -1,2 +1,12 @@
-# rquickjs-moduledef-ext
-Experiment to improve ModuleDef
+# rquickjs module
+
+[![github](https://img.shields.io/badge/github-delskayn/rquickjs-8da0cb.svg?style=for-the-badge&logo=github)](https://github.com/rquickjs/rquickjs-module)
+[![crates](https://img.shields.io/crates/v/rquickjs.svg?style=for-the-badge&color=fc8d62&logo=rust)](https://crates.io/crates/rquickjs-module)
+
+This is an extension to [rquickjs](https://github.com/DelSkayn/rquickjs) to allow the ecosystem to create more unified Rust modules.
+
+The goal was to create a better version of [`ModuleDef`](https://docs.rs/rquickjs/latest/rquickjs/module/trait.ModuleDef.html) that would allow it to have options as input and set global.
+
+For example, a `fetch` module using `ModuleDefExt` could set a global `fetch` function and have as options an allowlist of domains.
+
+## Usage

src/definition.rs

@@ -10,7 +10,7 @@ use rquickjs::{
 ///
 /// ```
 /// use rquickjs::{Ctx, JsLifetime, Object, Result};
-/// use rquickjs_moduledef_ext::{ModuleDefExt, ModuleImpl};
+/// use rquickjs_module::{ModuleDefExt, ModuleImpl};
 ///
 /// #[derive(JsLifetime, Debug)]
 /// struct MyModuleOptions {

src/lib.rs

@@ -14,10 +14,7 @@ mod tests {
         JsLifetime, Object, Result, Value,
     };
 
-    use crate::{
-        definition::{GlobalsOnly, ModuleImpl},
-        globals_only_module, ModuleLoader,
-    };
+    use crate::{globals_only_module, GlobalsOnly, ModuleImpl, ModuleLoader};
 
     use super::ModuleDefExt;
 
@@ -29,9 +26,7 @@ mod tests {
             &GlobalsOnly
         }
 
-        fn options(self) -> () {
-            ()
-        }
+        fn options(self) {}
     }
 
     struct Example2;

src/loader/builder.rs

@@ -12,6 +12,35 @@ fn load_module_func<D: ModuleDef>(ctx: Ctx<'_>, name: Vec<u8>) -> Result<Module<
     Module::declare_def::<D, _>(ctx, name)
 }
 
+/// Builder to create a [`ModuleLoader`], [`ModuleResolver`] and [`GlobalInitializer`]
+///
+/// # Example
+/// ```rust
+/// use rquickjs_module::{ModuleLoader, ModuleDefExt, ModuleImpl};
+///
+/// struct MyModule;
+///
+/// impl ModuleDefExt for MyModule {
+///     type Implementation = ModuleImpl<()>;
+///
+///     fn implementation() -> &'static Self::Implementation {
+///         &ModuleImpl {
+///             declare: |decl| {
+///                 decl.declare("hello")?;
+///                 Ok(())
+///             },
+///             evaluate: |ctx, exports, options| {
+///                 exports.export("hello", "world".to_string())?;
+///                 Ok(())
+///             },
+///             name: "my-module",
+///         }
+///     }
+///
+///     fn options(self) -> () {}
+/// }
+///
+/// ```
 #[derive(Default)]
 pub struct ModuleLoaderBuilder {
     modules: HashMap<&'static str, ModuleLoadFn>,
@@ -20,6 +49,17 @@ pub struct ModuleLoaderBuilder {
 }
 
 impl ModuleLoaderBuilder {
+    #[must_use]
+    pub fn with_module<O, M, R>(mut self, module: M) -> Self
+    where
+        for<'js> O: JsLifetime<'js> + 'static,
+        R: ModuleDef + HasModule,
+        M: AsModule<O, R>,
+    {
+        self.add_module(module);
+        self
+    }
+
     pub fn add_module<O, M, R>(&mut self, module: M) -> &mut Self
     where
         for<'js> O: JsLifetime<'js> + 'static,

src/loader/mod.rs

@@ -5,13 +5,17 @@ use rquickjs::{loader::Loader, Ctx, Error, Module, Object, Result};
 pub use self::builder::ModuleLoaderBuilder;
 pub use self::global::GlobalInitializer;
 pub use self::resolver::ModuleResolver;
+
 mod builder;
 mod global;
 mod resolver;
 
-pub type GlobalLoadFn = Box<dyn for<'js> FnOnce(&Ctx<'js>, &Object<'js>) -> Result<()>>;
-pub type ModuleLoadFn = for<'js> fn(Ctx<'js>, Vec<u8>) -> Result<Module<'js>>;
+type GlobalLoadFn = Box<dyn for<'js> FnOnce(&Ctx<'js>, &Object<'js>) -> Result<()>>;
+type ModuleLoadFn = for<'js> fn(Ctx<'js>, Vec<u8>) -> Result<Module<'js>>;
 
+/// Loader for Rust modules defined using [`crate::ModuleDefExt`].
+///
+/// See [`ModuleLoaderBuilder`] for usage.
 pub struct ModuleLoader {
     modules: HashMap<&'static str, ModuleLoadFn>,
 }

src/wrapper/mod.rs

@@ -8,15 +8,15 @@ mod module;
 /// Module metadata
 ///
 /// We use this trait to still access metadata once we have
-/// converted it from a `ModuleDefExt` to a `ModuleDef`.
+/// converted it from a [`ModuleDefExt`] to a [`ModuleDef`].
 ///
 /// This is necessary for the loader to work.
 pub trait HasModule {
     fn name() -> &'static str;
     fn is_module() -> bool;
 }
 
-/// Convert a `ModuleDefExt` to a `ModuleDef`
+/// Convert a [`ModuleDefExt`] to a [`ModuleDef`]
 pub trait AsModule<O, R>
 where
     Self: ModuleDefExt<O>,