@xaendar/compiler 0.7.27 → 0.7.29

package/dist/xaendar-compiler.es.js

@@ -342,12 +342,45 @@ var GLOBAL_IDENTIFIERS = /* @__PURE__ */ new Set([
 	"Window"
 ]);
 var ROOT_NODE = "root";
+/**
+* Resolves references to component properties inside a template expression.
+*
+* Identifiers that are not found in the active scope chain and are not
+* well-known globals are prefixed with `this.` so they resolve against
+* the component instance at runtime. Identifiers found in the scope chain
+* are resolved either as a bare local reference (if declared directly in
+* the current generated function's own scope) or via a runtime
+* `parentContext.get(...)` traversal (if inherited from an enclosing
+* scope) — and a trailing `()` is appended in either case if the
+* identifier was declared as a signal, so the generated code always
+* correctly unwraps it.
+*
+* The original formatting of the expression — parentheses, spacing,
+* operator tokens, member access dots — is preserved verbatim by delegating
+* to `node.getText()` for any subtree that contains no resolvable identifiers.
+*
+* @param expression - Either a raw identifier string or a validated
+*   `Expression` node produced by `validateExpression`.
+* @param compilerContext - The active template scope context.
+* @returns The resolved expression as a JavaScript string ready for codegen.
+*
+* @example
+* // Simple identifier
+* resolveExpression('items', context) // → 'this.items'
+*
+* @example
+* // Signal identifier inherited from an ancestor scope (e.g. `$index` in a
+* // nested @for body)
+* resolveExpression('$index', context) // → "parentContext.get('$index')()"
+*
+* @example
+* // Complex expression — formatting preserved
+* resolveExpression(node, context)
+* // typeof id !== 'boolean' || pippo instanceof HTMLElement
+* // → typeof this.id !== 'boolean' || this.pippo instanceof HTMLElement
+*/
 function resolveExpression(expression, compilerContext, options) {
-	let actualCompilerContext;
-	let actualOptions;
-	if (compilerContext instanceof CompilerContext) actualCompilerContext = compilerContext;
-	else actualOptions = compilerContext;
-	return emitNode(expression, expression, actualCompilerContext, mapDefaultOptions(actualOptions));
+	return emitNode(expression, expression, compilerContext, mapDefaultOptions(options));
 }
 /**
 * Emits the resolved text for a node.
@@ -2878,18 +2911,16 @@ var Parser = class {
 * `TypeChecker` for why) — attribute expressions and event calls are
 * emitted as bare statements, validated in place.
 */
