@rsvelte/compiler 0.10.20 → 0.11.1

package/README.md

@@ -101,6 +101,43 @@ The exported names and JSON-string return values below are specific to this
 WASM package. They are deliberately not presented as `svelte/compiler`
 equivalents.
 
+## Compare CLI
+
+Projects that already have Svelte installed can compare official and rsvelte
+output before switching compilers:
+
+```bash
+npx --package @rsvelte/compiler rsvelte compare 'src/**/*.svelte'
+```
+
+The command compiles each component with both compilers and strictly compares
+the generated `js.code` and `css.code`. Source maps are not included: their
+segment layouts can differ even when the shipped code is identical. It exits 0
+only when every file matches; a difference or compile failure exits 1.
+
+```text
+.................X.................
+
+35 files scanned, 34 match, 1 difference
+
+Differences:
+* src/components/menu.svelte
+  [client js.code] line 8, column 14
+    official: "..."
+    rsvelte:  "..."
+```
+
+Client production output is the default. Use `--generate server` or
+`--generate both` for SSR, `--dev` for development output, and
+`--options compiler-options.json` to merge JSON-compatible Svelte compiler
+options. The CLI sets `filename` and `generate` per comparison. Directories and
+quoted `*`, `**`, and `?` globs are supported; `node_modules`, `.git`, and
+`target` are skipped during directory walks.
+
+This is a generated-output check, not an application test: preprocessors, Vite
+plugin behavior, runtime-version differences, source maps, and browser/server
+behavior remain outside its comparison key.
+
 ## Why it is fast
 
 - Written in Rust with a memory-efficient AST (`u32` spans, compact strings) and
@@ -121,6 +158,7 @@ MIT
 ---
 
 > **Maintainers:** `@rsvelte/compiler` is published from the wasm-pack output in
-> the repo-root `pkg/` directory, not from this directory. See
+> the repo-root `pkg/` directory. `finalize-pkg.mjs` overlays this README and the
+> hand-written `bin/` + `lib/` files from this directory. See
 > [`PUBLISHING.md`](./PUBLISHING.md) for how the version anchor and README
 > overlay work.

package/bin/rsvelte.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import {
+	HELP,
+	UsageError,
+	buildReport,
+	collectSvelteFiles,
+	compareFiles,
+	formatHumanReport,
+	parseArgs,
+	readCompilerOptions,
+} from '../lib/compare.mjs';
+
+async function main() {
+	if (process.argv[2] !== 'compare') {
+		if (process.argv[2] === '-h' || process.argv[2] === '--help') {
+			process.stdout.write(`Usage: rsvelte <command>\n\nCommands:\n  compare   compare official and rsvelte compiler output\n`);
+			return 0;
+		}
+		throw new UsageError(process.argv[2] ? `Unknown command: ${process.argv[2]}` : 'Missing command');
+	}
+
+	const args = parseArgs(process.argv.slice(3));
+	if (args.help) {
+		process.stdout.write(`${HELP}\n`);
+		return 0;
+	}
+	const files = await collectSvelteFiles(args.paths, process.cwd());
+	if (files.length === 0) throw new UsageError('No .svelte files matched');
+	const compilerOptions = await readCompilerOptions(args.optionsPath, process.cwd());
+	if (args.dev) compilerOptions.dev = true;
+	const targets = args.generate === 'both' ? ['client', 'server'] : [args.generate];
+	const { officialCompile, rsvelteCompile } = await loadCompilers();
+	const results = await compareFiles({
+		files,
+		cwd: process.cwd(),
+		targets,
+		options: compilerOptions,
+		officialCompile,
+		rsvelteCompile,
+	});
+	const report = buildReport(results);
+	process.stdout.write(args.json ? `${JSON.stringify(report, null, 2)}\n` : formatHumanReport(report));
+	return report.different === 0 ? 0 : 1;
+}
+
+async function loadCompilers() {
+	let official;
+	try {
+		const projectRequire = createRequire(resolve(process.cwd(), 'package.json'));
+		official = await import(pathToFileURL(projectRequire.resolve('svelte/compiler')).href);
+	} catch {
+		throw new UsageError('Cannot load svelte/compiler; install Svelte in the project being compared');
+	}
+
+	const rsvelte = await import('@rsvelte/compiler');
+	const require = createRequire(import.meta.url);
+	const wasmPath = require.resolve('@rsvelte/compiler/wasm');
+	rsvelte.initSync({ module: readFileSync(wasmPath) });
+	const officialCompile = official.compile ?? official.default?.compile;
+	if (typeof officialCompile !== 'function') {
+		throw new UsageError('Loaded svelte/compiler does not export compile()');
+	}
+	return { officialCompile, rsvelteCompile: rsvelte.compile };
+}
+
+try {
+	process.exitCode = await main();
+} catch (error) {
+	if (error instanceof UsageError) {
+		process.stderr.write(`rsvelte: ${error.message}\n\n${HELP}\n`);
+		process.exitCode = 2;
+	} else {
+		process.stderr.write(`rsvelte: ${error?.stack ?? error}\n`);
+		process.exitCode = 2;
+	}
+}

