@octanejs/rspack-plugin 0.1.47 → 0.1.48

package/README.md

@@ -196,6 +196,18 @@ export default {
 
 The class plugin is recommended unless another integration owns those concerns.
 
+## Scoped CSS
+
+Scoped `<style>` blocks compile to `injectStyle(hash, css)` calls — one per
+style scope, in lexical order — emitted as module-level statements in client
+compilations and inside the component body per request in server
+compilations, where the render collects them into the response's
+`<style data-octane>` tags. A theme (`export const theme = <style>…</style>`)
+is an ordinary module value, so importing it injects its sheet ahead of the
+importer's own scopes. There is no virtual CSS module and no CSS HMR path:
+editing a block re-evaluates the module like any other source change. Neither
+the plugin nor the loader needs a CSS rule for this.
+
 ## App-level metadata
 
 Transformed Rspack modules receive a serializable `buildInfo.octane` record

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octanejs/rspack-plugin",
-  "version": "0.1.47",
+  "version": "0.1.48",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -54,7 +54,7 @@
     "css-loader": "6.11.0",
     "jsdom": "^30.0.1",
     "vitest": "^4.1.10",
-    "octane": "0.2.0"
+    "octane": "0.2.4"
   },
   "scripts": {
     "test": "vitest run --config vitest.config.js"

package/src/descriptor-children.js

@@ -0,0 +1,116 @@
+import { readFile } from 'node:fs/promises';
+import { dirname, isAbsolute } from 'node:path';
+import {
+	cleanModuleId,
+	findDescriptorChildrenExports,
+	findDescriptorChildrenImports,
+} from 'octane/compiler/bundler';
+
+/**
+ * A loader runs before Rspack publishes outgoing module-graph edges. Resolve
+ * each JSX import with its ESM resolver, then prove the named export from the
+ * resolved authored source. Every file in the proof becomes a loader dependency
+ * so changing a marker or any barrel invalidates its compiled consumers.
+ */
+export async function loadDescriptorChildrenImports(context, source, id) {
+	if (typeof context.getResolve !== 'function' || !/<\s*[A-Z_$]/.test(source)) return null;
+	const imports = findDescriptorChildrenImports(source, id).filter(
+		(candidate) => candidate.local !== undefined && candidate.request !== 'octane',
+	);
+	if (imports.length === 0) return null;
+	const resolver = context.getResolve({ dependencyType: 'esm' });
+	const analyses = new Map();
+	const classifications = new Map();
+	const proven = new Set();
+
+	async function analyze(resolvedId) {
+		const filename = cleanModuleId(resolvedId);
+		if (!isAbsolute(filename) || !/\.(?:[cm]?[jt]sx?|tsrx)$/.test(filename)) return null;
+		let analysis = analyses.get(filename);
+		if (analysis === undefined) {
+			context.addDependency?.(filename);
+			analysis = readFile(filename, 'utf8')
+				.then((code) => {
+					// An ordinary source with neither the marker's name nor an
+					// import/re-export pair cannot prove any binding. Keep that
+					// common case out of the parser entirely.
+					const mayReexport = code.includes('export') && code.includes('from');
+					return {
+						exports: code.includes('descriptorChildren')
+							? new Set(findDescriptorChildrenExports(code, filename))
+							: new Set(),
+						code: mayReexport ? code : null,
+						reexports: mayReexport ? undefined : [],
+					};
+				})
+				.catch((error) => {
+					if (error?.code === 'ENOENT') context.addMissingDependency?.(filename);
+					return null;
+				});
+			analyses.set(filename, analysis);
+		}
+		return analysis;
+	}
+
+	async function resolveImport(request, importer) {
+		try {
+			return await resolver(dirname(cleanModuleId(importer)), request);
+		} catch {
+			// Let Rspack's module factory report unresolved imports with its own
+			// issuer trace; no export can be proven from a missing dependency.
+			return null;
+		}
+	}
+
+	async function isMarked(resolvedId, imported, ancestors = new Set()) {
+		const key = `${resolvedId}\0${imported}`;
+		if (ancestors.has(key)) return false;
+		let classification = ancestors.size === 0 ? classifications.get(key) : undefined;
+		if (classification === undefined) {
+			classification = (async () => {
+				const analysis = await analyze(resolvedId);
+				if (analysis === null) return false;
+				if (analysis.exports.has(imported)) return true;
+				const reexports = (analysis.reexports ??=
+					analysis.code !== null
+						? findDescriptorChildrenImports(analysis.code, cleanModuleId(resolvedId)).filter(
+								(candidate) => candidate.exported !== undefined,
+							)
+						: []);
+				const nextAncestors = new Set(ancestors);
+				nextAncestors.add(key);
+				for (const candidate of reexports) {
+					if (candidate.exported !== imported) continue;
+					const target = await resolveImport(candidate.request, resolvedId);
+					if (typeof target === 'string' && target !== resolvedId) {
+						if (await isMarked(target, candidate.imported, nextAncestors)) return true;
+					}
+				}
+				return false;
+			})();
+			// A result inside a cycle can depend on the starting point. Only root
+			// classifications are safe to share across independent import paths.
+			if (ancestors.size === 0) classifications.set(key, classification);
+		}
+		return classification;
+	}
+
+	const byRequest = new Map();
+	for (const candidate of imports) {
+		const values = byRequest.get(candidate.request) ?? [];
+		values.push(candidate);
+		byRequest.set(candidate.request, values);
+	}
+	await Promise.all(
+		[...byRequest].map(async ([request, candidates]) => {
+			const target = await resolveImport(request, id);
+			if (typeof target !== 'string' || target === id) return;
+			await Promise.all(
+				candidates.map(async ({ imported }) => {
+					if (await isMarked(target, imported)) proven.add(`${request}\0${imported}`);
+				}),
+			);
+		}),
+	);
+	return proven.size === 0 ? null : (request, imported) => proven.has(`${request}\0${imported}`);
+}

package/src/loader.js

@@ -13,6 +13,7 @@ import {
 	normalizeLoaderOptions,
 	selectLayerCompilerOptions,
 } from './shared.js';
+import { loadDescriptorChildrenImports } from './descriptor-children.js';
 
 function realRoot(path) {
 	try {
@@ -142,7 +143,7 @@ export default function octaneLoader(source, inputSourceMap) {
 						dev,
 					})
 				: null;
-		const finish = (clientOnlyImports, callback) => {
+		const finish = (clientOnlyImports, isDescriptorChildrenImport, callback) => {
 			try {
 				const result = compiler.transform(authoredSource, id, {
 					environment,
@@ -150,6 +151,7 @@ export default function octaneLoader(source, inputSourceMap) {
 					dev,
 					profile,
 					...(clientOnlyImports.length > 0 ? { clientOnlyImports } : null),
+					...(isDescriptorChildrenImport === null ? null : { isDescriptorChildrenImport }),
 					...cssModuleConstants?.transformOptions,
 				});
 
@@ -191,22 +193,31 @@ export default function octaneLoader(source, inputSourceMap) {
 			environment === 'server' && typeof compiler.clientReferenceForFile === 'function'
 				? compiler.clientReferenceForFile(id)
 				: null;
-		if (
+		const needsServerImports =
 			environment === 'server' &&
 			currentReference === null &&
-			typeof this.getResolve === 'function'
-		) {
-			const requests = compiler.findServerImportRequests(authoredSource, id);
-			if (requests.length > 0) {
-				const asyncCallback = this.async?.() ?? callback;
-				resolveClientOnlyImports(this, compiler, authoredSource, id).then(
-					(imports) => finish(imports, asyncCallback),
-					(error) => asyncCallback(error instanceof Error ? error : new Error(String(error))),
-				);
-				return;
-			}
+			typeof this.getResolve === 'function';
+		const requests = needsServerImports
+			? compiler.findServerImportRequests(authoredSource, id)
+			: [];
+		const mayUseDescriptorImports =
+			typeof this.getResolve === 'function' &&
+			(environment !== 'server' || currentReference === null) &&
+			/\.(?:tsrx|tsx)$/.test(cleanModuleId(id)) &&
+			/<\s*[A-Z_$]/.test(authoredSource) &&
+			authoredSource.includes('import');
+		if (requests.length > 0 || mayUseDescriptorImports) {
+			const asyncCallback = this.async?.() ?? callback;
+			Promise.all([
+				requests.length > 0 ? resolveClientOnlyImports(this, compiler, authoredSource, id) : [],
+				mayUseDescriptorImports ? loadDescriptorChildrenImports(this, authoredSource, id) : null,
+			]).then(
+				([imports, descriptorImport]) => finish(imports, descriptorImport, asyncCallback),
+				(error) => asyncCallback(error instanceof Error ? error : new Error(String(error))),
+			);
+			return;
 		}
-		finish([], callback);
+		finish([], null, callback);
 	} catch (error) {
 		this.callback(error instanceof Error ? error : new Error(String(error)));
 	}