@graffiticode/parser 1.2.1 → 1.3.0

package/.claude/settings.local.json

@@ -0,0 +1,12 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(NODE_OPTIONS=--experimental-vm-modules npx jest:*)",
+      "Bash(npx eslint:*)",
+      "Bash(npm test:*)",
+      "Bash(npm publish:*)",
+      "Bash(grep:*)",
+      "Bash(npm install:*)"
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiticode/parser",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -22,6 +22,6 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
-    "@graffiticode/basis": "^1.6.2"
+    "@graffiticode/basis": "^1.6.3"
   }
 }

package/src/ast.js

@@ -120,6 +120,7 @@ export class Ast {
       case "STR":
       case "IDENT":
       case "BOOL":
+      case "TAG":
         elts[0] = n.elts[0];
         break;
       default:

package/src/folder.js

@@ -28,6 +28,7 @@ export class Folder {
       // "MUL": mul,
       // "DIV": div,
       // "SUB": sub,
+      TAG: Folder.tag,
       ADD: Folder.add,
       POW: Folder.pow,
       MOD: Folder.mod,
@@ -227,8 +228,8 @@ export class Folder {
     } else {
       // Tag value.
       Ast.push(ctx, {
-        tag: name,
-        elts: [],
+        tag: "TAG",
+        elts: [name],
         coord: node.coord,
       });
     }
@@ -245,6 +246,10 @@ export class Folder {
   static bool(node) {
     Ast.bool(Folder.#ctx, node.elts[0]);
   }
+
+  static tag(node) {
+    Ast.push(Folder.#ctx, node);
+  }
 }
 
 // Keep backward compatibility export

package/src/index.js

@@ -1 +1,2 @@
 export { parser } from "./parser.js";
+export { unparse } from "./unparse.js";

package/src/parser.spec.js

@@ -2,6 +2,7 @@ import { jest } from "@jest/globals";
 import { buildParser, parser } from "./parser.js";
 import { mockPromiseValue, mockPromiseError } from "./testing/index.js";
 import { lexicon as basisLexicon } from "@graffiticode/basis";
+import { unparse } from "./unparse.js";
 
 describe("lang/parser", () => {
   const log = jest.fn();
@@ -547,6 +548,36 @@ describe("parser integration tests", () => {
     expect(strNode.elts[0]).toBe("Price: ${amount}");
   });
 
+  it("should parse and unparse a tag node", async () => {
+    // Arrange - use an empty lexicon so "foo" is not recognized as a function
+    const emptyLexicon = {};
+
+    // Act - parse "foo.." where "foo" is not in the lexicon, producing a TAG node
+    const result = await parser.parse(0, "foo..", emptyLexicon);
+
+    // Assert - find the TAG node
+    expect(result).toHaveProperty("root");
+
+    let tagNode = null;
+    for (const key in result) {
+      if (key !== "root") {
+        const node = result[key];
+        if (node.tag === "TAG" && node.elts[0] === "foo") {
+          tagNode = node;
+          break;
+        }
+      }
+    }
+
+    expect(tagNode).not.toBeNull();
+    expect(tagNode.tag).toBe("TAG");
+    expect(tagNode.elts).toEqual(["foo"]);
+
+    // Unparse should reproduce the original source
+    const source = unparse(result, emptyLexicon);
+    expect(source).toBe("foo..");
+  });
+
   it("should parse strings with mixed escape sequences", async () => {
     // Arrange & Act
     const result = await parser.parse(0, '"Line 1\\nTab\\t\\"Quote\\""..', basisLexicon);

package/src/unparse.js

@@ -46,9 +46,9 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
     if (node.elts.length >= 3) {
       const first = node.elts[0];
       // Check if first element is an identifier that could be a function
-      if (first && first.tag && first.elts && first.elts.length === 0) {
+      if (first && first.tag === "TAG") {
         // This might be a function name followed by arguments
-        const funcName = first.tag;
+        const funcName = first.elts[0];
         // Check if this matches a lexicon function
         if (lexicon && lexicon[funcName]) {
           const arity = lexicon[funcName].arity || 0;
@@ -88,6 +88,9 @@ function unparseNode(node, lexicon, indent = 0, options = {}) {
   case "IDENT":
     return node.elts[0];
 
+  case "TAG":
+    return node.elts[0];
+
   case "LIST": {
     // Array literal [a, b, c]
     if (!node.elts || node.elts.length === 0) {
@@ -371,6 +374,7 @@ function reconstructNode(pool, nodeId) {
   case "STR":
   case "IDENT":
   case "BOOL":
+  case "TAG":
     // These nodes have primitive values in elts[0]
     result.elts = [node.elts[0]];
     break;