htmv 0.0.42 → 0.0.44

package/dist/compiler/parser.js

@@ -35,17 +35,20 @@ export function parse(tokens) {
                 const tag = token.tag.toLowerCase();
                 i++;
                 if (tag === "for") {
-                    const nextToken = tokens[i]; //should be arguments token
+                    const itemNameToken = tokens[i];
+                    if (itemNameToken?.type !== "arguments")
+                        throw new Error("Missing item name in for");
+                    const itemName = itemNameToken.value;
+                    i++;
+                    const inToken = tokens[i];
+                    if (inToken?.type !== "arguments" || inToken.value !== "in")
+                        throw new Error("Expected reserved word in");
+                    i++;
+                    const listNameToken = tokens[i];
+                    if (listNameToken?.type !== "arguments")
+                        throw new Error("Expected list name in for");
+                    const listName = listNameToken.value;
                     i++;
-                    if (nextToken?.type !== "arguments")
-                        throw new Error("Missing arguments in for");
-                    const [itemName, _in, listName] = nextToken.value;
-                    if (itemName === undefined ||
-                        _in === undefined ||
-                        listName === undefined)
-                        throw new Error("Incorrect amount of arguments in for. Expected 3 arguments");
-                    if (_in !== "in")
-                        throw new Error("Expected reserved word in.");
                     const children = parseChildren(tag);
                     nodes.push({
                         type: "for",
@@ -60,7 +63,7 @@ export function parse(tokens) {
                     i++;
                     if (nextToken?.type !== "arguments")
                         throw new Error("Missing arguments in isset");
-                    const [itemName] = nextToken.value;
+                    const itemName = nextToken.value;
                     if (itemName === undefined)
                         throw new Error("Expected item name");
                     const children = parseChildren(tag);
@@ -71,23 +74,28 @@ export function parse(tokens) {
                     });
                     continue;
                 }
-                const nextToken = tokens[i]; //may be arguments token
-                if (nextToken?.type === "arguments") {
-                    nodes.push({
-                        type: "text",
-                        text: `<${tag} `,
-                    });
+                nodes.push({
+                    type: "text",
+                    text: `<${tag} `,
+                });
+                let nextToken = tokens[i];
+                while (nextToken?.type === "arguments") {
                     parseArgs(nextToken.value);
+                    i++;
+                    nextToken = tokens[i];
+                }
+                while (nextToken?.type === "attr-binding") {
                     nodes.push({
-                        type: "text",
-                        text: `>`,
+                        type: "attr-binding",
+                        name: nextToken.name,
+                        expr: nextToken.expression,
                     });
                     i++;
-                    continue;
+                    nextToken = tokens[i];
                 }
                 nodes.push({
                     type: "text",
-                    text: `<${tag}>`,
+                    text: `>`,
                 });
                 continue;
             }
@@ -103,8 +111,7 @@ export function parse(tokens) {
             }
         }
         return nodes;
-        function parseArgs(_args) {
-            const args = _args.join(" ");
+        function parseArgs(args) {
             let textBuffer = "";
             for (let i = 0; i < args.length; i++) {
                 const letter = args[i];

package/dist/compiler/renderer.d.ts

@@ -1,4 +1,4 @@
-export type Node = RootNode | TextNode | InterpolationNode | IssetNode | ForNode;
+export type Node = RootNode | TextNode | InterpolationNode | IssetNode | ForNode | AttributeBindingNode;
 export interface RootNode {
     type: "root";
     children: Node[];
@@ -22,5 +22,10 @@ interface ForNode {
     itemName: string;
     children: Node[];
 }
+interface AttributeBindingNode {
+    type: "attr-binding";
+    name: string;
+    expr: string;
+}
 export declare function render(node: Node, context: Record<string, unknown>): string;
 export {};

package/dist/compiler/renderer.js

@@ -1,4 +1,9 @@
 export function render(node, context) {
+    if (node.type === "attr-binding") {
+        const prop = resolvePropertyPath(node.expr);
+        const exists = isset(prop);
+        return exists ? node.name : "";
+    }
     if (node.type === "text") {
         return node.text;
     }

package/dist/compiler/tokenizer.d.ts

@@ -1,4 +1,4 @@
-export type Token = TextToken | InterpolationToken | OpenToken | CloseToken | ArgumentsToken;
+export type Token = TextToken | InterpolationToken | OpenToken | CloseToken | ArgumentsToken | AttributeBindingToken;
 type TextToken = {
     type: "text";
     text: string;
@@ -17,7 +17,12 @@ type CloseToken = {
 };
 type ArgumentsToken = {
     type: "arguments";
-    value: string[];
+    value: string;
+};
+type AttributeBindingToken = {
+    type: "attr-binding";
+    name: string;
+    expression: string;
 };
 export declare function tokenize(input: string): Token[];
 export {};

package/dist/compiler/tokenizer.js

@@ -40,10 +40,28 @@ export function tokenize(input) {
                 type: "open",
                 tag,
             });
-            if (args.length > 0) {
+            for (const arg of args) {
+                if (!arg.startsWith(":")) {
+                    tokens.push({
+                        type: "arguments",
+                        value: arg,
+                    });
+                    continue;
+                }
+                const [name, expr] = arg.slice(1).split("=");
+                if (name === undefined)
+                    throw new Error("Missing name on attribute binding attempt.");
+                if (expr === undefined)
+                    throw new Error("Missing expression on attribute binding attempt.");
+                if (!expr.startsWith("{"))
+                    throw new Error("Expected interpolation on expression when using attribute binding");
+                if (!expr.endsWith("}"))
+                    throw new Error("Expected interpolation closure on expression when using attribute binding");
+                const expression = expr.slice(1, -1);
                 tokens.push({
-                    type: "arguments",
-                    value: args,
+                    type: "attr-binding",
+                    name,
+                    expression,
                 });
             }
             i = finishingPosition;

package/package.json

@@ -2,7 +2,7 @@
 	"name": "htmv",
 	"main": "dist/index.js",
 	"type": "module",
-	"version": "0.0.42",
+	"version": "0.0.44",
 	"devDependencies": {
 		"@biomejs/biome": "2.3.3",
 		"@types/bun": "latest"