roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/rewriter/wasm/src/lib.rs

@@ -0,0 +1,144 @@
+pub mod error;
+
+use error::{Result, RewriterError};
+use js::cfg::{Config, Flags};
+use js_sys::{Object, Reflect};
+use jsr::{JsRewriter, JsRewriterOutput, create_js, create_js_output};
+use oxc::allocator::Allocator;
+use wasm_bindgen::prelude::*;
+
+use crate::jsr::{WasmUrlRewriter, get_url_rewriter, scramtag};
+
+mod jsr;
+
+#[wasm_bindgen]
+extern "C" {
+	#[wasm_bindgen(js_namespace = console, js_name = error)]
+	fn console_error(s: &str);
+	#[wasm_bindgen(js_namespace = console, js_name = error)]
+	fn console_error2(s: &JsValue);
+}
+
+fn get_obj(obj: &JsValue, k: &'static str) -> Result<JsValue> {
+	Ok(Reflect::get(obj, &k.into())?)
+}
+
+fn get_str(obj: &JsValue, k: &'static str) -> Result<String> {
+	Reflect::get(obj, &k.into())?
+		.as_string()
+		.ok_or_else(|| RewriterError::not_str(k))
+}
+fn get_bool(obj: &JsValue, k: &'static str) -> Result<bool> {
+	Reflect::get(obj, &k.into())?
+		.as_bool()
+		.ok_or_else(|| RewriterError::not_bool(k))
+}
+
+fn set_obj(obj: &Object, k: &str, v: &JsValue) -> Result<()> {
+	if Reflect::set(&obj.into(), &k.into(), v)? {
+		Ok(())
+	} else {
+		Err(RewriterError::ReflectSetFail(k.to_string()))
+	}
+}
+
+fn get_js_config(config: &Object) -> Result<Config> {
+	Ok(Config {
+		prefix: get_str(config, "prefix")?,
+
+		wrapfn: get_str(config, "wrapfn")?,
+		wrappropertybase: get_str(config, "wrappropertybase")?,
+		wrappropertyfn: get_str(config, "wrappropertyfn")?,
+		cleanrestfn: get_str(config, "cleanrestfn")?,
+		importfn: get_str(config, "importfn")?,
+		rewritefn: get_str(config, "rewritefn")?,
+		wrappostmessagefn: get_str(config, "wrappostmessagefn")?,
+		metafn: get_str(config, "metafn")?,
+		pushsourcemapfn: get_str(config, "pushsourcemapfn")?,
+
+		trysetfn: get_str(config, "trysetfn")?,
+		templocid: get_str(config, "templocid")?,
+		tempunusedid: get_str(config, "tempunusedid")?,
+	})
+}
+
+fn get_js_flags(obj: &Object, base: String, is_module: bool) -> Result<Flags> {
+	Ok(Flags {
+		base,
+		sourcetag: scramtag(),
+		is_module,
+
+		do_sourcemaps: get_bool(obj, "sourcemaps")?,
+		capture_errors: get_bool(obj, "captureErrors")?,
+		scramitize: get_bool(obj, "scramitize")?,
+		disable_computed_wrap: get_bool(obj, "disableComputedWrap")?,
+		destructure_rewrites: get_bool(obj, "destructureRewrites")?,
+
+	})
+}
+
+#[wasm_bindgen]
+pub struct Rewriter {
+	alloc: Allocator,
+
+	js: JsRewriter,
+}
+
+#[wasm_bindgen]
+impl Rewriter {
+	#[wasm_bindgen(constructor)]
+	pub fn new() -> Result<Self> {
+		Ok(Self {
+			alloc: Allocator::default(),
+
+			js: create_js()?
+		})
+	}
+
+	#[wasm_bindgen]
+	pub fn rewrite_js(
+		&mut self,
+		jsconfig: &Object,
+		jsflags: &Object,
+		encode_url: Object,
+		js: String,
+		base: String,
+		url: String,
+		module: bool,
+	) -> Result<JsRewriterOutput> {
+		let config = get_js_config(jsconfig)?;
+		let flags = get_js_flags(jsflags, base, module)?;
+		let rewriter = get_url_rewriter(encode_url)?;
+
+		let out = match self.js.rewrite(&self.alloc, &js, config, flags, &rewriter) {
+			Ok(x) => x,
+			Err(x) => {
+				self.alloc.reset();
+				Err(x)?
+			}
+		};
+
+		let ret = create_js_output(out, url, js);
+
+		self.alloc.reset();
+		ret
+	}
+
+	#[wasm_bindgen]
+	pub fn rewrite_js_bytes(
+		&mut self,
+		jsconfig: &Object,
+		jsflags: &Object,
+		encode_url: Object,
+		js: Vec<u8>,
+		base: String,
+		url: String,
+		module: bool,
+	) -> Result<JsRewriterOutput> {
+		// SAFETY: we know the js is a valid utf-8 string
+		let js = unsafe { std::string::String::from_utf8_unchecked(js) };
+
+		self.rewrite_js(jsconfig, jsflags, encode_url, js, base, url, module)
+	}
+
+}

