jsxpression 0.1.28 → 0.1.29

package/src/analyze/analyze.test.ts

@@ -1,8 +1,8 @@
-import { describe, it, expect } from "vitest";
-import { analyze } from "./analyze.js";
-import { parse } from "../parse/index.js";
-import { type Schema } from "../schema.js";
+import { describe, expect, it } from "vitest";
 import { getBuiltins } from "../builtins.js";
+import { parse } from "../parse/index.js";
+import type { Schema } from "../schema.js";
+import { analyze } from "./analyze.js";
 
 describe("analyze - consolidated tests", () => {
   const baseSchema = {
@@ -75,66 +75,66 @@ describe("analyze - consolidated tests", () => {
   describe("data access validation", () => {
     describe("basic data access", () => {
       it("should allow valid data access", () => {
-        const ast = parse("<Text>{data.user.name}</Text>");
+        const ast = parse("<Text>{user.name}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should allow nested object access", () => {
-        const ast = parse("<Text>{data.user.profile.avatar}</Text>");
+        const ast = parse("<Text>{user.profile.avatar}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should block invalid data properties", () => {
-        const ast = parse("<Text>{data.user.invalid}</Text>");
+        const ast = parse("<Text>{user.invalid}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
-        expect(result.errors[0].message).toContain("Property 'data.user.invalid' does not exist in schema");
+        expect(result.errors[0].message).toContain("Property 'user.invalid' does not exist in schema");
       });
 
       it("should block invalid nested properties", () => {
-        const ast = parse("<Text>{data.user.profile.invalid}</Text>");
+        const ast = parse("<Text>{user.profile.invalid}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
-        expect(result.errors[0].message).toContain("Property 'data.user.profile.invalid' does not exist in schema");
+        expect(result.errors[0].message).toContain("Property 'user.profile.invalid' does not exist in schema");
       });
     });
 
     describe("array access", () => {
       it("should allow array access with valid methods", () => {
-        const ast = parse("<Text>{data.items.map(item => item)}</Text>");
+        const ast = parse("<Text>{items.map(item => item)}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should allow numeric array index access", () => {
-        const ast = parse("<Text>{data.items[0]}</Text>");
+        const ast = parse("<Text>{items[0]}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should allow various numeric array indices", () => {
-        const ast = parse("<Text>{data.items[42]} and {data.numbers[1]}</Text>");
+        const ast = parse("<Text>{items[42]} and {numbers[1]}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should allow nested array access with indices", () => {
-        const ast = parse("<Text>{data.products[0].tags[1]}</Text>");
+        const ast = parse("<Text>{products[0].tags[1]}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should require array indices for nested object access", () => {
-        const ast = parse("<Text>{data.products.tags}</Text>");
+        const ast = parse("<Text>{products.tags}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
-        expect(result.errors[0].message).toContain("data.products.tags");
+        expect(result.errors[0].message).toContain("products.tags");
       });
 
       it("should detect typos on array properties", () => {
-        const ast = parse("<Text>{data.departments.lengdth}</Text>");
+        const ast = parse("<Text>{departments.lengdth}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
         expect(result.errors[0].code).toBe("INVALID_DATA_ACCESS");
@@ -142,31 +142,31 @@ describe("analyze - consolidated tests", () => {
       });
 
       it("should allow string members on array elements", () => {
-        const ast = parse("<Text>{data.items[0].length}</Text>");
+        const ast = parse("<Text>{items[0].length}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should allow array.at() method with positive index", () => {
-        const ast = parse("<Text>{data.items.at(0)}</Text>");
+        const ast = parse("<Text>{items.at(0)}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should allow array.at() method with negative index", () => {
-        const ast = parse("<Text>{data.items.at(-1)}</Text>");
+        const ast = parse("<Text>{items.at(-1)}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should allow array.at() method in complex expressions", () => {
-        const ast = parse("<Text>{data.products.at(-1).name}</Text>");
+        const ast = parse("<Text>{products.at(-1).name}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should block dynamic array access with variables", () => {
-        const ast = parse("<Text>{data.items[variable]}</Text>");
+        const ast = parse("<Text>{items[variable]}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
         expect(result.errors.some((e) => e.message.includes("variable") || e.message.includes("not allowed"))).toBe(
@@ -175,55 +175,55 @@ describe("analyze - consolidated tests", () => {
       });
 
       it("should block string-based computed access on objects", () => {
-        const ast = parse("<Text>{data.user['name']}</Text>");
+        const ast = parse("<Text>{user['name']}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
         expect(result.errors.some((e) => e.message.includes("computed member access not allowed"))).toBe(true);
       });
 
       it("should block mutating array methods", () => {
-        const ast = parse("<Text>{data.items.push('new')}</Text>");
+        const ast = parse("<Text>{items.push('new')}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
-        expect(result.errors[0].message).toContain("method .push not allowed");
+        expect(result.errors[0].message).toContain("method items.push not allowed");
       });
     });
 
     describe("arrow function parameter validation", () => {
       it("should validate arrow function parameters - valid access", () => {
-        const ast = parse("<Text>{data.products.map((product, i) => product.name)}</Text>");
+        const ast = parse("<Text>{products.map((product, i) => product.name)}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should validate arrow function parameters - invalid property", () => {
-        const ast = parse("<Text>{data.products.map((product, i) => product.invalid)}</Text>");
+        const ast = parse("<Text>{products.map((product, i) => product.invalid)}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
         expect(result.errors[0].message).toContain("Property 'invalid' does not exist on parameter 'product'");
       });
 
       it("should validate nested arrow functions", () => {
-        const ast = parse("<Text>{data.products.map(product => product.tags.map(tag => tag))}</Text>");
+        const ast = parse("<Text>{products.map(product => product.tags.map(tag => tag))}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should catch errors in nested arrow functions", () => {
-        const ast = parse("<Text>{data.products.map(product => product.tags.map(tag => tag.invalid))}</Text>");
+        const ast = parse("<Text>{products.map(product => product.tags.map(tag => tag.invalid))}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
         expect(result.errors[0].message).toContain("Cannot access property 'invalid' on string type");
       });
 
       it("should validate index parameters", () => {
-        const ast = parse("<Text>{data.items.map((item, i) => i + 1)}</Text>");
+        const ast = parse("<Text>{items.map((item, i) => i + 1)}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
 
       it("should catch invalid index parameter access", () => {
-        const ast = parse("<Text>{data.items.map((item, i) => i.invalid)}</Text>");
+        const ast = parse("<Text>{items.map((item, i) => i.invalid)}</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
         expect(result.errors[0].message).toContain("Cannot access property 'invalid' on number type");
@@ -231,7 +231,7 @@ describe("analyze - consolidated tests", () => {
 
       it("should handle complex nested scenarios", () => {
         const ast = parse(
-          "<Text>{data.departments.map((dept) => dept.employees.map((employee) => employee.salary))}</Text>"
+          "<Text>{departments.map((dept) => dept.employees.map((employee) => employee.salary))}</Text>"
         );
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
@@ -239,7 +239,7 @@ describe("analyze - consolidated tests", () => {
 
       it("should detect typos in complex nested scenarios", () => {
         const ast = parse(
-          "<Text>{data.departments.map((dept) => dept.employees.map((employee) => employee.saladry))}</Text>"
+          "<Text>{departments.map((dept) => dept.employees.map((employee) => employee.saladry))}</Text>"
         );
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(true);
@@ -277,39 +277,39 @@ describe("analyze - consolidated tests", () => {
               } else if (objectName === "Array.prototype") {
                 // Array methods
                 if (methodName === "map" || methodName === "filter") {
-                  testExpression = `<Text>{data.items.${methodName}(x => x)}</Text>`;
+                  testExpression = `<Text>{items.${methodName}(x => x)}</Text>`;
                 } else if (methodName === "reduce") {
-                  testExpression = `<Text>{data.numbers.${methodName}((a, b) => a + b, 0)}</Text>`;
+                  testExpression = `<Text>{numbers.${methodName}((a, b) => a + b, 0)}</Text>`;
                 } else if (methodName === "slice") {
-                  testExpression = `<Text>{data.items.${methodName}(0, 2)}</Text>`;
+                  testExpression = `<Text>{items.${methodName}(0, 2)}</Text>`;
                 } else if (methodName === "join") {
-                  testExpression = `<Text>{data.items.${methodName}(", ")}</Text>`;
+                  testExpression = `<Text>{items.${methodName}(", ")}</Text>`;
                 } else if (methodName === "includes" || methodName === "indexOf") {
-                  testExpression = `<Text>{data.items.${methodName}("test")}</Text>`;
+                  testExpression = `<Text>{items.${methodName}("test")}</Text>`;
                 } else if (methodName === "find" || methodName === "some" || methodName === "every") {
                   // These methods need proper boolean-returning callbacks
-                  testExpression = `<Text>{data.items.${methodName}(x => x === "test")}</Text>`;
+                  testExpression = `<Text>{items.${methodName}(x => x === "test")}</Text>`;
                 } else {
                   // Other array methods with basic usage
-                  testExpression = `<Text>{data.items.${methodName}(x => x.length > 0)}</Text>`;
+                  testExpression = `<Text>{items.${methodName}(x => x.length > 0)}</Text>`;
                 }
               } else if (objectName === "String.prototype") {
                 // String methods
                 if (methodName === "charAt" || methodName === "charCodeAt") {
-                  testExpression = `<Text>{data.text.${methodName}(0)}</Text>`;
+                  testExpression = `<Text>{text.${methodName}(0)}</Text>`;
                 } else if (methodName === "slice" || methodName === "substring") {
-                  testExpression = `<Text>{data.text.${methodName}(0, 5)}</Text>`;
+                  testExpression = `<Text>{text.${methodName}(0, 5)}</Text>`;
                 } else if (methodName === "indexOf" || methodName === "lastIndexOf") {
-                  testExpression = `<Text>{data.text.${methodName}("test")}</Text>`;
+                  testExpression = `<Text>{text.${methodName}("test")}</Text>`;
                 } else if (methodName === "split") {
-                  testExpression = `<Text>{data.text.${methodName}(",")}</Text>`;
+                  testExpression = `<Text>{text.${methodName}(",")}</Text>`;
                 } else if (methodName === "concat") {
-                  testExpression = `<Text>{data.text.${methodName}(" world")}</Text>`;
+                  testExpression = `<Text>{text.${methodName}(" world")}</Text>`;
                 } else if (methodName === "includes" || methodName === "startsWith" || methodName === "endsWith") {
-                  testExpression = `<Text>{data.text.${methodName}("test")}</Text>`;
+                  testExpression = `<Text>{text.${methodName}("test")}</Text>`;
                 } else {
                   // Methods with no parameters like trim, toLowerCase
-                  testExpression = `<Text>{data.text.${methodName}()}</Text>`;
+                  testExpression = `<Text>{text.${methodName}()}</Text>`;
                 }
               } else {
                 // Fallback
@@ -332,9 +332,9 @@ describe("analyze - consolidated tests", () => {
                 if (objectName === "Math") {
                   testExpression = `<Text>{Math.${methodName}()}</Text>`;
                 } else if (objectName === "Array.prototype") {
-                  testExpression = `<Text>{data.items.${methodName}()}</Text>`;
+                  testExpression = `<Text>{items.${methodName}()}</Text>`;
                 } else if (objectName === "String.prototype") {
-                  testExpression = `<Text>{data.text.${methodName}()}</Text>`;
+                  testExpression = `<Text>{text.${methodName}()}</Text>`;
                 } else {
                   testExpression = `<Text>{${objectName}.${methodName}()}</Text>`;
                 }
@@ -363,12 +363,12 @@ describe("analyze - consolidated tests", () => {
                   testExpression = `<Text>{Math.${methodName}(${extraParams})}</Text>`;
                 } else if (objectName === "Array.prototype") {
                   if (methodName === "map" || methodName === "filter") {
-                    testExpression = `<Text>{data.items.${methodName}(x => x, {}, ${extraParams})}</Text>`;
+                    testExpression = `<Text>{items.${methodName}(x => x, {}, ${extraParams})}</Text>`;
                   } else {
-                    testExpression = `<Text>{data.items.${methodName}(${extraParams})}</Text>`;
+                    testExpression = `<Text>{items.${methodName}(${extraParams})}</Text>`;
                   }
                 } else if (objectName === "String.prototype") {
-                  testExpression = `<Text>{data.text.${methodName}(${extraParams})}</Text>`;
+                  testExpression = `<Text>{text.${methodName}(${extraParams})}</Text>`;
                 } else {
                   testExpression = `<Text>{${objectName}.${methodName}(${extraParams})}</Text>`;
                 }
@@ -396,9 +396,9 @@ describe("analyze - consolidated tests", () => {
               let testExpression: string;
 
               if (objectName === "Array.prototype") {
-                testExpression = `<Text>{data.items.${propName}}</Text>`;
+                testExpression = `<Text>{items.${propName}}</Text>`;
               } else if (objectName === "String.prototype") {
-                testExpression = `<Text>{data.text.${propName}}</Text>`;
+                testExpression = `<Text>{text.${propName}}</Text>`;
               } else {
                 testExpression = `<Text>{${objectName}.${propName}}</Text>`;
               }
@@ -417,10 +417,10 @@ describe("analyze - consolidated tests", () => {
         const blockedMethods = ["push", "pop", "shift", "unshift", "splice", "reverse", "sort"];
 
         blockedMethods.forEach((method) => {
-          const ast = parse(`<Text>{data.items.${method}()}</Text>`);
+          const ast = parse(`<Text>{items.${method}()}</Text>`);
           const result = analyze(ast, baseSchema);
           expect(result.hasErrors).toBe(true);
-          expect(result.errors[0].message).toContain(`method .${method} not allowed`);
+          expect(result.errors[0].message).toContain(`method items.${method} not allowed`);
         });
       });
 
@@ -451,12 +451,12 @@ describe("analyze - consolidated tests", () => {
         };
 
         // Math.max should work with default builtins
-        const ast1 = parse("<Text>{Math.max(data.value, 10)}</Text>");
+        const ast1 = parse("<Text>{Math.max(value, 10)}</Text>");
         const result1 = analyze(ast1, customSchema);
         expect(result1.hasErrors).toBe(false);
 
         // Math.min should also work since we use BUILTINS
-        const ast2 = parse("<Text>{Math.min(data.value, 10)}</Text>");
+        const ast2 = parse("<Text>{Math.min(value, 10)}</Text>");
         const result2 = analyze(ast2, customSchema);
         expect(result2.hasErrors).toBe(false);
       });
@@ -471,11 +471,11 @@ describe("analyze - consolidated tests", () => {
           },
         };
 
-        const ast1 = parse("<Text>{data.text.toUpperCase()}</Text>");
+        const ast1 = parse("<Text>{text.toUpperCase()}</Text>");
         const result1 = analyze(ast1, customSchema);
         expect(result1.hasErrors).toBe(false);
 
-        const ast2 = parse("<Text>{data.text.toLowerCase()}</Text>");
+        const ast2 = parse("<Text>{text.toLowerCase()}</Text>");
         const result2 = analyze(ast2, customSchema);
         expect(result2.hasErrors).toBe(false);
       });
@@ -492,7 +492,7 @@ describe("analyze - consolidated tests", () => {
         };
 
         // Should work with default builtin schema
-        const ast = parse("<Text>{Math.max(data.x, 10)}</Text>");
+        const ast = parse("<Text>{Math.max(x, 10)}</Text>");
         const result = analyze(ast, schemaWithoutBuiltins);
         expect(result.hasErrors).toBe(false);
       });
@@ -587,7 +587,7 @@ describe("analyze - consolidated tests", () => {
           },
         };
 
-        const ast = parse("<Card {...data.props} />");
+        const ast = parse("<Card {...props} />");
         const result = analyze(ast, schema);
         expect(result.hasErrors).toBe(false);
       });
@@ -618,7 +618,7 @@ describe("analyze - consolidated tests", () => {
           },
         };
 
-        const ast = parse("<Text {...data.user.attributes} />");
+        const ast = parse("<Text {...user.attributes} />");
         const result = analyze(ast, schema);
         expect(result.hasErrors).toBe(false);
       });
@@ -656,7 +656,7 @@ describe("analyze - consolidated tests", () => {
           },
         };
 
-        const ast = parse("<div>{data.items.map(item => <Item {...item.props} />)}</div>");
+        const ast = parse("<div>{items.map(item => <Item {...item.props} />)}</div>");
         const result = analyze(ast, schema);
         expect(result.hasErrors).toBe(false);
       });
@@ -688,7 +688,7 @@ describe("analyze - consolidated tests", () => {
           },
         };
 
-        const ast = parse("<div>{data.items.map(item => <Item {...item} />)}</div>");
+        const ast = parse("<div>{items.map(item => <Item {...item} />)}</div>");
         const result = analyze(ast, schema);
         expect(result.hasErrors).toBe(false);
       });
@@ -713,7 +713,7 @@ describe("analyze - consolidated tests", () => {
           },
         };
 
-        const ast = parse("<Card {...data.props} highlighted={true} />");
+        const ast = parse("<Card {...props} highlighted={true} />");
         const result = analyze(ast, schema);
         expect(result.hasErrors).toBe(false);
       });
@@ -744,7 +744,7 @@ describe("analyze - consolidated tests", () => {
           },
         };
 
-        const ast = parse("<Card {...data.baseProps} {...data.extraProps} />");
+        const ast = parse("<Card {...baseProps} {...extraProps} />");
         const result = analyze(ast, schema);
         expect(result.hasErrors).toBe(false);
       });
@@ -764,7 +764,7 @@ describe("analyze - consolidated tests", () => {
       });
 
       it("should allow empty expressions mixed with content in children", () => {
-        const ast = parse("<Text>Hello {}{data.user.name}{} World</Text>");
+        const ast = parse("<Text>Hello {}{user.name}{} World</Text>");
         const result = analyze(ast, baseSchema);
         expect(result.hasErrors).toBe(false);
       });
@@ -817,7 +817,7 @@ describe("analyze - consolidated tests", () => {
     it("should catch multiple errors in complex expressions", () => {
       const ast = parse(`
         <InvalidElement>
-          <Text>{data.user.invalid}</Text>
+          <Text>{user.invalid}</Text>
           <span>{window.location}</span>
         </InvalidElement>
       `);
@@ -826,4 +826,43 @@ describe("analyze - consolidated tests", () => {
       expect(result.errors.length).toBeGreaterThan(1);
     });
   });
+
+  describe("return requirement", () => {
+    it("should allow bare JSX without return (no declarations)", () => {
+      const ast = parse("<Text>hello</Text>");
+      const result = analyze(ast, baseSchema);
+      expect(result.issues.filter((i) => i.code === "RETURN_REQUIRED")).toHaveLength(0);
+    });
+
+    it("should require return when const is present", () => {
+      const ast = parse("const x = 1;\n<Text>hello</Text>");
+      const result = analyze(ast, baseSchema);
+      expect(result.issues.some((i) => i.code === "RETURN_REQUIRED")).toBe(true);
+    });
+
+    it("should allow const + return", () => {
+      const ast = parse("const x = 1\nreturn <Text>hello</Text>");
+      const result = analyze(ast, baseSchema);
+      expect(result.issues.filter((i) => i.code === "RETURN_REQUIRED")).toHaveLength(0);
+    });
+
+    it("should require return when function is present", () => {
+      const ast = parse("function Foo() {\n  return <Text>hi</Text>\n}\n<Foo />");
+      const result = analyze(ast, baseSchema);
+      expect(result.issues.some((i) => i.code === "RETURN_REQUIRED")).toBe(true);
+    });
+
+    it("should allow function + return", () => {
+      const ast = parse("function Foo() {\n  return <Text>hi</Text>\n}\nreturn <Foo />");
+      const result = analyze(ast, baseSchema);
+      expect(result.issues.filter((i) => i.code === "RETURN_REQUIRED")).toHaveLength(0);
+    });
+
+    it("should give helpful message for bare JSX after declarations", () => {
+      const ast = parse("const x = 1;\n<Text>hello</Text>");
+      const result = analyze(ast, baseSchema);
+      const issue = result.issues.find((i) => i.code === "RETURN_REQUIRED");
+      expect(issue?.message).toContain("Add 'return' before the JSX");
+    });
+  });
 });