@rsvelte/vite-plugin-svelte-native 0.3.14 → 0.3.16

package/envelope.js

@@ -13,6 +13,7 @@
 'use strict';
 
 const { isWindowOutOfBounds, windowOutOfBoundsMessage } = require('./lib/bounds-check.js');
+const { attachSourceMapMethods } = require('./lib/source-map.js');
 
 const MAGIC = 0x31565352; // "RSV1" little-endian
 const VERSION = 1;
@@ -199,7 +200,9 @@ function makeCodeMapObject(buf, slice, codeOff, codeLen, mapOff, mapLen, sourceC
 				// parsed object matches the legacy compile() shape —
 				// callers that just want the raw JSON to write to disk
 				// should prefer `mapBytes` / `mapText` (no JSON.parse).
-				mapCache = attachSourceContent(JSON.parse(slice(mapOff, mapLen)), sourceContent);
+				mapCache = attachSourceMapMethods(
+					attachSourceContent(JSON.parse(slice(mapOff, mapLen)), sourceContent),
+				);
 			}
 			return mapCache;
 		},

package/index.cjs

@@ -5,6 +5,7 @@
 const { decodeEnvelope, decodeBatch } = require('./envelope.js');
 const { decodeParseEnvelope } = require('./parse-envelope.js');
 const { resolveTriple } = require('./platform.cjs');
+const { attachResultSourceMapMethods } = require('./lib/source-map.js');
 
 const { platform, arch } = process;
 
@@ -93,7 +94,9 @@ function compile(source, options) {
 	}
 	const { options: resolved, warningFilter } = prepareCompileOptions(options);
 	if (resolved?.modernAst) {
-		return applyWarningFilter(binding.compile(source, resolved), warningFilter);
+		return attachResultSourceMapMethods(
+			applyWarningFilter(binding.compile(source, resolved), warningFilter),
+		);
 	}
 	return applyWarningFilter(
 		decodeEnvelope(binding.compileEnvelopeExternalSources(source, resolved), source),
@@ -134,7 +137,9 @@ function compileBatch(inputs) {
 	});
 	if (prepared.some((input) => input.options?.modernAst)) {
 		return prepared.map((input, i) =>
-			applyWarningFilter(binding.compile(input.source, input.options), filters[i]),
+			attachResultSourceMapMethods(
+				applyWarningFilter(binding.compile(input.source, input.options), filters[i]),
+			),
 		);
 	}
 	const sourceContents = prepared.map((input) => input.source);