package/source/packages/scramjet/packages/core/src/Tap.ts

@@ -0,0 +1,166 @@
+import { Promise_all } from "@/shared/snapshot";
+
+type Description = {
+	context?: object;
+	props?: object;
+};
+
+type Callback<T extends Description> = (
+	context: T["context"],
+	props: T["props"]
+) => void | Promise<void>;
+
+export type TapOrder = {
+	/** Run before these plugins. */
+	before?: readonly string[];
+	/** Run after these plugins. */
+	after?: readonly string[];
+};
+
+type CallbackInfo<T extends Description> = {
+	callback: Callback<T>;
+	plugin: Plugin;
+	order: TapOrder;
+};
+
+type InternalHookDescription = {
+	tap: TapInternal;
+	key: string;
+};
+
+type TapInternal = {
+	callbacks: Record<string, CallbackInfo<Description>[]>;
+};
+
+export type TapInstance<T extends Record<string, Description>> = {
+	[K in keyof T]: T[K] & InternalHookDescription;
+};
+
+function mergeTapOrder(plugin: Plugin, order?: TapOrder): TapOrder {
+	return {
+		before: order?.before ?? plugin.tapOrder.before,
+		after: order?.after ?? plugin.tapOrder.after,
+	};
+}
+
+function sortCallbacks<T extends Description>(
+	callbacks: CallbackInfo<T>[]
+): CallbackInfo<T>[] {
+	const afters: Record<string, string[]> = {};
+	for (const callback of callbacks) {
+		if (callback.order.before) {
+			for (const before of callback.order.before) {
+				afters[before] ??= [];
+				if (!afters[before].includes(callback.plugin.name)) {
+					afters[before].push(callback.plugin.name);
+				}
+			}
+		}
+		if (callback.order.after) {
+			for (const after of callback.order.after) {
+				afters[callback.plugin.name] ??= [];
+				if (!afters[callback.plugin.name].includes(after)) {
+					afters[callback.plugin.name].push(after);
+				}
+			}
+		}
+	}
+
+	const sorted: CallbackInfo<T>[] = [];
+	function recurse(callback: CallbackInfo<T>, visited: string[]) {
+		if (afters[callback.plugin.name]) {
+			for (const after of afters[callback.plugin.name]) {
+				if (visited.includes(after)) {
+					throw `Circular dependency detected: ${callback.plugin.name} -> ${after}. Using append order.`;
+				}
+				const afterCallback = callbacks.find((c) => c.plugin.name === after);
+				if (afterCallback) {
+					recurse(afterCallback, [...visited, callback.plugin.name]);
+				}
+			}
+		}
+		if (!sorted.includes(callback)) {
+			sorted.push(callback);
+		}
+	}
+
+	try {
+		for (const callback of callbacks) {
+			recurse(callback, []);
+		}
+		return sorted;
+	} catch (err) {
+		dbg.error("an error occurred:", err);
+		return sorted;
+	}
+}
+
+export class Plugin {
+	constructor(
+		public name: string,
+		public readonly tapOrder: TapOrder = {}
+	) {}
+
+	tap<T extends Description>(
+		hook: T,
+		callback: Callback<T>,
+		order?: TapOrder
+	): void {
+		Tap.tap(hook, callback, this, mergeTapOrder(this, order));
+	}
+}
+
+export class Tap {
+	static dispatch<T extends Description>(
+		hook: T,
+		context: T["context"],
+		props: T["props"]
+	): Promise<void[]> | null {
+		const internal = hook as unknown as InternalHookDescription;
+		let callbacks = internal.tap.callbacks[internal.key];
+		if (!callbacks || callbacks.length === 0) return null;
+
+		callbacks = sortCallbacks([...callbacks] as CallbackInfo<T>[]);
+
+		const results = callbacks.map((cb) => cb.callback(context, props));
+		return Promise_all(results);
+	}
+
+	static tap<T extends Description>(
+		hook: T,
+		callback: Callback<T>,
+		plugin: Plugin = new Plugin("anonymous"),
+		order: TapOrder = {}
+	) {
+		const internal = hook as unknown as InternalHookDescription;
+		const callbacks = internal.tap.callbacks;
+		if (!callbacks[internal.key]) callbacks[internal.key] = [];
+		callbacks[internal.key]!.push({
+			callback,
+			plugin,
+			order,
+		});
+	}
+
+	static create<T extends Record<string, Description>>(): TapInstance<T> {
+		const internal: TapInternal = {
+			callbacks: {},
+		};
+		const hooks: Record<string, InternalHookDescription> = {};
+
+		return new Proxy(internal as unknown as TapInstance<T>, {
+			get(target, key: string) {
+				if (key === "callbacks") return internal.callbacks;
+				if (!hooks[key]) {
+					hooks[key] = { tap: internal, key };
+				}
+				return hooks[key];
+			},
+		});
+	}
+
+	static getTappers<T extends Description>(hook: T): Plugin[] {
+		const internal = hook as unknown as InternalHookDescription;
+		return internal.tap.callbacks[internal.key].map((c) => c.plugin);
+	}
+}