@rsvelte/vite-plugin-svelte-native 0.2.8 → 0.3.0

package/index.cjs

@@ -51,6 +51,72 @@ try {
 	);
 }
 
+// The NAPI boundary can't accept function values, so resolve them here: evaluate
+// `customElement`/`css`/`runes` and hand back `warningFilter` for the caller to
+// post-filter warnings (which never affect codegen).
+function prepareCompileOptions(options) {
+	if (options == null) return { options, warningFilter: undefined };
+	const { customElement, css, runes, warningFilter } = options;
+	const hasParametric =
+		typeof customElement === 'function' ||
+		typeof css === 'function' ||
+		typeof runes === 'function';
+	const hasWarningFilter = typeof warningFilter === 'function';
+	if (!hasParametric && !hasWarningFilter) {
+		return { options, warningFilter: undefined };
+	}
+	// Svelte defaults `filename` to '(unknown)' before invoking these functions.
+	const meta = { filename: options.filename ?? '(unknown)' };
+	const resolved = { ...options };
+	if (typeof customElement === 'function') resolved.customElement = customElement(meta);
+	if (typeof css === 'function') resolved.css = css(meta);
+	if (typeof runes === 'function') resolved.runes = runes(meta);
+	if (hasWarningFilter) delete resolved.warningFilter;
+	return { options: resolved, warningFilter: hasWarningFilter ? warningFilter : undefined };
+}
+
+// Port of Svelte's `hash()` (submodules/svelte/packages/svelte/src/utils.js),
+// handed to a user `cssHash` callback so custom scope classes match upstream's digest.
+const regexReturnCharacters = /\r/g;
+function hash(str) {
+	str = str.replace(regexReturnCharacters, '');
+	let h = 5381;
+	let i = str.length;
+	while (i--) h = ((h << 5) - h) ^ str.charCodeAt(i);
+	return (h >>> 0).toString(36);
+}
+
+// Adapt a user `cssHash` to the bridge shape. It must never reject: a rejected
+// Promise crossing the NAPI boundary can crash V8 during threadsafe-function
+// teardown — so a throw becomes `{ error }` (Rust turns it into a compile failure)
+// and a non-string return becomes `{ value: null }` (Rust falls back to the default hash).
+function makeCssHashCallback(userCssHash) {
+	return async (name, filename, css) => {
+		try {
+			const result = await userCssHash({ hash, css, name, filename });
+			return { value: typeof result === 'string' ? result : null };
+		} catch (err) {
+			return { error: err instanceof Error ? err.message : String(err) };
+		}
+	};
+}
+
+function applyWarningFilter(result, warningFilter) {
+	if (!warningFilter || result == null) return result;
+	const warnings = result.warnings;
+	if (Array.isArray(warnings) && warnings.length) {
+		// `warnings` is a lazy getter on the envelope-decoded result; redefine it
+		// as a plain data property so the filtered array replaces the accessor.
+		Object.defineProperty(result, 'warnings', {
+			value: warnings.filter((warning) => warningFilter(warning)),
+			writable: true,
+			enumerable: true,
+			configurable: true,
+		});
+	}
+	return result;
+}
+
 // `compile` / `compileModule` are wrapped to route through the
 // raw-transfer envelope (`compileEnvelope`): the Rust side hands us
 // one `Buffer`, the JS side lazy-decodes only the fields the caller