@@ -160,10 +165,12 @@ async function compileAsync(source, options) {
 		// 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);
+		return attachResultSourceMapMethods(applyWarningFilter(result, warningFilter));
 	}
 	if (resolved?.modernAst) {
-		return applyWarningFilter(binding.compile(source, resolved), warningFilter);
+		return attachResultSourceMapMethods(
+			applyWarningFilter(binding.compile(source, resolved), warningFilter),
+		);
 	}
 	return applyWarningFilter(
 		decodeEnvelope(
@@ -184,7 +191,9 @@ async function compileBatchAsync(inputs) {
 	});
 	if (prepared.some((input) => input.options?.modernAst)) {
 		return prepared.map((input, i) =>
-			applyWarningFilter(binding.compile(input.source, input.options), filters[i]),
+			attachResultSourceMapMethods(
+				applyWarningFilter(binding.compile(input.source, input.options), filters[i]),
+			),
 		);
 	}
 	const sourceContents = prepared.map((input) => input.source);
@@ -254,4 +263,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.57.0';
+module.exports.VERSION = '5.57.1';

package/index.d.ts

@@ -135,16 +135,34 @@ export interface Warning {
 // Compile result
 // ---------------------------------------------------------------------------
 
+/**
+ * What `svelte/compiler` hands back as `js.map` / `css.map`: the standard
+ * Source Map v3 fields plus magic-string's `toString()` / `toUrl()`, which
+ * tooling calls to inline a map. Both methods are non-enumerable, so the
+ * object still serializes as a plain map.
+ */
+export interface SourceMap {
+	version: number;
+	file?: string;
+	sources: string[];
+	sourcesContent?: (string | null)[];
+	names: string[];
+	mappings: string;
+	toString(): string;
+	toUrl(): string;
+}
+
 export interface CompileResultJs {
 	code: string;
 	/**
-	 * A standard SourceMap v3 JSON object. Accessing this triggers a
-	 * one-time `JSON.parse` of the underlying envelope bytes. For
-	 * callers that immediately re-serialize (writing to disk,
-	 * sending over the wire) prefer {@link mapBytes} / {@link mapText}
-	 * to skip the parse round-trip.
+	 * A standard SourceMap v3 JSON object carrying magic-string's
+	 * `toString()` / `toUrl()`. Accessing this triggers a one-time
+	 * `JSON.parse` of the underlying envelope bytes. For callers that
+	 * immediately re-serialize (writing to disk, sending over the wire)
+	 * prefer {@link mapBytes} / {@link mapText} to skip the parse
+	 * round-trip.
 	 */
-	map: unknown;
+	map: SourceMap | null;
 	/**
 	 * Zero-copy `Buffer` / `Uint8Array` view over the raw sourcemap
 	 * JSON bytes in a raw envelope. The standard `compile` wrappers
@@ -159,7 +177,7 @@ export interface CompileResultJs {
 export interface CompileResultCss {
 	code: string;
 	/** See {@link CompileResultJs.map}. */
-	map: unknown;
+	map: SourceMap | null;
 	mapBytes: Buffer | Uint8Array | null;
 	mapText: string | null;
 	hasGlobal: boolean;

package/lib/source-map.js

@@ -0,0 +1,73 @@
+// `svelte/compiler`'s `compile` / `compileModule` return `js.map` and
+// `css.map` as magic-string `SourceMap` instances, so downstream tooling
+// calls `map.toUrl()` to inline the map (upstream does it itself in
+// `3-transform/css/index.js`, and `vite-plugin-svelte`'s dep optimizer does
+// it in `setup-optimizer.js`). The NAPI boundary can only hand back a plain
+// Source Map v3 object, so those callers get `map.toUrl is not a function`
+// (#4695).
+//
+// Upstream hits the same problem in `utils/mapped_code.js` and solves it the
+// same way — tack the two methods on instead of wrapping in a class, so the
+// object stays a plain data map for `JSON.stringify` and structural
+// comparison. Both are non-enumerable, which is what keeps `{...map}`,
+// `Object.keys(map)` and a serialized envelope byte-identical to before.
+
+'use strict';
+
+// browser vs node.js, mirroring `mapped_code.js`'s `b64enc`.
+const b64enc =
+	typeof window !== 'undefined' && typeof btoa === 'function'
+		? /** @param {string} str */ (str) => btoa(unescape(encodeURIComponent(str)))
+		: /** @param {string} str */ (str) => Buffer.from(str).toString('base64');
+
+/**
+ * Give a plain Source Map v3 object magic-string's `SourceMap` methods.
+ * Returns the same object; a non-object (or a map that already carries
+ * `toUrl`, e.g. one a caller assigned) is handed back untouched.
+ *
+ * @template T
+ * @param {T} map
+ * @returns {T}
+ */
+function attachSourceMapMethods(map) {
+	if (map === null || typeof map !== 'object') return map;
+	if (typeof (/** @type {any} */ (map).toUrl) === 'function') return map;
+	Object.defineProperties(map, {
+		toString: {
+			enumerable: false,
+			writable: true,
+			configurable: true,
+			value: function toString() {
+				return JSON.stringify(this);
+			},
+		},
+		toUrl: {
+			enumerable: false,
+			writable: true,
+			configurable: true,
+			value: function toUrl() {
+				return 'data:application/json;charset=utf-8;base64,' + b64enc(this.toString());
+			},
+		},
+	});
+	return map;
+}
+
+/**
+ * Apply {@link attachSourceMapMethods} to every map a `CompileResult`
+ * carries. The JSON NAPI entries (`modernAst`, `compileWithCssHash`) return
+ * plain objects rather than an envelope, so they need it at the call site.
+ *
+ * @template T
+ * @param {T} result
+ * @returns {T}
+ */
+function attachResultSourceMapMethods(result) {
+	if (result === null || typeof result !== 'object') return result;
+	const r = /** @type {any} */ (result);
+	if (r.js) attachSourceMapMethods(r.js.map);
+	if (r.css) attachSourceMapMethods(r.css.map);
+	return result;
+}
+
+module.exports = { attachSourceMapMethods, attachResultSourceMapMethods };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsvelte/vite-plugin-svelte-native",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "description": "NAPI bindings to the rsvelte compiler — used by the @rsvelte vite-plugin-svelte shim",
   "license": "MIT",
   "repository": {
@@ -26,15 +26,16 @@
     "parse-envelope.js",
     "platform.cjs",
     "lib/bounds-check.js",
+    "lib/source-map.js",
     "index.cjs",
     "index.d.ts"
   ],
   "optionalDependencies": {
-    "@rsvelte/vite-plugin-svelte-native-darwin-arm64": "^0.3.14",
-    "@rsvelte/vite-plugin-svelte-native-darwin-x64": "^0.3.14",
-    "@rsvelte/vite-plugin-svelte-native-linux-arm64-gnu": "^0.3.14",
-    "@rsvelte/vite-plugin-svelte-native-linux-x64-gnu": "^0.3.14",
-    "@rsvelte/vite-plugin-svelte-native-win32-x64-msvc": "^0.3.14"
+    "@rsvelte/vite-plugin-svelte-native-darwin-arm64": "^0.3.16",
+    "@rsvelte/vite-plugin-svelte-native-darwin-x64": "^0.3.16",
+    "@rsvelte/vite-plugin-svelte-native-linux-arm64-gnu": "^0.3.16",
+    "@rsvelte/vite-plugin-svelte-native-linux-x64-gnu": "^0.3.16",
+    "@rsvelte/vite-plugin-svelte-native-win32-x64-msvc": "^0.3.16"
   },
   "publishConfig": {
     "access": "public"

package/parse-envelope.js

@@ -1168,9 +1168,11 @@ function readJsProgram(ctx, start, end) {
 function readJsExpressionStatement(ctx, start, end) {
 	const loc = readTypedLoc(ctx);
 	const expression = readNode(ctx);
+	const directive = readOptStr(ctx);
 	const node = { type: 'ExpressionStatement', start, end };
 	if (loc !== null) node.loc = loc;
 	node.expression = expression;
+	if (directive !== null) node.directive = directive;
 	return node;
 }