@xaendar/compiler 0.7.25 → 0.7.27

package/dist/xaendar-compiler.es.js

@@ -342,45 +342,12 @@ 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) {
-	return emitNode(expression, expression, compilerContext, mapDefaultOptions(options));
+	let actualCompilerContext;
+	let actualOptions;
+	if (compilerContext instanceof CompilerContext) actualCompilerContext = compilerContext;
+	else actualOptions = compilerContext;
+	return emitNode(expression, expression, actualCompilerContext, mapDefaultOptions(actualOptions));
 }
 /**
 * Emits the resolved text for a node.
@@ -395,8 +362,10 @@ function resolveExpression(expression, compilerContext, options) {
 function emitNode(node, parent, compilerContext, options) {
 	if (isIdentifier(node) && needsResolution(node, parent)) {
 		const text = node.text;
-		if (compilerContext.hasUnresolvableIdentifier(text) || options.skipResolution) return text;
-		return resolveIdentifierAccess(text, compilerContext, options.resolver);
+		if (compilerContext?.hasUnresolvableIdentifier(text) || options.skipResolution) return text;
+		if (options.resolver) return `${options.resolver}.${text}`;
+		if (compilerContext) return resolveIdentifierAccess(text, compilerContext);
+		return text;
 	}
 	if (!containsResolvableIdentifier(node, parent)) return node.getText();
 	const sourceText = node.getSourceFile().text;
@@ -427,13 +396,13 @@ function emitNode(node, parent, compilerContext, options) {
 * @param compilerContext - The active template scope context.
 * @returns The generated code expression that yields the identifier's value.
 */
