@xaendar/compiler 0.7.28 → 0.7.30

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.
@@ -2879,17 +2912,17 @@ var Parser = class {
 * emitted as bare statements, validated in place.
 */
 function typeCheckElement(node, processNode, context) {
-	const lines = [];
+	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 eventContext = new CompilerContext([], context);
+		eventContext.addUnresolvableIdentifier("$event");
+		const args = parameters.map((parameter) => resolveExpression(parameter, eventContext, { resolver: "root" })).join(", ");
 		lines.push(`root.${handler}(${args});`);
 	});
-	node.children.forEach((child, i) => {
-		lines.push(...processNode(child, context));
-	});
+	node.children.forEach((child) => lines.push(...processNode(child, context)));
 	return lines;
 }
 //#endregion
@@ -2919,7 +2952,7 @@ function typeCheckFor(node, processNode, context) {
 		oddName,
 		node.itemAlias
 	].forEach((identifier) => forContext.addUnresolvableIdentifier(identifier));
-	const lines = [];
+	const lines = new Array();
 	lines.push(`for (const ${node.itemAlias} of root.${node.iterableSource}) {`);
 	lines.push(...indent([
 		`let ${indexName}!: number;`,
@@ -2927,8 +2960,8 @@ function typeCheckFor(node, processNode, context) {
 		`let ${lastName}!: boolean;`,
 		`let ${evenName}!: boolean;`,
 		`let ${oddName}!: boolean;`,
-		`${resolveExpression(node.trackExpression, { skipResolution: true })};`,
-		...node.children.flatMap((child) => processNode(child, context))
+		`${resolveExpression(node.trackExpression, context, { skipResolution: true })};`,
+		...node.children.flatMap((child) => processNode(child, forContext))
 	]));
 	lines.push("}");
 	return lines;
@@ -2962,14 +2995,14 @@ function resolveImplicit(node, implicit) {
 * flat sibling functions could never express.
 */
 function typeCheckIf(node, processNode, context) {
-	const lines = [];
-	const condition = resolveExpression(node.conditionNode, { resolver: "root" });
+	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, 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, context))));
 		lines.push("}");
@@ -3000,7 +3033,7 @@ function typeCheckIf(node, processNode, context) {
 * JS/TS fallthrough syntax directly.
 */
 function typeCheckSwitch(node, processNode, context) {
-	const lines = [`switch (${resolveExpression(node.expression, { resolver: "root" })}) {`];
+	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;"])));
@@ -3017,8 +3050,8 @@ function typeCheckSwitch(node, processNode, context) {
 * 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, _context) {
-	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
@@ -3068,10 +3101,9 @@ var TypeChecker = class {
 	* relevant if the consuming project has `noUnusedLocals` enabled.
 	*/
 	generate() {
-		const body = this._ast.flatMap((node) => this._processNode(node));
 		return [
 			"function typeCheck() {",
-			...indent(body.some((line) => line.includes("$event")) ? ["let $event!: Event;", ...body] : body),
+			...indent(this._ast.flatMap((node) => this._processNode(node))),
 			"}"
 		].join("\n");
 	}

package/package.json

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