package/lib/compare.mjs

@@ -0,0 +1,272 @@
+import { lstat, readFile, readdir } from 'node:fs/promises';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+
+const SKIPPED_DIRECTORIES = new Set(['.git', 'node_modules', 'target']);
+const MAGIC = /[*?]/;
+const REGEXP_SPECIAL = new Set('\\^$+?.()|{}[]');
+
+export const HELP = `Usage: rsvelte compare [OPTIONS] [PATH...]
+
+Compare official Svelte and rsvelte generated JavaScript/CSS byte-for-byte.
+
+Arguments:
+  PATH                    .svelte file, directory, or glob (default: .)
+
+Options:
+  --generate <target>     client, server, or both (default: client)
+  --dev                   compile both sides with dev: true
+  --options <file>        merge JSON compiler options (filename/generate are set per file)
+  --json                  print a machine-readable report
+  -h, --help              show this help
+
+Exit codes: 0 all match, 1 differences or compile failures, 2 usage/setup error.`;
+
+export function parseArgs(argv) {
+	const parsed = {
+		dev: false,
+		generate: 'client',
+		help: false,
+		json: false,
+		optionsPath: null,
+		paths: [],
+	};
+
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === '--') {
+			parsed.paths.push(...argv.slice(index + 1));
+			break;
+		}
+		if (arg === '-h' || arg === '--help') parsed.help = true;
+		else if (arg === '--json') parsed.json = true;
+		else if (arg === '--dev') parsed.dev = true;
+		else if (arg === '--generate') parsed.generate = takeValue(argv, ++index, arg);
+		else if (arg.startsWith('--generate=')) parsed.generate = arg.slice('--generate='.length);
+		else if (arg === '--options') parsed.optionsPath = takeValue(argv, ++index, arg);
+		else if (arg.startsWith('--options=')) parsed.optionsPath = arg.slice('--options='.length);
+		else if (arg.startsWith('-')) throw new UsageError(`Unknown option: ${arg}`);
+		else parsed.paths.push(arg);
+	}
+
+	if (!['client', 'server', 'both'].includes(parsed.generate)) {
+		throw new UsageError(`Invalid --generate value: ${parsed.generate}`);
+	}
+	if (parsed.paths.length === 0) parsed.paths.push('.');
+	return parsed;
+}
+
+function takeValue(argv, index, option) {
+	const value = argv[index];
+	if (!value || value.startsWith('-')) throw new UsageError(`${option} requires a value`);
+	return value;
+}
+
+export class UsageError extends Error {}
+
+export async function collectSvelteFiles(inputs, cwd = process.cwd()) {
+	const found = new Set();
+	for (const input of inputs) {
+		if (MAGIC.test(input)) {
+			await collectGlob(input, cwd, found);
+			continue;
+		}
+
+		const path = resolve(cwd, input);
+		let stat;
+		try {
+			stat = await lstat(path);
+		} catch (error) {
+			if (error?.code === 'ENOENT') throw new UsageError(`Path does not exist: ${input}`);
+			throw error;
+		}
+		if (stat.isDirectory()) await walk(path, found);
+		else if (stat.isFile() && path.endsWith('.svelte')) found.add(path);
+		else throw new UsageError(`Not a .svelte file or directory: ${input}`);
+	}
+	return [...found].sort((a, b) => a.localeCompare(b));
+}
+
+async function collectGlob(pattern, cwd, found) {
+	const absolutePattern = slash(isAbsolute(pattern) ? pattern : resolve(cwd, pattern));
+	const firstMagic = absolutePattern.search(MAGIC);
+	const slashBeforeMagic = absolutePattern.lastIndexOf('/', firstMagic);
+	const root = slashBeforeMagic <= 0 ? '/' : absolutePattern.slice(0, slashBeforeMagic);
+	const matcher = globRegExp(absolutePattern);
+	let stat;
+	try {
+		stat = await lstat(root);
+	} catch (error) {
+		if (error?.code === 'ENOENT') return;
+		throw error;
+	}
+	if (!stat.isDirectory()) return;
+	await walk(root, found, (path) => matcher.test(slash(path)));
+}
+
+async function walk(directory, found, accept = (path) => path.endsWith('.svelte')) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	for (const entry of entries) {
+		const path = resolve(directory, entry.name);
+		if (entry.isDirectory()) {
+			if (!SKIPPED_DIRECTORIES.has(entry.name)) await walk(path, found, accept);
+		} else if (entry.isFile() && path.endsWith('.svelte') && accept(path)) {
+			found.add(path);
+		}
+	}
+}
+
+function globRegExp(pattern) {
+	let expression = '^';
+	for (let index = 0; index < pattern.length; index += 1) {
+		const char = pattern[index];
+		if (char === '*') {
+			if (pattern[index + 1] === '*') {
+				index += 1;
+				if (pattern[index + 1] === '/') {
+					index += 1;
+					expression += '(?:.*/)?';
+				} else expression += '.*';
+			} else expression += '[^/]*';
+		} else if (char === '?') expression += '[^/]';
+		else expression += REGEXP_SPECIAL.has(char) ? `\\${char}` : char;
+	}
+	return new RegExp(`${expression}$`);
+}
+
+const slash = (path) => path.split(sep).join('/');
+
+export async function readCompilerOptions(path, cwd = process.cwd()) {
+	if (!path) return {};
+	let value;
+	try {
+		value = JSON.parse(await readFile(resolve(cwd, path), 'utf8'));
+	} catch (error) {
+		throw new UsageError(`Cannot read compiler options from ${path}: ${error.message}`);
+	}
+	if (!value || Array.isArray(value) || typeof value !== 'object') {
+		throw new UsageError(`Compiler options in ${path} must be a JSON object`);
+	}
+	delete value.filename;
+	delete value.generate;
+	return value;
+}
+
+export async function compareFiles({ files, cwd, targets, options, officialCompile, rsvelteCompile }) {
+	const results = [];
+	for (const file of files) {
+		const source = await readFile(file, 'utf8');
+		const displayPath = slash(relative(cwd, file)) || slash(file);
+		const comparisons = targets.map((target) =>
+			compareSource({
+				source,
+				filename: displayPath,
+				target,
+				options,
+				officialCompile,
+				rsvelteCompile,
+			}),
+		);
+		results.push({ file: displayPath, match: comparisons.every((item) => item.match), comparisons });
+	}
+	return results;
+}
+
+export function compareSource({ source, filename, target, options, officialCompile, rsvelteCompile }) {
+	const compileOptions = { ...options, filename, generate: target };
+	let official;
+	let actual;
+	try {
+		official = normalizeResult(officialCompile(source, compileOptions));
+	} catch (error) {
+		return compileFailure(target, 'official', error);
+	}
+	try {
+		actual = normalizeResult(rsvelteCompile(source, compileOptions));
+	} catch (error) {
+		return compileFailure(target, 'rsvelte', error);
+	}
+
+	const differences = [];
+	compareArtifact(differences, 'js.code', official?.js?.code, actual?.js?.code);
+	compareArtifact(differences, 'css.code', official?.css?.code ?? null, actual?.css?.code ?? null);
+	return { target, match: differences.length === 0, differences };
+}
+
+function normalizeResult(result) {
+	return typeof result === 'string' ? JSON.parse(result) : result;
+}
+
+function compileFailure(target, side, error) {
+	return {
+		target,
+		match: false,
+		differences: [],
+		error: { side, code: error?.code ?? null, message: error?.message ?? String(error) },
+	};
+}
+
+function compareArtifact(differences, artifact, official, actual) {
+	if (official === actual) return;
+	const expected = official == null ? String(official) : String(official);
+	const received = actual == null ? String(actual) : String(actual);
+	const offset = firstDifference(expected, received);
+	const before = expected.slice(0, offset);
+	const line = before.split('\n').length;
+	const lastNewline = before.lastIndexOf('\n');
+	const column = offset - lastNewline;
+	differences.push({
+		artifact,
+		line,
+		column,
+		official: lineAt(expected, line),
+		rsvelte: lineAt(received, line),
+	});
+}
+
+function firstDifference(left, right) {
+	const length = Math.min(left.length, right.length);
+	let index = 0;
+	while (index < length && left[index] === right[index]) index += 1;
+	return index;
+}
+
+function lineAt(value, line) {
+	const text = value.split('\n')[line - 1] ?? '';
+	return text.length > 240 ? `${text.slice(0, 237)}...` : text;
+}
+
+export function buildReport(results) {
+	const differences = results.filter((result) => !result.match);
+	return {
+		scanned: results.length,
+		matched: results.length - differences.length,
+		different: differences.length,
+		files: results,
+	};
+}
+
+export function formatHumanReport(report) {
+	const noun = report.scanned === 1 ? 'file' : 'files';
+	const differenceNoun = report.different === 1 ? 'difference' : 'differences';
+	let output = `${report.files.map((file) => (file.match ? '.' : 'X')).join('')}\n\n`;
+	output += `${report.scanned} ${noun} scanned, ${report.matched} match, ${report.different} ${differenceNoun}\n`;
+	if (report.different === 0) return output;
+	output += '\nDifferences:\n';
+	for (const file of report.files.filter((item) => !item.match)) {
+		output += `* ${file.file}\n`;
+		for (const comparison of file.comparisons.filter((item) => !item.match)) {
+			if (comparison.error) {
+				output += `  [${comparison.target}] ${comparison.error.side} failed`;
+				if (comparison.error.code) output += ` (${comparison.error.code})`;
+				output += `: ${comparison.error.message}\n`;
+				continue;
+			}
+			for (const difference of comparison.differences) {
+				output += `  [${comparison.target} ${difference.artifact}] line ${difference.line}, column ${difference.column}\n`;
+				output += `    official: ${JSON.stringify(difference.official)}\n`;
+				output += `    rsvelte:  ${JSON.stringify(difference.rsvelte)}\n`;
+			}
+		}
+	}
+	return output;
+}