-function typeCheckElement(node, processNode) {
-	const lines = [];
+function typeCheckElement(node, processNode, context) {
+	const lines = new Array();
 	node.attributes.forEach(({ value }) => {
-		if (typeof value !== "string") lines.push(`${resolveExpression(value.expression, { resolver: "root" })};`);
+		if (typeof value !== "string") lines.push(`${resolveExpression(value.expression, context, { resolver: "root" })};`);
 	});
 	node.events.forEach(({ handler, parameters }) => {
-		const args = parameters.map((parameter) => resolveExpression(parameter, { resolver: "root" })).join(", ");
+		const args = parameters.map((parameter) => resolveExpression(parameter, context, { resolver: "root" })).join(", ");
 		lines.push(`root.${handler}(${args});`);
 	});
-	node.children.forEach((child, i) => {
-		lines.push(...processNode(child));
-	});
+	node.children.forEach((child) => lines.push(...processNode(child, context)));
 	return lines;
 }
 //#endregion
@@ -2904,13 +2935,22 @@ function typeCheckElement(node, processNode) {
 * exactly like it would for a loop written by hand — with no synthetic
 * function boundary needed.
 */
-function typeCheckFor(node, processNode) {
+function typeCheckFor(node, processNode, context) {
+	const forContext = new CompilerContext([], context);
 	const indexName = resolveImplicit(node, "$index");
 	const firstName = resolveImplicit(node, "$first");
 	const lastName = resolveImplicit(node, "$last");
 	const evenName = resolveImplicit(node, "$even");
 	const oddName = resolveImplicit(node, "$odd");
-	const lines = [];
+	[
+		indexName,
+		firstName,
+		lastName,
+		evenName,
+		oddName,
+		node.itemAlias
+	].forEach((identifier) => forContext.addUnresolvableIdentifier(identifier));
+	const lines = new Array();
 	lines.push(`for (const ${node.itemAlias} of root.${node.iterableSource}) {`);
 	lines.push(...indent([
 		`let ${indexName}!: number;`,
@@ -2918,8 +2958,8 @@ function typeCheckFor(node, processNode) {
 		`let ${lastName}!: boolean;`,
 		`let ${evenName}!: boolean;`,
 		`let ${oddName}!: boolean;`,
-		`${resolveExpression(node.trackExpression, { skipResolution: true })};`,
-		...node.children.flatMap((child, i) => processNode(child))
+		`${resolveExpression(node.trackExpression, context, { skipResolution: true })};`,
+		...node.children.flatMap((child) => processNode(child, forContext))
 	]));
 	lines.push("}");
 	return lines;
@@ -2952,23 +2992,23 @@ function resolveImplicit(node, implicit) {
 * `else if`, TS already knows the first condition was false) — something
 * flat sibling functions could never express.
 */
-function typeCheckIf(node, processNode) {
-	const lines = [];
-	const condition = resolveExpression(node.conditionNode, { resolver: "root" });
+function typeCheckIf(node, processNode, context) {
+	const lines = new Array();
+	const condition = resolveExpression(node.conditionNode, context, { resolver: "root" });
 	lines.push(`if (${condition}) {`);
-	lines.push(...indent(node.children.flatMap((child) => processNode(child))));
+	lines.push(...indent(node.children.flatMap((child) => processNode(child, context))));
 	lines.push("}");
 	let alt = node.alternate;
 	while (alt?.type === ASTNodeType.ElseIf) {
-		const elseIfCondition = resolveExpression(alt.conditionNode, { resolver: "root" });
+		const elseIfCondition = resolveExpression(alt.conditionNode, context, { resolver: "root" });
 		lines.push(`else if (${elseIfCondition}) {`);
-		lines.push(...indent(alt.children.flatMap((child) => processNode(child))));
+		lines.push(...indent(alt.children.flatMap((child) => processNode(child, context))));
 		lines.push("}");
 		alt = alt.alternate;
 	}
 	if (alt) {
 		lines.push("else {");
-		lines.push(...indent(alt.children.flatMap((child) => processNode(child))));
+		lines.push(...indent(alt.children.flatMap((child) => processNode(child, context))));
 		lines.push("}");
 	}
 	return lines;
@@ -2990,14 +3030,11 @@ function typeCheckIf(node, processNode) {
 * emitted as stacked `case` labels sharing that same body, matching real
 * JS/TS fallthrough syntax directly.
 */
-function typeCheckSwitch(node, processNode) {
-	const lines = [`switch (${resolveExpression(node.expression, { resolver: "root" })}) {`];
-	node.children.forEach((caseNode, i) => {
-		if (caseNode.condition?.length) caseNode.condition.forEach((conditionValue) => {
-			lines.push(`  case ${conditionValue}:`);
-		});
-		else lines.push("  default:");
-		lines.push(...indent(indent([...caseNode.children.flatMap((child) => processNode(child)), "break;"])));
+function typeCheckSwitch(node, processNode, context) {
+	const lines = [`switch (${resolveExpression(node.expression, context, { resolver: "root" })}) {`];
+	node.children.forEach((caseNode) => {
+		caseNode.condition?.length ? caseNode.condition.forEach((conditionValue) => lines.push(`  case ${conditionValue}:`)) : lines.push("  default:");
+		lines.push(...indent(indent([...caseNode.children.flatMap((child) => processNode(child, context)), "break;"])));
 	});
 	lines.push("}");
 	return lines;
@@ -3011,8 +3048,8 @@ function typeCheckSwitch(node, processNode) {
 * interpolation's expression is emitted as a bare statement — enough for
 * TS to validate it, with no name needing to be bound to the result.
 */
-function typeCheckTextAndInterpolation(node, _processNode) {
-	return node.type === ASTNodeType.Interpolation ? [`${resolveExpression(node.expression, { resolver: "root" })};`] : [];
+function typeCheckTextAndInterpolation(node, _processNode, context) {
+	return node.type === ASTNodeType.Interpolation ? [`${resolveExpression(node.expression, context, { resolver: "root" })};`] : [];
 }
 //#endregion
 //#region ../packages/compiler/src/type-checker/type-checker.ts
@@ -3062,7 +3099,7 @@ var TypeChecker = class {
 	* relevant if the consuming project has `noUnusedLocals` enabled.
 	*/
 	generate() {
-		const body = this._ast.flatMap((node, i) => this._processNode(node));
+		const body = this._ast.flatMap((node) => this._processNode(node));
 		return [
 			"function typeCheck() {",
 			...indent(body.some((line) => line.includes("$event")) ? ["let $event!: Event;", ...body] : body),
@@ -3074,10 +3111,10 @@ var TypeChecker = class {
 	* back down as `processNode` so state functions can recurse into their
 	* own children inline.
 	*/
-	_processNode = (node) => {
+	_processNode = (node, context) => {
 		const state = this._states[node.type];
 		if (!state) throw new Error(`[Type Checker] No transition function for token type ${ASTNodeType[node.type]}`);
-		return state(node, this._processNode);
+		return state(node, this._processNode, context);
 	};
 };
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xaendar/compiler",
-  "version": "0.7.27",
+  "version": "0.7.29",
   "description": "A library for transpiling Xaendar Templates into JavaScript code",
   "sideEffects": false,
   "type": "module",
@@ -16,8 +16,8 @@
     }
   },
   "dependencies": {
-    "@xaendar/common": "0.7.27",
-    "@xaendar/types": "0.7.27",
+    "@xaendar/common": "0.7.29",
+    "@xaendar/types": "0.7.29",
     "typescript": "^6.0.3"
   }
 }