@rsvelte/vite-plugin-svelte-native 0.3.1 → 0.3.2

package/envelope.js

@@ -47,9 +47,10 @@ function assertWindow(bufLen, off, len, label) {
  * Decode an envelope produced by `compileEnvelope` / `compileModuleEnvelope`.
  *
  * @param {Buffer|Uint8Array} buf
+ * @param {string} [sourceContent]
  * @returns {object} CompileResult-shaped object with lazy fields
  */
-function decodeEnvelope(buf) {
+function decodeEnvelope(buf, sourceContent) {
 	if (!buf || buf.byteLength < HEADER_LEN) {
 		throw new Error(
 			`[rsvelte] envelope too small (${buf ? buf.byteLength : 0} bytes, ` +
@@ -117,11 +118,27 @@ function decodeEnvelope(buf) {
 	// js — eagerly construct the wrapper object, but defer string/JSON
 	// realisation. Vite always touches `js.code`; the map is only
 	// touched when emitting sourcemaps.
-	const js = makeCodeMapObject(buf, slice, jsCodeOff, jsCodeLen, jsMapOff, jsMapLen);
+	const js = makeCodeMapObject(
+		buf,
+		slice,
+		jsCodeOff,
+		jsCodeLen,
+		jsMapOff,
+		jsMapLen,
+		sourceContent,
+	);
 
 	let css = null;
 	if (hasCss) {
-		css = makeCodeMapObject(buf, slice, cssCodeOff, cssCodeLen, cssMapOff, cssMapLen);
+		css = makeCodeMapObject(
+			buf,
+			slice,
+			cssCodeOff,
+			cssCodeLen,
+			cssMapOff,
+			cssMapLen,
+			sourceContent,
+		);
 		css.hasGlobal = (flags & FLAG_CSS_HAS_GLOBAL) !== 0;
 	}
 
@@ -150,7 +167,7 @@ function decodeEnvelope(buf) {
 	return result;
 }
 
-function makeCodeMapObject(buf, slice, codeOff, codeLen, mapOff, mapLen) {
+function makeCodeMapObject(buf, slice, codeOff, codeLen, mapOff, mapLen, sourceContent) {
 	const obj = {};
 	let codeCache = null;
 	// `code` and `map` need setters as well as getters — upstream
@@ -182,7 +199,7 @@ function makeCodeMapObject(buf, slice, codeOff, codeLen, mapOff, mapLen) {
 				// 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 = JSON.parse(slice(mapOff, mapLen));
+				mapCache = attachSourceContent(JSON.parse(slice(mapOff, mapLen)), sourceContent);
 			}
 			return mapCache;
 		},
@@ -199,6 +216,10 @@ function makeCodeMapObject(buf, slice, codeOff, codeLen, mapOff, mapLen) {
 		configurable: true,
 		get() {
 			if (!hasMap) return null;
+			const raw = slice(mapOff, mapLen);
+			if (hasExternalSourceContent(raw, sourceContent)) {
+				return Buffer.from(materializeMapText(raw, sourceContent));
+			}
 			return buf.subarray
 				? buf.subarray(mapOff, mapOff + mapLen)
 				: new Uint8Array(buf.buffer, buf.byteOffset + mapOff, mapLen);
@@ -212,12 +233,36 @@ function makeCodeMapObject(buf, slice, codeOff, codeLen, mapOff, mapLen) {
 		configurable: true,
 		get() {
 			if (!hasMap) return null;
-			return slice(mapOff, mapLen);
+			return materializeMapText(slice(mapOff, mapLen), sourceContent);
 		},
 	});
 	return obj;
 }
 
+function attachSourceContent(map, sourceContent) {
+	if (
+		sourceContent !== undefined &&
+		Array.isArray(map.sourcesContent) &&
+		map.sourcesContent.length === 1 &&
+		map.sourcesContent[0] === null
+	) {
+		map.sourcesContent[0] = sourceContent;
+	}
+	return map;
+}
+
+function hasExternalSourceContent(mapText, sourceContent) {
+	return sourceContent !== undefined && mapText.includes('"sourcesContent":[null]');
+}
+
+function materializeMapText(mapText, sourceContent) {
+	if (!hasExternalSourceContent(mapText, sourceContent)) return mapText;
+	return mapText.replace(
+		'"sourcesContent":[null]',
+		() => `"sourcesContent":[${JSON.stringify(sourceContent)}]`,
+	);
+}
+
 function decodeWarnings(buf, view, off, regionLen, count, slice) {
 	// Every record field is bounds-checked against the warnings region
 	// (already validated to lie inside the buffer by the caller) so a
@@ -322,9 +367,10 @@ const BATCH_STATUS_ERR = 1;
  * or an `Error` carrying the per-entry failure message.
  *
  * @param {Buffer|Uint8Array} buf
+ * @param {string[]} [sourceContents]
  * @returns {Array<object|Error>}
  */
-function decodeBatch(buf) {
+function decodeBatch(buf, sourceContents) {
 	if (!buf || buf.byteLength < BATCH_HEADER_LEN) {
 		throw new Error(
 			`[rsvelte] batch envelope too small (${buf ? buf.byteLength : 0} bytes, ` +
@@ -376,7 +422,7 @@ function decodeBatch(buf) {
 			? buf.subarray(payloadOff, payloadOff + payloadLen)
 			: new Uint8Array(buf.buffer, buf.byteOffset + payloadOff, payloadLen);
 		if (status === BATCH_STATUS_OK) {
-			out[i] = decodeEnvelope(slice);
+			out[i] = decodeEnvelope(slice, sourceContents?.[i]);
 		} else if (status === BATCH_STATUS_ERR) {
 			const msg = bufferIsNodeBuffer(slice)
 				? slice.toString('utf8')

package/index.cjs

@@ -118,10 +118,12 @@ function applyWarningFilter(result, warningFilter) {
 }
 
 // `compile` / `compileModule` are wrapped to route through the
-// raw-transfer envelope (`compileEnvelope`): the Rust side hands us
+// raw-transfer envelope: the Rust side hands us
 // one `Buffer`, the JS side lazy-decodes only the fields the caller
 // reads. This avoids the V8 string copy + `serde_json` round-trip
-// that the legacy JSON path pays for every call.
+// that the legacy JSON path pays for every call. The wrapper-only
+// native entry points leave `sourcesContent` external so the source
+// already owned by JavaScript is not copied into the envelope.
 //
 // Callers that need the raw envelope (e.g. to ship it across a worker
 // boundary without re-encoding) can still grab `binding.compileEnvelope`
@@ -136,7 +138,10 @@ function compile(source, options) {
 		);
 	}
 	const { options: resolved, warningFilter } = prepareCompileOptions(options);
-	return applyWarningFilter(decodeEnvelope(binding.compileEnvelope(source, resolved)), warningFilter);
+	return applyWarningFilter(
+		decodeEnvelope(binding.compileEnvelopeExternalSources(source, resolved), source),
+		warningFilter,
+	);
 }
 
 function compileModule(source, options) {
@@ -170,7 +175,11 @@ function compileBatch(inputs) {
 		if (warningFilter) filters[i] = warningFilter;
 		return options === input.options ? input : { source: input.source, options };
 	});
-	const results = decodeBatch(binding.compileBatch(prepared));
+	const sourceContents = prepared.map((input) => input.source);
+	const results = decodeBatch(
+		binding.compileBatchExternalSources(prepared),
+		sourceContents,
+	);
 	if (filters.length) {
 		results.forEach((result, i) => applyWarningFilter(result, filters[i]));
 	}
@@ -194,7 +203,10 @@ async function compileAsync(source, options) {
 		return applyWarningFilter(result, warningFilter);
 	}
 	return applyWarningFilter(
-		decodeEnvelope(await binding.compileEnvelopeAsync(source, resolved)),
+		decodeEnvelope(
+			await binding.compileEnvelopeExternalSourcesAsync(source, resolved),
+			source,
+		),
 		warningFilter,
 	);
 }
@@ -207,7 +219,11 @@ async function compileBatchAsync(inputs) {
 		if (warningFilter) filters[i] = warningFilter;
 		return options === input.options ? input : { source: input.source, options };
 	});
-	const results = decodeBatch(await binding.compileBatchAsync(prepared));
+	const sourceContents = prepared.map((input) => input.source);
+	const results = decodeBatch(
+		await binding.compileBatchExternalSourcesAsync(prepared),
+		sourceContents,
+	);
 	if (filters.length) {
 		results.forEach((result, i) => applyWarningFilter(result, filters[i]));
 	}

package/index.d.ts

@@ -138,9 +138,9 @@ export interface CompileResultJs {
 	map: unknown;
 	/**
 	 * Zero-copy `Buffer` / `Uint8Array` view over the raw sourcemap
-	 * JSON bytes in the envelope. `null` if no map was produced. Stable
-	 * for the lifetime of the parent `CompileResult` (becomes invalid
-	 * once a `compileEnvelopeZeroCopy` buffer is GC'd).
+	 * JSON bytes in a raw envelope. The standard `compile` wrappers
+	 * externalize the source text and materialize a complete buffer on
+	 * access instead. `null` if no map was produced.
 	 */
 	mapBytes: Buffer | Uint8Array | null;
 	/** Raw sourcemap JSON as a string — no `JSON.parse`. `null` if no map. */
@@ -214,8 +214,8 @@ export function compileModuleEnvelopeZeroCopy(
 	options?: ModuleCompileOptions,
 ): Buffer;
 
-/** Decode a buffer produced by {@link compileEnvelope}. */
-export function decodeEnvelope(buf: Buffer | Uint8Array): CompileResult;
+/** Decode an envelope, optionally restoring externally supplied source text. */
+export function decodeEnvelope(buf: Buffer | Uint8Array, sourceContent?: string): CompileResult;
 
 /**
  * Single entry in a {@link compileBatch} worklist. `options` is
@@ -249,8 +249,11 @@ export function compileBatch(
  */
 export function compileBatchRaw(inputs: CompileBatchInput[]): Buffer;
 
-/** Decode a batch envelope produced by {@link compileBatchRaw}. */
-export function decodeBatch(buf: Buffer | Uint8Array): Array<CompileResult | Error>;
+/** Decode a batch envelope, optionally restoring externally supplied source text. */
+export function decodeBatch(
+	buf: Buffer | Uint8Array,
+	sourceContents?: string[],
+): Array<CompileResult | Error>;
 
 /**
  * Async variant of {@link compile}. The Rust side runs on a libuv

package/package.json

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