@xaendar/compiler 0.6.18 → 0.6.20

package/dist/xaendar-compiler.es.js

@@ -1,5 +1,5 @@
 import { Stack, indent } from "@xaendar/common";
-import ts from "typescript";
+import ts, { ScriptTarget, SyntaxKind, createSourceFile, forEachChild, isExpressionStatement, isIdentifier } from "typescript";
 //#region ../packages/compiler/src/lexer/types/lexer-state.enum.ts
 /**
 * Represents the set of states the lexer can be in while processing template input.
@@ -196,7 +196,8 @@ function consumeAttributeValue(cursor, _context) {
 				tokens: [{
 					type: TokenType.ATTRIBUTE_VALUE,
 					parts: [value]
-				}]
+				}],
+				popState: true
 			};
 			break;
 		default:
@@ -384,12 +385,19 @@ function consumeEventParameter(cursor, _context) {
 					parts: [eventParameter]
 				});
 				cursor.advance();
+				cursor.skipSpaces();
 				eventParameter = "";
 			} else eventParameter = addCharacter$2(cursor, eventParameter);
 			break;
 		case 41:
 			cursor.advance();
-			read = false;
+			if (!charDelimiter) {
+				retVal.tokens.push({
+					type: TokenType.EVENT_PAREMETER,
+					parts: [eventParameter]
+				});
+				read = false;
+			}
 		default: eventParameter = addCharacter$2(cursor, eventParameter);
 	}
 	return retVal;
@@ -651,29 +659,6 @@ function addCharacter(cursor, interpolation) {
 	return `${interpolation}${cursor.currentChar.value}`;
 }
 //#endregion
-//#region ../packages/compiler/src/utils/chars.utils.ts
-/**
-* Checks whether a string contains at least one non-whitespace character.
-*
-* Whitespace characters include space, `\n`, `\r`, `\t`, `\f`, and `\v`.
-*
-* @param str - The string to check.
-* @returns `true` if the string is not blank, `false` if it consists entirely of whitespace.
-*/
-function isNotBlank(str) {
-	return /\S/.test(str);
-}
-/**
-* Checks whether the given ASCII code is a valid first character for a
-* JavaScript identifier (`A`–`Z`, `a`–`z`, `$`, `_`).
-*
-* @param code - The ASCII code to evaluate.
-* @returns `true` if the code can start a JS identifier, `false` otherwise.
-*/
-function isJSIdentifierStart(code) {
-	return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 36 || code === 95;
-}
-//#endregion
 //#region ../packages/compiler/src/lexer/states/interpolation.state.ts
 /**
 * Dispatches between an expression and a literal interpolation after the opening `{`.
@@ -685,14 +670,9 @@ function isJSIdentifierStart(code) {
 * @returns Transition result with the appropriate interpolation sub-state.
 */
 function consumeInterpolation(cursor, _context) {
-	let retVal;
 	cursor.advance();
 	cursor.skipSpaces();
-	const nextChar = cursor.peek();
-	if (nextChar === 96) retVal = { state: LexerState.INTERPOLATION_LITERAL };
-	else if (isJSIdentifierStart(nextChar)) retVal = { state: LexerState.INTERPOLATION_EXPRESSION };
-	else throw new Error(`Unrecognized First Character ${String.fromCharCode(nextChar)} in interpolation`);
-	return retVal;
+	return cursor.peek() === 96 ? { state: LexerState.INTERPOLATION_LITERAL } : { state: LexerState.INTERPOLATION_EXPRESSION };
 }
 //#endregion
 //#region ../packages/compiler/src/lexer/states/tag-body.state.ts
@@ -835,6 +815,19 @@ function consumeTagOpenName(cursor, _context) {
 	return retVal;
 }
 //#endregion
