@rsvelte/vite-plugin-svelte-native 0.3.7 → 0.3.9

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.9';
+module.exports.VERSION = '5.56.10';

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.
 	 */
@@ -192,6 +193,13 @@ export function compileModule(
  * {@link decodeEnvelope} to obtain
  * the legacy {@link CompileResult} shape; or pass the buffer through
  * worker `postMessage` (transferable) to avoid a copy.
+ *
+ * Unlike {@link compile}, this does NOT go through the wrapper that resolves
+ * upstream's function-valued options, so a `runes` / `css` / `customElement` /
+ * `warningFilter` callback is **rejected** here rather than honoured — evaluate
+ * it yourself and pass the plain value. `runes` and `warningFilter` used to be
+ * dropped in silence instead, which produced a successful compile with the
+ * wrong result; `css` and `customElement` already threw.
  */
 export function compileEnvelope(source: string, options?: CompileOptions): Buffer;
 export function compileModuleEnvelope(
@@ -275,6 +283,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[],
@@ -314,6 +335,13 @@ export function compileModuleBuffers(
 /**
  * The legacy JSON-on-the-boundary path. Kept exported for parity tests
  * and as an escape hatch — production callers should use {@link compile}.
+ *
+ * Unlike {@link compile}, this does NOT go through the wrapper that resolves
+ * upstream's function-valued options, so a `runes` / `css` / `customElement` /
+ * `warningFilter` callback is **rejected** here rather than honoured — evaluate
+ * it yourself and pass the plain value. `runes` and `warningFilter` used to be
+ * dropped in silence instead, which produced a successful compile with the
+ * wrong result; `css` and `customElement` already threw.
  */
 export function compileLegacy(source: string, options?: CompileOptions): CompileResult;
 export function compileModuleLegacy(
@@ -345,12 +373,29 @@ export interface ParseOptions {
 	 * JSON-parse step.
 	 */
 	skipCssAst?: boolean;
+	/**
+	 * `modern` from `svelte/compiler`'s `parse()`. **Defaults to `false`**,
+	 * which returns the LEGACY AST (`{ html, instance, module, css }`); pass
+	 * `true` for the modern `Root` shape. The modern AST stays opt-in until
+	 * Svelte 6, and this binding defaults the same way official does.
+	 */
+	modern?: boolean;
+	/**
+	 * `loose` from `svelte/compiler`'s `parse()`. Recover from a parse error
+	 * and return an AST anyway — what an editor integration needs to parse a
+	 * document mid-keystroke. Not blanket recovery: a source official still
+	 * rejects under `loose` (e.g. a stray `</div>`) throws here too.
+	 */
+	loose?: boolean;
 }
 
 /**
  * Parse a Svelte component and return the AST as a JSON string. The
  * caller is responsible for `JSON.parse` on the returned value.
  *
+ * Without `{ modern: true }` this returns the LEGACY AST, matching
+ * `svelte/compiler`'s default.
+ *
  * For the fastest path skip JSON entirely: use {@link parseEnvelope}
  * with `decodeParseEnvelope` from
  * `@rsvelte/vite-plugin-svelte-native/parse-envelope.js`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsvelte/vite-plugin-svelte-native",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "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.7",
-    "@rsvelte/vite-plugin-svelte-native-darwin-x64": "^0.3.7",
-    "@rsvelte/vite-plugin-svelte-native-linux-arm64-gnu": "^0.3.7",
-    "@rsvelte/vite-plugin-svelte-native-linux-x64-gnu": "^0.3.7",
-    "@rsvelte/vite-plugin-svelte-native-win32-x64-msvc": "^0.3.7"
+    "@rsvelte/vite-plugin-svelte-native-darwin-arm64": "^0.3.9",
+    "@rsvelte/vite-plugin-svelte-native-darwin-x64": "^0.3.9",
+    "@rsvelte/vite-plugin-svelte-native-linux-arm64-gnu": "^0.3.9",
+    "@rsvelte/vite-plugin-svelte-native-linux-x64-gnu": "^0.3.9",
+    "@rsvelte/vite-plugin-svelte-native-win32-x64-msvc": "^0.3.9"
   },
   "publishConfig": {
     "access": "public"

package/parse-envelope.js

@@ -19,7 +19,7 @@ const MAGIC = 0x3156_5052; // "RPV1" little-endian
 // 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 VERSION = 5;
 const HEADER_LEN = 24;
 
 // Tags — must mirror napi_raw_parse.rs.
@@ -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;
@@ -1640,7 +1652,14 @@ function readJsComment(ctx, start, end) {
 	const kindByte = readU8(ctx);
 	const kind = kindByte === 1 ? 'Block' : 'Line';
 	const value = readStr(ctx);
+	// Only an in-tag comment's `loc` carries `character`; a script comment's
+	// comes from the JS parser, which does not produce one.
+	const hasCharacter = readU8(ctx) === 1;
 	const loc = readSourceLocation(ctx);
+	if (!hasCharacter) {
+		delete loc.start.character;
+		delete loc.end.character;
+	}
 	return { type: kind, start, end, value, loc };
 }