package/package.json

@@ -2,12 +2,14 @@
   "name": "@rsvelte/compiler",
   "type": "module",
   "description": "A high-performance Rust implementation of the Svelte compiler",
-  "version": "0.10.20",
+  "version": "0.11.1",
   "license": "MIT",
   "files": [
     "rsvelte_lint_bg.wasm",
     "rsvelte_lint.js",
-    "rsvelte_lint.d.ts"
+    "rsvelte_lint.d.ts",
+    "bin/rsvelte.mjs",
+    "lib/compare.mjs"
   ],
   "main": "rsvelte_lint.js",
   "types": "rsvelte_lint.d.ts",
@@ -28,6 +30,17 @@
     "rust",
     "wasm"
   ],
+  "bin": {
+    "rsvelte": "bin/rsvelte.mjs"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "svelte": {
+      "optional": true
+    }
+  },
   "exports": {
     ".": {
       "types": "./rsvelte_lint.d.ts",

package/rsvelte_lint.d.ts

@@ -55,7 +55,7 @@ export function init(): void;
 
 /**
  * Lint `source`, returning a JSON array of diagnostics:
- * `[{ "severity", "line", "column", "endLine", "endColumn", "code", "message" }]`.
+ * `[{ "severity", "line", "column", "endLine"?, "endColumn"?, "code", "message" }]`.
  * Lines are 1-indexed, columns 0-indexed (UTF-16), matching `rsvelte check`.
  */
 export function lint(source: string, filename: string): string;

package/rsvelte_lint.js

@@ -202,7 +202,7 @@ export function init() {
 
 /**
  * Lint `source`, returning a JSON array of diagnostics:
- * `[{ "severity", "line", "column", "endLine", "endColumn", "code", "message" }]`.
+ * `[{ "severity", "line", "column", "endLine"?, "endColumn"?, "code", "message" }]`.
  * Lines are 1-indexed, columns 0-indexed (UTF-16), matching `rsvelte check`.
  * @param {string} source
  * @param {string} filename
@@ -358,10 +358,21 @@ function __wbg_get_imports() {
             const ret = arg0 === null;
             return ret;
         },
+        __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
         __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
         },
+        __wbg___wbindgen_number_get_394265ed1e1b84ee: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
         __wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -395,10 +406,30 @@ function __wbg_get_imports() {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
+        __wbg_get_unchecked_6e0ad6d2a41b06f6: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_isArray_0677c962b281d01a: function(arg0) {
+            const ret = Array.isArray(arg0);
+            return ret;
+        },
+        __wbg_keys_58421f8f96795607: function(arg0) {
+            const ret = Object.keys(arg0);
+            return ret;
+        },
+        __wbg_length_370319915dc99107: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_new_227d7c05414eb861: function() {
             const ret = new Error();
             return ret;
         },
+        __wbg_new_b667d279fd5aa943: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
         __wbg_new_da52cf8fe3429cb2: function() {
             const ret = new Object();
             return ret;
@@ -411,6 +442,9 @@ function __wbg_get_imports() {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_set_name_3bbc583faefa4193: function(arg0, arg1, arg2) {
+            arg0.name = getStringFromWasm0(arg1, arg2);
+        },
         __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
             const ret = arg1.stack;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -418,8 +452,12 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg_stringify_b54333f60f1e4dad: function() { return handleError(function (arg0) {
+            const ret = JSON.stringify(arg0);
+            return ret;
+        }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [String], shim_idx: 4, ret: String, inner_ret: Some(String) }, mutable: false }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [String], shim_idx: 6, ret: String, inner_ret: Some(String) }, mutable: false }) -> Externref`.
             const ret = makeClosure(arg0, arg1, wasm_bindgen_de7100a3341595c3___convert__closures_____invoke___alloc_a941a2cfab7efbc4___string__String__alloc_a941a2cfab7efbc4___string__String__true_);
             return ret;
         },