ezno 0.0.13

A JavaScript checker and compiler. For use as a library or cli
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use std::path::Path;
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
extern "C" {
	#[wasm_bindgen(js_namespace = console)]
	pub(crate) fn log(s: &str);
}

#[wasm_bindgen(js_name = build)]
pub fn build_wasm(fs_resolver_js: &js_sys::Function, entry_path: String, minify: bool) -> JsValue {
	std::panic::set_hook(Box::new(console_error_panic_hook::hook));

	let fs_resolver = |path: &std::path::Path| {
		let res =
			fs_resolver_js.call1(&JsValue::null(), &JsValue::from(path.display().to_string()));
		res.ok().and_then(|res| res.as_string())
	};
	let result = crate::commands::build(
		&fs_resolver,
		Path::new(&entry_path),
		None,
		Path::new("out.js"),
		minify,
	);
	serde_wasm_bindgen::to_value(&result).unwrap()
}

#[wasm_bindgen(js_name = check)]
pub fn check_wasm(fs_resolver_js: &js_sys::Function, entry_path: String) -> JsValue {
	std::panic::set_hook(Box::new(console_error_panic_hook::hook));

	let fs_resolver = |path: &std::path::Path| {
		let res =
			fs_resolver_js.call1(&JsValue::null(), &JsValue::from(path.display().to_string()));
		res.ok().and_then(|res| res.as_string())
	};
	let (_fs, diagnostics, _) = crate::commands::check(&fs_resolver, Path::new(&entry_path), None);
	// TODO also emit mappings
	serde_wasm_bindgen::to_value(&diagnostics).unwrap()
}

#[wasm_bindgen(js_name = run_cli)]
pub fn run_cli_wasm(
	cli_arguments: Box<[JsValue]>,
	fs_resolver_js: &js_sys::Function,
	cli_input_resolver_js: &js_sys::Function,
) {
	std::panic::set_hook(Box::new(console_error_panic_hook::hook));

	let arguments = cli_arguments.into_iter().flat_map(JsValue::as_string).collect::<Vec<_>>();
	let arguments = arguments.iter().map(String::as_str).collect::<Vec<_>>();

	let fs_resolver = |path: &std::path::Path| {
		let res =
			fs_resolver_js.call1(&JsValue::null(), &JsValue::from(path.display().to_string()));
		res.ok().and_then(|res| res.as_string())
	};

	let cli_input_resolver = |prompt: &str| {
		cli_input_resolver_js
			.call1(&JsValue::null(), &JsValue::from(prompt.to_owned()))
			.ok()
			.as_ref()
			.and_then(JsValue::as_string)
	};

	crate::run_cli(&arguments, fs_resolver, cli_input_resolver)
}

#[wasm_bindgen(js_name = parse_expression)]
pub fn parse_expression_to_json(input: String) -> JsValue {
	use parser::{ASTNode, Expression, SourceId};

	std::panic::set_hook(Box::new(console_error_panic_hook::hook));
	let expression = Expression::from_string(input, Default::default(), SourceId::NULL, None);
	match expression {
		Ok(expression) => serde_wasm_bindgen::to_value(&Ok::<_, ()>(expression)).unwrap(),
		Err(parse_error) => {
			serde_wasm_bindgen::to_value(&(parse_error.reason, parse_error.position)).unwrap()
		}
	}
}