@rusveltejs/compiler 0.1.0 → 0.1.1

package/compiler.js

@@ -4,6 +4,8 @@
 // built by Svelte's own code. Anything rusvelte doesn't handle falls back to the real compiler:
 // other Svelte versions, unsupported options, compile errors (so their messages and frames
 // are Svelte's own) and internal failures.
+import { createRequire } from 'node:module';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import * as native from './native.js';
 
 const debug = !!process.env.RUSVELTE_DEBUG;
@@ -132,17 +134,54 @@ class JsSourceMap {
 }
 
 /**
- * @param {{
- *   real: typeof import('svelte/compiler'),
- *   state: any,
- *   CompileDiagnostic: any,
- *   merge_with_preprocessor_map: Function,
- *   get_source_name: Function,
- *   MagicSourceMap: any
- * }} svelte
+ * The internals of the installed compiler that results are built with (its `state`,
+ * `CompileDiagnostic`, source map helpers and magic-string's `SourceMap`), loaded only once the
+ * versions match: another version may lay its files out differently
+ * @param {string} real_url the URL of the installed `svelte/compiler` entry
  */
-export function create(svelte) {
-	const { real, state, CompileDiagnostic, merge_with_preprocessor_map, get_source_name, MagicSourceMap } = svelte;
+async function load_internals(real_url) {
+	const at = (path) => new URL(path, real_url).href;
+	const [state, { CompileDiagnostic }, { merge_with_preprocessor_map, get_source_name }, { validate_component_options }] = await Promise.all([
+		import(at('./state.js')),
+		import(at('./utils/compile_diagnostic.js')),
+		import(at('./utils/mapped_code.js')),
+		import(at('./validate-options.js'))
+	]);
+	const magic_string = createRequire(fileURLToPath(real_url)).resolve('magic-string');
+	// `require` resolves its CommonJS build, where `SourceMap` hangs off the default export
+	const magic = await import(pathToFileURL(magic_string).href);
+	const MagicSourceMap = magic.SourceMap ?? magic.default?.SourceMap;
+	for (const [name, value] of Object.entries({ CompileDiagnostic, merge_with_preprocessor_map, get_source_name, MagicSourceMap, validate_component_options })) {
+		if (typeof value !== 'function') throw new Error(`${name} is not available`);
+	}
+	if (typeof state.reset !== 'function' || typeof state.set_source !== 'function' || typeof state.adjust !== 'function') {
+		throw new Error('svelte/compiler state has an unexpected shape');
+	}
+	return { state, CompileDiagnostic, merge_with_preprocessor_map, get_source_name, MagicSourceMap, validate_component_options };
+}
+
+/**
+ * `compile` and `compileModule` for the installed compiler: rusvelte's where it can run, the
+ * installed compiler's otherwise
+ * @param {typeof import('svelte/compiler')} real
+ * @param {string} real_url
+ */
+export async function create(real, real_url) {
+	const use_real = (reason) => {
+		console.warn(`[rusvelte] ${reason}; using svelte/compiler`);
+		return { compile: real.compile, compileModule: real.compileModule };
+	};
+	if (!native.native) return use_real(native.load_error);
+	if (real.VERSION !== native.svelteVersion && !process.env.RUSVELTE_ALLOW_VERSION_MISMATCH) {
+		return use_real(`svelte ${real.VERSION} is installed, but this rusvelte build reproduces svelte ${native.svelteVersion}`);
+	}
+	let internals;
+	try {
+		internals = await load_internals(real_url);
+	} catch (e) {
+		return use_real(`can't use the internals of the installed svelte/compiler (${e.message})`);
+	}
+	const { state, CompileDiagnostic, merge_with_preprocessor_map, get_source_name, MagicSourceMap, validate_component_options } = internals;
 
 	/** results rusvelte produced (not the real compiler) */
 	const native_results = new WeakSet();
@@ -151,18 +190,6 @@ export function create(svelte) {
 		name = 'CompileWarning';
 	}
 
-	if (!native.native) {
-		console.warn(`[rusvelte] ${native.load_error}; using svelte/compiler`);
-		return { compile: real.compile, compileModule: real.compileModule };
-	}
-
-	const version_ok = real.VERSION === native.svelteVersion || !!process.env.RUSVELTE_ALLOW_VERSION_MISMATCH;
-	if (!version_ok) {
-		console.warn(
-			`[rusvelte] svelte ${real.VERSION} is installed, but this rusvelte build reproduces svelte ${native.svelteVersion}; using svelte/compiler`
-		);
-	}
-
 	/**
 	 * Runs the native compiler; null means "use the real one"
 	 * @param {boolean} module
@@ -170,10 +197,17 @@ export function create(svelte) {
 	function run(source, options, module) {
 		// `validate-options.js` defaults `rootDir` to the working directory
 		if (options.rootDir === undefined && typeof process !== 'undefined') options = { ...options, rootDir: process.cwd() };
-		if (!version_ok) return fell_back(`svelte ${real.VERSION}`), null;
+		// a lone surrogate doesn't survive the trip into Rust (its strings are valid UTF-8)
+		if (!source.isWellFormed()) return fell_back('the source has a lone surrogate'), null;
 		const bad = unsupported_option(options, module ? MODULE_OPTIONS : COMPONENT_OPTIONS);
 		if (bad) return fell_back(`option ${bad}`), null;
-		const result = JSON.parse((module ? native.compileModule : native.compile)(source, native_options(options)));
+		let result;
+		try {
+			result = JSON.parse((module ? native.compileModule : native.compile)(source, native_options(options)));
+		} catch (e) {
+			// a broken or mismatched native build: the real compiler takes over
+			return fell_back(`native error: ${e.message}`), null;
+		}
 		if (result.unsupported) return fell_back(result.unsupported), null;
 		// let the real compiler throw, so the error is exactly Svelte's
 		if (result.error) return fell_back(`compile error ${result.error.code}`), null;
@@ -192,6 +226,7 @@ export function create(svelte) {
 		const filter = options.warningFilter ?? (() => true);
 		const out = [];
 		for (const w of result.warnings) {
+			if (w.code.startsWith('options_deprecated_')) continue;
 			const warning = new CompileWarning(w.code, w.message, w.position ?? undefined);
 			if (filter(warning)) out.push(warning);
 		}
@@ -234,6 +269,14 @@ export function create(svelte) {
 		const result = run(source, options, false);
 		if (!result) return real.compile(source, options);
 		set_state(source, options, result.runes);
+		// the option warnings (deprecated options) come from the installed compiler's own
+		// validation, so its once-per-instance memory and the warning filter apply as in compile
+		try {
+			validate_component_options(options, '');
+		} catch {
+			return real.compile(source, options);
+		}
+		const option_warnings = [...state.warnings];
 		// `validate_component_options` defaults the filename
 		options = { ...options, filename: options.filename ?? '(unknown)' };
 
@@ -256,7 +299,7 @@ export function create(svelte) {
 			merge_with_preprocessor_map(css, options, css.map.sources[0]);
 		}
 
-		const warnings = warnings_of(result, options);
+		const warnings = [...option_warnings, ...warnings_of(result, options)];
 		let ast;
 		const compiled = {
 			js,
@@ -265,7 +308,8 @@ export function create(svelte) {
 			metadata: { runes: result.runes },
 			// parsed on demand: vite-plugin-svelte doesn't read it
 			get ast() {
-				return (ast ??= real.parse(source, { modern: !!options.modernAst, filename: options.filename }));
+				// compile's AST (TypeScript removed etc.); warnings are dropped so the filter isn't called twice
+				return (ast ??= real.compile(source, { ...options, generate: false, warningFilter: () => false }).ast);
 			},
 			set ast(value) {
 				ast = value;
@@ -277,19 +321,28 @@ export function create(svelte) {
 
 	/** @type {typeof real.compileModule} */
 	function compileModule(source, options) {
+		const result = compile_module_native(source, options);
+		if (verify && native_results.has(result)) check('module', remove_bom(source), options, result);
+		return result;
+	}
+
+	/** @type {typeof real.compileModule} */
+	function compile_module_native(source, options) {
 		source = remove_bom(source);
 		const result = run(source, options, true);
 		if (!result) return real.compileModule(source, options);
 		set_state(source, options, true);
 		options = { ...options, filename: options.filename ?? '(unknown)' };
 		const js_source_name = get_source_name(options.filename, undefined, 'input.svelte.js');
-		return {
+		const compiled = {
 			js: { code: result.js.code, map: new JsSourceMap(result.js.mappings, js_source_name, source) },
 			css: null,
 			warnings: warnings_of(result, options),
 			metadata: { runes: true },
 			ast: null
 		};
+		native_results.add(compiled);
+		return compiled;
 	}
 
 	return { compile, compileModule };

package/native.js

@@ -32,7 +32,13 @@ export let native = null;
 export let load_error = null;
 try {
 	native = load();
+	// a build from another rusvelte version may not have this API
+	if (typeof native.compile !== 'function' || typeof native.compileModule !== 'function' || typeof native.svelteVersion !== 'function') {
+		throw new Error('it lacks compile, compileModule or svelteVersion');
+	}
+	native.version = native.svelteVersion();
 } catch (e) {
+	native = null;
 	const where = process.env.RUSVELTE_NATIVE ?? platform_package();
 	load_error = `no native module for ${process.platform}-${process.arch} (${where}): ${e.message.split('\n')[0]}`;
 }
@@ -40,4 +46,4 @@ try {
 export const compile = native?.compile;
 export const compileModule = native?.compileModule;
 /** The Svelte version whose output this build reproduces */
-export const svelteVersion = native?.svelteVersion() ?? null;
+export const svelteVersion = native?.version ?? null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rusveltejs/compiler",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "The Svelte 5 compiler ported to Rust, as a drop-in for svelte/compiler in Vite builds",
   "keywords": [
     "svelte",
@@ -21,7 +21,8 @@
   "exports": {
     ".": "./native.js",
     "./register": "./register.js",
-    "./vite": "./vite.js"
+    "./vite": "./vite.js",
+    "./package.json": "./package.json"
   },
   "files": [
     "native.js",
@@ -39,11 +40,11 @@
     "svelte": "^5.0.0"
   },
   "optionalDependencies": {
-    "@rusveltejs/darwin-arm64": "0.1.0",
-    "@rusveltejs/darwin-x64": "0.1.0",
-    "@rusveltejs/linux-x64-gnu": "0.1.0",
-    "@rusveltejs/linux-arm64-gnu": "0.1.0",
-    "@rusveltejs/linux-x64-musl": "0.1.0",
-    "@rusveltejs/win32-x64-msvc": "0.1.0"
+    "@rusveltejs/darwin-arm64": "0.1.1",
+    "@rusveltejs/darwin-x64": "0.1.1",
+    "@rusveltejs/linux-x64-gnu": "0.1.1",
+    "@rusveltejs/linux-arm64-gnu": "0.1.1",
+    "@rusveltejs/linux-x64-musl": "0.1.1",
+    "@rusveltejs/win32-x64-msvc": "0.1.1"
   }
 }

package/register.js

@@ -7,24 +7,20 @@
 // or call `register()` before importing them dynamically (vite.js does).
 import { registerHooks } from 'node:module';
 
-const PACKAGE = new URL('./', import.meta.url).href;
 const SHIM = new URL('./svelte-compiler.js', import.meta.url).href;
 const COMPILER = new URL('./compiler.js', import.meta.url).href;
 
-let registered = false;
+// one hook per process, even with several copies of this package installed: a second hook
+// would wrap the first one's module instead of the real compiler
+const REGISTERED = Symbol.for('@rusveltejs/compiler/register');
 
 export function register() {
-	if (registered) return;
-	registered = true;
+	if (globalThis[REGISTERED]) return;
+	globalThis[REGISTERED] = true;
 	registerHooks({
 		resolve(specifier, context, next) {
 			const parent = context.parentURL ?? '';
-			// the generated module's own imports resolve from the real compiler's location
-			if (parent.startsWith(SHIM + '?')) {
-				const real = new URL(parent).searchParams.get('real');
-				return next(specifier, { ...context, parentURL: real });
-			}
-			if (specifier === 'svelte/compiler' && !parent.startsWith(PACKAGE) && context.conditions?.includes('import')) {
+			if (specifier === 'svelte/compiler' && !parent.startsWith(SHIM) && context.conditions?.includes('import')) {
 				const real = next(specifier, context);
 				return { url: `${SHIM}?real=${encodeURIComponent(real.url)}`, format: 'module', shortCircuit: true };
 			}
@@ -32,17 +28,12 @@ export function register() {
 		},
 		load(url, context, next) {
 			if (!url.startsWith(SHIM + '?')) return next(url, context);
-			const real = new URL(url).searchParams.get('real');
-			const at = (path) => JSON.stringify(new URL(path, real).href);
+			const real = JSON.stringify(new URL(url).searchParams.get('real'));
 			const source = `
-export * from ${JSON.stringify(real)};
-import * as real from ${JSON.stringify(real)};
-import * as state from ${at('./state.js')};
-import { CompileDiagnostic } from ${at('./utils/compile_diagnostic.js')};
-import { merge_with_preprocessor_map, get_source_name } from ${at('./utils/mapped_code.js')};
-import { SourceMap as MagicSourceMap } from 'magic-string';
+export * from ${real};
+import * as real from ${real};
 import { create } from ${JSON.stringify(COMPILER)};
-export const { compile, compileModule } = create({ real, state, CompileDiagnostic, merge_with_preprocessor_map, get_source_name, MagicSourceMap });
+export const { compile, compileModule } = await create(real, ${real});
 `;
 			return { format: 'module', source, shortCircuit: true };
 		}