octane 0.13.3 → 0.13.5

package/dist/cjs/version.cjs

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

package/dist/compiler/compile.js

@@ -3872,7 +3872,9 @@ const CALCULATION_VALUE_PROOFS = [
  * a pure projection from template evaluation to the end of setup is
  * unobservable. Positions whose evaluation is conditional or deferred keep
  * their expression: directive arms, component children (the child decides
- * whether and when they render), and built-in boundaries. An expression holding
+ * whether and when they render), and built-in boundaries. Already-evaluated
+ * named literals can still be read at eligible props inside component children;
+ * only their identifier reads are collected there. An expression holding
  * JSX keeps its list and descriptor lowering, and event handlers and keys keep
  * their wiring. Ref arrays use the same identity proof as props. A render tree that writes to anything keeps its whole
  * evaluation order.
@@ -3880,34 +3882,34 @@ const CALCULATION_VALUE_PROOFS = [
  * Returns null when nothing moves; otherwise the copy-on-write render nodes,
  * the declarations to append, and their names.
  */
-function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates) {
+function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates, literalsOnly = false) {
 	if ((!ctx.strongMemo && !ctx.strongLiteralMemo) || ctx.nativeReads || !ctx.currentComponentLocals)
 		return null;
 	if (renderTreeWrites(jsxNodes)) return null;
 	const declarations = [];
 	const names = [];
 	const literalReads = new Map();
-	const nodes = mapNodes(jsxNodes, visitNode);
+	const nodes = mapNodes(jsxNodes, (node) => visitNode(node, false));
 	return declarations.length === 0 && literalReads.size === 0
 		? null
 		: { jsxNodes: nodes, declarations, names, literalReads };
 
-	function visitNode(node) {
+	function visitNode(node, deferred) {
 		switch (node?.type) {
 			case 'JSXElement':
-				return visitElement(node);
+				return visitElement(node, deferred);
 			case 'JSXFragment': {
-				const children = mapNodes(node.children, visitNode);
+				const children = mapNodes(node.children, (child) => visitNode(child, deferred));
 				return children === node.children ? node : { ...node, children };
 			}
 			case 'JSXExpressionContainer':
-				return visitContainer(node);
+				return deferred ? node : visitContainer(node);
 			default:
 				return node;
 		}
 	}
 
-	function visitElement(node) {
+	function visitElement(node, deferred) {
 		const opening = node.openingElement;
 		const tag = opening?.name;
 		const component = isComponentTag(node);
@@ -3942,11 +3944,12 @@ function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates) {
 				return attribute;
 			if (!component && /^on[A-Z]/.test(name)) return attribute;
 			if (attribute.value?.type !== 'JSXExpressionContainer') return attribute;
-			const value = visitContainer(attribute.value, true);
+			const value = visitContainer(attribute.value, true, deferred);
 			return value === attribute.value ? attribute : { ...attribute, value };
 		});
-		// Component children render inside the child, if at all.
-		const children = component ? node.children : mapNodes(node.children, visitNode);
+		// Component children own evaluation. Discover named reads without moving
+		// any expression from those children into the parent's render.
+		const children = mapNodes(node.children, (child) => visitNode(child, deferred || component));
 		if (attributes === opening.attributes && children === node.children) return node;
 		return {
 			...node,
@@ -3955,7 +3958,7 @@ function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates) {
 		};
 	}
 
-	function visitContainer(container, prop = false) {
+	function visitContainer(container, prop = false, deferred = false) {
 		const expression = container.expression;
 		const inner = unwrapTsExpr(expression);
 		if (!inner || inner.type === 'JSXEmptyExpression' || containsJsxNode(inner)) return container;
@@ -3964,6 +3967,7 @@ function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates) {
 			if (!nodes) literalReads.set(inner.name, (nodes = new Set()));
 			nodes.add(inner);
 		}
+		if (deferred) return container;
 		const calculation = autoCalculationOf(
 			inner,
 			null,
@@ -3973,7 +3977,7 @@ function hoistStrongRenderCalculations(jsxNodes, ctx, immutableStates) {
 		);
 		if (
 			calculation === null ||
-			(!ctx.strongMemo && !calculation.literal) ||
+			((literalsOnly || !ctx.strongMemo) && !calculation.literal) ||
 			(calculation.literal && !prop)
 		) {
 			return container;
@@ -17920,9 +17924,11 @@ function compileFunctionBody(node, ctx, name, parentNs = 'html', cssHash = null,
 	let warmThunk = null;
 	let staticChildOnly = false;
 	let hoistedCalculations = null;
-	if (options && options.autoCallback) {
-		const creations = [];
-		const warmChildren = [];
+	const componentBody = options?.autoCallback === true;
+	const literalsOnly = !componentBody && options?.memoizeRenderLiterals === true;
+	const creations = [];
+	const warmChildren = [];
+	if (componentBody) {
 		// Pass A′ first: use()-fed const chains memoize at their declarations,
 		// so Pass A then sees their trivial identifier arguments as already
 		// stable and the warm plan includes the chain heads. Param names feed
@@ -17938,62 +17944,75 @@ function compileFunctionBody(node, ctx, name, parentNs = 'html', cssHash = null,
 			creations,
 			puParamNames,
 		);
-		// Auto-calculation runs AFTER Pass A′ so use()-fed chains keep their
-		// Symbol-slot treatment (their rewritten inits are hook-shaped and are
-		// skipped here), and BEFORE Pass A/B so the numeric-slot useMemo it mints is
-		// lowered by the authored inline tier rather than re-wrapped. Client only:
-		// a server render evaluates each body once, so a cache is pure overhead.
-		if (ctx.currentComponentLocals && ctx.mode !== 'server') {
-			// Strong inline render expressions become calculations too (#1610). A
-			// returned-output body lowers its JSX into a record whose holes may be
-			// evaluated later, so it keeps them inline.
-			const hoisted = returnedOutput
-				? null
-				: hoistStrongRenderCalculations(jsxNodes, ctx, immutableStateProvenance);
-			if (hoisted !== null) {
-				jsxNodes = hoisted.jsxNodes;
-				hoistedCalculations = hoisted.declarations;
-				workingStatements = [...workingStatements, ...hoistedCalculations];
-				ctx.currentComponentLocals = new Set([...ctx.currentComponentLocals, ...hoisted.names]);
-			}
-			const renderReadNames = closeCalculationReads(
-				workingStatements,
-				collectRenderReadNames(jsxNodes, ctx),
-				ctx.currentComponentLocals,
-				ctx,
-				immutableStateProvenance,
-				hoisted?.literalReads,
-				jsxNodes,
-			);
-			if (renderReadNames.size > 0) {
-				workingStatements = workingStatements.map((statement) => {
-					const rewritten = rewriteAutoCalculation(
+	}
+	// Auto-calculation runs AFTER Pass A′ so use()-fed chains keep their
+	// Symbol-slot treatment (their rewritten inits are hook-shaped and are
+	// skipped here), and BEFORE Pass A/B so the numeric-slot useMemo it mints is
+	// lowered by the authored inline tier rather than re-wrapped. Client only:
+	// a server render evaluates each body once, so a cache is pure overhead.
+	if (
+		(componentBody || (literalsOnly && ctx.strongLiteralMemo)) &&
+		ctx.currentComponentLocals &&
+		ctx.mode !== 'server'
+	) {
+		// Strong inline render expressions become calculations too (#1610). A
+		// returned-output body lowers its JSX into a record whose holes may be
+		// evaluated later, so it keeps them inline.
+		const hoisted = returnedOutput
+			? null
+			: hoistStrongRenderCalculations(jsxNodes, ctx, immutableStateProvenance, literalsOnly);
+		if (hoisted !== null) {
+			jsxNodes = hoisted.jsxNodes;
+			hoistedCalculations = hoisted.declarations;
+			workingStatements = [...workingStatements, ...hoistedCalculations];
+			ctx.currentComponentLocals = new Set([...ctx.currentComponentLocals, ...hoisted.names]);
+		}
+		const renderReadNames = closeCalculationReads(
+			workingStatements,
+			collectRenderReadNames(jsxNodes, ctx),
+			ctx.currentComponentLocals,
+			ctx,
+			immutableStateProvenance,
+			hoisted?.literalReads,
+			jsxNodes,
+		);
+		if (renderReadNames.size > 0) {
+			workingStatements = workingStatements.map((statement) => {
+				// A construct helper inherits only the literal cache. Ordinary
+				// calculations and callback stability still require component ownership.
+				if (literalsOnly) {
+					const init = unwrapTsExpr(calculationDeclarator(statement)?.init);
+					if (init?.type !== 'ObjectExpression' && init?.type !== 'ArrayExpression')
+						return statement;
+				}
+				const rewritten = rewriteAutoCalculation(
+					statement,
+					ctx.currentComponentLocals,
+					renderReadNames,
+					ctx,
+					immutableStateProvenance,
+				);
+				if (
+					rewritten !== statement &&
+					rewritten.declarations[0].init.callee._octaneImmutableArrayFilter !== undefined
+				) {
+					hasImmutableArrayProjection = true;
+				}
+				if (ctx.autoMemo && rewritten !== statement) {
+					(autoCalculatedDeclarations ??= new Map()).set(
+						statement.declarations[0].id.name,
 						statement,
-						ctx.currentComponentLocals,
-						renderReadNames,
-						ctx,
-						immutableStateProvenance,
-					);
-					if (
-						rewritten !== statement &&
-						rewritten.declarations[0].init.callee._octaneImmutableArrayFilter !== undefined
-					) {
-						hasImmutableArrayProjection = true;
-					}
-					if (ctx.autoMemo && rewritten !== statement) {
-						(autoCalculatedDeclarations ??= new Map()).set(
-							statement.declarations[0].id.name,
-							statement,
-						);
-					}
-					return rewritten;
-				});
-				if (ctx.nativeReads)
-					workingStatements = workingStatements.flatMap(
-						(statement) => lowerNativeAutoCalculation(statement, ctx, name) ?? [statement],
 					);
-			}
+				}
+				return rewritten;
+			});
+			if (ctx.nativeReads)
+				workingStatements = workingStatements.flatMap(
+					(statement) => lowerNativeAutoCalculation(statement, ctx, name) ?? [statement],
+				);
 		}
+	}
+	if (componentBody) {
 		workingStatements = parallelUseMemoizePass(workingStatements, ctx, name, creations, [], null);
 		jsxNodes = parallelUseWalkJsx(jsxNodes, ctx, name, creations, warmChildren, [], new Set());
 		const warm = buildWarmArtifacts(node, ctx, name, creations, warmChildren);
@@ -33741,6 +33760,9 @@ function hoistBodyHelper(
 		if (!free.has('arguments') && !free.has('eval')) inheritedEnvNames = envNames;
 	}
 	const helperOptions = {
+		// Only construct blocks provide an entered render scope. Component
+		// children have envNames === null and may be evaluated by their caller.
+		memoizeRenderLiterals: envNames !== null && !mappedItem,
 		keyedSelection,
 		inlineBindingGuards,
 		mappedItem,

package/dist/node/version.js

@@ -1,4 +1,4 @@
-const version = "0.13.3";
+const version = "0.13.5";
 export {
   version
 };

package/dist/version.js

@@ -1,4 +1,4 @@
-const version = "0.13.3";
+const version = "0.13.5";
 export {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octane",
-  "version": "0.13.3",
+  "version": "0.13.5",
   "license": "MIT",
   "type": "module",
   "sideEffects": [