+//#region ../packages/compiler/src/utils/chars.utils.ts
+/**
+* Checks whether a string contains at least one non-whitespace character.
+*
+* Whitespace characters include space, `\n`, `\r`, `\t`, `\f`, and `\v`.
+*
+* @param str - The string to check.
+* @returns `true` if the string is not blank, `false` if it consists entirely of whitespace.
+*/
+function isNotBlank(str) {
+	return /\S/.test(str);
+}
+//#endregion
 //#region ../packages/compiler/src/lexer/states/text.state.ts
 /**
 * Consumes plain text content, accumulating characters until a structural boundary
@@ -1308,7 +1301,7 @@ var ASTNodeType = /* @__PURE__ */ function(ASTNodeType) {
 * //   "'await' is not allowed inside template expressions."
 */
 function validateExpression(source) {
-	const expression = ts.createSourceFile("expression.ts", `const x = ${source}`, ts.ScriptTarget.ESNext, true).statements[0].declarationList.declarations[0].initializer;
+	const expression = createSourceFile("expression.ts", `const x = ${source}`, ScriptTarget.ESNext, true).statements[0].declarationList.declarations[0].initializer;
 	const diagnostics = new Array();
 	visitNode(expression, 10, diagnostics);
 	if (diagnostics.length) throw new Error(diagnostics.reduce((acc, d) => `${acc}${d.message}\n`, ""));
@@ -1328,7 +1321,7 @@ function validateExpression(source) {
 */
 function visitNode(node, offset, diagnostics) {
 	if (!isAllowedNode(node)) throw new Error(buildDisallowedMessage(node));
-	ts.forEachChild(node, (child) => visitNode(child, offset, diagnostics));
+	forEachChild(node, (child) => visitNode(child, offset, diagnostics));
 	if (diagnostics.length) throw new Error(diagnostics[0].message);
 }
 /**
@@ -1341,62 +1334,63 @@ function visitNode(node, offset, diagnostics) {
 */
 function isAllowedNode(node) {
 	switch (node.kind) {
-		case ts.SyntaxKind.StringLiteral:
-		case ts.SyntaxKind.NumericLiteral:
-		case ts.SyntaxKind.BigIntLiteral:
-		case ts.SyntaxKind.TrueKeyword:
-		case ts.SyntaxKind.FalseKeyword:
-		case ts.SyntaxKind.NullKeyword:
-		case ts.SyntaxKind.UndefinedKeyword:
-		case ts.SyntaxKind.Identifier:
-		case ts.SyntaxKind.PropertyAccessExpression:
-		case ts.SyntaxKind.ElementAccessExpression:
-		case ts.SyntaxKind.CallExpression:
-		case ts.SyntaxKind.BinaryExpression:
-		case ts.SyntaxKind.EqualsEqualsToken:
-		case ts.SyntaxKind.EqualsEqualsEqualsToken:
-		case ts.SyntaxKind.ExclamationEqualsToken:
-		case ts.SyntaxKind.ExclamationEqualsEqualsToken:
-		case ts.SyntaxKind.LessThanToken:
-		case ts.SyntaxKind.LessThanEqualsToken:
-		case ts.SyntaxKind.GreaterThanToken:
-		case ts.SyntaxKind.GreaterThanEqualsToken:
-		case ts.SyntaxKind.PlusToken:
-		case ts.SyntaxKind.MinusToken:
-		case ts.SyntaxKind.AsteriskToken:
-		case ts.SyntaxKind.SlashToken:
-		case ts.SyntaxKind.PercentToken:
-		case ts.SyntaxKind.AsteriskAsteriskToken:
-		case ts.SyntaxKind.AmpersandAmpersandToken:
-		case ts.SyntaxKind.BarBarToken:
-		case ts.SyntaxKind.QuestionQuestionToken:
-		case ts.SyntaxKind.AmpersandToken:
-		case ts.SyntaxKind.BarToken:
-		case ts.SyntaxKind.CaretToken:
-		case ts.SyntaxKind.LessThanLessThanToken:
-		case ts.SyntaxKind.GreaterThanGreaterThanToken:
-		case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
-		case ts.SyntaxKind.InstanceOfKeyword:
-		case ts.SyntaxKind.InKeyword:
-		case ts.SyntaxKind.PrefixUnaryExpression:
-		case ts.SyntaxKind.PostfixUnaryExpression:
-		case ts.SyntaxKind.TypeOfExpression:
-		case ts.SyntaxKind.VoidExpression:
-		case ts.SyntaxKind.ConditionalExpression:
-		case ts.SyntaxKind.ParenthesizedExpression:
-		case ts.SyntaxKind.TemplateExpression:
-		case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
-		case ts.SyntaxKind.TemplateHead:
-		case ts.SyntaxKind.TemplateMiddle:
-		case ts.SyntaxKind.TemplateTail:
-		case ts.SyntaxKind.TemplateSpan:
-		case ts.SyntaxKind.ArrayLiteralExpression:
-		case ts.SyntaxKind.ObjectLiteralExpression:
-		case ts.SyntaxKind.PropertyAssignment:
-		case ts.SyntaxKind.ShorthandPropertyAssignment:
-		case ts.SyntaxKind.SpreadAssignment:
-		case ts.SyntaxKind.SpreadElement:
-		case ts.SyntaxKind.SyntaxList: return true;
+		case SyntaxKind.StringLiteral:
+		case SyntaxKind.NumericLiteral:
+		case SyntaxKind.BigIntLiteral:
+		case SyntaxKind.TrueKeyword:
+		case SyntaxKind.FalseKeyword:
+		case SyntaxKind.NullKeyword:
+		case SyntaxKind.UndefinedKeyword:
+		case SyntaxKind.Identifier:
+		case SyntaxKind.PropertyAccessExpression:
+		case SyntaxKind.ElementAccessExpression:
+		case SyntaxKind.CallExpression:
+		case SyntaxKind.BinaryExpression:
+		case SyntaxKind.EqualsEqualsToken:
+		case SyntaxKind.EqualsEqualsEqualsToken:
+		case SyntaxKind.ExclamationEqualsToken:
+		case SyntaxKind.ExclamationEqualsEqualsToken:
+		case SyntaxKind.LessThanToken:
+		case SyntaxKind.LessThanEqualsToken:
+		case SyntaxKind.GreaterThanToken:
+		case SyntaxKind.GreaterThanEqualsToken:
+		case SyntaxKind.PlusToken:
+		case SyntaxKind.MinusToken:
+		case SyntaxKind.AsteriskToken:
+		case SyntaxKind.SlashToken:
+		case SyntaxKind.PercentToken:
+		case SyntaxKind.AsteriskAsteriskToken:
+		case SyntaxKind.AmpersandAmpersandToken:
+		case SyntaxKind.BarBarToken:
+		case SyntaxKind.QuestionQuestionToken:
+		case SyntaxKind.QuestionDotToken:
+		case SyntaxKind.AmpersandToken:
+		case SyntaxKind.BarToken:
+		case SyntaxKind.CaretToken:
+		case SyntaxKind.LessThanLessThanToken:
+		case SyntaxKind.GreaterThanGreaterThanToken:
+		case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+		case SyntaxKind.InstanceOfKeyword:
+		case SyntaxKind.InKeyword:
+		case SyntaxKind.PrefixUnaryExpression:
+		case SyntaxKind.PostfixUnaryExpression:
+		case SyntaxKind.TypeOfExpression:
+		case SyntaxKind.VoidExpression:
+		case SyntaxKind.ConditionalExpression:
+		case SyntaxKind.ParenthesizedExpression:
+		case SyntaxKind.TemplateExpression:
+		case SyntaxKind.NoSubstitutionTemplateLiteral:
+		case SyntaxKind.TemplateHead:
+		case SyntaxKind.TemplateMiddle:
+		case SyntaxKind.TemplateTail:
+		case SyntaxKind.TemplateSpan:
+		case SyntaxKind.ArrayLiteralExpression:
+		case SyntaxKind.ObjectLiteralExpression:
+		case SyntaxKind.PropertyAssignment:
+		case SyntaxKind.ShorthandPropertyAssignment:
+		case SyntaxKind.SpreadAssignment:
+		case SyntaxKind.SpreadElement:
+		case SyntaxKind.SyntaxList: return true;
 		default: return false;
 	}
 }
@@ -1409,25 +1403,25 @@ function isAllowedNode(node) {
 */
 function buildDisallowedMessage(node) {
 	switch (node.kind) {
-		case ts.SyntaxKind.AwaitExpression: return "'await' is not allowed inside template expressions.";
-		case ts.SyntaxKind.YieldExpression: return "'yield' is not allowed inside template expressions.";
-		case ts.SyntaxKind.NewExpression: return "'new' is not allowed inside template expressions.";
-		case ts.SyntaxKind.ArrowFunction:
-		case ts.SyntaxKind.FunctionExpression: return "Function expressions are not allowed inside template expressions.";
-		case ts.SyntaxKind.TaggedTemplateExpression: return "Tagged template expressions are not allowed inside template expressions.";
-		case ts.SyntaxKind.BinaryExpression: return isAssignmentOperator(node.operatorToken.kind) ? "Assignments are not allowed inside template expressions. Use @const to declare local template variables instead." : `'${ts.SyntaxKind[node.kind]}' is not allowed inside template expressions.`;
-		default: return `'${ts.SyntaxKind[node.kind]}' is not allowed inside template expressions.`;
+		case SyntaxKind.AwaitExpression: return "'await' is not allowed inside template expressions.";
+		case SyntaxKind.YieldExpression: return "'yield' is not allowed inside template expressions.";
+		case SyntaxKind.NewExpression: return "'new' is not allowed inside template expressions.";
+		case SyntaxKind.ArrowFunction:
+		case SyntaxKind.FunctionExpression: return "Function expressions are not allowed inside template expressions.";
+		case SyntaxKind.TaggedTemplateExpression: return "Tagged template expressions are not allowed inside template expressions.";
+		case SyntaxKind.BinaryExpression: return isAssignmentOperator(node.operatorToken.kind) ? "Assignments are not allowed inside template expressions. Use @const to declare local template variables instead." : `'${SyntaxKind[node.kind]}' is not allowed inside template expressions.`;
+		default: return `'${SyntaxKind[node.kind]}' is not allowed inside template expressions.`;
 	}
 }
 /**
-* Returns `true` if the given {@link ts.SyntaxKind} is an assignment operator.
+* Returns `true` if the given {@link SyntaxKind} is an assignment operator.
 *
 * Covers simple assignment (`=`) as well as all compound assignment operators
 * (`+=`, `-=`, `&&=`, `||=`, `??=`, etc.) as defined by the TypeScript
 * `FirstAssignment`–`LastAssignment` range.
 */
 function isAssignmentOperator(kind) {
-	return kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+	return kind >= SyntaxKind.FirstAssignment && kind <= SyntaxKind.LastAssignment;
 }
 //#endregion
 //#region ../packages/compiler/src/parser/states/parse-interpolation.state.ts
@@ -1749,8 +1743,8 @@ function splitForSections(source) {
 */
 function isValidIdentifier(name) {
 	if (!name.length) return false;
-	const statement = ts.createSourceFile("__id.ts", name, ts.ScriptTarget.ESNext, false).statements[0];
-	return !!statement && ts.isExpressionStatement(statement) && ts.isIdentifier(statement.expression) && statement.expression.text === name;
+	const statement = createSourceFile("__id.ts", name, ScriptTarget.ESNext, false).statements[0];
+	return !!statement && isExpressionStatement(statement) && isIdentifier(statement.expression) && statement.expression.text === name;
 }
 //#endregion
 //#region ../packages/compiler/src/parser/states/parse-if.state.ts
@@ -2327,7 +2321,14 @@ function mapAttributes(attributes, compilerContext) {
 function mapEvents(events, compilerContext) {
 	compilerContext.addIdentifier("$event");
 	const mappedEvents = events?.map((event) => {
-		const parameters = event.parameters.map((parameter) => `() => ${resolveExpression(parameter, compilerContext)},`);
+		let parsedEventParameter = false;
+		const parameters = event.parameters.map((parameter) => {
+			const resolvedParameter = resolveExpression(parameter, compilerContext);
+			if (!parsedEventParameter && resolvedParameter === "$event") {
+				parsedEventParameter = true;
+				return `($event) => ${resolvedParameter},`;
+			} else return `() => ${resolvedParameter},`;
+		});
 		return [
 			"{",
 			...indent([
@@ -2412,7 +2413,7 @@ function processFor(node, nodeName, parentNode, compilerContext) {
 			counterName
 		]
 	});
-	mainBlock.push(`_for(${parentNode}, context, () => ${iterableExpr}, this.${forKey}.bind(this));`);
+	mainBlock.push(`_for(${parentNode}, context, () => ${iterableExpr}, (${node.itemAlias}) => ${resolveExpression(node.trackExpression, forContext)}, this.${forKey}.bind(this));`);
 	return {
 		mainBlock,
 		fns: functionsToProcess

package/package.json

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