git.delta.rocks / jrsonnet / refs/commits / 9aabcd49c223

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1119,6 +1119,7 @@
  "jrsonnet-stdlib",
  "jrsonnet-types",
  "js-sys",
+ "rustc-hash 2.1.2",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",

--- a/README.adoc
+++ b/README.adoc
@@ -88,6 +88,21 @@
 
 Jrsonnet is written in rust itself, so just add it as dependency
 
+=== JavaScript/TypeScript (WASM)
+
+// image:https://img.shields.io/npm/v/jrsonnet[alt=npm, link=https://www.npmjs.com/package/jrsonnet]
+image:https://jsr.io/badges/@jrsonnet/jrsonnet[alt=JSR, link=https://jsr.io/@jrsonnet/jrsonnet]
+image:https://jsr.io/badges/@jrsonnet/jrsonnet/score[alt=JSR score, link=https://jsr.io/@jrsonnet/jrsonnet]
+
+WASM bindings are published to JSR as `@jrsonnet/jrsonnet`.
+
+[source,sh]
+----
+deno add jsr:@jrsonnet/jrsonnet
+----
+
+// npm package (`jrsonnet`) is not yet published.
+
 === Python
 
 image:https://img.shields.io/pypi/v/rjsonnet[alt=crates.io, link=https://pypi.org/project/rjsonnet/]
@@ -100,6 +115,6 @@
 
 === Other
 
-WASM bingings are also available, Java bindings (Both JNI and WASM compiled to `.class`) are in progress
+Java bindings (Both JNI and WASM compiled to `.class`) are in progress
 
 See link:./bindings/[bindings] for more information.

--- a/bindings/jrsonnet-web/Cargo.toml
+++ b/bindings/jrsonnet-web/Cargo.toml
@@ -1,6 +1,8 @@
 [package]
 name = "jrsonnet-web"
-description = "WASM JS bindings for jrsonnet"
+description = "WebAssembly JavaScript bindings for jrsonnet"
+keywords = ["jsonnet", "wasm", "web"]
+categories = ["wasm"]
 authors.workspace = true
 edition.workspace = true
 license.workspace = true
@@ -17,6 +19,7 @@
 jrsonnet-stdlib.workspace = true
 jrsonnet-types.workspace = true
 js-sys.workspace = true
+rustc-hash.workspace = true
 url.workspace = true
 wasm-bindgen.workspace = true
 wasm-bindgen-futures.workspace = true

--- a/bindings/jrsonnet-web/deno.json
+++ b/bindings/jrsonnet-web/deno.json
@@ -1,7 +1,7 @@
 {
 	"name": "@jrsonnet/jrsonnet",
 	"license": "MIT",
-	"version": "0.0.1",
+	"version": "0.0.2",
 	"tasks": {
 		"wasmbuild": "deno run -A @deno/wasmbuild -p jrsonnet-web --skip-opt"
 	},
@@ -11,11 +11,15 @@
 		"@std/assert": "jsr:@std/assert@^1.0.19"
 	},
 	"exports": {
-		".": "./mod.ts"
+		".": "./mod.ts",
+		"./fmt": "./fmt.ts"
 	},
 	"publish": {
 		"exclude": [
 			"!lib"
 		]
+	},
+	"fmt": {
+		"useTabs": true
 	}
 }

--- a/bindings/jrsonnet-web/fmt.test.ts
+++ b/bindings/jrsonnet-web/fmt.test.ts
@@ -1,7 +1,7 @@
 import { assertEquals } from "@std/assert";
-import { format, FormatOptions } from "./mod.ts";
+import { format, FormatOptions } from "./fmt.ts";
 
 Deno.test("format", () => {
-  const opts = new FormatOptions();
-  assertEquals(format("{a:1+1}", opts), "{ a: 1 + 1 }\n");
+	const opts = new FormatOptions();
+	assertEquals(format("{a:1+1}", opts), "{ a: 1 + 1 }\n");
 });

--- a/bindings/jrsonnet-web/fmt.ts
+++ b/bindings/jrsonnet-web/fmt.ts
@@ -0,0 +1 @@
+export { format, FormatOptions } from "./lib/jsonnet_web.js";

--- a/bindings/jrsonnet-web/mod.test.ts
+++ b/bindings/jrsonnet-web/mod.test.ts
@@ -1,8 +1,139 @@
-import { assertEquals } from "@std/assert";
-import { WasmState } from "./mod.ts";
+import { assertEquals, assertRejects, assertThrows } from "@std/assert";
+import { type ImportResolver, JrsonnetError, State, ValKind } from "./mod.ts";
+
+Deno.test("evaluateSnippet returns numbers", () => {
+	const state = new State();
+	const v = state.evaluateSnippet("test.jsonnet", "1 + 2");
+	assertEquals(v.kind, ValKind.Num);
+	assertEquals(v.asNum(), 3);
+});
+
+Deno.test("evaluateSnippet returns booleans", () => {
+	const state = new State();
+	const v = state.evaluateSnippet("test.jsonnet", "true && !false");
+	assertEquals(v.kind, ValKind.Bool);
+	assertEquals(v.asBool(), true);
+});
+
+Deno.test("evaluateSnippet returns strings", () => {
+	const state = new State();
+	const v = state.evaluateSnippet("test.jsonnet", "'hello ' + 'world'");
+	assertEquals(v.kind, ValKind.Str);
+	assertEquals(v.asString(), "hello world");
+});
 
