@rspack/binding 0.0.2 → 0.0.3

package/Cargo.toml

@@ -1,44 +0,0 @@
-[package]
-edition = "2021"
-name = "rspack_node"
-publish = false
-version = "0.1.0"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-anyhow = {version = "1", features = ["backtrace"]}
-async-trait = "0.1.53"
-backtrace = "0.3"
-dashmap = "5.0.0"
-futures = "0.3"
-napi = {git = "https://github.com/speedy-js/napi-rs", branch = "speedy-release", default-features = false, features = [
-  "async",
-  "tokio_rt",
-  "serde-json",
-]}
-napi-derive = {git = "https://github.com/speedy-js/napi-rs", branch = "speedy-release"}
-napi-sys = {git = "https://github.com/speedy-js/napi-rs", branch = "speedy-release"}
-once_cell = "1"
-regex = "1.6.0"
-rspack = {path = "../rspack"}
-rspack_binding_options = {path = "../rspack_binding_options", features = ["node-api"]}
-rspack_core = {path = "../rspack_core"}
-rspack_error = {path = "../rspack_error"}
-rspack_plugin_html = {path = "../rspack_plugin_html"}
-serde = {version = "1", features = ["derive"]}
-serde_json = "1"
-tokio = {version = "1.17.0", features = ["full"]}
-tracing = "0.1.34"
-
-[target.'cfg(all(not(all(target_os = "linux", target_arch = "aarch64", target_env = "musl"))))'.dependencies]
-mimalloc-rust = {version = "0.1"}
-
-[build-dependencies]
-napi-build = {git = "https://github.com/speedy-js/napi-rs", branch = "speedy-release"}
-
-[dev-dependencies]
-testing_macros = {version = "0.2.5"}

package/build.rs

@@ -1,5 +0,0 @@
-extern crate napi_build;
-
-fn main() {
-  napi_build::setup();
-}

package/napirs.rc.json

@@ -1,20 +0,0 @@
-{
-  "napi": {
-    "name": "rspack",
-    "triples": {
-      "defaults": true,
-      "additional": [
-        "x86_64-unknown-linux-musl",
-        "aarch64-unknown-linux-gnu",
-        "i686-pc-windows-msvc",
-        "armv7-unknown-linux-gnueabihf",
-        "aarch64-apple-darwin",
-        "x86_64-unknown-freebsd",
-        "aarch64-unknown-linux-musl",
-        "aarch64-pc-windows-msvc",
-        "aarch64-linux-android",
-        "armv7-linux-androideabi"
-      ]
-    }
-  }
-}

package/src/adapter/common.rs

@@ -1,11 +0,0 @@
-use std::sync::Arc;
-
-use dashmap::DashMap;
-use napi::threadsafe_function::{ErrorStrategy, ThreadsafeFunction};
-use once_cell::sync::Lazy;
-use tokio::sync::oneshot::Sender;
-
-pub type ThreadsafeRspackCallback = ThreadsafeFunction<String, ErrorStrategy::CalleeHandled>;
-
-pub static REGISTERED_DONE_SENDERS: Lazy<Arc<DashMap<usize, Sender<()>>>> =
-  Lazy::new(Default::default);

package/src/adapter/mod.rs

