summaryrefslogtreecommitdiff
path: root/ext
diff options
context:
space:
mode:
Diffstat (limited to 'ext')
-rw-r--r--ext/broadcast_channel/lib.rs62
-rw-r--r--ext/cache/lib.rs64
-rw-r--r--ext/console/lib.rs17
-rw-r--r--ext/crypto/lib.rs105
-rw-r--r--ext/fetch/lib.rs97
-rw-r--r--ext/ffi/lib.rs168
-rw-r--r--ext/flash/lib.rs111
-rw-r--r--ext/fs/lib.rs161
-rw-r--r--ext/http/lib.rs47
-rw-r--r--ext/io/lib.rs126
-rw-r--r--ext/napi/lib.rs125
-rw-r--r--ext/net/lib.rs86
-rw-r--r--ext/net/ops.rs43
-rw-r--r--ext/net/ops_tls.rs11
-rw-r--r--ext/node/lib.rs166
-rw-r--r--ext/tls/lib.rs7
-rw-r--r--ext/url/benches/url_ops.rs4
-rw-r--r--ext/url/lib.rs44
-rw-r--r--ext/web/benches/encoding.rs12
-rw-r--r--ext/web/benches/timers_ops.rs9
-rw-r--r--ext/web/lib.rs156
-rw-r--r--ext/webidl/benches/dict.rs2
-rw-r--r--ext/webidl/lib.rs13
-rw-r--r--ext/websocket/lib.rs88
-rw-r--r--ext/webstorage/lib.rs58
25 files changed, 701 insertions, 1081 deletions
diff --git a/ext/broadcast_channel/lib.rs b/ext/broadcast_channel/lib.rs
index 14884e99c..3df11566f 100644
--- a/ext/broadcast_channel/lib.rs
+++ b/ext/broadcast_channel/lib.rs
@@ -2,7 +2,6 @@
mod in_memory_broadcast_channel;
-use deno_core::ExtensionBuilder;
pub use in_memory_broadcast_channel::InMemoryBroadcastChannel;
pub use in_memory_broadcast_channel::InMemoryBroadcastChannelResource;
@@ -12,9 +11,7 @@ use std::rc::Rc;
use async_trait::async_trait;
use deno_core::error::AnyError;
-use deno_core::include_js_files;
use deno_core::op;
-use deno_core::Extension;
use deno_core::OpState;
use deno_core::Resource;
use deno_core::ResourceId;
@@ -107,46 +104,25 @@ where
bc.recv(&resource).await
}
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(
- env!("CARGO_PKG_NAME"),
- &["deno_webidl", "deno_web"],
- )
-}
-
-fn ops<BC: BroadcastChannel + 'static>(
- ext: &mut ExtensionBuilder,
- bc: BC,
- unstable: bool,
-) -> &mut ExtensionBuilder {
- ext
- .ops(vec![
- op_broadcast_subscribe::decl::<BC>(),
- op_broadcast_unsubscribe::decl::<BC>(),
- op_broadcast_send::decl::<BC>(),
- op_broadcast_recv::decl::<BC>(),
- ])
- .state(move |state| {
- state.put(bc.clone());
- state.put(Unstable(unstable));
- })
-}
-
-pub fn init_ops_and_esm<BC: BroadcastChannel + 'static>(
- bc: BC,
- unstable: bool,
-) -> Extension {
- ops::<BC>(&mut ext(), bc, unstable)
- .esm(include_js_files!("01_broadcast_channel.js",))
- .build()
-}
-
-pub fn init_ops<BC: BroadcastChannel + 'static>(
- bc: BC,
- unstable: bool,
-) -> Extension {
- ops::<BC>(&mut ext(), bc, unstable).build()
-}
+deno_core::extension!(deno_broadcast_channel,
+ deps = [ deno_webidl, deno_web ],
+ parameters = [BC: BroadcastChannel],
+ ops = [
+ op_broadcast_subscribe<BC>,
+ op_broadcast_unsubscribe<BC>,
+ op_broadcast_send<BC>,
+ op_broadcast_recv<BC>,
+ ],
+ esm = [ "01_broadcast_channel.js" ],
+ config = {
+ bc: BC,
+ unstable: bool,
+ },
+ state = |state, bc, unstable| {
+ state.put(bc);
+ state.put(Unstable(unstable));
+ },
+);
pub fn get_declaration() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
diff --git a/ext/cache/lib.rs b/ext/cache/lib.rs
index a89296df9..eaf56c8b7 100644
--- a/ext/cache/lib.rs
+++ b/ext/cache/lib.rs
@@ -7,13 +7,10 @@ use std::sync::Arc;
use async_trait::async_trait;
use deno_core::error::AnyError;
-use deno_core::include_js_files;
use deno_core::op;
use deno_core::serde::Deserialize;
use deno_core::serde::Serialize;
use deno_core::ByteString;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::OpState;
use deno_core::Resource;
use deno_core::ResourceId;
@@ -23,46 +20,27 @@ pub use sqlite::SqliteBackedCache;
#[derive(Clone)]
pub struct CreateCache<C: Cache + 'static>(pub Arc<dyn Fn() -> C>);
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(
- env!("CARGO_PKG_NAME"),
- &["deno_webidl", "deno_web", "deno_url", "deno_fetch"],
- )
-}
-
-fn ops<CA: Cache + 'static>(
- ext: &mut ExtensionBuilder,
- maybe_create_cache: Option<CreateCache<CA>>,
-) -> &mut ExtensionBuilder {
- ext
- .ops(vec![
- op_cache_storage_open::decl::<CA>(),
- op_cache_storage_has::decl::<CA>(),
- op_cache_storage_delete::decl::<CA>(),
- op_cache_put::decl::<CA>(),
- op_cache_match::decl::<CA>(),
- op_cache_delete::decl::<CA>(),
- ])
- .state(move |state| {
- if let Some(create_cache) = maybe_create_cache.clone() {
- state.put(create_cache);
- }
- })
-}
-
-pub fn init_ops_and_esm<CA: Cache + 'static>(
- maybe_create_cache: Option<CreateCache<CA>>,
-) -> Extension {
- ops::<CA>(&mut ext(), maybe_create_cache)
- .esm(include_js_files!("01_cache.js",))
- .build()
-}
-
-pub fn init_ops<CA: Cache + 'static>(
- maybe_create_cache: Option<CreateCache<CA>>,
-) -> Extension {
- ops::<CA>(&mut ext(), maybe_create_cache).build()
-}
+deno_core::extension!(deno_cache,
+ deps = [ deno_webidl, deno_web, deno_url, deno_fetch ],
+ parameters=[CA: Cache],
+ ops = [
+ op_cache_storage_open<CA>,
+ op_cache_storage_has<CA>,
+ op_cache_storage_delete<CA>,
+ op_cache_put<CA>,
+ op_cache_match<CA>,
+ op_cache_delete<CA>,
+ ],
+ esm = [ "01_cache.js" ],
+ config = {
+ maybe_create_cache: Option<CreateCache<CA>>,
+ },
+ state = |state, maybe_create_cache| {
+ if let Some(create_cache) = maybe_create_cache {
+ state.put(create_cache);
+ }
+ },
+);
pub fn get_declaration() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_cache.d.ts")
diff --git a/ext/console/lib.rs b/ext/console/lib.rs
index a9a30c328..a45b856cd 100644
--- a/ext/console/lib.rs
+++ b/ext/console/lib.rs
@@ -1,22 +1,7 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-
-use deno_core::include_js_files;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use std::path::PathBuf;
-fn ext() -> ExtensionBuilder {
- Extension::builder(env!("CARGO_PKG_NAME"))
-}
-pub fn init() -> Extension {
- ext().build()
-}
-
-pub fn init_esm() -> Extension {
- ext()
- .esm(include_js_files!("01_colors.js", "02_console.js",))
- .build()
-}
+deno_core::extension!(deno_console, esm = ["01_colors.js", "02_console.js"],);
pub fn get_declaration() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_console.d.ts")
diff --git a/ext/crypto/lib.rs b/ext/crypto/lib.rs
index 89ca8e0d6..48c5acf4a 100644
--- a/ext/crypto/lib.rs
+++ b/ext/crypto/lib.rs
@@ -8,11 +8,8 @@ use deno_core::error::custom_error;
use deno_core::error::not_supported;
use deno_core::error::type_error;
use deno_core::error::AnyError;
-use deno_core::include_js_files;
use deno_core::op;
-use deno_core::ExtensionBuilder;
-use deno_core::Extension;
use deno_core::OpState;
use deno_core::ZeroCopyBuf;
use serde::Deserialize;
@@ -73,65 +70,49 @@ use crate::key::CryptoNamedCurve;
use crate::key::HkdfOutput;
use crate::shared::RawKeyData;
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(
- env!("CARGO_PKG_NAME"),
- &["deno_webidl", "deno_web"],
- )
-}
-
-fn ops(
- ext: &mut ExtensionBuilder,
- maybe_seed: Option<u64>,
-) -> &mut ExtensionBuilder {
- ext
- .ops(vec![
- op_crypto_get_random_values::decl(),
- op_crypto_generate_key::decl(),
- op_crypto_sign_key::decl(),
- op_crypto_verify_key::decl(),
- op_crypto_derive_bits::decl(),
- op_crypto_import_key::decl(),
- op_crypto_export_key::decl(),
- op_crypto_encrypt::decl(),
- op_crypto_decrypt::decl(),
- op_crypto_subtle_digest::decl(),
- op_crypto_random_uuid::decl(),
- op_crypto_wrap_key::decl(),
- op_crypto_unwrap_key::decl(),
- op_crypto_base64url_decode::decl(),
- op_crypto_base64url_encode::decl(),
- x25519::op_generate_x25519_keypair::decl(),
- x25519::op_derive_bits_x25519::decl(),
- x25519::op_import_spki_x25519::decl(),
- x25519::op_import_pkcs8_x25519::decl(),
- ed25519::op_generate_ed25519_keypair::decl(),
- ed25519::op_import_spki_ed25519::decl(),
- ed25519::op_import_pkcs8_ed25519::decl(),
- ed25519::op_sign_ed25519::decl(),
- ed25519::op_verify_ed25519::decl(),
- ed25519::op_export_spki_ed25519::decl(),
- ed25519::op_export_pkcs8_ed25519::decl(),
- ed25519::op_jwk_x_ed25519::decl(),
- x25519::op_export_spki_x25519::decl(),
- x25519::op_export_pkcs8_x25519::decl(),
- ])
- .state(move |state| {
- if let Some(seed) = maybe_seed {
- state.put(StdRng::seed_from_u64(seed));
- }
- })
-}
-
-pub fn init_ops_and_esm(maybe_seed: Option<u64>) -> Extension {
- ops(&mut ext(), maybe_seed)
- .esm(include_js_files!("00_crypto.js", "01_webidl.js",))
- .build()
-}
-
-pub fn init_ops(maybe_seed: Option<u64>) -> Extension {
- ops(&mut ext(), maybe_seed).build()
-}
+deno_core::extension!(deno_crypto,
+ deps = [ deno_webidl, deno_web ],
+ ops = [
+ op_crypto_get_random_values,
+ op_crypto_generate_key,
+ op_crypto_sign_key,
+ op_crypto_verify_key,
+ op_crypto_derive_bits,
+ op_crypto_import_key,
+ op_crypto_export_key,
+ op_crypto_encrypt,
+ op_crypto_decrypt,
+ op_crypto_subtle_digest,
+ op_crypto_random_uuid,
+ op_crypto_wrap_key,
+ op_crypto_unwrap_key,
+ op_crypto_base64url_decode,
+ op_crypto_base64url_encode,
+ x25519::op_generate_x25519_keypair,
+ x25519::op_derive_bits_x25519,
+ x25519::op_import_spki_x25519,
+ x25519::op_import_pkcs8_x25519,
+ ed25519::op_generate_ed25519_keypair,
+ ed25519::op_import_spki_ed25519,
+ ed25519::op_import_pkcs8_ed25519,
+ ed25519::op_sign_ed25519,
+ ed25519::op_verify_ed25519,
+ ed25519::op_export_spki_ed25519,
+ ed25519::op_export_pkcs8_ed25519,
+ ed25519::op_jwk_x_ed25519,
+ x25519::op_export_spki_x25519,
+ x25519::op_export_pkcs8_x25519,
+ ],
+ esm = [ "00_crypto.js", "01_webidl.js" ],
+ config = {
+ maybe_seed: Option<u64>,
+ },
+ state = |state, maybe_seed| {
+ if let Some(seed) = maybe_seed {
+ state.put(StdRng::seed_from_u64(seed));
+ }
+ },
+);
#[op]
pub fn op_crypto_base64url_decode(data: String) -> ZeroCopyBuf {
diff --git a/ext/fetch/lib.rs b/ext/fetch/lib.rs
index 20885dda5..4cd5d68c8 100644
--- a/ext/fetch/lib.rs
+++ b/ext/fetch/lib.rs
@@ -10,10 +10,8 @@ use deno_core::futures::stream::Peekable;
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;
use deno_core::BufView;
-use deno_core::ExtensionBuilder;
use deno_core::WriteOutcome;
use deno_core::url::Url;
@@ -24,7 +22,6 @@ use deno_core::CancelFuture;
use deno_core::CancelHandle;
use deno_core::CancelTryFuture;
use deno_core::Canceled;
-use deno_core::Extension;
use deno_core::OpState;
use deno_core::RcRef;
use deno_core::Resource;
@@ -93,65 +90,41 @@ impl Default for Options {
}
}
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(
- env!("CARGO_PKG_NAME"),
- &["deno_webidl", "deno_web", "deno_url", "deno_console"],
- )
-}
-
-fn ops<FP>(
- ext: &mut ExtensionBuilder,
- options: Options,
-) -> &mut ExtensionBuilder
-where
- FP: FetchPermissions + 'static,
-{
- ext
- .ops(vec![
- op_fetch::decl::<FP>(),
- op_fetch_send::decl(),
- op_fetch_custom_client::decl::<FP>(),
- ])
- .state(move |state| {
- state.put::<Options>(options.clone());
- state.put::<reqwest::Client>({
- create_http_client(
- options.user_agent.clone(),
- options.root_cert_store.clone(),
- vec![],
- options.proxy.clone(),
- options.unsafely_ignore_certificate_errors.clone(),
- options.client_cert_chain_and_key.clone(),
- )
- .unwrap()
- });
- })
-}
-
-pub fn init_ops_and_esm<FP>(options: Options) -> Extension
-where
- FP: FetchPermissions + 'static,
-{
- ops::<FP>(&mut ext(), options)
- .esm(include_js_files!(
- "20_headers.js",
- "21_formdata.js",
- "22_body.js",
- "22_http_client.js",
- "23_request.js",
- "23_response.js",
- "26_fetch.js",
- ))
- .build()
-}
-
-pub fn init_ops<FP>(options: Options) -> Extension
-where
- FP: FetchPermissions + 'static,
-{
- ops::<FP>(&mut ext(), options).build()
-}
+deno_core::extension!(deno_fetch,
+ deps = [ deno_webidl, deno_web, deno_url, deno_console ],
+ parameters = [FP: FetchPermissions],
+ ops = [
+ op_fetch<FP>,
+ op_fetch_send,
+ op_fetch_custom_client<FP>,
+ ],
+ esm = [
+ "20_headers.js",
+ "21_formdata.js",
+ "22_body.js",
+ "22_http_client.js",
+ "23_request.js",
+ "23_response.js",
+ "26_fetch.js"
+ ],
+ config = {
+ options: Options,
+ },
+ state = |state, options| {
+ state.put::<Options>(options.clone());
+ state.put::<reqwest::Client>({
+ create_http_client(
+ options.user_agent,
+ options.root_cert_store,
+ vec![],
+ options.proxy,
+ options.unsafely_ignore_certificate_errors,
+ options.client_cert_chain_and_key
+ )
+ .unwrap()
+ });
+ },
+);
pub type CancelableResponseFuture =
Pin<Box<dyn Future<Output = CancelableResponseResult>>>;
diff --git a/ext/ffi/lib.rs b/ext/ffi/lib.rs
index 2b90cd1c4..1fd01c9d2 100644
--- a/ext/ffi/lib.rs
+++ b/ext/ffi/lib.rs
@@ -2,10 +2,7 @@
use deno_core::error::AnyError;
use deno_core::futures::channel::mpsc;
-use deno_core::include_js_files;
use deno_core::v8;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::OpState;
use std::cell::RefCell;
@@ -82,92 +79,83 @@ pub(crate) struct FfiState {
pub(crate) async_work_receiver: mpsc::UnboundedReceiver<PendingFfiAsyncWork>,
}
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(env!("CARGO_PKG_NAME"), &["deno_web"])
-}
-
-fn ops<P: FfiPermissions + 'static>(
- ext: &mut ExtensionBuilder,
- unstable: bool,
-) -> &mut ExtensionBuilder {
- ext
- .ops(vec![
- op_ffi_load::decl::<P>(),
- op_ffi_get_static::decl(),
- op_ffi_call_nonblocking::decl(),
- op_ffi_call_ptr::decl::<P>(),
- op_ffi_call_ptr_nonblocking::decl::<P>(),
- op_ffi_ptr_create::decl::<P>(),
- op_ffi_ptr_equals::decl::<P>(),
- op_ffi_ptr_of::decl::<P>(),
- op_ffi_ptr_offset::decl::<P>(),
- op_ffi_ptr_value::decl::<P>(),
- op_ffi_get_buf::decl::<P>(),
- op_ffi_buf_copy_into::decl::<P>(),
- op_ffi_cstr_read::decl::<P>(),
- op_ffi_read_bool::decl::<P>(),
- op_ffi_read_u8::decl::<P>(),
- op_ffi_read_i8::decl::<P>(),
- op_ffi_read_u16::decl::<P>(),
- op_ffi_read_i16::decl::<P>(),
- op_ffi_read_u32::decl::<P>(),
- op_ffi_read_i32::decl::<P>(),
- op_ffi_read_u64::decl::<P>(),
- op_ffi_read_i64::decl::<P>(),
- op_ffi_read_f32::decl::<P>(),
- op_ffi_read_f64::decl::<P>(),
- op_ffi_read_ptr::decl::<P>(),
- op_ffi_unsafe_callback_create::decl::<P>(),
- op_ffi_unsafe_callback_ref::decl(),
- ])
- .event_loop_middleware(|op_state_rc, _cx| {
- // FFI callbacks coming in from other threads will call in and get queued.
- let mut maybe_scheduling = false;
-
- let mut work_items: Vec<PendingFfiAsyncWork> = vec![];
-
- {
- let mut op_state = op_state_rc.borrow_mut();
- let ffi_state = op_state.borrow_mut::<FfiState>();
-
- while let Ok(Some(async_work_fut)) =
- ffi_state.async_work_receiver.try_next()
- {
- // Move received items to a temporary vector so that we can drop the `op_state` borrow before we do the work.
- work_items.push(async_work_fut);
- maybe_scheduling = true;
- }
-
- drop(op_state);
- }
- while let Some(async_work_fut) = work_items.pop() {
- async_work_fut();
- }
-
- maybe_scheduling
- })
- .state(move |state| {
- // Stolen from deno_webgpu, is there a better option?
- state.put(Unstable(unstable));
-
- let (async_work_sender, async_work_receiver) =
- mpsc::unbounded::<PendingFfiAsyncWork>();
-
- state.put(FfiState {
- async_work_receiver,
- async_work_sender,
- });
- })
-}
-
-pub fn init_ops_and_esm<P: FfiPermissions + 'static>(
- unstable: bool,
-) -> Extension {
- ops::<P>(&mut ext(), unstable)
- .esm(include_js_files!("00_ffi.js",))
- .build()
-}
+deno_core::extension!(deno_ffi,
+ deps = [ deno_web ],
+ parameters = [P: FfiPermissions],
+ ops = [
+ op_ffi_load<P>,
+ op_ffi_get_static,
+ op_ffi_call_nonblocking,
+ op_ffi_call_ptr<P>,
+ op_ffi_call_ptr_nonblocking<P>,
+ op_ffi_ptr_create<P>,
+ op_ffi_ptr_equals<P>,
+ op_ffi_ptr_of<P>,
+ op_ffi_ptr_offset<P>,
+ op_ffi_ptr_value<P>,
+ op_ffi_get_buf<P>,
+ op_ffi_buf_copy_into<P>,
+ op_ffi_cstr_read<P>,
+ op_ffi_read_bool<P>,
+ op_ffi_read_u8<P>,
+ op_ffi_read_i8<P>,
+ op_ffi_read_u16<P>,
+ op_ffi_read_i16<P>,
+ op_ffi_read_u32<P>,
+ op_ffi_read_i32<P>,
+ op_ffi_read_u64<P>,
+ op_ffi_read_i64<P>,
+ op_ffi_read_f32<P>,
+ op_ffi_read_f64<P>,
+ op_ffi_read_ptr<P>,
+ op_ffi_unsafe_callback_create<P>,
+ op_ffi_unsafe_callback_ref,
+ ],
+ esm = [ "00_ffi.js" ],
+ config = {
+ unstable: bool,
+ },
+ state = |state, unstable| {
+ // Stolen from deno_webgpu, is there a better option?
+ state.put(Unstable(unstable));
+
+ let (async_work_sender, async_work_receiver) =
+ mpsc::unbounded::<PendingFfiAsyncWork>();
+
+ state.put(FfiState {
+ async_work_receiver,
+ async_work_sender,
+ });
+ },
+ event_loop_middleware = event_loop_middleware,
+);
+
+fn event_loop_middleware(
+ op_state_rc: Rc<RefCell<OpState>>,
+ _cx: &mut std::task::Context,
+) -> bool {
+ // FFI callbacks coming in from other threads will call in and get queued.
+ let mut maybe_scheduling = false;
+
+ let mut work_items: Vec<PendingFfiAsyncWork> = vec![];
+
+ {
+ let mut op_state = op_state_rc.borrow_mut();
+ let ffi_state = op_state.borrow_mut::<FfiState>();
+
+ while let Ok(Some(async_work_fut)) =
+ ffi_state.async_work_receiver.try_next()
+ {
+ // Move received items to a temporary vector so that we can drop the `op_state` borrow before we do the work.
+ work_items.push(async_work_fut);
+ maybe_scheduling = true;
+ }
+
+ drop(op_state);
+ }
+ while let Some(async_work_fut) = work_items.pop() {
+ async_work_fut();
+ }
-pub fn init_ops<P: FfiPermissions + 'static>(unstable: bool) -> Extension {
- ops::<P>(&mut ext(), unstable).build()
+ maybe_scheduling
}
diff --git a/ext/flash/lib.rs b/ext/flash/lib.rs
index 77b8b6791..6f11e14af 100644
--- a/ext/flash/lib.rs
+++ b/ext/flash/lib.rs
@@ -16,8 +16,6 @@ use deno_core::v8::fast_api;
use deno_core::ByteString;
use deno_core::CancelFuture;
use deno_core::CancelHandle;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::OpState;
use deno_core::StringOrBuffer;
use deno_core::ZeroCopyBuf;
@@ -1527,66 +1525,49 @@ pub trait FlashPermissions {
) -> Result<(), AnyError>;
}
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(
- env!("CARGO_PKG_NAME"),
- &[
- "deno_web",
- "deno_net",
- "deno_fetch",
- "deno_websocket",
- "deno_http",
- ],
- )
-}
-
-fn ops<P: FlashPermissions + 'static>(
- ext: &mut ExtensionBuilder,
- unstable: bool,
-) -> &mut ExtensionBuilder {
- ext
- .ops(vec![
- op_flash_serve::decl::<P>(),
- op_node_unstable_flash_serve::decl::<P>(),
- op_flash_respond::decl(),
- op_flash_respond_async::decl(),
- op_flash_respond_chunked::decl(),
- op_flash_method::decl(),
- op_flash_path::decl(),
- op_flash_headers::decl(),
- op_flash_addr::decl(),
- op_flash_next::decl(),
- op_flash_next_server::decl(),
- op_flash_next_async::decl(),
- op_flash_read_body::decl(),
- op_flash_upgrade_websocket::decl(),
- op_flash_drive_server::decl(),
- op_flash_wait_for_listening::decl(),
- op_flash_first_packet::decl(),
- op_flash_has_body_stream::decl(),
- op_flash_close_server::decl(),
- op_flash_make_request::decl(),
- op_flash_write_resource::decl(),
- op_try_flash_respond_chunked::decl(),
- ])
- .state(move |op_state| {
- op_state.put(Unstable(unstable));
- op_state.put(FlashContext {
- next_server_id: 0,
- join_handles: HashMap::default(),
- servers: HashMap::default(),
- });
- })
-}
-
-pub fn init_ops_and_esm<P: FlashPermissions + 'static>(
- unstable: bool,
-) -> Extension {
- ops::<P>(&mut ext(), unstable)
- .esm(deno_core::include_js_files!("01_http.js",))
- .build()
-}
-
-pub fn init_ops<P: FlashPermissions + 'static>(unstable: bool) -> Extension {
- ops::<P>(&mut ext(), unstable).build()
-}
+deno_core::extension!(deno_flash,
+ deps = [
+ deno_web,
+ deno_net,
+ deno_fetch,
+ deno_websocket,
+ deno_http
+ ],
+ parameters = [P: FlashPermissions],
+ ops = [
+ op_flash_serve<P>,
+ op_node_unstable_flash_serve<P>,
+ op_flash_respond,
+ op_flash_respond_async,
+ op_flash_respond_chunked,
+ op_flash_method,
+ op_flash_path,
+ op_flash_headers,
+ op_flash_addr,
+ op_flash_next,
+ op_flash_next_server,
+ op_flash_next_async,
+ op_flash_read_body,
+ op_flash_upgrade_websocket,
+ op_flash_drive_server,
+ op_flash_wait_for_listening,
+ op_flash_first_packet,
+ op_flash_has_body_stream,
+ op_flash_close_server,
+ op_flash_make_request,
+ op_flash_write_resource,
+ op_try_flash_respond_chunked,
+ ],
+ esm = [ "01_http.js" ],
+ config = {
+ unstable: bool,
+ },
+ state = |state, unstable| {
+ state.put(Unstable(unstable));
+ state.put(FlashContext {
+ next_server_id: 0,
+ join_handles: HashMap::default(),
+ servers: HashMap::default(),
+ });
+ },
+);
diff --git a/ext/fs/lib.rs b/ext/fs/lib.rs
index 746d40dff..48b0e3495 100644
--- a/ext/fs/lib.rs
+++ b/ext/fs/lib.rs
@@ -4,12 +4,9 @@
use deno_core::error::custom_error;
use deno_core::error::type_error;
use deno_core::error::AnyError;
-use deno_core::include_js_files;
use deno_core::op;
use deno_core::CancelFuture;
use deno_core::CancelHandle;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::OpState;
use deno_core::ResourceId;
use deno_core::ZeroCopyBuf;
@@ -118,92 +115,78 @@ use deno_core::error::generic_error;
#[cfg(not(unix))]
use deno_core::error::not_supported;
-fn ext() -> ExtensionBuilder {
- Extension::builder("deno_fs")
-}
-
-fn ops<P: FsPermissions + 'static>(
- ext: &mut ExtensionBuilder,
- unstable: bool,
-) -> &mut ExtensionBuilder {
- ext
- .state(move |state| {
- state.put(UnstableChecker { unstable });
- })
- .ops(vec![
- op_open_sync::decl::<P>(),
- op_open_async::decl::<P>(),
- op_write_file_sync::decl::<P>(),
- op_write_file_async::decl::<P>(),
- op_seek_sync::decl(),
- op_seek_async::decl(),
- op_fdatasync_sync::decl(),
- op_fdatasync_async::decl(),
- op_fsync_sync::decl(),
- op_fsync_async::decl(),
- op_fstat_sync::decl(),
- op_fstat_async::decl(),
- op_flock_sync::decl(),
- op_flock_async::decl(),
- op_funlock_sync::decl(),
- op_funlock_async::decl(),
- op_umask::decl(),
- op_chdir::decl::<P>(),
- op_mkdir_sync::decl::<P>(),
- op_mkdir_async::decl::<P>(),
- op_chmod_sync::decl::<P>(),
- op_chmod_async::decl::<P>(),
- op_chown_sync::decl::<P>(),
- op_chown_async::decl::<P>(),
- op_remove_sync::decl::<P>(),
- op_remove_async::decl::<P>(),
- op_copy_file_sync::decl::<P>(),
- op_copy_file_async::decl::<P>(),
- op_stat_sync::decl::<P>(),
- op_stat_async::decl::<P>(),
- op_realpath_sync::decl::<P>(),
- op_realpath_async::decl::<P>(),
- op_read_dir_sync::decl::<P>(),
- op_read_dir_async::decl::<P>(),
- op_rename_sync::decl::<P>(),
- op_rename_async::decl::<P>(),
- op_link_sync::decl::<P>(),
- op_link_async::decl::<P>(),
- op_symlink_sync::decl::<P>(),
- op_symlink_async::decl::<P>(),
- op_read_link_sync::decl::<P>(),
- op_read_link_async::decl::<P>(),
- op_ftruncate_sync::decl(),
- op_ftruncate_async::decl(),
- op_truncate_sync::decl::<P>(),
- op_truncate_async::decl::<P>(),
- op_make_temp_dir_sync::decl::<P>(),
- op_make_temp_dir_async::decl::<P>(),
- op_make_temp_file_sync::decl::<P>(),
- op_make_temp_file_async::decl::<P>(),
- op_cwd::decl::<P>(),
- op_futime_sync::decl(),
- op_futime_async::decl(),
- op_utime_sync::decl::<P>(),
- op_utime_async::decl::<P>(),
- op_readfile_sync::decl::<P>(),
- op_readfile_text_sync::decl::<P>(),
- op_readfile_async::decl::<P>(),
- op_readfile_text_async::decl::<P>(),
- ])
-}
-
-pub fn init_ops_and_esm<P: FsPermissions + 'static>(
- unstable: bool,
-) -> Extension {
- ops::<P>(&mut ext(), unstable)
- .esm(include_js_files!("30_fs.js",))
- .build()
-}
-
-pub fn init_ops<P: FsPermissions + 'static>(unstable: bool) -> Extension {
- ops::<P>(&mut ext(), unstable).build()
-}
+deno_core::extension!(deno_fs,
+ deps = [ deno_web, deno_io ],
+ parameters = [P: FsPermissions],
+ ops = [
+ op_open_sync<P>,
+ op_open_async<P>,
+ op_write_file_sync<P>,
+ op_write_file_async<P>,
+ op_seek_sync,
+ op_seek_async,
+ op_fdatasync_sync,
+ op_fdatasync_async,
+ op_fsync_sync,
+ op_fsync_async,
+ op_fstat_sync,
+ op_fstat_async,
+ op_flock_sync,
+ op_flock_async,
+ op_funlock_sync,
+ op_funlock_async,
+ op_umask,
+ op_chdir<P>,
+ op_mkdir_sync<P>,
+ op_mkdir_async<P>,
+ op_chmod_sync<P>,
+ op_chmod_async<P>,
+ op_chown_sync<P>,
+ op_chown_async<P>,
+ op_remove_sync<P>,
+ op_remove_async<P>,
+ op_copy_file_sync<P>,
+ op_copy_file_async<P>,
+ op_stat_sync<P>,
+ op_stat_async<P>,
+ op_realpath_sync<P>,
+ op_realpath_async<P>,
+ op_read_dir_sync<P>,
+ op_read_dir_async<P>,
+ op_rename_sync<P>,
+ op_rename_async<P>,
+ op_link_sync<P>,
+ op_link_async<P>,
+ op_symlink_sync<P>,
+ op_symlink_async<P>,
+ op_read_link_sync<P>,
+ op_read_link_async<P>,
+ op_ftruncate_sync,
+ op_ftruncate_async,
+ op_truncate_sync<P>,
+ op_truncate_async<P>,
+ op_make_temp_dir_sync<P>,
+ op_make_temp_dir_async<P>,
+ op_make_temp_file_sync<P>,
+ op_make_temp_file_async<P>,
+ op_cwd<P>,
+ op_futime_sync,
+ op_futime_async,
+ op_utime_sync<P>,
+ op_utime_async<P>,
+ op_readfile_sync<P>,
+ op_readfile_text_sync<P>,
+ op_readfile_async<P>,
+ op_readfile_text_async<P>,
+ ],
+ esm = [ "30_fs.js" ],
+ config = {
+ unstable: bool
+ },
+ state = |state, unstable| {
+ state.put(UnstableChecker { unstable });
+ },
+);
fn default_err_mapper(err: Error, desc: String) -> Error {
Error::new(err.kind(), format!("{err}, {desc}"))
diff --git a/ext/http/lib.rs b/ext/http/lib.rs
index 11bd91aa4..20436a82d 100644
--- a/ext/http/lib.rs
+++ b/ext/http/lib.rs
@@ -19,7 +19,6 @@ use deno_core::futures::stream::Peekable;
use deno_core::futures::FutureExt;
use deno_core::futures::StreamExt;
use deno_core::futures::TryFutureExt;
-use deno_core::include_js_files;
use deno_core::op;
use deno_core::AsyncRefCell;
use deno_core::AsyncResult;
@@ -28,8 +27,6 @@ use deno_core::ByteString;
use deno_core::CancelFuture;
use deno_core::CancelHandle;
use deno_core::CancelTryFuture;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::OpState;
use deno_core::RcRef;
use deno_core::Resource;
@@ -78,35 +75,21 @@ use crate::reader_stream::ShutdownHandle;
pub mod compressible;
mod reader_stream;
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(
- env!("CARGO_PKG_NAME"),
- &["deno_web", "deno_net", "deno_fetch", "deno_websocket"],
- )
-}
-
-fn ops(ext: &mut ExtensionBuilder) -> &mut ExtensionBuilder {
- ext.ops(vec![
- op_http_accept::decl(),
- op_http_write_headers::decl(),
- op_http_headers::decl(),
- op_http_write::decl(),
- op_http_write_resource::decl(),
- op_http_shutdown::decl(),
- op_http_websocket_accept_header::decl(),
- op_http_upgrade_websocket::decl(),
- ])
-}
-
-pub fn init_ops_and_esm() -> Extension {
- ops(&mut ext())
- .esm(include_js_files!("01_http.js",))
- .build()
-}
-
-pub fn init_ops() -> Extension {
- ops(&mut ext()).build()
-}
+deno_core::extension!(
+ deno_http,
+ deps = [deno_web, deno_net, deno_fetch, deno_websocket],
+ ops = [
+ op_http_accept,
+ op_http_write_headers,
+ op_http_headers,
+ op_http_write,
+ op_http_write_resource,
+ op_http_shutdown,
+ op_http_websocket_accept_header,
+ op_http_upgrade_websocket,
+ ],
+ esm = ["01_http.js"],
+);
pub enum HttpSocketAddr {
IpSocket(std::net::SocketAddr),
diff --git a/ext/io/lib.rs b/ext/io/lib.rs
index 92f681f1e..bfbb1d94f 100644
--- a/ext/io/lib.rs
+++ b/ext/io/lib.rs
@@ -2,7 +2,6 @@
use deno_core::error::resource_unavailable;
use deno_core::error::AnyError;
-use deno_core::include_js_files;
use deno_core::op;
use deno_core::parking_lot::Mutex;
use deno_core::AsyncMutFuture;
@@ -12,8 +11,6 @@ use deno_core::BufMutView;
use deno_core::BufView;
use deno_core::CancelHandle;
use deno_core::CancelTryFuture;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::OpState;
use deno_core::RcRef;
use deno_core::Resource;
@@ -79,80 +76,61 @@ pub static STDERR_HANDLE: Lazy<StdFile> = Lazy::new(|| {
unsafe { StdFile::from_raw_handle(GetStdHandle(winbase::STD_ERROR_HANDLE)) }
});
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps("deno_io", &["deno_web"])
-}
-
-fn ops(
- ext: &mut ExtensionBuilder,
- stdio: Rc<RefCell<Option<Stdio>>>,
-) -> &mut ExtensionBuilder {
- ext
- .ops(vec![op_read_sync::decl(), op_write_sync::decl()])
- .middleware(|op| match op.name {
- "op_print" => op_print::decl(),
- _ => op,
- })
- .state(move |state| {
- let stdio = stdio
- .borrow_mut()
- .take()
- .expect("Extension only supports being used once.");
- let t = &mut state.resource_table;
-
- let rid = t.add(StdFileResource::stdio(
- match stdio.stdin {
- StdioPipe::Inherit => StdFileResourceInner {
- kind: StdFileResourceKind::Stdin,
- file: STDIN_HANDLE.try_clone().unwrap(),
- },
- StdioPipe::File(pipe) => StdFileResourceInner::file(pipe),
+deno_core::extension!(deno_io,
+ deps = [ deno_web ],
+ ops = [op_read_sync, op_write_sync],
+ esm = [ "12_io.js" ],
+ config = {
+ stdio: Rc<RefCell<Option<Stdio>>>,
+ },
+ middleware = |op| match op.name {
+ "op_print" => op_print::decl(),
+ _ => op,
+ },
+ state = |state, stdio| {
+ let stdio = stdio
+ .borrow_mut()
+ .take()
+ .expect("Extension only supports being used once.");
+ let t = &mut state.resource_table;
+
+ let rid = t.add(StdFileResource::stdio(
+ match stdio.stdin {
+ StdioPipe::Inherit => StdFileResourceInner {
+ kind: StdFileResourceKind::Stdin,
+ file: STDIN_HANDLE.try_clone().unwrap(),
},
- "stdin",
- ));
- assert_eq!(rid, 0, "stdin must have ResourceId 0");
-
- let rid = t.add(StdFileResource::stdio(
- match stdio.stdout {
- StdioPipe::Inherit => StdFileResourceInner {
- kind: StdFileResourceKind::Stdout,
- file: STDOUT_HANDLE.try_clone().unwrap(),
- },
- StdioPipe::File(pipe) => StdFileResourceInner::file(pipe),
+ StdioPipe::File(pipe) => StdFileResourceInner::file(pipe),
+ },
+ "stdin",
+ ));
+ assert_eq!(rid, 0, "stdin must have ResourceId 0");
+
+ let rid = t.add(StdFileResource::stdio(
+ match stdio.stdout {
+ StdioPipe::Inherit => StdFileResourceInner {
+ kind: StdFileResourceKind::Stdout,
+ file: STDOUT_HANDLE.try_clone().unwrap(),
},
- "stdout",
- ));
- assert_eq!(rid, 1, "stdout must have ResourceId 1");
-
- let rid = t.add(StdFileResource::stdio(
- match stdio.stderr {
- StdioPipe::Inherit => StdFileResourceInner {
- kind: StdFileResourceKind::Stderr,
- file: STDERR_HANDLE.try_clone().unwrap(),
- },
- StdioPipe::File(pipe) => StdFileResourceInner::file(pipe),
+ StdioPipe::File(pipe) => StdFileResourceInner::file(pipe),
+ },
+ "stdout",
+ ));
+ assert_eq!(rid, 1, "stdout must have ResourceId 1");
+
+ let rid = t.add(StdFileResource::stdio(
+ match stdio.stderr {
+ StdioPipe::Inherit => StdFileResourceInner {
+ kind: StdFileResourceKind::Stderr,
+ file: STDERR_HANDLE.try_clone().unwrap(),
},
- "stderr",
- ));
- assert_eq!(rid, 2, "stderr must have ResourceId 2");
- })
-}
-
-pub fn init_ops_and_esm(stdio: Stdio) -> Extension {
- // todo(dsheret): don't do this? Taking out the writers was necessary to prevent invalid handle panics
- let stdio = Rc::new(RefCell::new(Some(stdio)));
-
- ops(&mut ext(), stdio)
- .esm(include_js_files!("12_io.js",))
- .build()
-}
-
-pub fn init_ops(stdio: Stdio) -> Extension {
- // todo(dsheret): don't do this? Taking out the writers was necessary to prevent invalid handle panics
- let stdio = Rc::new(RefCell::new(Some(stdio)));
-
- ops(&mut ext(), stdio).build()
-}
+ StdioPipe::File(pipe) => StdFileResourceInner::file(pipe),
+ },
+ "stderr",
+ ));
+ assert_eq!(rid, 2, "stderr must have ResourceId 2");
+ },
+);
pub enum StdioPipe {
Inherit,
diff --git a/ext/napi/lib.rs b/ext/napi/lib.rs
index 41004638e..2e7ceed67 100644
--- a/ext/napi/lib.rs
+++ b/ext/napi/lib.rs
@@ -13,7 +13,6 @@ use deno_core::futures::StreamExt;
use deno_core::op;
use deno_core::parking_lot::Mutex;
use deno_core::serde_v8;
-use deno_core::Extension;
use deno_core::OpState;
use std::cell::RefCell;
use std::ffi::CString;
@@ -514,72 +513,78 @@ impl Env {
}
}
-pub fn init_ops<P: NapiPermissions + 'static>() -> Extension {
- Extension::builder(env!("CARGO_PKG_NAME"))
- .ops(vec![op_napi_open::decl::<P>()])
- .event_loop_middleware(|op_state_rc, cx| {
- // `work` can call back into the runtime. It can also schedule an async task
- // but we don't know that now. We need to make the runtime re-poll to make
- // sure no pending NAPI tasks exist.
- let mut maybe_scheduling = false;
-
- {
- let mut op_state = op_state_rc.borrow_mut();
- let napi_state = op_state.borrow_mut::<NapiState>();
+deno_core::extension!(deno_napi,
+ parameters = [P: NapiPermissions],
+ ops = [
+ op_napi_open<P>
+ ],
+ state = |state| {
+ let (async_work_sender, async_work_receiver) =
+ mpsc::unbounded::<PendingNapiAsyncWork>();
+ let (threadsafe_function_sender, threadsafe_function_receiver) =
+ mpsc::unbounded::<ThreadSafeFunctionStatus>();
+ state.put(NapiState {
+ pending_async_work: Vec::new(),
+ async_work_sender,
+ async_work_receiver,
+ threadsafe_function_sender,
+ threadsafe_function_receiver,
+ active_threadsafe_functions: 0,
+ env_cleanup_hooks: Rc::new(RefCell::new(vec![])),
+ tsfn_ref_counters: Arc::new(Mutex::new(vec![])),
+ });
+ },
+ event_loop_middleware = event_loop_middleware,
+);
- while let Poll::Ready(Some(async_work_fut)) =
- napi_state.async_work_receiver.poll_next_unpin(cx)
- {
- napi_state.pending_async_work.push(async_work_fut);
- }
+fn event_loop_middleware(
+ op_state_rc: Rc<RefCell<OpState>>,
+ cx: &mut std::task::Context,
+) -> bool {
+ // `work` can call back into the runtime. It can also schedule an async task
+ // but we don't know that now. We need to make the runtime re-poll to make
+ // sure no pending NAPI tasks exist.
+ let mut maybe_scheduling = false;
+
+ {
+ let mut op_state = op_state_rc.borrow_mut();
+ let napi_state = op_state.borrow_mut::<NapiState>();
+
+ while let Poll::Ready(Some(async_work_fut)) =
+ napi_state.async_work_receiver.poll_next_unpin(cx)
+ {
+ napi_state.pending_async_work.push(async_work_fut);
+ }
- if napi_state.active_threadsafe_functions > 0 {
- maybe_scheduling = true;
- }
+ if napi_state.active_threadsafe_functions > 0 {
+ maybe_scheduling = true;
+ }
- let tsfn_ref_counters = napi_state.tsfn_ref_counters.lock().clone();
- for (_id, counter) in tsfn_ref_counters.iter() {
- if counter.load(std::sync::atomic::Ordering::SeqCst) > 0 {
- maybe_scheduling = true;
- break;
- }
- }
+ let tsfn_ref_counters = napi_state.tsfn_ref_counters.lock().clone();
+ for (_id, counter) in tsfn_ref_counters.iter() {
+ if counter.load(std::sync::atomic::Ordering::SeqCst) > 0 {
+ maybe_scheduling = true;
+ break;
}
+ }
+ }
- loop {
- let maybe_work = {
- let mut op_state = op_state_rc.borrow_mut();
- let napi_state = op_state.borrow_mut::<NapiState>();
- napi_state.pending_async_work.pop()
- };
+ loop {
+ let maybe_work = {
+ let mut op_state = op_state_rc.borrow_mut();
+ let napi_state = op_state.borrow_mut::<NapiState>();
+ napi_state.pending_async_work.pop()
+ };
- if let Some(work) = maybe_work {
- work();
- maybe_scheduling = true;
- } else {
- break;
- }
- }
+ if let Some(work) = maybe_work {
+ work();
+ maybe_scheduling = true;
+ } else {
+ break;
+ }
+ }
- maybe_scheduling
- })
- .state(move |state| {
- let (async_work_sender, async_work_receiver) =
- mpsc::unbounded::<PendingNapiAsyncWork>();
- let (threadsafe_function_sender, threadsafe_function_receiver) =
- mpsc::unbounded::<ThreadSafeFunctionStatus>();
- state.put(NapiState {
- pending_async_work: Vec::new(),
- async_work_sender,
- async_work_receiver,
- threadsafe_function_sender,
- threadsafe_function_receiver,
- active_threadsafe_functions: 0,
- env_cleanup_hooks: Rc::new(RefCell::new(vec![])),
- tsfn_ref_counters: Arc::new(Mutex::new(vec![])),
- });
- })
- .build()
+ maybe_scheduling
}
pub trait NapiPermissions {
diff --git a/ext/net/lib.rs b/ext/net/lib.rs
index 4703b05cc..76ed02706 100644
--- a/ext/net/lib.rs
+++ b/ext/net/lib.rs
@@ -8,9 +8,6 @@ pub mod ops_unix;
pub mod resolve_addr;
use deno_core::error::AnyError;
-use deno_core::include_js_files;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::OpState;
use deno_tls::rustls::RootCertStore;
use std::cell::RefCell;
@@ -78,55 +75,48 @@ pub struct DefaultTlsOptions {
/// would override previously used alias.
pub struct UnsafelyIgnoreCertificateErrors(pub Option<Vec<String>>);
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(env!("CARGO_PKG_NAME"), &["deno_web"])
-}
+deno_core::extension!(deno_net,
+ deps = [ deno_web ],
+ parameters = [ P: NetPermissions ],
+ ops = [
+ ops::op_net_accept_tcp,
+ ops::op_net_connect_tcp<P>,
+ ops::op_net_listen_tcp<P>,
+ ops::op_net_listen_udp<P>,
+ ops::op_node_unstable_net_listen_udp<P>,
+ ops::op_net_recv_udp,
+ ops::op_net_send_udp<P>,
+ ops::op_dns_resolve<P>,
+ ops::op_set_nodelay,
+ ops::op_set_keepalive,
-fn ops<P: NetPermissions + 'static>(
- ext: &mut ExtensionBuilder,
- root_cert_store: Option<RootCertStore>,
- unstable: bool,
- unsafely_ignore_certificate_errors: Option<Vec<String>>,
-) -> &mut ExtensionBuilder {
- let mut ops = ops::init::<P>();
- ops.extend(ops_tls::init::<P>());
+ ops_tls::op_tls_start<P>,
+ ops_tls::op_net_connect_tls<P>,
+ ops_tls::op_net_listen_tls<P>,
+ ops_tls::op_net_accept_tls,
+ ops_tls::op_tls_handshake,
- ext.ops(ops).state(move |state| {
+ #[cfg(unix)] ops_unix::op_net_accept_unix,
+ #[cfg(unix)] ops_unix::op_net_connect_unix<P>,
+ #[cfg(unix)] ops_unix::op_net_listen_unix<P>,
+ #[cfg(unix)] ops_unix::op_net_listen_unixpacket<P>,
+ #[cfg(unix)] ops_unix::op_node_unstable_net_listen_unixpacket<P>,
+ #[cfg(unix)] ops_unix::op_net_recv_unixpacket,
+ #[cfg(unix)] ops_unix::op_net_send_unixpacket<P>,
+ ],
+ esm = [ "01_net.js", "02_tls.js" ],
+ config = {
+ root_cert_store: Option<RootCertStore>,
+ unstable: bool,
+ unsafely_ignore_certificate_errors: Option<Vec<String>>,
+ },
+ state = |state, root_cert_store, unstable, unsafely_ignore_certificate_errors| {
state.put(DefaultTlsOptions {
- root_cert_store: root_cert_store.clone(),
+ root_cert_store,
});
state.put(UnstableChecker { unstable });
state.put(UnsafelyIgnoreCertificateErrors(
- unsafely_ignore_certificate_errors.clone(),
+ unsafely_ignore_certificate_errors,
));
- })
-}
-
-pub fn init_ops_and_esm<P: NetPermissions + 'static>(
- root_cert_store: Option<RootCertStore>,
- unstable: bool,
- unsafely_ignore_certificate_errors: Option<Vec<String>>,
-) -> Extension {
- ops::<P>(
- &mut ext(),
- root_cert_store,
- unstable,
- unsafely_ignore_certificate_errors,
- )
- .esm(include_js_files!("01_net.js", "02_tls.js",))
- .build()
-}
-
-pub fn init_ops<P: NetPermissions + 'static>(
- root_cert_store: Option<RootCertStore>,
- unstable: bool,
- unsafely_ignore_certificate_errors: Option<Vec<String>>,
-) -> Extension {
- ops::<P>(
- &mut ext(),
- root_cert_store,
- unstable,
- unsafely_ignore_certificate_errors,
- )
- .build()
-}
+ },
+);
diff --git a/ext/net/ops.rs b/ext/net/ops.rs
index 8ac08119a..c094ddac2 100644
--- a/ext/net/ops.rs
+++ b/ext/net/ops.rs
@@ -15,7 +15,6 @@ use deno_core::AsyncRefCell;
use deno_core::ByteString;
use deno_core::CancelHandle;
use deno_core::CancelTryFuture;
-use deno_core::OpDecl;
use deno_core::OpState;
use deno_core::RcRef;
use deno_core::Resource;
@@ -44,35 +43,6 @@ use trust_dns_resolver::error::ResolveErrorKind;
use trust_dns_resolver::system_conf;
use trust_dns_resolver::AsyncResolver;
-pub fn init<P: NetPermissions + 'static>() -> Vec<OpDecl> {
- vec![
- op_net_accept_tcp::decl(),
- #[cfg(unix)]
- crate::ops_unix::op_net_accept_unix::decl(),
- op_net_connect_tcp::decl::<P>(),
- #[cfg(unix)]
- crate::ops_unix::op_net_connect_unix::decl::<P>(),
- op_net_listen_tcp::decl::<P>(),
- op_net_listen_udp::decl::<P>(),
- op_node_unstable_net_listen_udp::decl::<P>(),
- #[cfg(unix)]
- crate::ops_unix::op_net_listen_unix::decl::<P>(),
- #[cfg(unix)]
- crate::ops_unix::op_net_listen_unixpacket::decl::<P>(),
- #[cfg(unix)]
- crate::ops_unix::op_node_unstable_net_listen_unixpacket::decl::<P>(),
- op_net_recv_udp::decl(),
- #[cfg(unix)]
- crate::ops_unix::op_net_recv_unixpacket::decl(),
- op_net_send_udp::decl::<P>(),
- #[cfg(unix)]
- crate::ops_unix::op_net_send_unixpacket::decl::<P>(),
- op_dns_resolve::decl::<P>(),
- op_set_nodelay::decl(),
- op_set_keepalive::decl(),
- ]
-}
-
#[derive(Serialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
pub struct TlsHandshakeInfo {
@@ -650,7 +620,6 @@ fn rdata_to_return_record(
mod tests {
use super::*;
use crate::UnstableChecker;
- use deno_core::Extension;
use deno_core::JsRuntime;
use deno_core::RuntimeOptions;
use socket2::SockRef;
@@ -906,15 +875,17 @@ mod tests {
let listener = TcpListener::bind(addr).await.unwrap();
let _ = listener.accept().await;
});
- let my_ext = Extension::builder("test_ext")
- .state(move |state| {
+
+ deno_core::extension!(
+ test_ext,
+ state = |state| {
state.put(TestPermission {});
state.put(UnstableChecker { unstable: true });
- })
- .build();
+ }
+ );
let mut runtime = JsRuntime::new(RuntimeOptions {
- extensions: vec![my_ext],
+ extensions: vec![test_ext::init_ops()],
..Default::default()
});
diff --git a/ext/net/ops_tls.rs b/ext/net/ops_tls.rs
index f550569a1..c0cfb8674 100644
--- a/ext/net/ops_tls.rs
+++ b/ext/net/ops_tls.rs
@@ -31,7 +31,6 @@ use deno_core::AsyncResult;
use deno_core::ByteString;
use deno_core::CancelHandle;
use deno_core::CancelTryFuture;
-use deno_core::OpDecl;
use deno_core::OpState;
use deno_core::RcRef;
use deno_core::Resource;
@@ -653,16 +652,6 @@ impl Write for ImplementWriteTrait<'_, TcpStream> {
}
}
-pub fn init<P: NetPermissions + 'static>() -> Vec<OpDecl> {
- vec![
- op_tls_start::decl::<P>(),
- op_net_connect_tls::decl::<P>(),
- op_net_listen_tls::decl::<P>(),
- op_net_accept_tls::decl(),
- op_tls_handshake::decl(),
- ]
-}
-
#[derive(Debug)]
pub struct TlsStreamResource {
rd: AsyncRefCell<ReadHalf>,
diff --git a/ext/node/lib.rs b/ext/node/lib.rs
index 318667d59..06138cf4c 100644
--- a/ext/node/lib.rs
+++ b/ext/node/lib.rs
@@ -1,11 +1,8 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
use deno_core::error::AnyError;
-use deno_core::include_js_files;
use deno_core::located_script_name;
use deno_core::op;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::JsRuntime;
use once_cell::sync::Lazy;
use std::collections::HashSet;
@@ -96,41 +93,32 @@ fn op_node_build_os() -> String {
.to_string()
}
-fn ext_polyfill() -> ExtensionBuilder {
- Extension::builder_with_deps(env!("CARGO_PKG_NAME"), &["deno_io", "deno_fs"])
-}
-
-fn ops_polyfill(ext: &mut ExtensionBuilder) -> &mut ExtensionBuilder {
- ext.ops(vec![
- crypto::op_node_cipheriv_encrypt::decl(),
- crypto::op_node_cipheriv_final::decl(),
- crypto::op_node_create_cipheriv::decl(),
- crypto::op_node_create_hash::decl(),
- crypto::op_node_hash_update::decl(),
- crypto::op_node_hash_update_str::decl(),
- crypto::op_node_hash_digest::decl(),
- crypto::op_node_hash_digest_hex::decl(),
- crypto::op_node_hash_clone::decl(),
- crypto::op_node_private_encrypt::decl(),
- crypto::op_node_private_decrypt::decl(),
- crypto::op_node_public_encrypt::decl(),
- winerror::op_node_sys_to_uv_error::decl(),
- v8::op_v8_cached_data_version_tag::decl(),
- v8::op_v8_get_heap_statistics::decl(),
- idna::op_node_idna_domain_to_ascii::decl(),
- idna::op_node_idna_domain_to_unicode::decl(),
- idna::op_node_idna_punycode_decode::decl(),
- idna::op_node_idna_punycode_encode::decl(),
- op_node_build_os::decl(),
- ])
-}
-
-pub fn init_polyfill_ops() -> Extension {
- ops_polyfill(&mut ext_polyfill()).build()
-}
-
-pub fn init_polyfill_ops_and_esm() -> Extension {
- let esm_files = include_js_files!(
+deno_core::extension!(deno_node,
+ deps = [ deno_io, deno_fs ],
+ ops = [
+ crypto::op_node_cipheriv_encrypt,
+ crypto::op_node_cipheriv_final,
+ crypto::op_node_create_cipheriv,
+ crypto::op_node_create_hash,
+ crypto::op_node_hash_update,
+ crypto::op_node_hash_update_str,
+ crypto::op_node_hash_digest,
+ crypto::op_node_hash_digest_hex,
+ crypto::op_node_hash_clone,
+ crypto::op_node_private_encrypt,
+ crypto::op_node_private_decrypt,
+ crypto::op_node_public_encrypt,
+ winerror::op_node_sys_to_uv_error,
+ v8::op_v8_cached_data_version_tag,
+ v8::op_v8_get_heap_statistics,
+ idna::op_node_idna_domain_to_ascii,
+ idna::op_node_idna_domain_to_unicode,
+ idna::op_node_idna_punycode_decode,
+ idna::op_node_idna_punycode_encode,
+ op_node_build_os,
+ ],
+ esm_entry_point = "ext:deno_node/module_all.ts",
+ esm = [
dir "polyfills",
"_core.ts",
"_events.mjs",
@@ -352,71 +340,45 @@ pub fn init_polyfill_ops_and_esm() -> Extension {
"wasi.ts",
"worker_threads.ts",
"zlib.ts",
- );
-
- ops_polyfill(&mut ext_polyfill())
- .esm(esm_files)
- .esm_entry_point("ext:deno_node/module_all.ts")
- .build()
-}
-
-fn ext() -> ExtensionBuilder {
- Extension::builder("deno_node_loading")
-}
-
-fn ops<P: NodePermissions + 'static>(
- ext: &mut ExtensionBuilder,
- maybe_npm_resolver: Option<Rc<dyn RequireNpmResolver>>,
-) -> &mut ExtensionBuilder {
- ext
- .ops(vec![
- ops::op_require_init_paths::decl(),
- ops::op_require_node_module_paths::decl::<P>(),
- ops::op_require_proxy_path::decl(),
- ops::op_require_is_deno_dir_package::decl(),
- ops::op_require_resolve_deno_dir::decl(),
- ops::op_require_is_request_relative::decl(),
- ops::op_require_resolve_lookup_paths::decl(),
- ops::op_require_try_self_parent_path::decl::<P>(),
- ops::op_require_try_self::decl::<P>(),
- ops::op_require_real_path::decl::<P>(),
- ops::op_require_path_is_absolute::decl(),
- ops::op_require_path_dirname::decl(),
- ops::op_require_stat::decl::<P>(),
- ops::op_require_path_resolve::decl(),
- ops::op_require_path_basename::decl(),
- ops::op_require_read_file::decl::<P>(),
- ops::op_require_as_file_path::decl(),
- ops::op_require_resolve_exports::decl::<P>(),
- ops::op_require_read_closest_package_json::decl::<P>(),
- ops::op_require_read_package_scope::decl::<P>(),
- ops::op_require_package_imports_resolve::decl::<P>(),
- ops::op_require_break_on_next_statement::decl(),
- ])
- .state(move |state| {
- if let Some(npm_resolver) = maybe_npm_resolver.clone() {
- state.put(npm_resolver);
- }
- })
-}
-
-pub fn init_ops_and_esm<P: NodePermissions + 'static>(
- maybe_npm_resolver: Option<Rc<dyn RequireNpmResolver>>,
-) -> Extension {
- ops::<P>(&mut ext(), maybe_npm_resolver)
- .esm(include_js_files!(
- "01_node.js",
- "02_require.js",
- "module_es_shim.js",
- ))
- .build()
-}
+ ],
+);
-pub fn init_ops<P: NodePermissions + 'static>(
- maybe_npm_resolver: Option<Rc<dyn RequireNpmResolver>>,
-) -> Extension {
- ops::<P>(&mut ext(), maybe_npm_resolver).build()
-}
+deno_core::extension!(deno_node_loading,
+ parameters = [P: NodePermissions],
+ ops = [
+ ops::op_require_init_paths,
+ ops::op_require_node_module_paths<P>,
+ ops::op_require_proxy_path,
+ ops::op_require_is_deno_dir_package,
+ ops::op_require_resolve_deno_dir,
+ ops::op_require_is_request_relative,
+ ops::op_require_resolve_lookup_paths,
+ ops::op_require_try_self_parent_path<P>,
+ ops::op_require_try_self<P>,
+ ops::op_require_real_path<P>,
+ ops::op_require_path_is_absolute,
+ ops::op_require_path_dirname,
+ ops::op_require_stat<P>,
+ ops::op_require_path_resolve,
+ ops::op_require_path_basename,
+ ops::op_require_read_file<P>,
+ ops::op_require_as_file_path,
+ ops::op_require_resolve_exports<P>,
+ ops::op_require_read_closest_package_json<P>,
+ ops::op_require_read_package_scope<P>,
+ ops::op_require_package_imports_resolve<P>,
+ ops::op_require_break_on_next_statement,
+ ],
+ esm = ["01_node.js", "02_require.js", "module_es_shim.js"],
+ config = {
+ maybe_npm_resolver: Option<Rc<dyn RequireNpmResolver>>,
+ },
+ state = |state, maybe_npm_resolver| {
+ if let Some(npm_resolver) = maybe_npm_resolver.clone() {
+ state.put(npm_resolver);
+ }
+ },
+);
pub async fn initialize_runtime(
js_runtime: &mut JsRuntime,
diff --git a/ext/tls/lib.rs b/ext/tls/lib.rs
index fb4e8759d..123d35acf 100644
--- a/ext/tls/lib.rs
+++ b/ext/tls/lib.rs
@@ -10,7 +10,6 @@ use deno_core::anyhow::anyhow;
use deno_core::error::custom_error;
use deno_core::error::AnyError;
use deno_core::parking_lot::Mutex;
-use deno_core::Extension;
use rustls::client::HandshakeSignatureValid;
use rustls::client::ServerCertVerified;
@@ -35,10 +34,8 @@ use std::io::Cursor;
use std::sync::Arc;
use std::time::SystemTime;
-/// This extension has no runtime apis, it only exports some shared native functions.
-pub fn init_ops() -> Extension {
- Extension::builder(env!("CARGO_PKG_NAME")).build()
-}
+// This extension has no runtime apis, it only exports some shared native functions.
+deno_core::extension!(deno_tls);
struct DefaultSignatureVerification;
diff --git a/ext/url/benches/url_ops.rs b/ext/url/benches/url_ops.rs
index 7dc2651b2..4096a6a92 100644
--- a/ext/url/benches/url_ops.rs
+++ b/ext/url/benches/url_ops.rs
@@ -11,8 +11,8 @@ use deno_core::ExtensionFileSourceCode;
fn setup() -> Vec<Extension> {
vec![
- deno_webidl::init_esm(),
- deno_url::init_ops_and_esm(),
+ deno_webidl::deno_webidl::init_ops_and_esm(),
+ deno_url::deno_url::init_ops_and_esm(),
Extension::builder("bench_setup")
.esm(vec![ExtensionFileSource {
specifier: "ext:setup".to_string(),
diff --git a/ext/url/lib.rs b/ext/url/lib.rs
index 8a20c9bc6..cfb6497c3 100644
--- a/ext/url/lib.rs
+++ b/ext/url/lib.rs
@@ -4,13 +4,10 @@ mod urlpattern;
use deno_core::error::type_error;
use deno_core::error::AnyError;
-use deno_core::include_js_files;
use deno_core::op;
use deno_core::url::form_urlencoded;
use deno_core::url::quirks;
use deno_core::url::Url;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::OpState;
use deno_core::ZeroCopyBuf;
use std::path::PathBuf;
@@ -18,32 +15,21 @@ use std::path::PathBuf;
use crate::urlpattern::op_urlpattern_parse;
use crate::urlpattern::op_urlpattern_process_match_input;
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(env!("CARGO_PKG_NAME"), &["deno_webidl"])
-}
-
-fn ops(ext: &mut ExtensionBuilder) -> &mut ExtensionBuilder {
- ext.ops(vec![
- op_url_reparse::decl(),
- op_url_parse::decl(),
- op_url_get_serialization::decl(),
- op_url_parse_with_base::decl(),
- op_url_parse_search_params::decl(),
- op_url_stringify_search_params::decl(),
- op_urlpattern_parse::decl(),
- op_urlpattern_process_match_input::decl(),
- ])
-}
-
-pub fn init_ops_and_esm() -> Extension {
- ops(&mut ext())
- .esm(include_js_files!("00_url.js", "01_urlpattern.js",))
- .build()
-}
-
-pub fn init_ops() -> Extension {
- ops(&mut ext()).build()
-}
+deno_core::extension!(
+ deno_url,
+ deps = [deno_webidl],
+ ops = [
+ op_url_reparse,
+ op_url_parse,
+ op_url_get_serialization,
+ op_url_parse_with_base,
+ op_url_parse_search_params,
+ op_url_stringify_search_params,
+ op_urlpattern_parse,
+ op_urlpattern_process_match_input
+ ],
+ esm = ["00_url.js", "01_urlpattern.js"],
+);
/// Parse `href` with a `base_href`. Fills the out `buf` with URL components.
#[op]
diff --git a/ext/web/benches/encoding.rs b/ext/web/benches/encoding.rs
index feb309785..2deba07f3 100644
--- a/ext/web/benches/encoding.rs
+++ b/ext/web/benches/encoding.rs
@@ -10,6 +10,7 @@ use deno_core::ExtensionFileSourceCode;
use deno_core::OpState;
use deno_web::BlobStore;
+#[derive(Clone)]
struct Permissions;
impl deno_web::TimersPermission for Permissions {
@@ -23,10 +24,13 @@ impl deno_web::TimersPermission for Permissions {
fn setup() -> Vec<Extension> {
vec![
- deno_webidl::init_esm(),
- deno_url::init_ops_and_esm(),
- deno_console::init_esm(),
- deno_web::init_ops_and_esm::<Permissions>(BlobStore::default(), None),
+ deno_webidl::deno_webidl::init_ops_and_esm(),
+ deno_url::deno_url::init_ops_and_esm(),
+ deno_console::deno_console::init_ops_and_esm(),
+ deno_web::deno_web::init_ops_and_esm::<Permissions>(
+ BlobStore::default(),
+ None,
+ ),
Extension::builder("bench_setup")
.esm(vec![ExtensionFileSource {
specifier: "ext:setup".to_string(),
diff --git a/ext/web/benches/timers_ops.rs b/ext/web/benches/timers_ops.rs
index e1e97df65..372a317c9 100644
--- a/ext/web/benches/timers_ops.rs
+++ b/ext/web/benches/timers_ops.rs
@@ -10,6 +10,7 @@ use deno_core::ExtensionFileSourceCode;
use deno_core::OpState;
use deno_web::BlobStore;
+#[derive(Clone)]
struct Permissions;
impl deno_web::TimersPermission for Permissions {
@@ -21,10 +22,10 @@ impl deno_web::TimersPermission for Permissions {
fn setup() -> Vec<Extension> {
vec![
- deno_webidl::init_esm(),
- deno_url::init_ops_and_esm(),
- deno_console::init_esm(),
- deno_web::init_ops_and_esm::<Permissions>(BlobStore::default(), None),
+ deno_webidl::deno_webidl::init_ops_and_esm(),
+ deno_url::deno_url::init_ops_and_esm(),
+ deno_console::deno_console::init_ops_and_esm(),
+ deno_web::deno_web::init_ops_and_esm::<Permissions>(BlobStore::default(), None),
Extension::builder("bench_setup")
.esm(vec![
ExtensionFileSource {
diff --git a/ext/web/lib.rs b/ext/web/lib.rs
index dfc5ece72..f3a22d623 100644
--- a/ext/web/lib.rs
+++ b/ext/web/lib.rs
@@ -8,15 +8,12 @@ mod timers;
use deno_core::error::range_error;
use deno_core::error::type_error;
use deno_core::error::AnyError;
-use deno_core::include_js_files;
use deno_core::op;
use deno_core::serde_v8;
use deno_core::url::Url;
use deno_core::v8;
use deno_core::ByteString;
use deno_core::CancelHandle;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::OpState;
use deno_core::Resource;
use deno_core::ResourceId;
@@ -58,93 +55,72 @@ use crate::timers::op_timer_handle;
use crate::timers::StartTime;
pub use crate::timers::TimersPermission;
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(
- env!("CARGO_PKG_NAME"),
- &["deno_webidl", "deno_console", "deno_url"],
- )
-}
-
-fn ops<P: TimersPermission + 'static>(
- ext: &mut ExtensionBuilder,
- blob_store: BlobStore,
- maybe_location: Option<Url>,
-) -> &mut ExtensionBuilder {
- ext
- .ops(vec![
- op_base64_decode::decl(),
- op_base64_encode::decl(),
- op_base64_atob::decl(),
- op_base64_btoa::decl(),
- op_encoding_normalize_label::decl(),
- op_encoding_decode_single::decl(),
- op_encoding_decode_utf8::decl(),
- op_encoding_new_decoder::decl(),
- op_encoding_decode::decl(),
- op_encoding_encode_into::decl(),
- op_encode_binary_string::decl(),
- op_blob_create_part::decl(),
- op_blob_slice_part::decl(),
- op_blob_read_part::decl(),
- op_blob_remove_part::decl(),
- op_blob_create_object_url::decl(),
- op_blob_revoke_object_url::decl(),
- op_blob_from_object_url::decl(),
- op_message_port_create_entangled::decl(),
- op_message_port_post_message::decl(),
- op_message_port_recv_message::decl(),
- compression::op_compression_new::decl(),
- compression::op_compression_write::decl(),
- compression::op_compression_finish::decl(),
- op_now::decl::<P>(),
- op_timer_handle::decl(),
- op_cancel_handle::decl(),
- op_sleep::decl(),
- op_transfer_arraybuffer::decl(),
- ])
- .state(move |state| {
- state.put(blob_store.clone());
- if let Some(location) = maybe_location.clone() {
- state.put(Location(location));
- }
- state.put(StartTime::now());
- })
-}
-
-pub fn init_ops_and_esm<P: TimersPermission + 'static>(
- blob_store: BlobStore,
- maybe_location: Option<Url>,
-) -> Extension {
- ops::<P>(&mut ext(), blob_store, maybe_location)
- .esm(include_js_files!(
- "00_infra.js",
- "01_dom_exception.js",
- "01_mimesniff.js",
- "02_event.js",
- "02_structured_clone.js",
- "02_timers.js",
- "03_abort_signal.js",
- "04_global_interfaces.js",
- "05_base64.js",
- "06_streams.js",
- "08_text_encoding.js",
- "09_file.js",
- "10_filereader.js",
- "11_blob_url.js",
- "12_location.js",
- "13_message_port.js",
- "14_compression.js",
- "15_performance.js",
- ))
- .build()
-}
-
-pub fn init_ops<P: TimersPermission + 'static>(
- blob_store: BlobStore,
- maybe_location: Option<Url>,
-) -> Extension {
- ops::<P>(&mut ext(), blob_store, maybe_location).build()
-}
+deno_core::extension!(deno_web,
+ deps = [ deno_webidl, deno_console, deno_url ],
+ parameters = [P: TimersPermission],
+ ops = [
+ op_base64_decode,
+ op_base64_encode,
+ op_base64_atob,
+ op_base64_btoa,
+ op_encoding_normalize_label,
+ op_encoding_decode_single,
+ op_encoding_decode_utf8,
+ op_encoding_new_decoder,
+ op_encoding_decode,
+ op_encoding_encode_into,
+ op_encode_binary_string,
+ op_blob_create_part,
+ op_blob_slice_part,
+ op_blob_read_part,
+ op_blob_remove_part,
+ op_blob_create_object_url,
+ op_blob_revoke_object_url,
+ op_blob_from_object_url,
+ op_message_port_create_entangled,
+ op_message_port_post_message,
+ op_message_port_recv_message,
+ compression::op_compression_new,
+ compression::op_compression_write,
+ compression::op_compression_finish,
+ op_now<P>,
+ op_timer_handle,
+ op_cancel_handle,
+ op_sleep,
+ op_transfer_arraybuffer,
+ ],
+ esm = [
+ "00_infra.js",
+ "01_dom_exception.js",
+ "01_mimesniff.js",
+ "02_event.js",
+ "02_structured_clone.js",
+ "02_timers.js",
+ "03_abort_signal.js",
+ "04_global_interfaces.js",
+ "05_base64.js",
+ "06_streams.js",
+ "08_text_encoding.js",
+ "09_file.js",
+ "10_filereader.js",
+ "11_blob_url.js",
+ "12_location.js",
+ "13_message_port.js",
+ "14_compression.js",
+ "15_performance.js",
+ ],
+ config = {
+ blob_store: BlobStore,
+ maybe_location: Option<Url>,
+ },
+ state = |state, blob_store, maybe_location| {
+ state.put(blob_store);
+ if let Some(location) = maybe_location {
+ state.put(Location(location));
+ }
+ state.put(StartTime::now());
+ }
+);
#[op]
fn op_base64_decode(input: String) -> Result<ZeroCopyBuf, AnyError> {
diff --git a/ext/webidl/benches/dict.rs b/ext/webidl/benches/dict.rs
index 2ed9adf78..89a83ddaa 100644
--- a/ext/webidl/benches/dict.rs
+++ b/ext/webidl/benches/dict.rs
@@ -11,7 +11,7 @@ use deno_core::ExtensionFileSourceCode;
fn setup() -> Vec<Extension> {
vec![
- deno_webidl::init_esm(),
+ deno_webidl::deno_webidl::init_ops_and_esm(),
Extension::builder("deno_webidl_bench")
.esm(vec![ExtensionFileSource {
specifier: "ext:setup".to_string(),
diff --git a/ext/webidl/lib.rs b/ext/webidl/lib.rs
index 42559e501..332bea815 100644
--- a/ext/webidl/lib.rs
+++ b/ext/webidl/lib.rs
@@ -1,14 +1,3 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-use deno_core::include_js_files;
-use deno_core::Extension;
-
-pub fn init() -> Extension {
- Extension::builder(env!("CARGO_PKG_NAME")).build()
-}
-
-pub fn init_esm() -> Extension {
- Extension::builder(env!("CARGO_PKG_NAME"))
- .esm(include_js_files!("00_webidl.js",))
- .build()
-}
+deno_core::extension!(deno_webidl, esm = ["00_webidl.js"],);
diff --git a/ext/websocket/lib.rs b/ext/websocket/lib.rs
index dbbeae21f..e480d7f4c 100644
--- a/ext/websocket/lib.rs
+++ b/ext/websocket/lib.rs
@@ -7,16 +7,13 @@ 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;
-use deno_core::ExtensionBuilder;
use deno_core::url;
use deno_core::AsyncRefCell;
use deno_core::ByteString;
use deno_core::CancelFuture;
use deno_core::CancelHandle;
-use deno_core::Extension;
use deno_core::OpState;
use deno_core::RcRef;
use deno_core::Resource;
@@ -498,67 +495,30 @@ pub async fn op_ws_next_event(
Ok(res)
}
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(
- env!("CARGO_PKG_NAME"),
- &["deno_url", "deno_webidl"],
- )
-}
-
-fn ops<P: WebSocketPermissions + 'static>(
- ext: &mut ExtensionBuilder,
- user_agent: String,
- root_cert_store: Option<RootCertStore>,
- unsafely_ignore_certificate_errors: Option<Vec<String>>,
-) -> &mut ExtensionBuilder {
- ext
- .ops(vec![
- op_ws_check_permission_and_cancel_handle::decl::<P>(),
- op_ws_create::decl::<P>(),
- op_ws_send::decl(),
- op_ws_close::decl(),
- op_ws_next_event::decl(),
- ])
- .state(move |state| {
- state.put::<WsUserAgent>(WsUserAgent(user_agent.clone()));
- state.put(UnsafelyIgnoreCertificateErrors(
- unsafely_ignore_certificate_errors.clone(),
- ));
- state.put::<WsRootStore>(WsRootStore(root_cert_store.clone()));
- })
-}
-
-pub fn init_ops_and_esm<P: WebSocketPermissions + 'static>(
- user_agent: String,
- root_cert_store: Option<RootCertStore>,
- unsafely_ignore_certificate_errors: Option<Vec<String>>,
-) -> Extension {
- ops::<P>(
- &mut ext(),
- user_agent,
- root_cert_store,
- unsafely_ignore_certificate_errors,
- )
- .esm(include_js_files!(
- "01_websocket.js",
- "02_websocketstream.js",
- ))
- .build()
-}
-
-pub fn init_ops<P: WebSocketPermissions + 'static>(
- user_agent: String,
- root_cert_store: Option<RootCertStore>,
- unsafely_ignore_certificate_errors: Option<Vec<String>>,
-) -> Extension {
- ops::<P>(
- &mut ext(),
- user_agent,
- root_cert_store,
- unsafely_ignore_certificate_errors,
- )
- .build()
-}
+deno_core::extension!(deno_websocket,
+ deps = [ deno_url, deno_webidl ],
+ parameters = [P: WebSocketPermissions],
+ ops = [
+ op_ws_check_permission_and_cancel_handle<P>,
+ op_ws_create<P>,
+ op_ws_send,
+ op_ws_close,
+ op_ws_next_event,
+ ],
+ esm = [ "01_websocket.js", "02_websocketstream.js" ],
+ config = {
+ user_agent: String,
+ root_cert_store: Option<RootCertStore>,
+ unsafely_ignore_certificate_errors: Option<Vec<String>>
+ },
+ state = |state, user_agent, root_cert_store, unsafely_ignore_certificate_errors| {
+ state.put::<WsUserAgent>(WsUserAgent(user_agent));
+ state.put(UnsafelyIgnoreCertificateErrors(
+ unsafely_ignore_certificate_errors,
+ ));
+ state.put::<WsRootStore>(WsRootStore(root_cert_store));
+ },
+);
pub fn get_declaration() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_websocket.d.ts")
diff --git a/ext/webstorage/lib.rs b/ext/webstorage/lib.rs
index f3caddbaf..6cdc7bbff 100644
--- a/ext/webstorage/lib.rs
+++ b/ext/webstorage/lib.rs
@@ -6,10 +6,7 @@ use std::fmt;
use std::path::PathBuf;
use deno_core::error::AnyError;
-use deno_core::include_js_files;
use deno_core::op;
-use deno_core::Extension;
-use deno_core::ExtensionBuilder;
use deno_core::OpState;
use rusqlite::params;
use rusqlite::Connection;
@@ -22,40 +19,27 @@ struct OriginStorageDir(PathBuf);
const MAX_STORAGE_BYTES: usize = 10 * 1024 * 1024;
-fn ext() -> ExtensionBuilder {
- Extension::builder_with_deps(env!("CARGO_PKG_NAME"), &["deno_webidl"])
-}
-
-fn ops(
- ext: &mut ExtensionBuilder,
- origin_storage_dir: Option<PathBuf>,
-) -> &mut ExtensionBuilder {
- ext
- .ops(vec![
- op_webstorage_length::decl(),
- op_webstorage_key::decl(),
- op_webstorage_set::decl(),
- op_webstorage_get::decl(),
- op_webstorage_remove::decl(),
- op_webstorage_clear::decl(),
- op_webstorage_iterate_keys::decl(),
- ])
- .state(move |state| {
- if let Some(origin_storage_dir) = &origin_storage_dir {
- state.put(OriginStorageDir(origin_storage_dir.clone()));
- }
- })
-}
-
-pub fn init_ops_and_esm(origin_storage_dir: Option<PathBuf>) -> Extension {
- ops(&mut ext(), origin_storage_dir)
- .esm(include_js_files!("01_webstorage.js",))
- .build()
-}
-
-pub fn init_ops(origin_storage_dir: Option<PathBuf>) -> Extension {
- ops(&mut ext(), origin_storage_dir).build()
-}
+deno_core::extension!(deno_webstorage,
+ deps = [ deno_webidl ],
+ ops = [
+ op_webstorage_length,
+ op_webstorage_key,
+ op_webstorage_set,
+ op_webstorage_get,
+ op_webstorage_remove,
+ op_webstorage_clear,
+ op_webstorage_iterate_keys,
+ ],
+ esm = [ "01_webstorage.js" ],
+ config = {
+ origin_storage_dir: Option<PathBuf>
+ },
+ state = |state, origin_storage_dir| {
+ if let Some(origin_storage_dir) = origin_storage_dir {
+ state.put(OriginStorageDir(origin_storage_dir));
+ }
+ },
+);
pub fn get_declaration() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("lib.deno_webstorage.d.ts")
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-10 06:11:50 +0000