-Deno.test("basic", () => {
-  const state = new WasmState();
+Deno.test("evaluateSnippet returns null", () => {
+	const state = new State();
+	const v = state.evaluateSnippet("test.jsonnet", "null");
+	assertEquals(v.kind, ValKind.Null);
+	assertEquals(v.asNum(), undefined);
+});
 
-  assertEquals(state.evaluate_snippet("test.jsonnet", "1 + 2").as_num(), 3);
+Deno.test("Val.asArr exposes ArrValue", () => {
+	const state = new State();
+	const arr = state.evaluateSnippet("test.jsonnet", "[10, 20, 30]").asArr();
+	if (!arr) throw new Error("expected array");
+	assertEquals(arr.length, 3);
+	assertEquals(arr.at(1)?.asNum(), 20);
+	assertEquals(arr.at(99), undefined);
+});
+
+Deno.test("Val.asObj exposes ObjValue", () => {
+	const state = new State();
+	const obj = state.evaluateSnippet("test.jsonnet", "{a: 1, b: 'two'}").asObj();
+	if (!obj) throw new Error("expected object");
+	assertEquals(obj.keys().sort(), ["a", "b"]);
+	assertEquals(obj.get("a")?.asNum(), 1);
+	assertEquals(obj.get("b")?.asString(), "two");
+	assertEquals(obj.get("missing"), undefined);
+});
+
+Deno.test("evaluateSnippet manifests JSON", () => {
+	const state = new State();
+	const v = state.evaluateSnippet("test.jsonnet", "{a: 1, b: [2, 3]}");
+	assertEquals(v.manifestJson(0), '{"a":1,"b":[2,3]}');
+});
+
+Deno.test("evaluateSnippet propagates jsonnet errors", () => {
+	const state = new State();
+	assertThrows(() => state.evaluateSnippet("test.jsonnet", "error 'boom'"));
+});
+
+Deno.test("evaluateFile without resolver rejects", async () => {
+	const state = new State();
+	await assertRejects(() => state.evaluateFile("anything.jsonnet"));
+});
+
+Deno.test("resolver errors become JrsonnetError with cause", async () => {
+	const original = new Error("disk on fire");
+	const resolver: ImportResolver = {
+		resolveFrom(_from, path) {
+			return Promise.resolve(`memory:///${path}`);
+		},
+		loadFileContents(_resolved) {
+			throw original;
+		},
+	};
+	const state = new State(resolver);
+	const err = await assertRejects(
+		() => state.evaluateFile("anything.jsonnet"),
+		JrsonnetError,
+		"loadFileContents",
+	);
+	assertEquals(err.cause, original);
+	assertEquals(err.frames[0]?.desc, "loadFileContents");
+	// The wrapped error's own stack must not mention internal wasm frames.
+	assertEquals((err.stack ?? "").includes(".wasm"), false);
+});
+
+Deno.test("Val.applyTla calls function with named args", () => {
+	const state = new State();
+	const fn = state.evaluateSnippet(
+		"test.jsonnet",
+		"function(x, y) x + y",
+	);
+	const result = fn.applyTla({
+		x: state.evaluateSnippet("x.jsonnet", "10"),
+		y: state.evaluateSnippet("y.jsonnet", "32"),
+	});
+	assertEquals(result.asNum(), 42);
+});
+
+Deno.test("Val.applyTla borrows args without consuming them", () => {
+	const state = new State();
+	const fn = state.evaluateSnippet("test.jsonnet", "function(x) x * 2");
+	const x = state.evaluateSnippet("x.jsonnet", "21");
+	assertEquals(fn.applyTla({ x }).asNum(), 42);
+	assertEquals(x.asNum(), 21);
+	assertEquals(fn.applyTla({ x }).asNum(), 42);
+});
+
+Deno.test("Val.applyTla on non-function returns the value unchanged", () => {
+	const state = new State();
+	const v = state.evaluateSnippet("test.jsonnet", "123");
+	assertEquals(v.applyTla({}).asNum(), 123);
+});
+
+Deno.test("evaluateFileFrom resolves relative paths", async () => {
+	const files: Record<string, string> = {
+		"memory:///root/main.jsonnet": "import 'lib.jsonnet'",
+		"memory:///root/lib.jsonnet": "{ answer: 42 }",
+	};
+	const resolver: ImportResolver = {
+		resolveFrom(from, path) {
+			const base = from ?? "memory:///root/";
+			return Promise.resolve(new URL(path, base).toString());
+		},
+		loadFileContents(resolved) {
+			const code = files[resolved];
+			if (code === undefined) throw new Error(`missing ${resolved}`);
+			return Promise.resolve(new TextEncoder().encode(code));
+		},
+	};
+	const state = new State(resolver);
+	const v = await state.evaluateFileFrom(
+		"memory:///root/main.jsonnet",
+		"./lib.jsonnet",
+	);
+	assertEquals(v.asObj()?.get("answer")?.asNum(), 42);
 });

--- a/bindings/jrsonnet-web/mod.ts
+++ b/bindings/jrsonnet-web/mod.ts
@@ -1,60 +1,71 @@
 import { assert } from "@std/assert";
 import {
-  format as formatRaw,
-  type ImportResolver,
-  WasmFormatOptions,
-  WasmState,
-  WasmVal,
+	ArrValue,
+	type ImportResolver,
+	ObjValue,
+	setErrorFactory,
+	State,
+	Val,
+	ValKind,
 } from "./lib/jsonnet_web.js";
 
-export { type ImportResolver, WasmFormatOptions, WasmState, WasmVal };
+export interface JrsonnetFrame {
+	desc: string;
+	path?: string;
+	line?: number;
+	column?: number;
+}
 
-class FetchImportResolver implements ImportResolver {
-  constructor(public base: string) {}
+export class JrsonnetError extends Error {
+	override name = "JrsonnetError" as const;
+	frames: JrsonnetFrame[];
 
-  resolution = new Map<string, URL>();
-  response = new Map<string, Response>();
+	constructor(message: string, frames: JrsonnetFrame[], cause?: unknown) {
+		super(message, cause !== undefined ? { cause } : undefined);
+		this.frames = frames;
+	}
+}
 
-  async resolveFrom(from: string | undefined, path: string): Promise<string> {
-    let resolved: URL;
-    if (from) {
-      resolved = new URL(path, from);
-    } else {
-      resolved = new URL(path, this.base);
-    }
-    const resolvingStr = resolved.toString();
-    resolved = this.resolution.get(resolvingStr) ?? resolved;
+setErrorFactory(
+	(message: string, frames: JrsonnetFrame[], cause: unknown) =>
+		new JrsonnetError(message, frames, cause),
+);
+
+export { ArrValue, type ImportResolver, ObjValue, State, Val, ValKind };
 
-    const resolvedStr = resolved.toString();
-    if (!this.response.has(resolvedStr)) {
-      console.log(resolved);
-      const v = await fetch(resolved);
-      this.response.set(resolvedStr, v);
-      resolved = new URL(v.url);
-      this.resolution.set(resolvingStr, resolved);
-    }
-    return resolved.toString();
-  }
-  loadFileContents(resolved: string): Promise<Uint8Array> {
-    console.log(resolved);
-    const v = this.response.get(resolved);
-    assert(v, "should be resolved");
-    return v.bytes();
-  }
-}
+export class FetchImportResolver implements ImportResolver {
+	constructor(base: URL | string) {
+		this.#base = new URL(base);
+	}
 
-//
-// try {
-//   console.log("eval file");
-//   await state.evaluate_file("example.jsonnet");
-//   console.log("eval file done");
-// } catch (e) {
-//   console.log(e);
-// }
-//
-export function format(
-  code: string,
-  opts: WasmFormatOptions = new WasmFormatOptions(),
-): string {
-  return formatRaw(code, opts);
+	#base: URL;
+	#resolution = new Map<string, string>();
+	#bytes = new Map<string, Uint8Array>();
+
+	async resolveFrom(from: string | undefined, path: string): Promise<string> {
+		const base = from !== undefined ? from : this.#base;
+		const requestStr = new URL(path, base).toString();
+
+		const cached = this.#resolution.get(requestStr);
+		if (cached !== undefined) return cached;
+
+		const resp = await fetch(requestStr);
+		if (!resp.ok) {
+			throw new Error(
+				`fetch ${requestStr}: HTTP ${resp.status} ${resp.statusText}`,
+			);
+		}
+		const canonical = resp.url;
+		if (!this.#bytes.has(canonical)) {
+			this.#bytes.set(canonical, await resp.bytes());
+		}
+		this.#resolution.set(requestStr, canonical);
+		return canonical;
+	}
+
+	loadFileContents(resolved: string): Promise<Uint8Array> {
+		const bytes = this.#bytes.get(resolved);
+		assert(bytes, `not loaded: ${resolved}`);
+		return Promise.resolve(bytes);
+	}
 }

--- a/bindings/jrsonnet-web/scripts/build_npm.ts
+++ b/bindings/jrsonnet-web/scripts/build_npm.ts
@@ -3,27 +3,27 @@
 await emptyDir("./npm");
 
 await build({
-  entryPoints: ["./mod.ts"],
-  outDir: "./npm",
-  shims: {
-    // see JS docs for overview and more options
-    deno: true,
-  },
-  package: {
-    // package.json properties
-    name: "jrsonnet",
-    version: Deno.args[0],
-    description: "Jrsonnet.",
-    license: "MIT",
-    repository: {
-      type: "git",
-      url: "git+https://github.com/CertainLach/jrsonnet.git",
-    },
-    bugs: {
-      url: "https://github.com/CertainLach/jrsonnet/issues",
-    },
-  },
-  postBuild() {
-    Deno.copyFileSync("../../LICENSE", "npm/LICENSE");
-  },
+	entryPoints: ["./mod.ts"],
+	outDir: "./npm",
+	shims: {
+		// see JS docs for overview and more options
+		deno: true,
+	},
+	package: {
+		// package.json properties
+		name: "jrsonnet",
+		version: Deno.args[0],
+		description: "Jrsonnet.",
+		license: "MIT",
+		repository: {
+			type: "git",
+			url: "git+https://github.com/CertainLach/jrsonnet.git",
+		},
+		bugs: {
+			url: "https://github.com/CertainLach/jrsonnet/issues",
+		},
+	},
+	postBuild() {
+		Deno.copyFileSync("../../LICENSE", "npm/LICENSE");
+	},
 });

1use std::result::Result;1#![allow(clippy::future_not_send, reason = "we work with js promises anyway")]
22
3use std::{cell::RefCell, result::Result};
4
3use jrsonnet_evaluator::{5use jrsonnet_evaluator::{
4	NumValue, Result as JrResult, SourcePath, SourceUrl, State, StateBuilder, Val,6	IStr, NumValue, ObjValue, Result as JrResult, SourcePath, SourceUrl, State, StateBuilder, Val,
5	async_import::{ResolvedImportResolver, async_import},7	async_import::{ResolvedImportResolver, async_import},
6	error,8	error,
7	function::builtin::{NativeCallback, NativeCallbackHandler},9	function::builtin::{NativeCallback, NativeCallbackHandler},
8	manifest::{JsonFormat, ManifestFormat, StringFormat, ToStringFormat, YamlStreamFormat},10	manifest::{JsonFormat, ManifestFormat, StringFormat, ToStringFormat, YamlStreamFormat},
9	trace::{JsFormat, PathResolver, TraceFormat},11	tla::{TlaArg, apply_tla},
12	trace::PathResolver,
13	val::ArrValue,
10	with_state,14	with_state,
11};15};
12use jrsonnet_formatter::FormatOptions;16use jrsonnet_formatter::FormatOptions;
13use jrsonnet_gcmodule::Trace;17use jrsonnet_gcmodule::Trace;
14use jrsonnet_stdlib::{IniFormat, TomlFormat, XmlJsonmlFormat, YamlFormat};18use jrsonnet_stdlib::{IniFormat, TomlFormat, XmlJsonmlFormat, YamlFormat};
15use jrsonnet_types::ValType;19use jrsonnet_types::ValType;
16use wasm_bindgen::prelude::*;20use js_sys::Reflect::get;
21use rustc_hash::FxHashMap;
22use wasm_bindgen::{convert::RefFromWasmAbi, prelude::*};
1723
18#[wasm_bindgen]24#[wasm_bindgen]
19#[derive(Clone, Copy)]25#[derive(Clone, Copy)]
27	Func,33	Func,
28}34}
2935
30#[wasm_bindgen(inline_js = r"36thread_local! {
31export class JrsonnetError extends Error {37	static ERR_FACTORY: RefCell<Option<js_sys::Function>> = const { RefCell::new(None) };
32	constructor(message, frames) {
33		super(message);
34		this.name = 'JrsonnetError';
35		this.frames = frames;
36	}
37}38}
38export function makeJrsonnetError(message, frames) {39#[wasm_bindgen(js_name = setErrorFactory)]
40pub fn set_error_factory(f: js_sys::Function) {
39	return new JrsonnetError(message, frames);41	ERR_FACTORY.with(|c| *c.borrow_mut() = Some(f));
40}42}
41")]
42extern "C" {
43	#[wasm_bindgen(js_name = makeJrsonnetError)]
44	fn make_jrsonnet_error(message: &str, frames: js_sys::Array) -> JsValue;43fn make_jrsonnet_error(message: &str, frames: js_sys::Array, cause: &JsValue) -> JsValue {
44	ERR_FACTORY.with(|c| {
45		c.borrow().as_ref().map_or_else(
46			|| js_sys::Error::new(message).into(),
47			|f| {
48				let args = js_sys::Array::new();
49				args.push(&JsValue::from_str(message));
50				args.push(&frames);
51				args.push(cause);
52				f.apply(&JsValue::NULL, &args)
53					.unwrap_or_else(|e| js_sys::Error::new(&format!("{e:?}")).into())
54			},
55		)
56	})
45}57}
4658
47#[wasm_bindgen(typescript_custom_section)]59fn js_error_message(e: &JsValue) -> String {
48const TS_JRSONNET_ERROR: &'static str = r"
49export interface JrsonnetFrame {
50	desc: string;60	e.dyn_ref::<js_sys::Error>().map_or_else(
51	path?: string;61		|| e.as_string().unwrap_or_else(|| format!("{e:?}")),
52	line?: number;62		|err| String::from(err.message()),
53	column?: number;63	)
54}64}
65
55export class JrsonnetError extends Error {66fn unwrap_val_ref(value: &JsValue) -> Result<<WasmVal as RefFromWasmAbi>::Anchor, JsValue> {
56	name: 'JrsonnetError';67	let ptr = get(value, &JsValue::from_str("__wbg_ptr"))
68		.ok()
69		.and_then(|v| v.as_f64())
70		.ok_or_else(|| JsValue::from_str("expected a Val instance"))? as u32;
57	frames: JrsonnetFrame[];71	if ptr == 0 {
72		return Err(JsValue::from_str("Val has been freed"));
73	}
74	Ok(unsafe { <WasmVal as RefFromWasmAbi>::ref_from_abi(ptr) })
58}75}
59";
6076
77fn js_resolver_error(prefix: &str, e: JsValue) -> JsValue {
78	let msg = format!("{prefix}: {}", js_error_message(&e));
79	let frames = js_sys::Array::new();
80	let frame = js_sys::Object::new();
81	let _ = js_sys::Reflect::set(
82		&frame,
83		&JsValue::from_str("desc"),
84		&JsValue::from_str(prefix),
85	);
86	frames.push(&frame);
87	make_jrsonnet_error(&msg, frames, &e)
88}
89
61fn jrsonnet_js_error(e: &jrsonnet_evaluator::Error) -> JsValue {90fn jrsonnet_js_error(e: &jrsonnet_evaluator::Error) -> JsValue {
62	let msg = e.error().to_string();91	let msg = e.error().to_string();
63	// let msg = format.format(e).unwrap_or_else(|_| e.to_string());92	// let msg = format.format(e).unwrap_or_else(|_| e.to_string());
90		}119		}
91		frames.push(&frame);120		frames.push(&frame);
92	}121	}
93	make_jrsonnet_error(&msg, frames)122	make_jrsonnet_error(&msg, frames, &JsValue::UNDEFINED)
94}123}
95124
96impl From<ValType> for ValKind {125impl From<ValType> for ValKind {
107	}136	}
108}137}
109138
110#[wasm_bindgen]139#[wasm_bindgen(js_name = Val)]
111pub struct WasmVal {140pub struct WasmVal {
112	val: Val,141	val: Val,
113	state: Option<State>,142	state: Option<State>,
123			state: Some(state),152			state: Some(state),
124		}153		}
125	}154	}
126	fn child(&self, val: Val) -> Self {
127		Self {
128			val,
129			state: self.state.clone(),
130		}
131	}
132	fn run<R>(&self, f: impl FnOnce(&Val) -> R) -> R {155	fn run<R>(&self, f: impl FnOnce(&Val) -> R) -> R {
133		if let Some(state) = &self.state {156		if let Some(state) = &self.state {
134			let _guard = state.try_enter();157			let _guard = state.try_enter();
143	}166	}
144}167}
145168
146#[wasm_bindgen]169#[wasm_bindgen(js_class = Val)]
147impl WasmVal {170impl WasmVal {
148	pub fn null() -> Self {171	pub fn null() -> Self {
149		Self::new(Val::Null)172		Self::new(Val::Null)
167	pub fn func(190	pub fn func(
168		params: Vec<String>,191		params: Vec<String>,
169192
170		#[wasm_bindgen(unchecked_param_type = "(...args: WasmVal[]) => WasmVal")]193		#[wasm_bindgen(unchecked_param_type = "(...args: Val[]) => Val")]
171		callback: js_sys::Function,194		callback: js_sys::Function,
172	) -> Self {195	) -> Self {
173		#[allow(deprecated)]196		#[allow(deprecated)]
181	pub fn kind(&self) -> ValKind {204	pub fn kind(&self) -> ValKind {
182		self.val.value_type().into()205		self.val.value_type().into()
183	}206	}
207	#[wasm_bindgen(js_name = asBool)]
184	pub fn as_bool(&self) -> Option<bool> {208	pub fn as_bool(&self) -> Option<bool> {
185		self.val.as_bool()209		self.val.as_bool()
186	}210	}
211	#[wasm_bindgen(js_name = asNum)]
187	pub fn as_num(&self) -> Option<f64> {212	pub fn as_num(&self) -> Option<f64> {
188		self.val.as_num()213		self.val.as_num()
189	}214	}
215	#[wasm_bindgen(js_name = asString)]
190	pub fn as_string(&self) -> Option<String> {216	pub fn as_string(&self) -> Option<String> {
191		self.val.as_str().map(|s| s.to_string())217		self.val.as_str().map(|s| s.to_string())
192	}218	}
193	pub fn arr_len(&self) -> Option<u32> {219	#[wasm_bindgen(js_name = asArr)]
220	pub fn as_arr(&self) -> Option<WasmArrValue> {
194		self.val.as_arr().map(|a| a.len())221		self.val.as_arr().map(|arr| WasmArrValue {
222			arr,
223			state: self.state.clone(),
224		})
195	}225	}
196	pub fn arr_at(&self, index: u32) -> Result<Option<WasmVal>, JsValue> {226	#[wasm_bindgen(js_name = asObj)]
227	pub fn as_obj(&self) -> Option<WasmObjValue> {
197		let Some(a) = self.val.as_arr() else {228		self.val.as_obj().map(|obj| WasmObjValue {
198			return Ok(None);229			obj,
199		};230			state: self.state.clone(),
200		self.run(|_| a.get(index))
201			.map(|opt| opt.map(|v| self.child(v)))231		})
202			.map_err(|e| jrsonnet_js_error(&e))
203	}232	}
233
204	pub fn obj_keys(&self) -> Option<Vec<String>> {234	#[wasm_bindgen(js_name = applyTla)]
235	pub fn apply_tla(
236		&self,
237		#[wasm_bindgen(unchecked_param_type = "Record<string, Val>")] args: &js_sys::Object,
238	) -> Result<WasmVal, JsValue> {
205		self.val239		let mut map: FxHashMap<IStr, TlaArg> = FxHashMap::default();
240		for entry in js_sys::Object::entries(args).iter() {
206			.as_obj()241			let pair: js_sys::Array = entry
242				.dyn_into()
207			.map(|o| o.fields().into_iter().map(|s| s.to_string()).collect())243				.map_err(|_| JsValue::from_str("expected [key, value] entry"))?;
244			let key = pair
245				.get(0)
246				.as_string()
208	}247				.ok_or_else(|| JsValue::from_str("TLA arg key must be a string"))?;
209	pub fn obj_get(&self, key: String) -> Result<Option<WasmVal>, JsValue> {
210		let Some(o) = self.val.as_obj() else {248			let value = unwrap_val_ref(&pair.get(1))?;
211			return Ok(None);249			map.insert(key.into(), TlaArg::Val(value.val.clone()));
212		};250		}
251		let val = self.val.clone();
213		self.run(|_| o.get(key.into()))252		self.run(|_| apply_tla(&map, val))
214			.map(|opt| opt.map(|v| self.child(v)))253			.map(|v| WasmVal {
254				val: v,
255				state: self.state.clone(),
256			})
215			.map_err(|e| jrsonnet_js_error(&e))257			.map_err(|e| jrsonnet_js_error(&e))
216	}258	}
217259
260	#[wasm_bindgen(js_name = manifestJson)]
218	pub fn manifest_json(&self, indent: u32) -> Result<String, JsValue> {261	pub fn manifest_json(&self, indent: u32) -> Result<String, JsValue> {
219		self.manifest_with(JsonFormat::cli(indent as usize))262		self.manifest_with(JsonFormat::cli(indent as usize))
220	}263	}
264	#[wasm_bindgen(js_name = manifestToString)]
221	pub fn manifest_to_string(&self) -> Result<String, JsValue> {265	pub fn manifest_to_string(&self) -> Result<String, JsValue> {
222		self.manifest_with(ToStringFormat)266		self.manifest_with(ToStringFormat)
223	}267	}
268	#[wasm_bindgen(js_name = manifestString)]
224	pub fn manifest_string(&self) -> Result<String, JsValue> {269	pub fn manifest_string(&self) -> Result<String, JsValue> {
225		self.manifest_with(StringFormat)270		self.manifest_with(StringFormat)
226	}271	}
272	#[wasm_bindgen(js_name = manifestYaml)]
227	pub fn manifest_yaml(&self, indent: u32, quote_keys: bool) -> Result<String, JsValue> {273	pub fn manifest_yaml(&self, indent: u32, quote_keys: bool) -> Result<String, JsValue> {
228		self.manifest_with(YamlFormat::std_to_yaml(indent != 0, quote_keys))274		self.manifest_with(YamlFormat::std_to_yaml(indent != 0, quote_keys))
229	}275	}
276	#[wasm_bindgen(js_name = manifestYamlStream)]
230	pub fn manifest_yaml_stream(277	pub fn manifest_yaml_stream(
231		&self,278		&self,
232		indent: u32,279		indent: u32,
238			c_document_end,285			c_document_end,
239		))286		))
240	}287	}
288	#[wasm_bindgen(js_name = manifestXmlJsonml)]
241	pub fn manifest_xml_jsonml(&self) -> Result<String, JsValue> {289	pub fn manifest_xml_jsonml(&self) -> Result<String, JsValue> {
242		self.manifest_with(XmlJsonmlFormat::std_to_xml())290		self.manifest_with(XmlJsonmlFormat::std_to_xml())
243	}291	}
292	#[wasm_bindgen(js_name = manifestToml)]
244	pub fn manifest_toml(&self, indent: u32) -> Result<String, JsValue> {293	pub fn manifest_toml(&self, indent: u32) -> Result<String, JsValue> {
245		self.manifest_with(TomlFormat::std_to_toml(" ".repeat(indent as usize)))294		self.manifest_with(TomlFormat::std_to_toml(" ".repeat(indent as usize)))
246	}295	}
296	#[wasm_bindgen(js_name = manifestIni)]
247	pub fn manifest_ini(&self) -> Result<String, JsValue> {297	pub fn manifest_ini(&self) -> Result<String, JsValue> {
248		self.manifest_with(IniFormat::std())298		self.manifest_with(IniFormat::std())
249	}299	}
250}300}
251301
302#[wasm_bindgen(js_name = ArrValue)]
303pub struct WasmArrValue {
304	arr: ArrValue,
305	state: Option<State>,
306}
307
308#[wasm_bindgen(js_class = ArrValue)]
309impl WasmArrValue {
310	#[wasm_bindgen(getter)]
311	pub fn length(&self) -> u32 {
312		self.arr.len()
313	}
314	pub fn at(&self, index: u32) -> Result<Option<WasmVal>, JsValue> {
315		let result = self.state.as_ref().map_or_else(
316			|| self.arr.get(index),
317			|state| {
318				let _guard = state.try_enter();
319				self.arr.get(index)
320			},
321		);
322		result
323			.map(|opt: Option<Val>| {
324				opt.map(|v| WasmVal {
325					val: v,
326					state: self.state.clone(),
327				})
328			})
329			.map_err(|e| jrsonnet_js_error(&e))
330	}
331}
332
333#[wasm_bindgen(js_name = ObjValue)]
334pub struct WasmObjValue {
335	obj: ObjValue,
336	state: Option<State>,
337}
338
339#[wasm_bindgen(js_class = ObjValue)]
340impl WasmObjValue {
341	pub fn keys(&self) -> Vec<String> {
342		self.obj
343			.fields()
344			.into_iter()
345			.map(|s| s.to_string())
346			.collect()
347	}
348	pub fn get(&self, key: String) -> Result<Option<WasmVal>, JsValue> {
349		let result = if let Some(state) = &self.state {
350			let _guard = state.try_enter();
351			self.obj.get(key.into())
352		} else {
353			self.obj.get(key.into())
354		};
355		result
356			.map(|opt: Option<Val>| {
357				opt.map(|v| WasmVal {
358					val: v,
359					state: self.state.clone(),
360				})
361			})
362			.map_err(|e| jrsonnet_js_error(&e))
363	}
364}
365
252#[derive(Trace)]366#[derive(Trace)]
253struct JsHandler {367struct JsHandler {
254	#[trace(skip)]368	#[trace(skip)]
292	}406	}
293}407}
294408
295#[wasm_bindgen]409#[wasm_bindgen(js_name = State)]
296pub struct WasmState {410pub struct WasmState {
297	state: State,411	state: State,
298	resolver: JsAsyncResolver,412	resolver: Option<JsAsyncResolver>,
299}413}
300#[wasm_bindgen]414#[wasm_bindgen(js_class = State)]
301impl WasmState {415impl WasmState {
302	#[wasm_bindgen(constructor)]416	#[wasm_bindgen(constructor)]
303	pub fn new(resolver: ImportResolverJs) -> Self {417	pub fn new(resolver: Option<ImportResolverJs>) -> Self {
304		console_error_panic_hook::set_once();418		console_error_panic_hook::set_once();
305		let mut state = StateBuilder::default();419		let mut state = StateBuilder::default();
306		state.import_resolver(ResolvedImportResolver::new());420		state.import_resolver(ResolvedImportResolver::new());
309		let state = state.build();423		let state = state.build();
310		Self {424		Self {
311			state,425			state,
312			resolver: JsAsyncResolver { js: resolver },426			resolver: resolver.map(|js| JsAsyncResolver { js }),
313		}427		}
314	}428	}
315429
316	#[wasm_bindgen]430	#[wasm_bindgen(js_name = evaluateSnippet)]
317	pub fn evaluate_snippet(&self, name: &str, snippet: &str) -> Result<WasmVal, JsValue> {431	pub fn evaluate_snippet(&self, name: &str, snippet: &str) -> Result<WasmVal, JsValue> {
318		let _guard = self.state.enter();432		let _guard = self.state.enter();
319		self.state433		self.state
322			.map_err(|e| jrsonnet_js_error(&e))436			.map_err(|e| jrsonnet_js_error(&e))
323	}437	}
324438
439	#[wasm_bindgen(js_name = evaluateFile)]
325	pub async fn evaluate_file(&self, path: String) -> Result<WasmVal, JsValue> {440	pub async fn evaluate_file(&self, path: String) -> Result<WasmVal, JsValue> {
326		let path = async_import(self.state.clone(), self.resolver.clone(), &path.as_str()).await?;441		self.evaluate_file_from_impl(None, path).await
442	}
443
444	#[wasm_bindgen(js_name = evaluateFileFrom)]
445	pub async fn evaluate_file_from(&self, from: String, path: String) -> Result<WasmVal, JsValue> {
446		self.evaluate_file_from_impl(Some(from), path).await
447	}
448}
449
450impl WasmState {
451	async fn evaluate_file_from_impl(
452		&self,
453		from: Option<String>,
454		path: String,
455	) -> Result<WasmVal, JsValue> {
456		let resolver = self
457			.resolver
458			.clone()
459			.ok_or_else(|| JsValue::from_str("file evaluation requires an ImportResolver"))?;
460		let from = match from {
461			Some(s) => {
462				let url = url::Url::parse(&s).map_err(|e| JsValue::from_str(&e.to_string()))?;
463				SourcePath::new(SourceUrl::new(url))
464			}
465			None => SourcePath::default(),
466		};
467		let path = async_import(self.state.clone(), resolver, &from, &path.as_str()).await?;
327		let _guard = self.state.enter();468		let _guard = self.state.enter();
328		self.state469		self.state
329			.import_resolved(path)470			.import_resolved(path)
375	) -> Result<SourcePath, JsValue> {516	) -> Result<SourcePath, JsValue> {
376		let from_js = (!from.is_default()).then(|| from.to_string());517		let from_js = (!from.is_default()).then(|| from.to_string());
377		let path_str = path.as_path().as_ref().to_string_lossy().into_owned();518		let path_str = path.as_path().as_ref().to_string_lossy().into_owned();
378		let promise = self.js.resolve_from(from_js, &path_str)?;519		let promise = self
520			.js
521			.resolve_from(from_js, &path_str)
522			.map_err(|e| js_resolver_error("resolveFrom", e))?;
379		let resolved_js = wasm_bindgen_futures::JsFuture::from(promise).await?;523		let resolved_js = wasm_bindgen_futures::JsFuture::from(promise)
524			.await
525			.map_err(|e| js_resolver_error("resolveFrom", e))?;
380		let resolved_str = resolved_js526		let resolved_str = resolved_js
381			.as_string()527			.as_string()
382			.ok_or_else(|| JsValue::from_str("resolveFrom must return string"))?;528			.ok_or_else(|| JsValue::from_str("resolveFrom must return string"))?;
386532
387	async fn load_file_contents(&self, resolved: &SourcePath) -> Result<Vec<u8>, JsValue> {533	async fn load_file_contents(&self, resolved: &SourcePath) -> Result<Vec<u8>, JsValue> {
388		let resolved_str = resolved.to_string();534		let resolved_str = resolved.to_string();
389		let promise = self.js.load_file_contents(&resolved_str)?;535		let promise = self
536			.js
537			.load_file_contents(&resolved_str)
538			.map_err(|e| js_resolver_error("loadFileContents", e))?;
390		let bytes_js = wasm_bindgen_futures::JsFuture::from(promise).await?;539		let bytes_js = wasm_bindgen_futures::JsFuture::from(promise)
540			.await
541			.map_err(|e| js_resolver_error("loadFileContents", e))?;
391		let arr = bytes_js542		let arr = bytes_js
392			.dyn_into::<js_sys::Uint8Array>()543			.dyn_into::<js_sys::Uint8Array>()
393			.map_err(|_| JsValue::from_str("loadFileContents must return Uint8Array"))?;544			.map_err(|_| JsValue::from_str("loadFileContents must return Uint8Array"))?;
394		Ok(arr.to_vec())545		Ok(arr.to_vec())
395	}546	}
396}547}
397548
398#[wasm_bindgen]549#[wasm_bindgen(js_name = FormatOptions)]
399pub struct WasmFormatOptions {}550pub struct WasmFormatOptions {
551	indent: u8,
552}
400#[wasm_bindgen]553#[wasm_bindgen(js_class = FormatOptions)]
401impl WasmFormatOptions {554impl WasmFormatOptions {
402	#[wasm_bindgen(constructor)]555	#[wasm_bindgen(constructor)]
403	pub fn new() -> Self {556	pub fn new() -> Self {
404		Self {}557		Self { indent: 0 }
405	}558	}
406559
407	fn build(&self) -> FormatOptions {560	fn build(&self) -> FormatOptions {
408		FormatOptions { indent: 0 }561		FormatOptions {
562			indent: self.indent,
563		}
564	}
565}
566
567impl Default for WasmFormatOptions {
568	fn default() -> Self {
569		Self::new()
409	}570	}
410}571}
411572