@@ -1,124 +0,0 @@
-use std::fmt::Debug;
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-use rspack_core::{Plugin, PluginBuildEndHookOutput};
-
-use anyhow::Context;
-use async_trait::async_trait;
-use napi::threadsafe_function::ThreadsafeFunctionCallMode;
-use napi::Error;
-use napi_derive::napi;
-use once_cell::sync::Lazy;
-use serde::{Deserialize, Serialize};
-use tokio::sync::oneshot;
-
-mod common;
-pub mod utils;
-pub use utils::create_node_adapter_from_plugin_callbacks;
-
-use common::ThreadsafeRspackCallback;
-use common::REGISTERED_DONE_SENDERS;
-
-pub static CALL_ID: Lazy<AtomicUsize> = Lazy::new(|| AtomicUsize::new(1));
-
-pub struct RspackPluginNodeAdapter {
-  pub done_tsfn: ThreadsafeRspackCallback,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct RspackThreadsafeContext<T: Debug> {
-  id: usize,
-  inner: T,
-}
-
-impl<T: Debug> RspackThreadsafeContext<T> {
-  pub fn new(payload: T) -> Self {
-    Self {
-      id: CALL_ID.fetch_add(1, Ordering::SeqCst),
-      inner: payload,
-    }
-  }
-
-  #[inline(always)]
-  pub fn get_call_id(&self) -> usize {
-    self.id
-  }
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct RspackThreadsafeResult<T: Debug> {
-  id: usize,
-  inner: T,
-}
-
-impl<T: Debug> RspackThreadsafeResult<T> {
-  #[inline(always)]
-  pub fn get_call_id(&self) -> usize {
-    self.id
-  }
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-#[napi(object)]
-pub struct OnLoadContext {
-  pub id: String,
-}
-
-impl Debug for RspackPluginNodeAdapter {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    f.debug_struct("RspackPluginNodeAdapter").finish()
-  }
-}
-
-#[async_trait]
-impl Plugin for RspackPluginNodeAdapter {
-  fn name(&self) -> &'static str {
-    "rspack_plugin_node_adapter"
-  }
-  #[tracing::instrument(skip_all)]
-  async fn done(&self) -> PluginBuildEndHookOutput {
-    let context = RspackThreadsafeContext::new(());
-
-    let (tx, rx) = oneshot::channel::<()>();
-
-    match REGISTERED_DONE_SENDERS.entry(context.get_call_id()) {
-      dashmap::mapref::entry::Entry::Vacant(v) => {
-        v.insert(tx);
-      }
-      dashmap::mapref::entry::Entry::Occupied(_) => {
-        let err = Error::new(
-          napi::Status::Unknown,
-          format!(
-            "duplicated call id encountered {}, please file an issue.",
-            context.get_call_id(),
-          ),
-        );
-        self
-          .done_tsfn
-          .call(Err(err.clone()), ThreadsafeFunctionCallMode::Blocking);
-
-        let any_error = anyhow::Error::from(err);
-        return Err(any_error.into());
-      }
-    }
-
-    let value = serde_json::to_string(&context).map_err(|_| {
-      Error::new(
-        napi::Status::Unknown,
-        "unable to convert context".to_owned(),
-      )
-    });
-
-    self
-      .done_tsfn
-      .call(value, ThreadsafeFunctionCallMode::Blocking);
-
-    let t = rx
-      .await
-      .context("failed to receive done result")
-      .map_err(|err| err.into());
-    return t;
-  }
-}

package/src/adapter/utils.rs

@@ -1,62 +0,0 @@
-use napi::bindgen_prelude::*;
-use napi::{
-  threadsafe_function::{ErrorStrategy, ThreadSafeResultContext, ThreadsafeFunction},
-  Env,
-};
-
-use super::common::REGISTERED_DONE_SENDERS;
-use crate::PluginCallbacks;
-
-pub fn create_node_adapter_from_plugin_callbacks(
-  env: &Env,
-  plugin_callbacks: Option<PluginCallbacks>,
-) -> Result<Option<super::RspackPluginNodeAdapter>> {
-  plugin_callbacks
-    .map(|PluginCallbacks { done_callback }| {
-      let mut done_tsfn: ThreadsafeFunction<String, ErrorStrategy::CalleeHandled> = done_callback
-        .create_threadsafe_function(
-        0,
-        |ctx| ctx.env.create_string_from_std(ctx.value).map(|v| vec![v]),
-        |ctx: ThreadSafeResultContext<Promise<String>>| {
-          let return_value = ctx.return_value;
-
-          ctx
-            .env
-            .execute_tokio_future(
-              async move {
-                let result = return_value.await?;
-
-                let result: super::RspackThreadsafeResult<()> =
-                  serde_json::from_str(&result).expect("failed to evaluate done result");
-
-                tracing::debug!("build end result {:?}", result);
-
-                let sender = REGISTERED_DONE_SENDERS.remove(&result.get_call_id());
-
-                if let Some((_, sender)) = sender {
-                  sender.send(()).map_err(|m| {
-                    Error::new(
-                      napi::Status::GenericFailure,
-                      format!("failed to send result {:#?}", m),
-                    )
-                  })?;
-                } else {
-                  return Err(Error::new(
-                    napi::Status::GenericFailure,
-                    "failed to get sender for plugin".to_owned(),
-                  ));
-                }
-
-                Ok(())
-              },
-              |_, ret| Ok(ret),
-            )
-            .expect("failed to execute tokio future");
-        },
-      )?;
-      done_tsfn.unref(env)?;
-
-      Ok(super::RspackPluginNodeAdapter { done_tsfn })
-    })
-    .transpose()
-}

package/src/lib.rs

@@ -1,272 +0,0 @@
-use std::fmt::Debug;
-// use std::path::Path;
-use std::sync::Arc;
-
-use napi::bindgen_prelude::*;
-use napi::{Env, Result};
-use napi_derive::napi;
-// use nodejs_resolver::Resolver;
-use tokio::sync::Mutex;
-mod adapter;
-// mod options;
-mod utils;
-use adapter::create_node_adapter_from_plugin_callbacks;
-
-use utils::get_named_property_value_string;
-
-// use adapter::utils::create_node_adapter_from_plugin_callbacks;
-pub use rspack_binding_options::{normalize_bundle_options, NodeLoaderAdapter, RawOptions};
-
-#[cfg(all(not(all(target_os = "linux", target_arch = "aarch64", target_env = "musl"))))]
-#[global_allocator]
-static ALLOC: mimalloc_rust::GlobalMiMalloc = mimalloc_rust::GlobalMiMalloc;
-
-pub fn create_external<T>(value: T) -> External<T> {
-  External::new(value)
-}
-
-pub type Rspack = Arc<Mutex<rspack::Compiler>>;
-
-#[napi(object)]
-
-pub struct PluginCallbacks {
-  pub done_callback: JsFunction,
-}
-impl Debug for PluginCallbacks {
-  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    f.debug_struct("PluginCallbacks")
-      .field("done_callback", &"done_adapter")
-      .finish()
-  }
-}
-
-pub struct RspackBindingContext {
-  pub rspack: Rspack,
-  // pub resolver: Arc<Resolver>,
-}
-#[napi(object)]
-pub struct RspackError {
-  pub message: String,
-}
-#[napi(object)]
-pub struct Stats {
-  pub errors: Vec<RspackError>,
-}
-
-impl<'a> From<rspack_core::Stats<'a>> for Stats {
-  fn from(rspack_stats: rspack_core::Stats) -> Self {
-    Self {
-      errors: rspack_stats
-        .compilation
-        .diagnostic
-        .iter()
-        .map(|d| RspackError {
-          message: d.message.clone(),
-        })
-        .collect(),
-    }
-  }
-}
-
-#[napi]
-pub fn init_trace_subscriber(env: Env) -> Result<()> {
-  utils::init_custom_trace_subscriber(env)
-}
-
-#[napi(ts_return_type = "ExternalObject<RspackInternal>")]
-#[allow(clippy::too_many_arguments)]
-pub fn new_rspack(
-  env: Env,
-  mut options: RawOptions,
-  plugin_callbacks: Option<PluginCallbacks>,
-) -> Result<External<RspackBindingContext>> {
-  #[cfg(debug_assertions)]
-  {
-    if let Some(module) = options.module.as_mut() {
-      for rule in &mut module.rules {
-        if let Some(uses) = rule.uses.as_mut() {
-          for item in uses {
-            if let Some(loader) = item.loader.as_ref() {
-              // let (env_ptr, loader_ptr) = unsafe { (env.raw(), loader.raw()) };
-              if let Ok(display_name) = get_named_property_value_string(env, loader, "displayName")
-              {
-                item.__loader_name = Some(display_name);
-              } else if let Ok(name) = get_named_property_value_string(env, loader, "name") {
-                item.__loader_name = Some(name);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-  let node_adapter = create_node_adapter_from_plugin_callbacks(&env, plugin_callbacks)?;
-  let mut compiler_options =
-    normalize_bundle_options(options).map_err(|e| Error::from_reason(format!("{:?}", e)))?;
-  if let Some(node_adapter) = node_adapter {
-    compiler_options
-      .plugins
-      .push(Box::new(node_adapter) as Box<dyn rspack_core::Plugin>);
-  }
-  // TODO: this way or passing env as context to `normalize_bundle_option`?
-  compiler_options
-    .module
-    .rules
-    .iter_mut()
-    .try_for_each(|rule| {
-      rule.uses.iter_mut().try_for_each(|loader| {
-        let casted = loader.as_any_mut();
-        if let Some(adapter) = casted.downcast_mut::<NodeLoaderAdapter>() {
-          adapter.unref(&env)
-        } else {
-          Ok(())
-        }
-      })
-    })
-    .map_err(|e| Error::from_reason(format!("failed to unref tsfn {:?}", e)))?;
-
-  let rspack = rspack::rspack(compiler_options, vec![]);
-
-  // let resolver = rspack.resolver.clone();
-  Ok(create_external(RspackBindingContext {
-    rspack: Arc::new(Mutex::new(rspack)),
-    // resolver,
-  }))
-}
-
-#[napi(
-  ts_args_type = "rspack: ExternalObject<RspackInternal>",
-  ts_return_type = "Promise<Stats>"
-)]
-pub fn build(env: Env, binding_context: External<RspackBindingContext>) -> Result<napi::JsObject> {
-  let compiler = binding_context.rspack.clone();
-  env.execute_tokio_future(
-    async move {
-      let mut compiler = compiler.lock().await;
-      let rspack_stats = compiler
-        .build()
-        .await
-        .map_err(|e| Error::new(napi::Status::GenericFailure, format!("{:?}", e)))?;
-
-      let stats: Stats = rspack_stats.into();
-      if stats.errors.is_empty() {
-        println!("build success");
-      } else {
-        println!("build failed");
-      }
-      Ok(stats)
-    },
-    |_env, ret| Ok(ret),
-  )
-}
-
-#[napi(
-  // ts_args_type = "rspack: ExternalObject<RspackInternal>, changedFile: string[]",
-  ts_args_type = "rspack: ExternalObject<RspackInternal>",
-  // ts_return_type = "Promise<[diff: Record<string, string>, map: Record<string, string>]>"
-  ts_return_type = "Promise<Record<string, string>>"
-)]
-pub fn rebuild(
-  env: Env,
-  binding_context: External<RspackBindingContext>,
-  changed_file: Vec<String>,
-) -> Result<napi::JsObject> {
-  let compiler = binding_context.rspack.clone();
-  env.execute_tokio_future(
-    async move {
-      let mut compiler = compiler.lock().await;
-      let _rspack_stats = compiler
-        .rebuild(changed_file)
-        .await
-        .map_err(|e| Error::new(napi::Status::GenericFailure, format!("{:?}", e)))?;
-
-      let stats: Stats = _rspack_stats.into();
-      println!("rebuild success");
-      Ok(stats)
-    },
-    |_env, ret| Ok(ret),
-  )
-}
-
-// #[napi(
-//   ts_args_type = "rspack: ExternalObject<RspackInternal>, source: string, resolveOptions: ResolveOptions",
-//   ts_return_type = "ResolveResult"
-// )]
-// pub fn resolve(
-//   binding_context: External<RspackBindingContext>,
-//   source: String,
-//   resolve_options: ResolveOptions,
-// ) -> Result<ResolveResult> {
-//   let resolver = (*binding_context).resolver.clone();
-//   let res = resolver.resolve(Path::new(&resolve_options.resolve_dir), &source);
-//   match res {
-//     Ok(val) => {
-//       if let nodejs_resolver::ResolveResult::Path(p) = val {
-//         Ok(ResolveResult {
-//           status: true,
-//           path: Some(p.to_string_lossy().to_string()),
-//         })
-//       } else {
-//         Ok(ResolveResult {
-//           status: false,
-//           path: None,
-//         })
-//       }
-//     }
-//     Err(err) => Err(Error::new(Status::GenericFailure, err)),
-//   }
-// }
-
-// #[napi(object)]
-// pub struct ResolveOptions {
-//   pub resolve_dir: String,
-// }
-
-// #[napi(object)]
-// pub struct ResolveResult {
-//   pub status: bool,
-//   pub path: Option<String>,
-// }
-
-// #[napi]
-// pub fn resolve_file(base_dir: String, import_path: String) -> Result<String> {
-//   let resolver = Resolver::new(nodejs_resolver::ResolverOptions {
-//     extensions: vec!["less", "css", "scss", "sass", "js"]
-//       .into_iter()
-//       .map(|s| s.to_owned())
-//       .collect(),
-//     ..Default::default()
-//   });
-//   match resolver.resolve(Path::new(&base_dir), &import_path) {
-//     Ok(res) => {
-//       if let nodejs_resolver::ResolveResult::Path(abs_path) = res {
-//         match abs_path.to_str() {
-//           Some(s) => Ok(s.to_owned()),
-//           None => Err(Error::new(
-//             napi::Status::GenericFailure,
-//             "unable to create string from path".to_owned(),
-//           )),
-//         }
-//       } else {
-//         Ok(import_path)
-//       }
-//     }
-//     Err(msg) => Err(Error::new(Status::GenericFailure, msg)),
-//   }
-// }
-
-#[napi::module_init]
-fn init() {
-  use backtrace::Backtrace;
-  use std::panic::set_hook;
-
-  set_hook(Box::new(|panic_info| {
-    let backtrace = Backtrace::new();
-    println!("Panic: {:?}\nBacktrace: {:?}", panic_info, backtrace);
-    std::process::exit(1)
-  }));
-}
-
-// for dts generation only
-#[napi(object)]
-pub struct RspackInternal {}

package/src/utils.rs

@@ -1,88 +0,0 @@
-use std::ffi::CStr;
-use std::io::Write;
-use std::ptr;
-
-use napi::{check_status, Env, Error, NapiRaw, Result};
-use napi_derive::napi;
-use once_cell::sync::OnceCell;
-
-static CUSTOM_TRACE_SUBSCRIBER: OnceCell<bool> = OnceCell::new();
-
-/// Try to resolve the string value of a given named property
-pub fn get_named_property_value_string<T: NapiRaw>(
-  env: Env,
-  object: T,
-  property_name: &str,
-) -> Result<String> {
-  let mut bytes_with_nul: Vec<u8> = Vec::with_capacity(property_name.len() + 1);
-
-  write!(&mut bytes_with_nul, "{}", property_name)?;
-  write!(&mut bytes_with_nul, "{}", '\0')?;
-
-  let mut value_ptr = ptr::null_mut();
-
-  check_status!(
-    unsafe {
-      napi_sys::napi_get_named_property(
-        env.raw(),
-        object.raw(),
-        CStr::from_bytes_with_nul_unchecked(&bytes_with_nul).as_ptr(),
-        &mut value_ptr,
-      )
-    },
-    "failed to get the value"
-  )?;
-
-  let mut str_len = 0;
-  check_status!(
-    unsafe {
-      napi_sys::napi_get_value_string_utf8(env.raw(), value_ptr, ptr::null_mut(), 0, &mut str_len)
-    },
-    "failed to get the value"
-  )?;
-
-  str_len += 1;
-  let mut buf = Vec::with_capacity(str_len);
-  let mut copied_len = 0;
-
-  check_status!(
-    unsafe {
-      napi_sys::napi_get_value_string_utf8(
-        env.raw(),
-        value_ptr,
-        buf.as_mut_ptr(),
-        str_len,
-        &mut copied_len,
-      )
-    },
-    "failed to get the value"
-  )?;
-
-  // Vec<i8> -> Vec<u8> See: https://stackoverflow.com/questions/59707349/cast-vector-of-i8-to-vector-of-u8-in-rust
-  let mut buf = std::mem::ManuallyDrop::new(buf);
-
-  let buf = unsafe { Vec::from_raw_parts(buf.as_mut_ptr() as *mut u8, copied_len, copied_len) };
-
-  String::from_utf8(buf).map_err(|_| Error::from_reason("failed to get property"))
-}
-
-#[napi]
-pub fn init_custom_trace_subscriber(
-  mut env: Env,
-  // trace_out_file_path: Option<String>,
-) -> Result<()> {
-  CUSTOM_TRACE_SUBSCRIBER.get_or_init(|| {
-    let guard = rspack_core::log::enable_tracing_by_env_with_chrome_layer();
-    if let Some(guard) = guard {
-      env
-        .add_env_cleanup_hook(guard, |flush_guard| {
-          flush_guard.flush();
-          drop(flush_guard);
-        })
-        .expect("Should able to initialize cleanup for custom trace subscriber");
-    }
-    true
-  });
-
-  Ok(())
-}

package/tests/answer.js

@@ -1 +0,0 @@
-export const answer = 42

package/tests/binding.spec.ts

@@ -1,19 +0,0 @@
-import assert from 'assert'
-import path from 'path'
-import log from 'why-is-node-running'
-import binding from '..'
-import { RawOptions } from '../binding.d'
-
-describe('binding', () => {
-  it('work', async () => {
-    const options: RawOptions = {
-      entries: { main: path.resolve(__dirname, './index.js') },
-      // entryFilename: path.resolve(__dirname, 'dist/main.js'),
-    }
-    const instance = binding.newRspack(JSON.stringify(options))
-    await binding.build(instance)
-    // setTimeout(() => {
-    //   log();
-    // }, 5000);
-  })
-})

package/tests/index.js

@@ -1,2 +0,0 @@
-import { answer } from './answer'
-console.log({ answer })