octane 0.2.4 → 0.2.6

package/dist/cjs/runtime.server.cjs

@@ -33,6 +33,7 @@ __export(runtime_server_exports, {
   addTransitionType: () => addTransitionType,
   beginNativeReadScope: () => beginNativeReadScope,
   beginNativeReadWitness: () => beginNativeReadWitness,
+  callWithReceiver: () => callWithReceiver,
   cloneElement: () => cloneElement,
   createContext: () => createContext,
   createElement: () => createElement,
@@ -967,9 +968,13 @@ function ssrComponentDescriptor(d, scope) {
   if (SCOPED_ELEMENT_PROPS.has(d.props)) {
     return ssrComponent(scope, d.type, d.props);
   }
+  const children = d.children;
+  if (children == null || children === d.props?.children) {
+    return ssrComponent(scope, d.type, d.props);
+  }
   return ssrComponent(scope, d.type, {
     ...d.props,
-    children: d.children ?? d.props?.children
+    children
   });
 }
 function ssrChild(v, scope) {
@@ -1601,7 +1606,7 @@ function ssrAttrs(sources, tag, namespace = "html", skipFormControls = false) {
       record(name, source[name]);
     }
   }
-  if (process.env.NODE_ENV === "production") {
+  if (process.env.NODE_ENV === "production" && classMerges === null) {
     let canonical = true;
     for (const name of props.keys()) {
       if (normalizeSsrAttributeName(name, tag, namespace) !== name || namespace === "html" && name.toLowerCase() !== name) {
@@ -3660,6 +3665,9 @@ function manualHook(fn, name) {
   Object.defineProperty(provider, "length", { value: fn.length, configurable: true });
   return provider;
 }
+function callWithReceiver(fn, receiver, ...args) {
+  return NATIVE_REFLECT_APPLY(fn, receiver, args);
+}
 function withSlot(sym, fn, ...args) {
   const driver = MANUAL_HOOK_DRIVER;
   const pending = driver?.pending;
@@ -3844,14 +3852,14 @@ function serializeSuspenseSeedJson(values) {
     return value;
   }).replace(/</g, "\\u003c");
 }
-function serializeSuspenseSeeds(values, nonceAttr) {
+function serializeSuspenseSeeds(values, nonceAttr, attr = import_constants.SUSPENSE_SCRIPT_ATTR) {
   const json = serializeSuspenseSeedJson(values);
   if (json === "[]") return "";
-  return '<script type="application/json" ' + import_constants.SUSPENSE_SCRIPT_ATTR + nonceAttr + ">" + json + "</script>";
+  return '<script type="application/json" ' + attr + nonceAttr + ">" + json + "</script>";
 }
-function serializeNativeSignalSeeds(signals, nonceAttr) {
+function serializeNativeSignalSeeds(signals, nonceAttr, attr = import_native_read_seeds.NATIVE_SIGNAL_SEED_ATTR) {
   const json = JSON.stringify(signals).replace(/</g, "\\u003c");
-  return '<script type="application/json" ' + import_native_read_seeds.NATIVE_SIGNAL_SEED_ATTR + nonceAttr + ">" + json + "</script>";
+  return '<script type="application/json" ' + attr + nonceAttr + ">" + json + "</script>";
 }
 function newResolvedMap(resourceOptions) {
   const m = /* @__PURE__ */ new Map();
@@ -4846,6 +4854,14 @@ function ssrTry(scope, siteKey, tryFn, pendFn, catchFn, namespace = FRAME?.names
         return pendingForm();
       }
       appendNativeSeedReads(nativeReads);
+      if (MARKERS && pendFn !== null) {
+        const idCount = ID_COUNTER - outerIdCounter;
+        const seeds = SERIAL === null ? [] : SERIAL.splice(serialStart);
+        const native = NATIVE_READ_COLLECTOR?.serialize(nativeReads);
+        return ssrBlock(
+          `<!--${import_constants.SUSPENSE_RESOLVED_COMMENT}${idCount}-->` + (seeds.length === 0 ? "" : serializeSuspenseSeeds(seeds, NONCE_ATTR, import_constants.SUSPENSE_RESOLVED_SEED_ATTR)) + (native === void 0 ? "" : serializeNativeSignalSeeds(native, NONCE_ATTR, import_constants.SUSPENSE_RESOLVED_NATIVE_ATTR)) + inner
+        );
+      }
       return ssrBlock(inner);
     } catch (e) {
       nativeFresh = NATIVE_SERVER_FAILURES !== nativeFailureStart;
@@ -6178,6 +6194,7 @@ function preinitModule(href, options) {
   addTransitionType,
   beginNativeReadScope,
   beginNativeReadWitness,
+  callWithReceiver,
   cloneElement,
   createContext,
   createElement,

package/dist/cjs/version.cjs

@@ -21,7 +21,7 @@ __export(version_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(version_exports);
-const version = "0.2.4";
+const version = "0.2.6";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version

package/dist/compiler/bundler.js

@@ -1299,7 +1299,13 @@ class OctaneBundlerCompiler {
 				return passThrough();
 			}
 			const manualSlots = this._hasManualHookSlots(file, collected);
-			if (!hasHookRuntimeImport && !manualSlots) return passThrough();
+			if (
+				!hasHookRuntimeImport &&
+				!manualSlots &&
+				!pragmaOwned &&
+				!this._pragmaClaimsOwnership(code)
+			)
+				return passThrough();
 			const inlinePlainMemo =
 				inlineHookMemo &&
 				environment === 'client' &&

package/dist/compiler/compile.js

@@ -7583,6 +7583,18 @@ function isTypeOnlyStatement(node) {
 	}
 	// `declare const/let/var/function/class/module/namespace …` — ambient, no emit.
 	if (node.declare === true) return true;
+	// Component/type declaration merging often uses a namespace containing only
+	// types. Like an interface, it must disappear from the emitted JavaScript.
+	// Keep value namespaces and Octane's `module server` dialect on their own paths.
+	if (node.type === 'TSModuleDeclaration' && node.kind === 'namespace') {
+		if (node.body?.type === 'TSModuleDeclaration') return isTypeOnlyStatement(node.body);
+		if (node.body?.type === 'TSModuleBlock') {
+			return node.body.body.every(
+				(statement) =>
+					isTypeOnlyStatement(statement) || stripTypeOnlySpecifiers(statement) === null,
+			);
+		}
+	}
 	// `import type { … } from …`
 	if (node.type === 'ImportDeclaration' && node.importKind === 'type') return true;
 	// `export type { … }`, `export type X = …`, `export interface I {}`

package/dist/compiler/hook-methods.js

@@ -0,0 +1,164 @@
+import { builders as b } from '@tsrx/core';
+
+function unwrapNonNullExpression(node) {
+	while (node?.type === 'TSNonNullExpression') node = node.expression;
+	return node;
+}
+
+/** Static hook methods need a call boundary, never an extra positional argument. */
+export function hookMethodName(node, hookLocals) {
+	if (
+		node?.type !== 'CallExpression' ||
+		node._octaneImportedHook ||
+		node._octaneHookRuntimeImportedHook
+	)
+		return null;
+	const callee = unwrapNonNullExpression(node.callee);
+	// Namespace calls are owned by the lexical import analysis. If it did not
+	// mark this call, the namespace is shadowed and must retain ordinary JS behavior.
+	if (callee?.object?.type === 'Identifier' && hookLocals?.get(callee.object.name) === '*')
+		return null;
+	return callee?.type === 'MemberExpression' &&
+		!callee.computed &&
+		callee.property?.type === 'Identifier' &&
+		/^use[A-Z]/.test(callee.property.name)
+		? callee.property.name
+		: null;
+}
+
+export function hasHookMethods(node) {
+	if (!node || typeof node !== 'object') return false;
+	if (Array.isArray(node)) return node.some(hasHookMethods);
+	if (hookMethodName(node) !== null) return true;
+	return Object.keys(node).some(
+		(key) => key !== 'loc' && key !== 'metadata' && hasHookMethods(node[key]),
+	);
+}
+
+// The call boundary is synchronous. Moving a suspension expression into its
+// callback would produce invalid JavaScript; nested callbacks keep their own
+// lexical function scope and are safe to pass as ordinary arguments.
+export function assertSynchronousHookMethod(node) {
+	function suspends(value) {
+		if (!value || typeof value !== 'object') return false;
+		if (Array.isArray(value)) return value.some(suspends);
+		if (value.type === 'AwaitExpression' || value.type === 'YieldExpression') return true;
+		if (
+			value.type === 'ArrowFunctionExpression' ||
+			value.type === 'FunctionExpression' ||
+			value.type === 'FunctionDeclaration'
+		)
+			return false;
+		return Object.keys(value).some(
+			(key) => key !== 'loc' && key !== 'metadata' && suspends(value[key]),
+		);
+	}
+	if (suspends(node)) {
+		throw new SyntaxError(
+			'An Octane hook method cannot contain await or yield in its receiver or arguments. Evaluate the suspended expression before calling the hook method.',
+		);
+	}
+}
+
+// A call boundary inside a ChainExpression would end its short-circuit region.
+// Lower only affected chains, sharing the guard/receiver rules between emitters.
+export function lowerHookMethodChain(chain, options, deleting = false) {
+	if (chain?.type !== 'ChainExpression') return null;
+	const links = [];
+	let base = chain.expression;
+	while (
+		base.type === 'MemberExpression' ||
+		base.type === 'CallExpression' ||
+		base.type === 'TSNonNullExpression'
+	) {
+		links.unshift(base);
+		base =
+			base.type === 'MemberExpression'
+				? base.object
+				: base.type === 'CallExpression'
+					? base.callee
+					: base.expression;
+	}
+	const firstOptional = links.findIndex((link) => link.optional);
+	if (
+		firstOptional === -1 ||
+		!links.slice(firstOptional).some((link) => hookMethodName(link, options.locals) !== null)
+	)
+		return null;
+	assertSynchronousHookMethod(chain);
+	base =
+		links[firstOptional].type === 'MemberExpression'
+			? links[firstOptional].object
+			: links[firstOptional].callee;
+	const steps = links.slice(firstOptional);
+	const skipped = deleting ? b.literal(true) : b.void0;
+	function scope(value, next) {
+		const local = b.id(options.allocateName('_oc$'));
+		return b.call(b.arrow([local], next(local)), value);
+	}
+	function guard(value, next) {
+		return b.conditional(
+			b.logical('||', b.binary('===', value, b.literal(null)), b.binary('===', value, b.void0)),
+			skipped,
+			next(value),
+		);
+	}
+	const properties = new Map();
+	function member(object, link) {
+		if (link.computed && !properties.has(link)) properties.set(link, options.visit(link.property));
+		return {
+			...link,
+			object,
+			property: link.computed ? properties.get(link) : link.property,
+			optional: false,
+		};
+	}
+	function proceed(value, index, reference = null) {
+		if (index === steps.length) return deleting ? b.unary('delete', value) : value;
+		const link = steps[index];
+		if (link.type === 'TSNonNullExpression')
+			return proceed({ ...link, expression: value }, index + 1, reference);
+		if (link.type === 'MemberExpression') {
+			const next = (object) => proceed(member(object, link), index + 1, { object, link });
+			return link.optional ? scope(value, (local) => guard(local, next)) : next(value);
+		}
+		const args = () => link.arguments.map(options.visit);
+		const method = hookMethodName(link, options.locals);
+		const invoke = (call) => (method === null ? call : options.wrap(call, link, method));
+		if (!link.optional) {
+			return proceed(
+				invoke({ ...link, callee: value, arguments: args(), optional: false }),
+				index + 1,
+			);
+		}
+		const call = (fn, receiver) =>
+			guard(fn, () =>
+				proceed(invoke(b.call(options.requireReceiver(), fn, receiver, ...args())), index + 1),
+			);
+		if (reference !== null) {
+			if (reference.object.type === 'Super') {
+				return scope(value, (fn) => call(fn, b.this));
+			}
+			return scope(reference.object, (receiver) =>
+				scope(member(receiver, reference.link), (fn) => call(fn, receiver)),
+			);
+		}
+		return scope(value, (fn) => call(fn, b.void0));
+	}
+	const referenceBase = unwrapNonNullExpression(base);
+	const reference =
+		referenceBase.type === 'MemberExpression'
+			? {
+					object:
+						referenceBase.object.type === 'Super'
+							? referenceBase.object
+							: options.visit(referenceBase.object),
+					link: referenceBase,
+				}
+			: null;
+	return proceed(
+		reference === null ? options.visit(base) : member(reference.object, referenceBase),
+		0,
+		reference,
+	);
+}

package/dist/compiler/parser-output.js

@@ -0,0 +1,37 @@
+/** @import { ParseOptions } from '@tsrx/core/types' */
+
+/**
+ * Isolate caller-owned output buffers without changing parser options. An
+ * unsolicited comments array would disable native eager parsing.
+ * @param {ParseOptions} [options]
+ * @param {boolean} [captureErrors]
+ * @returns {ParseOptions | undefined}
+ */
+export function isolateOutputOptions(options, captureErrors = false) {
+	if (!captureErrors && !Array.isArray(options?.errors) && !Array.isArray(options?.comments)) {
+		return options;
+	}
+	const original = options ?? {};
+	const descriptors = Object.getOwnPropertyDescriptors(original);
+	if (captureErrors || Array.isArray(options?.errors)) {
+		descriptors.errors = { value: [], enumerable: true, writable: true, configurable: true };
+	}
+	if (Array.isArray(options?.comments)) {
+		descriptors.comments = { value: [], enumerable: true, writable: true, configurable: true };
+	}
+	return Object.create(Object.getPrototypeOf(original), descriptors);
+}
+
+/**
+ * @param {ParseOptions | undefined} options
+ * @param {ParseOptions | undefined} selected
+ */
+export function publishOutput(options, selected) {
+	if (selected === options) return;
+	if (Array.isArray(options?.errors)) {
+		for (const error of selected?.errors ?? []) options.errors.push(error);
+	}
+	if (Array.isArray(options?.comments)) {
+		for (const comment of selected?.comments ?? []) options.comments.push(comment);
+	}
+}

package/dist/compiler/parser.browser.js

@@ -1 +1,145 @@
-export { parseModule } from '@tsrx/core';
+import { acorn, tsPlugin, getCommentHandlers, parseModule as parseTsrx } from '@tsrx/core';
+import { isolateOutputOptions, publishOutput } from './parser-output.js';
+
+// The TypeScript parser currently enters type context after consuming `{`, so a
+// first generic call signature is tokenized as JSX. Enter before its first token;
+// leave before consuming `}` so the following ordinary JavaScript stays intact.
+const TypeScriptParser = acorn.Parser.extend(
+	tsPlugin({ jsx: true }),
+	(Base) =>
+		class extends Base {
+			tsParseDeclaration(node, value, next) {
+				// `module` has additional TSRX semantics. The compatibility parser must
+				// never reinterpret a server block as an ordinary TypeScript namespace.
+				if (value === 'module') throw new SyntaxError('TSRX module requires the TSRX parser');
+				const declaration = super.tsParseDeclaration(node, value, next);
+				if (value === 'namespace') {
+					for (
+						let current = declaration;
+						current?.type === 'TSModuleDeclaration';
+						current = current.body
+					) {
+						current.kind = 'namespace';
+						current.metadata = { path: [], module_keyword: 'namespace' };
+					}
+				}
+				return declaration;
+			}
+			finishNode(node, type) {
+				const finished = super.finishNode(node, type);
+				if (type === 'TSModuleDeclaration' && finished.global) {
+					finished.kind = 'global';
+					delete finished.global;
+				}
+				return finished;
+			}
+			tsParseInterfaceBody() {
+				const previous = this.inType;
+				let members;
+				this.inType = true;
+				try {
+					this.expect(acorn.tokTypes.braceL);
+					members = this.tsParseList('TypeMembers', this.tsParseTypeMember.bind(this));
+				} finally {
+					this.inType = previous;
+				}
+				this.expect(acorn.tokTypes.braceR);
+				return members;
+			}
+		},
+);
+
+function supportsTypeScriptRetry(program) {
+	let genericSyntax = false;
+	let tsrxSyntax = false;
+	function visit(node, jsxType = false) {
+		if (!node || typeof node !== 'object') return;
+		if (Array.isArray(node)) {
+			for (const child of node) visit(child, jsxType);
+			return;
+		}
+		if (node.type === 'TSCallSignatureDeclaration' && node.typeParameters) genericSyntax = true;
+		if (jsxType && node.type === 'TSQualifiedName') genericSyntax = true;
+		// Raw-text elements and template directives require the TSRX lexer.
+		if (
+			node.type === 'JSXElement' &&
+			!node.openingElement.selfClosing &&
+			['style', 'script'].includes(node.openingElement.name.name)
+		)
+			tsrxSyntax = true;
+		if (node.type === 'JSXText' && node.value.includes('@')) tsrxSyntax = true;
+		for (const [key, child] of Object.entries(node)) {
+			if (key === 'loc' || key === 'metadata' || key.endsWith('Comments')) continue;
+			visit(
+				child,
+				jsxType ||
+					(node.type === 'JSXOpeningElement' &&
+						(key === 'typeParameters' || key === 'typeArguments')),
+			);
+		}
+	}
+	visit(program);
+	return genericSyntax && !tsrxSyntax;
+}
+
+function parseTypeScript(source, options) {
+	const comments = [];
+	const { onComment, add_comments } = getCommentHandlers(source, comments);
+	const keywordTokens = options?.keywordTokens ? [] : null;
+	const program = TypeScriptParser.parse(source, {
+		sourceType: 'module',
+		ecmaVersion: 'latest',
+		locations: true,
+		preserveParens: !!options?.preserveParens,
+		onComment,
+		onToken:
+			keywordTokens === null
+				? undefined
+				: (token) => {
+						const keyword =
+							token.type.keyword === 'function'
+								? 'function'
+								: token.type.label === 'name' && token.value === 'async'
+									? 'async'
+									: null;
+						if (keyword !== null)
+							keywordTokens.push({
+								value: keyword,
+								start: token.start,
+								end: token.end,
+								loc: token.loc,
+							});
+					},
+	});
+	if (!supportsTypeScriptRetry(program))
+		throw new SyntaxError('Unsupported TSRX compatibility retry');
+	add_comments(program);
+	if (keywordTokens !== null) program.tsrx_keyword_tokens = keywordTokens;
+	if (options?.comments) options.comments.push(...comments);
+	return program;
+}
+
+/** Preserve TSRX parsing and recovery; retry rejected ordinary TS/JSX modules. */
+export function parseModule(source, filename, options) {
+	const primary = isolateOutputOptions(options);
+	let program;
+	try {
+		program = parseTsrx(source, filename, primary);
+	} catch (error) {
+		if (!(error instanceof SyntaxError)) {
+			publishOutput(options, primary);
+			throw error;
+		}
+		const alternative = isolateOutputOptions(options, true);
+		try {
+			program = parseTypeScript(source, alternative);
+		} catch (alternativeError) {
+			publishOutput(options, primary);
+			throw alternativeError instanceof SyntaxError ? error : alternativeError;
+		}
+		publishOutput(options, alternative);
+		return program;
+	}
+	publishOutput(options, primary);
+	return program;
+}

package/dist/compiler/parser.node.js

@@ -4,41 +4,7 @@
 import { parseModule as parseNativeModule } from 'oxc-tsrx/tsrx-core-compat';
 import { parseModule as parseJavaScriptModule } from './parser.browser.js';
 
-/**
- * Isolate caller-owned output buffers without changing parser options. An
- * unsolicited comments array would disable native eager parsing.
- * @param {ParseOptions} [options]
- * @param {boolean} [captureErrors]
- * @returns {ParseOptions | undefined}
- */
-function isolateOutputOptions(options, captureErrors = false) {
-	if (!captureErrors && !Array.isArray(options?.errors) && !Array.isArray(options?.comments)) {
-		return options;
-	}
-	const original = options ?? {};
-	const descriptors = Object.getOwnPropertyDescriptors(original);
-	if (captureErrors || Array.isArray(options?.errors)) {
-		descriptors.errors = { value: [], enumerable: true, writable: true, configurable: true };
-	}
-	if (Array.isArray(options?.comments)) {
-		descriptors.comments = { value: [], enumerable: true, writable: true, configurable: true };
-	}
-	return Object.create(Object.getPrototypeOf(original), descriptors);
-}
-
-/**
- * @param {ParseOptions | undefined} options
- * @param {ParseOptions | undefined} selected
- */
-function publishOutput(options, selected) {
-	if (selected === options) return;
-	if (Array.isArray(options?.errors)) {
-		for (const error of selected?.errors ?? []) options.errors.push(error);
-	}
-	if (Array.isArray(options?.comments)) {
-		for (const comment of selected?.comments ?? []) options.comments.push(comment);
-	}
-}
+import { isolateOutputOptions, publishOutput } from './parser-output.js';
 
 /**
  * `<style>` with an expression child — `<style>{css}</style>`, an ordinary

package/dist/compiler/plain-hook-memo.js

@@ -134,6 +134,38 @@ function slotBaseHooks(ast, state, options) {
 	function visit(node) {
 		if (node === null || typeof node !== 'object') return node;
 		if (Array.isArray(node)) return mapChildren(node, visit);
+		if (!options.manualSlots) {
+			const deleting = node.type === 'UnaryExpression' && node.operator === 'delete';
+			const lowered = lowerHookMethodChain(
+				deleting ? node.argument : node,
+				{
+					locals: options.hookLocals,
+					allocateName: (name) => allocName(state, name),
+					visit,
+					requireReceiver: () => requireHelper(state, 'callWithReceiver'),
+					wrap: (call, origin) =>
+						inheritHookMemoOrigin(
+							b.call(
+								requireHelper(state, 'withSlot', 'octane'),
+								allocateHookSlot(state, origin),
+								b.arrow([], call),
+							),
+							origin,
+						),
+				},
+				deleting,
+			);
+			if (lowered !== null) return inheritHookMemoOrigin(lowered, node);
+		}
+		if (!options.manualSlots && hookMethodName(node, options.hookLocals) !== null) {
+			assertSynchronousHookMethod(node);
+			const slot = allocateHookSlot(state, node);
+			const mapped = mapChildren(node, visit);
+			return inheritHookMemoOrigin(
+				b.call(requireHelper(state, 'withSlot', 'octane'), slot, b.arrow([], mapped)),
+				node,
+			);
+		}
 		if (!options.manualSlots && node.type === 'CallExpression' && node._octaneCustomHookCall) {
 			const slot = allocateHookSlot(state, node);
 			const mapped = mapChildren(node, visit);
@@ -348,3 +380,8 @@ export function inlinePlainHookMemos(ast, source, id, options) {
 		return null;
 	}
 }
+import {
+	hookMethodName,
+	assertSynchronousHookMethod,
+	lowerHookMethodChain,
+} from './hook-methods.js';