@rsvelte/vite-plugin-svelte-native 0.3.6 → 0.3.8

package/index.cjs

@@ -54,32 +54,6 @@ function prepareCompileOptions(options) {
 	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;
@@ -183,11 +157,9 @@ async function compileAsync(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),
-		);
+		// The callback is handed straight through: Rust calls it with upstream's
+		// own `{ hash, css, name, filename }` object and reads the string back.
+		const result = await binding.compileWithCssHash(source, resolved, options.cssHash);
 		return applyWarningFilter(result, warningFilter);
 	}
 	if (resolved?.modernAst) {
@@ -254,6 +226,11 @@ module.exports.compileModuleBuffers = binding.compileModuleBuffers;
 module.exports.compileBatch = compileBatch;
 module.exports.compileBatchRaw = binding.compileBatch;
 module.exports.compileAsync = compileAsync;
+// The only entry that honours a function-valued `cssHash`. The callback takes
+// upstream's single `{ hash, css, name, filename }` argument and returns the
+// scope class; the synchronous entries reject a function `cssHash` rather than
+// dropping it. Returns a plain CompileResult (no envelope).
+module.exports.compileWithCssHash = binding.compileWithCssHash;
 module.exports.compileBatchAsync = compileBatchAsync;
 module.exports.compileEnvelopeAsync = binding.compileEnvelopeAsync;
 module.exports.compileBatchAsyncRaw = binding.compileBatchAsync;
@@ -277,4 +254,4 @@ module.exports.decodeParseEnvelope = decodeParseEnvelope;
 // with `submodules/svelte/packages/svelte/package.json` by hand; run
 // `node scripts/dev/check-vps-version.mjs` (also wired into CI) to
 // catch drift.
-module.exports.VERSION = '5.56.8';
+module.exports.VERSION = '5.56.9';

package/index.d.ts

@@ -46,7 +46,8 @@ export interface CompileOptions {
 	 * 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`.
+	 * callback and is only supported on the async path — use `compileAsync`
+	 * (or `compileWithCssHash`, which it routes to).
 	 * The synchronous `compile` throws if given a `cssHash` function; pass a
 	 * pre-computed constant via `cssHashOverride` instead.
 	 */
@@ -275,6 +276,19 @@ export function compileAsync(
 	options?: CompileOptions,
 ): Promise<CompileResult>;
 
+/**
+ * The one entry that honours a function-valued `cssHash`. The callback receives
+ * upstream's single `{ hash, css, name, filename }` argument and returns the
+ * scope class; a throw aborts the compile. `compileAsync` routes here
+ * automatically when `options.cssHash` is a function, so most callers never need
+ * this directly.
+ */
+export function compileWithCssHash(
+	source: string,
+	options: CompileOptions | undefined | null,
+	cssHash: NonNullable<CompileOptions['cssHash']>,
+): Promise<CompileResult>;
+
 /** Async variant of {@link compileBatch}. */
 export function compileBatchAsync(
 	inputs: CompileBatchInput[],

package/package.json

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

package/parse-envelope.js

@@ -173,6 +173,7 @@ const LV_NUMBER_I64 = 3;
 const LV_NUMBER_F64 = 4;
 const LV_STRING = 5;
 const LV_REGEX = 6;
+const LV_BIGINT = 7;
 
 // Element tag -> serialised `type` string. The decoder uses this
 // table for the shared element shape (RegularElement, Component, …).
@@ -660,6 +661,10 @@ function readLiteralValue(ctx) {
 			return readStr(ctx);
 		case LV_REGEX:
 			return {}; // Literal.regex value is serialised as an empty object upstream.
+		case LV_BIGINT:
+			// Sentinel consumed by readJsLiteral (value becomes a BigInt and the
+			// digits land on the node's `bigint` property, acorn-style).
+			return { bigint: readStr(ctx) };
 		default:
 			throw new EnvelopeError(`parse envelope: bad LiteralValue tag 0x${tag.toString(16)}`);
 	}
@@ -728,6 +733,13 @@ function readJsLiteral(ctx, start, end) {
 	const regex = readRegex(ctx);
 	const node = { type: 'Literal', start, end };
 	if (loc !== null) node.loc = loc;
+	if (value !== null && typeof value === 'object' && typeof value.bigint === 'string') {
+		node.value = BigInt(value.bigint);
+		node.raw = raw;
+		node.bigint = value.bigint;
+		if (regex !== null) node.regex = regex;
+		return node;
+	}
 	node.value = value;
 	node.raw = raw;
 	if (regex !== null) node.regex = regex;