diff options
Diffstat (limited to 'op_crates')
| -rw-r--r-- | op_crates/console/lib.rs | 24 | ||||
| -rw-r--r-- | op_crates/crypto/lib.rs | 31 | ||||
| -rw-r--r-- | op_crates/fetch/lib.rs | 81 | ||||
| -rw-r--r-- | op_crates/file/lib.rs | 47 | ||||
| -rw-r--r-- | op_crates/timers/lib.rs | 35 | ||||
| -rw-r--r-- | op_crates/url/benches/url_ops.rs | 22 | ||||
| -rw-r--r-- | op_crates/url/lib.rs | 33 | ||||
| -rw-r--r-- | op_crates/web/lib.rs | 53 | ||||
| -rw-r--r-- | op_crates/webgpu/lib.rs | 360 | ||||
| -rw-r--r-- | op_crates/webidl/lib.rs | 11 | ||||
| -rw-r--r-- | op_crates/websocket/lib.rs | 40 |
11 files changed, 556 insertions, 181 deletions
diff --git a/op_crates/console/lib.rs b/op_crates/console/lib.rs index a972f6212..4d6a213f2 100644 --- a/op_crates/console/lib.rs +++ b/op_crates/console/lib.rs @@ -1,23 +1,15 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. -use deno_core::JsRuntime; +use deno_core::include_js_files; +use deno_core::Extension; use std::path::PathBuf; -/// Load and execute the javascript code. -pub fn init(isolate: &mut JsRuntime) { - let files = vec![ - ( - "deno:op_crates/console/01_colors.js", - include_str!("01_colors.js"), - ), - ( - "deno:op_crates/console/02_console.js", - include_str!("02_console.js"), - ), - ]; - for (url, source_code) in files { - isolate.execute(url, source_code).unwrap(); - } +pub fn init() -> Extension { + Extension::pure_js(include_js_files!( + prefix "deno:op_crates/console", + "01_colors.js", + "02_console.js", + )) } pub fn get_declaration() -> PathBuf { diff --git a/op_crates/crypto/lib.rs b/op_crates/crypto/lib.rs index 8b4d34a7c..d5b0a30bc 100644 --- a/op_crates/crypto/lib.rs +++ b/op_crates/crypto/lib.rs @@ -2,25 +2,36 @@ use deno_core::error::null_opbuf; use deno_core::error::AnyError; -use deno_core::JsRuntime; +use deno_core::include_js_files; +use deno_core::op_sync; +use deno_core::Extension; use deno_core::OpState; use deno_core::ZeroCopyBuf; use rand::rngs::StdRng; use rand::thread_rng; use rand::Rng; +use rand::SeedableRng; use std::path::PathBuf; pub use rand; // Re-export rand -/// Execute this crates' JS source files. -pub fn init(isolate: &mut JsRuntime) { - let files = vec![( - "deno:op_crates/crypto/01_crypto.js", - include_str!("01_crypto.js"), - )]; - for (url, source_code) in files { - isolate.execute(url, source_code).unwrap(); - } +pub fn init(maybe_seed: Option<u64>) -> Extension { + Extension::with_ops( + include_js_files!( + prefix "deno:op_crates/crypto", + "01_crypto.js", + ), + vec![( + "op_crypto_get_random_values", + op_sync(op_crypto_get_random_values), + )], + Some(Box::new(move |state| { + if let Some(seed) = maybe_seed { + state.put(StdRng::seed_from_u64(seed)); + } + Ok(()) + })), + ) } pub fn op_crypto_get_random_values( diff --git a/op_crates/fetch/lib.rs b/op_crates/fetch/lib.rs index ad96dea46..7033a416c 100644 --- a/op_crates/fetch/lib.rs +++ b/op_crates/fetch/lib.rs @@ -8,12 +8,15 @@ use deno_core::error::AnyError; use deno_core::futures::Future; use deno_core::futures::Stream; use deno_core::futures::StreamExt; +use deno_core::include_js_files; +use deno_core::op_async; +use deno_core::op_sync; use deno_core::url::Url; use deno_core::AsyncRefCell; use deno_core::CancelFuture; use deno_core::CancelHandle; use deno_core::CancelTryFuture; -use deno_core::JsRuntime; +use deno_core::Extension; use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; @@ -49,49 +52,41 @@ use tokio_util::io::StreamReader; pub use reqwest; // Re-export reqwest -/// Execute this crates' JS source files. -pub fn init(isolate: &mut JsRuntime) { - let files = vec![ - ( - "deno:op_crates/fetch/01_fetch_util.js", - include_str!("01_fetch_util.js"), - ), - ( - "deno:op_crates/fetch/11_streams.js", - include_str!("11_streams.js"), - ), - ( - "deno:op_crates/fetch/20_headers.js", - include_str!("20_headers.js"), - ), - ( - "deno:op_crates/fetch/21_formdata.js", - include_str!("21_formdata.js"), - ), - ( - "deno:op_crates/fetch/22_body.js", - include_str!("22_body.js"), - ), - ( - "deno:op_crates/fetch/22_http_client.js", - include_str!("22_http_client.js"), - ), - ( - "deno:op_crates/fetch/23_request.js", - include_str!("23_request.js"), - ), - ( - "deno:op_crates/fetch/23_response.js", - include_str!("23_response.js"), - ), - ( - "deno:op_crates/fetch/26_fetch.js", - include_str!("26_fetch.js"), +pub fn init<P: FetchPermissions + 'static>( + user_agent: String, + ca_data: Option<Vec<u8>>, +) -> Extension { + Extension::with_ops( + include_js_files!( + prefix "deno:op_crates/fetch", + "01_fetch_util.js", + "11_streams.js", + "20_headers.js", + "21_formdata.js", + "22_body.js", + "22_http_client.js", + "23_request.js", + "23_response.js", + "26_fetch.js", ), - ]; - for (url, source_code) in files { - isolate.execute(url, source_code).expect(url); - } + vec![ + ("op_fetch", op_sync(op_fetch::<P>)), + ("op_fetch_send", op_async(op_fetch_send)), + ("op_fetch_request_write", op_async(op_fetch_request_write)), + ("op_fetch_response_read", op_async(op_fetch_response_read)), + ("op_create_http_client", op_sync(op_create_http_client::<P>)), + ], + Some(Box::new(move |state| { + state.put::<reqwest::Client>({ + create_http_client(user_agent.clone(), ca_data.clone()).unwrap() + }); + state.put::<HttpClientDefaults>(HttpClientDefaults { + ca_data: ca_data.clone(), + user_agent: user_agent.clone(), + }); + Ok(()) + })), + ) } pub struct HttpClientDefaults { diff --git a/op_crates/file/lib.rs b/op_crates/file/lib.rs index ea519046f..19bb8b19b 100644 --- a/op_crates/file/lib.rs +++ b/op_crates/file/lib.rs @@ -2,8 +2,10 @@ use deno_core::error::null_opbuf; use deno_core::error::AnyError; +use deno_core::include_js_files; +use deno_core::op_sync; use deno_core::url::Url; -use deno_core::JsRuntime; +use deno_core::Extension; use deno_core::ModuleSpecifier; use deno_core::ZeroCopyBuf; use std::collections::HashMap; @@ -82,22 +84,35 @@ pub fn op_file_revoke_object_url( Ok(()) } -/// Load and execute the javascript code. -pub fn init(isolate: &mut JsRuntime) { - let files = vec![ - ("deno:op_crates/file/01_file.js", include_str!("01_file.js")), - ( - "deno:op_crates/file/02_filereader.js", - include_str!("02_filereader.js"), +pub fn init( + blob_url_store: BlobUrlStore, + maybe_location: Option<Url>, +) -> Extension { + Extension::with_ops( + include_js_files!( + prefix "deno:op_crates/file", + "01_file.js", + "02_filereader.js", + "03_blob_url.js", ), - ( - "deno:op_crates/file/03_blob_url.js", - include_str!("03_blob_url.js"), - ), - ]; - for (url, source_code) in files { - isolate.execute(url, source_code).unwrap(); - } + vec![ + ( + "op_file_create_object_url", + op_sync(op_file_create_object_url), + ), + ( + "op_file_revoke_object_url", + op_sync(op_file_revoke_object_url), + ), + ], + Some(Box::new(move |state| { + state.put(blob_url_store.clone()); + if let Some(location) = maybe_location.clone() { + state.put(Location(location)); + } + Ok(()) + })), + ) } pub fn get_declaration() -> PathBuf { diff --git a/op_crates/timers/lib.rs b/op_crates/timers/lib.rs index 047b6923c..6359b20f0 100644 --- a/op_crates/timers/lib.rs +++ b/op_crates/timers/lib.rs @@ -13,6 +13,9 @@ use deno_core::futures; use deno_core::futures::channel::oneshot; use deno_core::futures::FutureExt; use deno_core::futures::TryFutureExt; +use deno_core::op_async; +use deno_core::op_sync; +use deno_core::Extension; use deno_core::OpState; use deno_core::ZeroCopyBuf; use std::cell::RefCell; @@ -28,12 +31,34 @@ pub trait TimersPermission { fn check_unstable(&self, state: &OpState, api_name: &'static str); } -pub fn init(rt: &mut deno_core::JsRuntime) { - rt.execute( - "deno:op_crates/timers/01_timers.js", - include_str!("01_timers.js"), +pub struct NoTimersPermission; + +impl TimersPermission for NoTimersPermission { + fn allow_hrtime(&mut self) -> bool { + false + } + fn check_unstable(&self, _: &OpState, _: &'static str) {} +} + +pub fn init<P: TimersPermission + 'static>() -> Extension { + Extension::with_ops( + vec![( + "deno:op_crates/timers/01_timers.js", + include_str!("01_timers.js"), + )], + vec![ + ("op_global_timer_stop", op_sync(op_global_timer_stop)), + ("op_global_timer_start", op_sync(op_global_timer_start)), + ("op_global_timer", op_async(op_global_timer)), + ("op_now", op_sync(op_now::<P>)), + ("op_sleep_sync", op_sync(op_sleep_sync::<P>)), + ], + Some(Box::new(|state| { + state.put(GlobalTimer::default()); + state.put(StartTime::now()); + Ok(()) + })), ) - .unwrap(); } pub type StartTime = Instant; diff --git a/op_crates/url/benches/url_ops.rs b/op_crates/url/benches/url_ops.rs index 0f584de90..8d5498540 100644 --- a/op_crates/url/benches/url_ops.rs +++ b/op_crates/url/benches/url_ops.rs @@ -1,21 +1,14 @@ use bencher::{benchmark_group, benchmark_main, Bencher}; -use deno_core::op_sync; use deno_core::v8; use deno_core::JsRuntime; +use deno_core::RuntimeOptions; fn create_js_runtime() -> JsRuntime { - let mut runtime = JsRuntime::new(Default::default()); - runtime.register_op("op_url_parse", op_sync(deno_url::op_url_parse)); - runtime.register_op( - "op_url_parse_search_params", - op_sync(deno_url::op_url_parse_search_params), - ); - runtime.register_op( - "op_url_stringify_search_params", - op_sync(deno_url::op_url_stringify_search_params), - ); - runtime.sync_ops_cache(); + let mut runtime = JsRuntime::new(RuntimeOptions { + extensions: vec![deno_url::init()], + ..Default::default() + }); runtime .execute( @@ -23,7 +16,10 @@ fn create_js_runtime() -> JsRuntime { "globalThis.__bootstrap = (globalThis.__bootstrap || {});", ) .unwrap(); - deno_url::init(&mut runtime); + + runtime.init_extension_js().unwrap(); + runtime.init_extension_ops().unwrap(); + runtime .execute("setup", "const { URL } = globalThis.__bootstrap.url;") .unwrap(); diff --git a/op_crates/url/lib.rs b/op_crates/url/lib.rs index 04663e411..49e34c47d 100644 --- a/op_crates/url/lib.rs +++ b/op_crates/url/lib.rs @@ -4,16 +4,39 @@ use deno_core::error::generic_error; use deno_core::error::type_error; use deno_core::error::uri_error; use deno_core::error::AnyError; +use deno_core::include_js_files; +use deno_core::op_sync; use deno_core::url::form_urlencoded; use deno_core::url::quirks; use deno_core::url::Url; -use deno_core::JsRuntime; +use deno_core::Extension; use deno_core::ZeroCopyBuf; use serde::Deserialize; use serde::Serialize; use std::panic::catch_unwind; use std::path::PathBuf; +pub fn init() -> Extension { + Extension::with_ops( + include_js_files!( + prefix "deno:op_crates/url", + "00_url.js", + ), + vec![ + ("op_url_parse", op_sync(op_url_parse)), + ( + "op_url_parse_search_params", + op_sync(op_url_parse_search_params), + ), + ( + "op_url_stringify_search_params", + op_sync(op_url_stringify_search_params), + ), + ], + None, + ) +} + #[derive(Deserialize)] #[serde(rename_all = "camelCase")] pub struct UrlParseArgs { @@ -146,14 +169,6 @@ pub fn op_url_stringify_search_params( Ok(search) } -/// Load and execute the javascript code. -pub fn init(isolate: &mut JsRuntime) { - let files = vec![("deno:op_crates/url/00_url.js", include_str!("00_url.js"))]; - for (url, source_code) in files { - isolate.execute(url, source_code).unwrap(); - } -} - pub fn get_declaration() -> PathBuf { PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_url.d.ts") } diff --git a/op_crates/web/lib.rs b/op_crates/web/lib.rs index a609dc4cd..7fd8221eb 100644 --- a/op_crates/web/lib.rs +++ b/op_crates/web/lib.rs @@ -1,47 +1,22 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. -use deno_core::JsRuntime; +use deno_core::include_js_files; +use deno_core::Extension; use std::path::PathBuf; /// Load and execute the javascript code. -pub fn init(isolate: &mut JsRuntime) { - let files = vec![ - ( - "deno:op_crates/web/00_infra.js", - include_str!("00_infra.js"), - ), - ( - "deno:op_crates/web/01_dom_exception.js", - include_str!("01_dom_exception.js"), - ), - ( - "deno:op_crates/web/01_mimesniff.js", - include_str!("01_mimesniff.js"), - ), - ( - "deno:op_crates/web/02_event.js", - include_str!("02_event.js"), - ), - ( - "deno:op_crates/web/03_abort_signal.js", - include_str!("03_abort_signal.js"), - ), - ( - "deno:op_crates/web/04_global_interfaces.js", - include_str!("04_global_interfaces.js"), - ), - ( - "deno:op_crates/web/08_text_encoding.js", - include_str!("08_text_encoding.js"), - ), - ( - "deno:op_crates/web/12_location.js", - include_str!("12_location.js"), - ), - ]; - for (url, source_code) in files { - isolate.execute(url, source_code).unwrap(); - } +pub fn init() -> Extension { + Extension::pure_js(include_js_files!( + prefix "deno:op_crates/web", + "00_infra.js", + "01_dom_exception.js", + "01_mimesniff.js", + "02_event.js", + "03_abort_signal.js", + "04_global_interfaces.js", + "08_text_encoding.js", + "12_location.js", + )) } pub fn get_declaration() -> PathBuf { diff --git a/op_crates/webgpu/lib.rs b/op_crates/webgpu/lib.rs index 62ec08ce7..a9cbbb882 100644 --- a/op_crates/webgpu/lib.rs +++ b/op_crates/webgpu/lib.rs @@ -2,6 +2,11 @@ use deno_core::error::AnyError; use deno_core::error::{bad_resource_id, not_supported}; +use deno_core::include_js_files; +use deno_core::op_async; +use deno_core::op_sync; +use deno_core::Extension; +use deno_core::OpFn; use deno_core::OpState; use deno_core::Resource; use deno_core::ResourceId; @@ -89,21 +94,23 @@ impl Resource for WebGpuQuerySet { } } -/// Execute this crates' JS source files. -pub fn init(isolate: &mut deno_core::JsRuntime) { - let files = vec![ - ( - "deno:op_crates/webgpu/01_webgpu.js", - include_str!("01_webgpu.js"), - ), - ( - "deno:op_crates/webgpu/02_idl_types.js", - include_str!("02_idl_types.js"), +pub fn init(unstable: bool) -> Extension { + Extension::with_ops( + include_js_files!( + prefix "deno:op_crates/webgpu", + "01_webgpu.js", + "02_idl_types.js", ), - ]; - for (url, source_code) in files { - isolate.execute(url, source_code).unwrap(); - } + declare_webgpu_ops(), + Some(Box::new(move |state| { + // TODO: check & possibly streamline this + // Unstable might be able to be OpMiddleware + // let unstable_checker = state.borrow::<super::UnstableChecker>(); + // let unstable = unstable_checker.unstable; + state.put(Unstable(unstable)); + Ok(()) + })), + ) } pub fn get_declaration() -> PathBuf { @@ -537,3 +544,328 @@ pub fn op_webgpu_create_query_set( Ok(WebGpuResult::rid_err(rid, maybe_err)) } + +fn declare_webgpu_ops() -> Vec<(&'static str, Box<OpFn>)> { + vec![ + // Request device/adapter + ( + "op_webgpu_request_adapter", + op_async(op_webgpu_request_adapter), + ), + ( + "op_webgpu_request_device", + op_async(op_webgpu_request_device), + ), + // Query Set + ( + "op_webgpu_create_query_set", + op_sync(op_webgpu_create_query_set), + ), + // buffer + ( + "op_webgpu_create_buffer", + op_sync(buffer::op_webgpu_create_buffer), + ), + ( + "op_webgpu_buffer_get_mapped_range", + op_sync(buffer::op_webgpu_buffer_get_mapped_range), + ), + ( + "op_webgpu_buffer_unmap", + op_sync(buffer::op_webgpu_buffer_unmap), + ), + // buffer async + ( + "op_webgpu_buffer_get_map_async", + op_async(buffer::op_webgpu_buffer_get_map_async), + ), + // remaining sync ops + + // texture + ( + "op_webgpu_create_texture", + op_sync(texture::op_webgpu_create_texture), + ), + ( + "op_webgpu_create_texture_view", + op_sync(texture::op_webgpu_create_texture_view), + ), + // sampler + ( + "op_webgpu_create_sampler", + op_sync(sampler::op_webgpu_create_sampler), + ), + // binding + ( + "op_webgpu_create_bind_group_layout", + op_sync(binding::op_webgpu_create_bind_group_layout), + ), + ( + "op_webgpu_create_pipeline_layout", + op_sync(binding::op_webgpu_create_pipeline_layout), + ), + ( + "op_webgpu_create_bind_group", + op_sync(binding::op_webgpu_create_bind_group), + ), + // pipeline + ( + "op_webgpu_create_compute_pipeline", + op_sync(pipeline::op_webgpu_create_compute_pipeline), + ), + ( + "op_webgpu_compute_pipeline_get_bind_group_layout", + op_sync(pipeline::op_webgpu_compute_pipeline_get_bind_group_layout), + ), + ( + "op_webgpu_create_render_pipeline", + op_sync(pipeline::op_webgpu_create_render_pipeline), + ), + ( + "op_webgpu_render_pipeline_get_bind_group_layout", + op_sync(pipeline::op_webgpu_render_pipeline_get_bind_group_layout), + ), + // command_encoder + ( + "op_webgpu_create_command_encoder", + op_sync(command_encoder::op_webgpu_create_command_encoder), + ), + ( + "op_webgpu_command_encoder_begin_render_pass", + op_sync(command_encoder::op_webgpu_command_encoder_begin_render_pass), + ), + ( + "op_webgpu_command_encoder_begin_compute_pass", + op_sync(command_encoder::op_webgpu_command_encoder_begin_compute_pass), + ), + ( + "op_webgpu_command_encoder_copy_buffer_to_buffer", + op_sync(command_encoder::op_webgpu_command_encoder_copy_buffer_to_buffer), + ), + ( + "op_webgpu_command_encoder_copy_buffer_to_texture", + op_sync( + command_encoder::op_webgpu_command_encoder_copy_buffer_to_texture, + ), + ), + ( + "op_webgpu_command_encoder_copy_texture_to_buffer", + op_sync( + command_encoder::op_webgpu_command_encoder_copy_texture_to_buffer, + ), + ), + ( + "op_webgpu_command_encoder_copy_texture_to_texture", + op_sync( + command_encoder::op_webgpu_command_encoder_copy_texture_to_texture, + ), + ), + ( + "op_webgpu_command_encoder_push_debug_group", + op_sync(command_encoder::op_webgpu_command_encoder_push_debug_group), + ), + ( + "op_webgpu_command_encoder_pop_debug_group", + op_sync(command_encoder::op_webgpu_command_encoder_pop_debug_group), + ), + ( + "op_webgpu_command_encoder_insert_debug_marker", + op_sync(command_encoder::op_webgpu_command_encoder_insert_debug_marker), + ), + ( + "op_webgpu_command_encoder_write_timestamp", + op_sync(command_encoder::op_webgpu_command_encoder_write_timestamp), + ), + ( + "op_webgpu_command_encoder_resolve_query_set", + op_sync(command_encoder::op_webgpu_command_encoder_resolve_query_set), + ), + ( + "op_webgpu_command_encoder_finish", + op_sync(command_encoder::op_webgpu_command_encoder_finish), + ), + // render_pass + ( + "op_webgpu_render_pass_set_viewport", + op_sync(render_pass::op_webgpu_render_pass_set_viewport), + ), + ( + "op_webgpu_render_pass_set_scissor_rect", + op_sync(render_pass::op_webgpu_render_pass_set_scissor_rect), + ), + ( + "op_webgpu_render_pass_set_blend_color", + op_sync(render_pass::op_webgpu_render_pass_set_blend_color), + ), + ( + "op_webgpu_render_pass_set_stencil_reference", + op_sync(render_pass::op_webgpu_render_pass_set_stencil_reference), + ), + ( + "op_webgpu_render_pass_begin_pipeline_statistics_query", + op_sync( + render_pass::op_webgpu_render_pass_begin_pipeline_statistics_query, + ), + ), + ( + "op_webgpu_render_pass_end_pipeline_statistics_query", + op_sync(render_pass::op_webgpu_render_pass_end_pipeline_statistics_query), + ), + ( + "op_webgpu_render_pass_write_timestamp", + op_sync(render_pass::op_webgpu_render_pass_write_timestamp), + ), + ( + "op_webgpu_render_pass_execute_bundles", + op_sync(render_pass::op_webgpu_render_pass_execute_bundles), + ), + ( + "op_webgpu_render_pass_end_pass", + op_sync(render_pass::op_webgpu_render_pass_end_pass), + ), + ( + "op_webgpu_render_pass_set_bind_group", + op_sync(render_pass::op_webgpu_render_pass_set_bind_group), + ), + ( + "op_webgpu_render_pass_push_debug_group", + op_sync(render_pass::op_webgpu_render_pass_push_debug_group), + ), + ( + "op_webgpu_render_pass_pop_debug_group", + op_sync(render_pass::op_webgpu_render_pass_pop_debug_group), + ), + ( + "op_webgpu_render_pass_insert_debug_marker", + op_sync(render_pass::op_webgpu_render_pass_insert_debug_marker), + ), + ( + "op_webgpu_render_pass_set_pipeline", + op_sync(render_pass::op_webgpu_render_pass_set_pipeline), + ), + ( + "op_webgpu_render_pass_set_index_buffer", + op_sync(render_pass::op_webgpu_render_pass_set_index_buffer), + ), + ( + "op_webgpu_render_pass_set_vertex_buffer", + op_sync(render_pass::op_webgpu_render_pass_set_vertex_buffer), + ), + ( + "op_webgpu_render_pass_draw", + op_sync(render_pass::op_webgpu_render_pass_draw), + ), + ( + "op_webgpu_render_pass_draw_indexed", + op_sync(render_pass::op_webgpu_render_pass_draw_indexed), + ), + ( + "op_webgpu_render_pass_draw_indirect", + op_sync(render_pass::op_webgpu_render_pass_draw_indirect), + ), + ( + "op_webgpu_render_pass_draw_indexed_indirect", + op_sync(render_pass::op_webgpu_render_pass_draw_indexed_indirect), + ), + // compute_pass + ( + "op_webgpu_compute_pass_set_pipeline", + op_sync(compute_pass::op_webgpu_compute_pass_set_pipeline), + ), + ( + "op_webgpu_compute_pass_dispatch", + op_sync(compute_pass::op_webgpu_compute_pass_dispatch), + ), + ( + "op_webgpu_compute_pass_dispatch_indirect", + op_sync(compute_pass::op_webgpu_compute_pass_dispatch_indirect), + ), + ( + "op_webgpu_compute_pass_end_pass", + op_sync(compute_pass::op_webgpu_compute_pass_end_pass), + ), + ( + "op_webgpu_compute_pass_set_bind_group", + op_sync(compute_pass::op_webgpu_compute_pass_set_bind_group), + ), + ( + "op_webgpu_compute_pass_push_debug_group", + op_sync(compute_pass::op_webgpu_compute_pass_push_debug_group), + ), + ( + "op_webgpu_compute_pass_pop_debug_group", + op_sync(compute_pass::op_webgpu_compute_pass_pop_debug_group), + ), + ( + "op_webgpu_compute_pass_insert_debug_marker", + op_sync(compute_pass::op_webgpu_compute_pass_insert_debug_marker), + ), + // bundle + ( + "op_webgpu_create_render_bundle_encoder", + op_sync(bundle::op_webgpu_create_render_bundle_encoder), + ), + ( + "op_webgpu_render_bundle_encoder_finish", + op_sync(bundle::op_webgpu_render_bundle_encoder_finish), + ), + ( + "op_webgpu_render_bundle_encoder_set_bind_group", + op_sync(bundle::op_webgpu_render_bundle_encoder_set_bind_group), + ), + ( + "op_webgpu_render_bundle_encoder_push_debug_group", + op_sync(bundle::op_webgpu_render_bundle_encoder_push_debug_group), + ), + ( + "op_webgpu_render_bundle_encoder_pop_debug_group", + op_sync(bundle::op_webgpu_render_bundle_encoder_pop_debug_group), + ), + ( + "op_webgpu_render_bundle_encoder_insert_debug_marker", + op_sync(bundle::op_webgpu_render_bundle_encoder_insert_debug_marker), + ), + ( + "op_webgpu_render_bundle_encoder_set_pipeline", + op_sync(bundle::op_webgpu_render_bundle_encoder_set_pipeline), + ), + ( + "op_webgpu_render_bundle_encoder_set_index_buffer", + op_sync(bundle::op_webgpu_render_bundle_encoder_set_index_buffer), + ), + ( + "op_webgpu_render_bundle_encoder_set_vertex_buffer", + op_sync(bundle::op_webgpu_render_bundle_encoder_set_vertex_buffer), + ), + ( + "op_webgpu_render_bundle_encoder_draw", + op_sync(bundle::op_webgpu_render_bundle_encoder_draw), + ), + ( + "op_webgpu_render_bundle_encoder_draw_indexed", + op_sync(bundle::op_webgpu_render_bundle_encoder_draw_indexed), + ), + ( + "op_webgpu_render_bundle_encoder_draw_indirect", + op_sync(bundle::op_webgpu_render_bundle_encoder_draw_indirect), + ), + // queue + ( + "op_webgpu_queue_submit", + op_sync(queue::op_webgpu_queue_submit), + ), + ( + "op_webgpu_write_buffer", + op_sync(queue::op_webgpu_write_buffer), + ), + ( + "op_webgpu_write_texture", + op_sync(queue::op_webgpu_write_texture), + ), + // shader + ( + "op_webgpu_create_shader_module", + op_sync(shader::op_webgpu_create_shader_module), + ), + ] +} diff --git a/op_crates/webidl/lib.rs b/op_crates/webidl/lib.rs index 7e617c7a7..a1a404dbd 100644 --- a/op_crates/webidl/lib.rs +++ b/op_crates/webidl/lib.rs @@ -1,14 +1,11 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. -use deno_core::JsRuntime; +use deno_core::Extension; /// Load and execute the javascript code. -pub fn init(isolate: &mut JsRuntime) { - let files = vec![( +pub fn init() -> Extension { + Extension::pure_js(vec![( "deno:op_crates/webidl/00_webidl.js", include_str!("00_webidl.js"), - )]; - for (url, source_code) in files { - isolate.execute(url, source_code).unwrap(); - } + )]) } diff --git a/op_crates/websocket/lib.rs b/op_crates/websocket/lib.rs index a2454b8e3..c682c6b2f 100644 --- a/op_crates/websocket/lib.rs +++ b/op_crates/websocket/lib.rs @@ -9,11 +9,14 @@ use deno_core::futures::stream::SplitSink; use deno_core::futures::stream::SplitStream; use deno_core::futures::SinkExt; use deno_core::futures::StreamExt; +use deno_core::include_js_files; +use deno_core::op_async; +use deno_core::op_sync; use deno_core::url; use deno_core::AsyncRefCell; use deno_core::CancelFuture; use deno_core::CancelHandle; -use deno_core::JsRuntime; +use deno_core::Extension; use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; @@ -333,14 +336,33 @@ pub async fn op_ws_next_event( Ok(res) } -/// Load and execute the javascript code. -pub fn init(isolate: &mut JsRuntime) { - isolate - .execute( - "deno:op_crates/websocket/01_websocket.js", - include_str!("01_websocket.js"), - ) - .unwrap(); +pub fn init<P: WebSocketPermissions + 'static>( + user_agent: String, + ca_data: Option<Vec<u8>>, +) -> Extension { + Extension::with_ops( + include_js_files!( + prefix "deno:op_crates/websocket", + "01_websocket.js", + ), + vec![ + ( + "op_ws_check_permission", + op_sync(op_ws_check_permission::<P>), + ), + ("op_ws_create", op_async(op_ws_create::<P>)), + ("op_ws_send", op_async(op_ws_send)), + ("op_ws_close", op_async(op_ws_close)), + ("op_ws_next_event", op_async(op_ws_next_event)), + ], + Some(Box::new(move |state| { + state.put::<WsUserAgent>(WsUserAgent(user_agent.clone())); + if let Some(ca_data) = ca_data.clone() { + state.put::<WsCaData>(WsCaData(ca_data)); + } + Ok(()) + })), + ) } pub fn get_declaration() -> PathBuf { |