2023-01-02 16:00:42 -05:00
|
|
|
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
|
2020-12-13 13:45:53 -05:00
|
|
|
|
2023-02-08 16:40:18 -05:00
|
|
|
use deno_core::include_js_files_dir;
|
2022-07-04 18:12:41 -04:00
|
|
|
use std::env;
|
|
|
|
use std::path::PathBuf;
|
|
|
|
|
|
|
|
// This is a shim that allows to generate documentation on docs.rs
|
|
|
|
mod not_docs {
|
2023-01-27 10:43:16 -05:00
|
|
|
use std::path::Path;
|
|
|
|
|
2022-07-04 18:12:41 -04:00
|
|
|
use super::*;
|
2022-09-28 08:11:12 -04:00
|
|
|
use deno_cache::SqliteBackedCache;
|
2022-11-21 08:36:26 -05:00
|
|
|
use deno_core::snapshot_util::*;
|
2022-07-04 18:12:41 -04:00
|
|
|
use deno_core::Extension;
|
|
|
|
|
2023-02-08 16:40:18 -05:00
|
|
|
use deno_ast::MediaType;
|
|
|
|
use deno_ast::ParseParams;
|
|
|
|
use deno_ast::SourceTextInfo;
|
|
|
|
use deno_core::error::AnyError;
|
|
|
|
use deno_core::ExtensionFileSource;
|
|
|
|
|
|
|
|
fn transpile_ts_for_snapshotting(
|
|
|
|
file_source: &ExtensionFileSource,
|
|
|
|
) -> Result<String, AnyError> {
|
|
|
|
let media_type = MediaType::from(Path::new(&file_source.specifier));
|
|
|
|
|
|
|
|
let should_transpile = match media_type {
|
|
|
|
MediaType::JavaScript => false,
|
|
|
|
MediaType::TypeScript => true,
|
|
|
|
_ => panic!("Unsupported media type for snapshotting {media_type:?}"),
|
|
|
|
};
|
|
|
|
|
|
|
|
if !should_transpile {
|
|
|
|
return Ok(file_source.code.to_string());
|
|
|
|
}
|
|
|
|
|
|
|
|
let parsed = deno_ast::parse_module(ParseParams {
|
|
|
|
specifier: file_source.specifier.to_string(),
|
|
|
|
text_info: SourceTextInfo::from_string(file_source.code.to_string()),
|
|
|
|
media_type,
|
|
|
|
capture_tokens: false,
|
|
|
|
scope_analysis: false,
|
|
|
|
maybe_syntax: None,
|
|
|
|
})?;
|
|
|
|
let transpiled_source = parsed.transpile(&Default::default())?;
|
|
|
|
Ok(transpiled_source.text)
|
|
|
|
}
|
|
|
|
|
2022-07-04 18:12:41 -04:00
|
|
|
struct Permissions;
|
|
|
|
|
|
|
|
impl deno_fetch::FetchPermissions for Permissions {
|
|
|
|
fn check_net_url(
|
|
|
|
&mut self,
|
|
|
|
_url: &deno_core::url::Url,
|
2022-09-27 16:36:33 -04:00
|
|
|
_api_name: &str,
|
2022-07-04 18:12:41 -04:00
|
|
|
) -> Result<(), deno_core::error::AnyError> {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_read(
|
|
|
|
&mut self,
|
|
|
|
_p: &Path,
|
2022-09-27 16:36:33 -04:00
|
|
|
_api_name: &str,
|
2022-07-04 18:12:41 -04:00
|
|
|
) -> Result<(), deno_core::error::AnyError> {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl deno_websocket::WebSocketPermissions for Permissions {
|
|
|
|
fn check_net_url(
|
|
|
|
&mut self,
|
|
|
|
_url: &deno_core::url::Url,
|
2022-09-27 16:36:33 -04:00
|
|
|
_api_name: &str,
|
2022-07-04 18:12:41 -04:00
|
|
|
) -> Result<(), deno_core::error::AnyError> {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl deno_web::TimersPermission for Permissions {
|
|
|
|
fn allow_hrtime(&mut self) -> bool {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_unstable(
|
|
|
|
&self,
|
|
|
|
_state: &deno_core::OpState,
|
|
|
|
_api_name: &'static str,
|
|
|
|
) {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl deno_ffi::FfiPermissions for Permissions {
|
|
|
|
fn check(
|
|
|
|
&mut self,
|
|
|
|
_path: Option<&Path>,
|
|
|
|
) -> Result<(), deno_core::error::AnyError> {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-05 10:06:44 -04:00
|
|
|
impl deno_napi::NapiPermissions for Permissions {
|
|
|
|
fn check(
|
|
|
|
&mut self,
|
|
|
|
_path: Option<&Path>,
|
|
|
|
) -> Result<(), deno_core::error::AnyError> {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-18 08:05:02 -04:00
|
|
|
impl deno_flash::FlashPermissions for Permissions {
|
|
|
|
fn check_net<T: AsRef<str>>(
|
|
|
|
&mut self,
|
|
|
|
_host: &(T, Option<u16>),
|
2022-09-27 16:36:33 -04:00
|
|
|
_api_name: &str,
|
2022-08-18 08:05:02 -04:00
|
|
|
) -> Result<(), deno_core::error::AnyError> {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-08-24 12:07:49 -04:00
|
|
|
impl deno_node::NodePermissions for Permissions {
|
|
|
|
fn check_read(
|
|
|
|
&mut self,
|
|
|
|
_p: &Path,
|
|
|
|
) -> Result<(), deno_core::error::AnyError> {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-04 18:12:41 -04:00
|
|
|
impl deno_net::NetPermissions for Permissions {
|
|
|
|
fn check_net<T: AsRef<str>>(
|
|
|
|
&mut self,
|
|
|
|
_host: &(T, Option<u16>),
|
2022-09-27 16:36:33 -04:00
|
|
|
_api_name: &str,
|
2022-07-04 18:12:41 -04:00
|
|
|
) -> Result<(), deno_core::error::AnyError> {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_read(
|
|
|
|
&mut self,
|
|
|
|
_p: &Path,
|
2022-09-27 16:36:33 -04:00
|
|
|
_api_name: &str,
|
2022-07-04 18:12:41 -04:00
|
|
|
) -> Result<(), deno_core::error::AnyError> {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_write(
|
|
|
|
&mut self,
|
|
|
|
_p: &Path,
|
2022-09-27 16:36:33 -04:00
|
|
|
_api_name: &str,
|
2022-07-04 18:12:41 -04:00
|
|
|
) -> Result<(), deno_core::error::AnyError> {
|
|
|
|
unreachable!("snapshotting!")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-08 16:40:18 -05:00
|
|
|
fn create_runtime_snapshot(
|
|
|
|
snapshot_path: PathBuf,
|
2023-02-13 09:34:32 -05:00
|
|
|
maybe_additional_extension: Option<Extension>,
|
2023-02-08 16:40:18 -05:00
|
|
|
) {
|
2023-02-13 09:34:32 -05:00
|
|
|
let runtime_extension = Extension::builder("runtime")
|
|
|
|
.dependencies(vec![
|
|
|
|
"deno_webidl",
|
|
|
|
"deno_console",
|
|
|
|
"deno_url",
|
|
|
|
"deno_tls",
|
|
|
|
"deno_web",
|
|
|
|
"deno_fetch",
|
|
|
|
"deno_cache",
|
|
|
|
"deno_websocket",
|
|
|
|
"deno_webstorage",
|
|
|
|
"deno_crypto",
|
|
|
|
"deno_webgpu",
|
|
|
|
"deno_broadcast_channel",
|
|
|
|
"deno_node",
|
|
|
|
"deno_ffi",
|
|
|
|
"deno_net",
|
|
|
|
"deno_napi",
|
|
|
|
"deno_http",
|
|
|
|
"deno_flash",
|
|
|
|
])
|
|
|
|
.esm(include_js_files_dir!(
|
|
|
|
dir "js",
|
|
|
|
"01_build.js",
|
|
|
|
"01_errors.js",
|
|
|
|
"01_version.ts",
|
|
|
|
"06_util.js",
|
|
|
|
"10_permissions.js",
|
|
|
|
"11_workers.js",
|
|
|
|
"12_io.js",
|
|
|
|
"13_buffer.js",
|
|
|
|
"30_fs.js",
|
|
|
|
"30_os.js",
|
|
|
|
"40_diagnostics.js",
|
|
|
|
"40_files.js",
|
|
|
|
"40_fs_events.js",
|
|
|
|
"40_http.js",
|
|
|
|
"40_process.js",
|
|
|
|
"40_read_file.js",
|
|
|
|
"40_signals.js",
|
|
|
|
"40_spawn.js",
|
|
|
|
"40_tty.js",
|
|
|
|
"40_write_file.js",
|
|
|
|
"41_prompt.js",
|
|
|
|
"90_deno_ns.js",
|
|
|
|
"98_global_scope.js",
|
|
|
|
))
|
|
|
|
.build();
|
|
|
|
|
|
|
|
let mut extensions_with_js: Vec<Extension> = vec![
|
2022-07-04 18:12:41 -04:00
|
|
|
deno_webidl::init(),
|
|
|
|
deno_console::init(),
|
|
|
|
deno_url::init(),
|
|
|
|
deno_tls::init(),
|
|
|
|
deno_web::init::<Permissions>(
|
|
|
|
deno_web::BlobStore::default(),
|
|
|
|
Default::default(),
|
|
|
|
),
|
|
|
|
deno_fetch::init::<Permissions>(Default::default()),
|
2022-09-28 08:11:12 -04:00
|
|
|
deno_cache::init::<SqliteBackedCache>(None),
|
2022-07-04 18:12:41 -04:00
|
|
|
deno_websocket::init::<Permissions>("".to_owned(), None, None),
|
|
|
|
deno_webstorage::init(None),
|
|
|
|
deno_crypto::init(None),
|
|
|
|
deno_webgpu::init(false),
|
|
|
|
deno_broadcast_channel::init(
|
|
|
|
deno_broadcast_channel::InMemoryBroadcastChannel::default(),
|
|
|
|
false, // No --unstable.
|
|
|
|
),
|
2022-11-10 11:57:10 -05:00
|
|
|
deno_node::init::<Permissions>(None),
|
2022-07-04 18:12:41 -04:00
|
|
|
deno_ffi::init::<Permissions>(false),
|
|
|
|
deno_net::init::<Permissions>(
|
|
|
|
None, false, // No --unstable.
|
|
|
|
None,
|
|
|
|
),
|
2022-10-05 10:06:44 -04:00
|
|
|
deno_napi::init::<Permissions>(false),
|
2022-07-04 18:12:41 -04:00
|
|
|
deno_http::init(),
|
2022-08-18 08:05:02 -04:00
|
|
|
deno_flash::init::<Permissions>(false), // No --unstable
|
2023-02-13 09:34:32 -05:00
|
|
|
runtime_extension,
|
2022-07-04 18:12:41 -04:00
|
|
|
];
|
|
|
|
|
2023-02-13 09:34:32 -05:00
|
|
|
if let Some(additional_extension) = maybe_additional_extension {
|
|
|
|
extensions_with_js.push(additional_extension);
|
|
|
|
}
|
|
|
|
|
2022-11-21 08:36:26 -05:00
|
|
|
create_snapshot(CreateSnapshotOptions {
|
|
|
|
cargo_manifest_dir: env!("CARGO_MANIFEST_DIR"),
|
|
|
|
snapshot_path,
|
|
|
|
startup_snapshot: None,
|
2022-11-26 18:58:23 -05:00
|
|
|
extensions: vec![],
|
|
|
|
extensions_with_js,
|
2022-11-21 08:36:26 -05:00
|
|
|
compression_cb: Some(Box::new(|vec, snapshot_slice| {
|
|
|
|
lzzzz::lz4_hc::compress_to_vec(
|
|
|
|
snapshot_slice,
|
|
|
|
vec,
|
|
|
|
lzzzz::lz4_hc::CLEVEL_MAX,
|
|
|
|
)
|
|
|
|
.expect("snapshot compression failed");
|
|
|
|
})),
|
2023-02-08 16:40:18 -05:00
|
|
|
snapshot_module_load_cb: Some(Box::new(transpile_ts_for_snapshotting)),
|
2022-07-04 18:12:41 -04:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn build_snapshot(runtime_snapshot_path: PathBuf) {
|
2023-02-08 16:40:18 -05:00
|
|
|
#[allow(unused_mut, unused_assignments)]
|
2023-02-13 09:34:32 -05:00
|
|
|
let mut maybe_additional_extension = None;
|
2023-02-07 14:22:46 -05:00
|
|
|
|
2022-11-28 06:47:25 -05:00
|
|
|
#[cfg(not(feature = "snapshot_from_snapshot"))]
|
|
|
|
{
|
2023-02-13 09:34:32 -05:00
|
|
|
maybe_additional_extension = Some(
|
|
|
|
Extension::builder("runtime_main")
|
|
|
|
.dependencies(vec!["runtime"])
|
|
|
|
.esm(vec![ExtensionFileSource {
|
|
|
|
specifier: "js/99_main.js".to_string(),
|
|
|
|
code: include_str!("js/99_main.js"),
|
|
|
|
}])
|
|
|
|
.build(),
|
|
|
|
);
|
2022-11-28 06:47:25 -05:00
|
|
|
}
|
2023-02-08 16:40:18 -05:00
|
|
|
|
2023-02-13 09:34:32 -05:00
|
|
|
create_runtime_snapshot(runtime_snapshot_path, maybe_additional_extension);
|
2022-07-04 18:12:41 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-11 12:01:30 -04:00
|
|
|
fn main() {
|
2022-07-04 18:12:41 -04:00
|
|
|
// To debug snapshot issues uncomment:
|
|
|
|
// op_fetch_asset::trace_serializer();
|
|
|
|
|
|
|
|
println!("cargo:rustc-env=TARGET={}", env::var("TARGET").unwrap());
|
|
|
|
println!("cargo:rustc-env=PROFILE={}", env::var("PROFILE").unwrap());
|
|
|
|
let o = PathBuf::from(env::var_os("OUT_DIR").unwrap());
|
|
|
|
|
|
|
|
// Main snapshot
|
2022-11-21 08:36:26 -05:00
|
|
|
let runtime_snapshot_path = o.join("RUNTIME_SNAPSHOT.bin");
|
2022-07-04 18:12:41 -04:00
|
|
|
|
|
|
|
// If we're building on docs.rs we just create
|
|
|
|
// and empty snapshot file and return, because `rusty_v8`
|
|
|
|
// doesn't actually compile on docs.rs
|
|
|
|
if env::var_os("DOCS_RS").is_some() {
|
|
|
|
let snapshot_slice = &[];
|
|
|
|
std::fs::write(&runtime_snapshot_path, snapshot_slice).unwrap();
|
2021-08-11 12:01:30 -04:00
|
|
|
}
|
2020-12-13 13:45:53 -05:00
|
|
|
|
2022-07-04 18:12:41 -04:00
|
|
|
#[cfg(not(feature = "docsrs"))]
|
|
|
|
not_docs::build_snapshot(runtime_snapshot_path)
|
2020-12-13 13:45:53 -05:00
|
|
|
}
|