@@ -62,11 +128,23 @@ try {
 // directly. The legacy JSON path is preserved as `compileLegacy` for
 // parity testing and as an escape hatch.
 function compile(source, options) {
-	return decodeEnvelope(binding.compileEnvelope(source, options));
+	if (typeof options?.cssHash === 'function') {
+		// A dynamic cssHash needs the Rust→JS callback bridge, which would deadlock
+		// the JS event loop on the sync path; direct the caller to `compileAsync`.
+		throw new Error(
+			'[@rsvelte/vite-plugin-svelte-native] A dynamic `cssHash` function requires the async compile path; call `compileAsync(source, options)` instead. (A constant hash can use `cssHashOverride`.)',
+		);
+	}
+	const { options: resolved, warningFilter } = prepareCompileOptions(options);
+	return applyWarningFilter(decodeEnvelope(binding.compileEnvelope(source, resolved)), warningFilter);
 }
 
 function compileModule(source, options) {
-	return decodeEnvelope(binding.compileModuleEnvelope(source, options));
+	const { options: resolved, warningFilter } = prepareCompileOptions(options);
+	return applyWarningFilter(
+		decodeEnvelope(binding.compileModuleEnvelope(source, resolved)),
+		warningFilter,
+	);
 }
 
 // `compileBatch([{source, options}, …])` compiles N files in
@@ -74,8 +152,29 @@ function compileModule(source, options) {
 // exactly once. The returned array is the same length as the input;
 // each slot is either a `CompileResult` or an `Error` (parse
 // failures don't abort the whole batch).
+// Batch compilation runs on rayon workers with no JS event loop to service the
+// callback, so a dynamic cssHash can't be bridged here — reject it rather than drop it.
+function assertNoDynamicCssHash(options) {
+	if (typeof options?.cssHash === 'function') {
+		throw new Error(
+			'[@rsvelte/vite-plugin-svelte-native] A dynamic `cssHash` function is not supported in compileBatch; compile such files individually with `compileAsync`.',
+		);
+	}
+}
+
 function compileBatch(inputs) {
-	return decodeBatch(binding.compileBatch(inputs));
+	const filters = [];
+	const prepared = inputs.map((input, i) => {
+		assertNoDynamicCssHash(input.options);
+		const { options, warningFilter } = prepareCompileOptions(input.options);
+		if (warningFilter) filters[i] = warningFilter;
+		return options === input.options ? input : { source: input.source, options };
+	});
+	const results = decodeBatch(binding.compileBatch(prepared));
+	if (filters.length) {
+		results.forEach((result, i) => applyWarningFilter(result, filters[i]));
+	}
+	return results;
 }
 
 // `compileAsync` / `compileBatchAsync` release the JS event loop
@@ -84,11 +183,35 @@ function compileBatch(inputs) {
 // (Vite middleware, SSR pre-render) — the await yields control
 // instead of blocking V8.
 async function compileAsync(source, options) {
-	return decodeEnvelope(await binding.compileEnvelopeAsync(source, options));
+	const { options: resolved, warningFilter } = prepareCompileOptions(options);
+	if (typeof options?.cssHash === 'function') {
+		// The bridge entry returns a plain (JSON) CompileResult, not an envelope.
+		const result = await binding.compileWithCssHash(
+			source,
+			resolved,
+			makeCssHashCallback(options.cssHash),
+		);
+		return applyWarningFilter(result, warningFilter);
+	}
+	return applyWarningFilter(
+		decodeEnvelope(await binding.compileEnvelopeAsync(source, resolved)),
+		warningFilter,
+	);
 }
 
 async function compileBatchAsync(inputs) {
-	return decodeBatch(await binding.compileBatchAsync(inputs));
+	const filters = [];
+	const prepared = inputs.map((input, i) => {
+		assertNoDynamicCssHash(input.options);
+		const { options, warningFilter } = prepareCompileOptions(input.options);
+		if (warningFilter) filters[i] = warningFilter;
+		return options === input.options ? input : { source: input.source, options };
+	});
+	const results = decodeBatch(await binding.compileBatchAsync(prepared));
+	if (filters.length) {
+		results.forEach((result, i) => applyWarningFilter(result, filters[i]));
+	}
+	return results;
 }
 
 // Re-export every NAPI function as its own named binding so node's

package/index.d.ts

@@ -22,29 +22,56 @@ export interface CompileOptions {
 	rootDir?: string;
 	/** Component identifier hint. */
 	name?: string;
-	/** Compile as a custom element. */
-	customElement?: boolean;
+	/**
+	 * Compile as a custom element. A function form `({ filename }) => boolean`
+	 * is evaluated once at the binding boundary.
+	 */
+	customElement?: boolean | ((meta: { filename: string }) => boolean);
 	/** Generate `accessors`. */
 	accessors?: boolean;
 	/** HTML namespace. */
 	namespace?: 'html' | 'svg' | 'mathml';
 	/** Hint that bindings are immutable. */
 	immutable?: boolean;
-	/** Output CSS injected into the bundle or as an external asset. */
-	css?: 'injected' | 'external';
-	/** Custom hash function for CSS scoping — currently honored as a string-mapper. */
+	/**
+	 * Output CSS injected into the bundle or as an external asset. A function
+	 * form `({ filename }) => 'injected' | 'external'` is evaluated once at the
+	 * binding boundary.
+	 */
+	css?:
+		| 'injected'
+		| 'external'
+		| ((meta: { filename: string }) => 'injected' | 'external');
+	/**
+	 * Custom hash function for CSS scoping. Called once per component with the
+	 * component's CSS; the returned string becomes the scope class. Because it
+	 * depends on the CSS, it is bridged into the compiler through a threadsafe
+	 * callback and is only supported on the async path — use `compileAsync`.
+	 * The synchronous `compile` throws if given a `cssHash` function; pass a
+	 * pre-computed constant via `cssHashOverride` instead.
+	 */
 	cssHash?: (args: {
 		hash: (input: string) => string;
 		css: string;
 		name: string;
-		filename: string | undefined;
+		filename: string;
 	}) => string;
+	/**
+	 * Pre-computed constant CSS scope hash. Escape hatch for callers (e.g.
+	 * `@rsvelte/vite-plugin-svelte`'s HMR path) that already know the hash and
+	 * want to skip the `cssHash` callback bridge entirely.
+	 */
+	cssHashOverride?: string;
 	/** Preserve HTML comments in output. */
 	preserveComments?: boolean;
 	/** Preserve whitespace in the template. */
 	preserveWhitespace?: boolean;
-	/** Force runes mode (`true`), legacy (`false`), or auto-detect (`undefined`). */
-	runes?: boolean;
+	/**
+	 * Force runes mode (`true`), legacy (`false`), or auto-detect (`undefined`).
+	 * A function form `({ filename }) => boolean | undefined` is evaluated once
+	 * at the binding boundary.
+	 */
+	runes?: boolean | ((meta: { filename: string }) => boolean | undefined);
 	/** Disclose the compiler version in the output banner. */
 	discloseVersion?: boolean;
 	/** Source-map options (forwarded through magic-string). */
@@ -70,6 +97,7 @@ export interface ModuleCompileOptions {
 	generate?: 'client' | 'server' | false;
 	filename?: string;
 	rootDir?: string;
+	/** Filter compiler warnings (applied to the returned `warnings` array). */
 	warningFilter?: (warning: Warning) => boolean;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsvelte/vite-plugin-svelte-native",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "NAPI bindings to the rsvelte compiler — used by the @rsvelte vite-plugin-svelte shim",
   "license": "MIT",
   "repository": {
@@ -29,11 +29,11 @@
     "index.d.ts"
   ],
   "optionalDependencies": {
-    "@rsvelte/vite-plugin-svelte-native-darwin-arm64": "^0.2.8",
-    "@rsvelte/vite-plugin-svelte-native-darwin-x64": "^0.2.8",
-    "@rsvelte/vite-plugin-svelte-native-linux-arm64-gnu": "^0.2.8",
-    "@rsvelte/vite-plugin-svelte-native-linux-x64-gnu": "^0.2.8",
-    "@rsvelte/vite-plugin-svelte-native-win32-x64-msvc": "^0.2.8"
+    "@rsvelte/vite-plugin-svelte-native-darwin-arm64": "^0.3.0",
+    "@rsvelte/vite-plugin-svelte-native-darwin-x64": "^0.3.0",
+    "@rsvelte/vite-plugin-svelte-native-linux-arm64-gnu": "^0.3.0",
+    "@rsvelte/vite-plugin-svelte-native-linux-x64-gnu": "^0.3.0",
+    "@rsvelte/vite-plugin-svelte-native-win32-x64-msvc": "^0.3.0"
   },
   "publishConfig": {
     "access": "public"

package/parse-envelope.js

@@ -15,7 +15,11 @@
 const { isWindowOutOfBounds, windowOutOfBoundsMessage } = require('./lib/bounds-check.js');
 
 const MAGIC = 0x3156_5052; // "RPV1" little-endian
-const VERSION = 1;
+// Bumped for the function-node AST-fidelity changes (FunctionExpression field
+// reorder, `typeParameters` on function-like nodes, Identifier `optional`);
+// v4 adds the object-method `typeParameters`-after-`body` flag byte.
+// Keep in lockstep with `napi_raw_parse.rs`'s `VERSION`.
+const VERSION = 4;
 const HEADER_LEN = 24;
 
 // Tags — must mirror napi_raw_parse.rs.
@@ -698,9 +702,11 @@ function readOptNode(ctx) {
 function readJsIdentifier(ctx, start, end) {
 	const loc = readTypedLoc(ctx);
 	const name = readStr(ctx);
+	const optional = readBool(ctx);
 	const node = { type: 'Identifier', start, end };
 	if (loc !== null) node.loc = loc;
 	node.name = name;
+	if (optional) node.optional = true;
 	const typeAnnotation = readOptTypeAnnotation(ctx);
 	if (typeAnnotation !== null) node.typeAnnotation = typeAnnotation;
 	return node;
@@ -809,19 +815,24 @@ function readJsNewExpression(ctx, start, end) {
 function readJsFunctionExpression(ctx, start, end) {
 	const loc = readTypedLoc(ctx);
 	const id = readOptNode(ctx);
+	const expression = readBool(ctx);
 	const generator = readBool(ctx);
 	const asyncFlag = readBool(ctx);
-	const expression = readBool(ctx);
+	const typeParameters = readOptTypeAnnotation(ctx);
 	const params = readChildArray(ctx);
 	const body = readOptNode(ctx);
+	// Object-method inner functions carry `typeParameters` after `body` (acorn).
+	const typeParametersAfterBody = readBool(ctx);
 	const node = { type: 'FunctionExpression', start, end };
 	if (loc !== null) node.loc = loc;
 	node.id = id;
+	node.expression = expression;
 	node.generator = generator;
 	node.async = asyncFlag;
-	node.expression = expression;
+	if (typeParameters !== null && !typeParametersAfterBody) node.typeParameters = typeParameters;
 	node.params = params;
 	node.body = body;
+	if (typeParameters !== null && typeParametersAfterBody) node.typeParameters = typeParameters;
 	return node;
 }
 
@@ -846,6 +857,7 @@ function readJsArrowFunctionExpression(ctx, start, end) {
 	const asyncFlag = readBool(ctx);
 	const params = readChildArray(ctx);
 	const body = readNode(ctx);
+	const typeParameters = readOptTypeAnnotation(ctx);
 	const node = { type: 'ArrowFunctionExpression', start, end };
 	if (loc !== null) node.loc = loc;
 	node.id = id;
@@ -854,6 +866,7 @@ function readJsArrowFunctionExpression(ctx, start, end) {
 	node.async = asyncFlag;
 	node.params = params;
 	node.body = body;
+	if (typeParameters !== null) node.typeParameters = typeParameters;
 	return node;
 }
 
@@ -1170,15 +1183,19 @@ function readJsVariableDeclarator(ctx, start, end) {
 function readJsFunctionDeclaration(ctx, start, end) {
 	const loc = readTypedLoc(ctx);
 	const id = readOptNode(ctx);
+	const expression = readBool(ctx);
 	const generator = readBool(ctx);
 	const asyncFlag = readBool(ctx);
+	const typeParameters = readOptTypeAnnotation(ctx);
 	const params = readChildArray(ctx);
 	const body = readOptNode(ctx);
 	const node = { type: 'FunctionDeclaration', start, end };
 	if (loc !== null) node.loc = loc;
 	node.id = id;
+	node.expression = expression;
 	node.generator = generator;
 	node.async = asyncFlag;
+	if (typeParameters !== null) node.typeParameters = typeParameters;
 	node.params = params;
 	node.body = body;
 	return node;