-function resolveIdentifierAccess(text, compilerContext, resolver) {
+function resolveIdentifierAccess(text, compilerContext) {
 	if (compilerContext.hasIdentifier(text)) {
 		const kind = compilerContext.getIdentifierKind(text);
 		const access = `context.get('${text}')`;
 		return kind === "signal" ? `${access}()` : access;
 	}
-	return `${resolver}.${text}`;
+	return text;
 }
 /**
 * Returns true if the subtree rooted at `node` contains at least one
@@ -2909,18 +2878,17 @@ var Parser = class {
 * `TypeChecker` for why) — attribute expressions and event calls are
 * emitted as bare statements, validated in place.
 */
-function typeCheckElement(node, context, index, processNode) {
+function typeCheckElement(node, processNode) {
 	const lines = [];
 	node.attributes.forEach(({ value }) => {
-		if (typeof value !== "string") lines.push(`${resolveExpression(value.expression, context, { resolver: "root" })};`);
+		if (typeof value !== "string") lines.push(`${resolveExpression(value.expression, { resolver: "root" })};`);
 	});
-	context.addUnresolvableIdentifier("$event");
 	node.events.forEach(({ handler, parameters }) => {
-		const args = parameters.map((parameter) => resolveExpression(parameter, context, { resolver: "root" })).join(", ");
+		const args = parameters.map((parameter) => resolveExpression(parameter, { resolver: "root" })).join(", ");
 		lines.push(`root.${handler}(${args});`);
 	});
 	node.children.forEach((child, i) => {
-		lines.push(...processNode(child, context, i.toString()));
+		lines.push(...processNode(child));
 	});
 	return lines;
 }
@@ -2936,31 +2904,22 @@ function typeCheckElement(node, context, index, processNode) {
 * exactly like it would for a loop written by hand — with no synthetic
 * function boundary needed.
 */
-function typeCheckFor(node, context, index, processNode) {
-	const iterableExpr = context.hasIdentifier(node.iterableSource) ? node.iterableSource : `root.${node.iterableSource}`;
+function typeCheckFor(node, processNode) {
 	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 forContext = new CompilerContext([
-		node.itemAlias,
-		[indexName, "signal"],
-		[firstName, "signal"],
-		[lastName, "signal"],
-		[evenName, "signal"],
-		[oddName, "signal"]
-	], context);
 	const lines = [];
-	lines.push(`for (const ${node.itemAlias} of ${iterableExpr}) {`);
+	lines.push(`for (const ${node.itemAlias} of root.${node.iterableSource}) {`);
 	lines.push(...indent([
 		`let ${indexName}!: number;`,
 		`let ${firstName}!: boolean;`,
 		`let ${lastName}!: boolean;`,
 		`let ${evenName}!: boolean;`,
 		`let ${oddName}!: boolean;`,
-		`${resolveExpression(node.trackExpression, forContext, { resolver: "root" })};`,
-		...node.children.flatMap((child, i) => processNode(child, forContext, i.toString()))
+		`${resolveExpression(node.trackExpression, { skipResolution: true })};`,
+		...node.children.flatMap((child, i) => processNode(child))
 	]));
 	lines.push("}");
 	return lines;
@@ -2993,26 +2952,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, context, index, processNode) {
+function typeCheckIf(node, processNode) {
 	const lines = [];
-	const condition = resolveExpression(node.conditionNode, context, { resolver: "root" });
-	const ifContext = new CompilerContext([], context);
+	const condition = resolveExpression(node.conditionNode, { resolver: "root" });
 	lines.push(`if (${condition}) {`);
-	lines.push(...indent(node.children.flatMap((child, i) => processNode(child, ifContext, i.toString()))));
+	lines.push(...indent(node.children.flatMap((child) => processNode(child))));
 	lines.push("}");
 	let alt = node.alternate;
 	while (alt?.type === ASTNodeType.ElseIf) {
-		const elseIfCondition = resolveExpression(alt.conditionNode, context, { resolver: "root" });
-		const elseIfContext = new CompilerContext([], context);
+		const elseIfCondition = resolveExpression(alt.conditionNode, { resolver: "root" });
 		lines.push(`else if (${elseIfCondition}) {`);
-		lines.push(...indent(alt.children.flatMap((child, i) => processNode(child, elseIfContext, i.toString()))));
+		lines.push(...indent(alt.children.flatMap((child) => processNode(child))));
 		lines.push("}");
 		alt = alt.alternate;
 	}
 	if (alt) {
-		const elseContext = new CompilerContext([], context);
 		lines.push("else {");
-		lines.push(...indent(alt.children.flatMap((child, i) => processNode(child, elseContext, i.toString()))));
+		lines.push(...indent(alt.children.flatMap((child) => processNode(child))));
 		lines.push("}");
 	}
 	return lines;
@@ -3034,15 +2990,14 @@ function typeCheckIf(node, context, index, processNode) {
 * emitted as stacked `case` labels sharing that same body, matching real
 * JS/TS fallthrough syntax directly.
 */
-function typeCheckSwitch(node, context, index, processNode) {
-	const lines = [`switch (${resolveExpression(node.expression, context, { resolver: "root" })}) {`];
+function typeCheckSwitch(node, processNode) {
+	const lines = [`switch (${resolveExpression(node.expression, { resolver: "root" })}) {`];
 	node.children.forEach((caseNode, i) => {
-		const caseContext = new CompilerContext([], context);
 		if (caseNode.condition?.length) caseNode.condition.forEach((conditionValue) => {
 			lines.push(`  case ${conditionValue}:`);
 		});
 		else lines.push("  default:");
-		lines.push(...indent(indent([...caseNode.children.flatMap((child, ci) => processNode(child, caseContext, ci.toString())), "break;"])));
+		lines.push(...indent(indent([...caseNode.children.flatMap((child) => processNode(child)), "break;"])));
 	});
 	lines.push("}");
 	return lines;
@@ -3056,8 +3011,8 @@ function typeCheckSwitch(node, context, index, 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, context, index, processNode) {
-	return node.type === ASTNodeType.Interpolation ? [`${resolveExpression(node.expression, context, { resolver: "root" })};`] : [];
+function typeCheckTextAndInterpolation(node, _processNode) {
+	return node.type === ASTNodeType.Interpolation ? [`${resolveExpression(node.expression, { resolver: "root" })};`] : [];
 }
 //#endregion
 //#region ../packages/compiler/src/type-checker/type-checker.ts
@@ -3107,8 +3062,7 @@ var TypeChecker = class {
 	* relevant if the consuming project has `noUnusedLocals` enabled.
 	*/
 	generate() {
-		const context = new CompilerContext();
-		const body = this._ast.flatMap((node, i) => this._processNode(node, context, i.toString()));
+		const body = this._ast.flatMap((node, i) => this._processNode(node));
 		return [
 			"function typeCheck() {",
 			...indent(body.some((line) => line.includes("$event")) ? ["let $event!: Event;", ...body] : body),
@@ -3120,10 +3074,10 @@ var TypeChecker = class {
 	* back down as `processNode` so state functions can recurse into their
 	* own children inline.
 	*/
-	_processNode = (node, context, index) => {
+	_processNode = (node) => {
 		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, context, index, this._processNode);
+		return state(node, this._processNode);
 	};
 };
 //#endregion

package/package.json

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