jsxpression 0.1.8 → 0.1.11

package/lib/analyze/analyze.test.js

@@ -1,8 +1,10 @@
-import { describe, it, expect } from "vitest";
-import { analyze } from "./analyze.js";
-import { parse } from "../parse/index.js";
-import { getBuiltins } from "../builtins.js";
-describe("analyze - consolidated tests", () => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const analyze_js_1 = require("./analyze.js");
+const index_js_1 = require("../parse/index.js");
+const builtins_js_1 = require("../builtins.js");
+(0, vitest_1.describe)("analyze - consolidated tests", () => {
     const baseSchema = {
         data: {
             user: {
@@ -69,164 +71,164 @@ describe("analyze - consolidated tests", () => {
             span: { props: {} },
         },
     };
-    describe("data access validation", () => {
-        describe("basic data access", () => {
-            it("should allow valid data access", () => {
-                const ast = parse("<Text>{data.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 result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(false);
-            });
-            it("should block invalid data properties", () => {
-                const ast = parse("<Text>{data.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");
-            });
-            it("should block invalid nested properties", () => {
-                const ast = parse("<Text>{data.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");
+    (0, vitest_1.describe)("data access validation", () => {
+        (0, vitest_1.describe)("basic data access", () => {
+            (0, vitest_1.it)("should allow valid data access", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.user.name}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should allow nested object access", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.user.profile.avatar}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should block invalid data properties", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.user.invalid}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("Property 'data.user.invalid' does not exist in schema");
+            });
+            (0, vitest_1.it)("should block invalid nested properties", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.user.profile.invalid}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("Property 'data.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 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 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 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 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 result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain("data.products.tags");
-            });
-            it("should detect typos on array properties", () => {
-                const ast = parse("<Text>{data.departments.lengdth}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].code).toBe("INVALID_DATA_ACCESS");
-                expect(result.errors[0].suggestions).toContain("length");
-            });
-            it("should allow string members on array elements", () => {
-                const ast = parse("<Text>{data.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 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 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 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 result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors.some((e) => e.message.includes("variable") || e.message.includes("not allowed"))).toBe(true);
-            });
-            it("should block string-based computed access on objects", () => {
-                const ast = parse("<Text>{data.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 result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain("method .push not allowed");
+        (0, vitest_1.describe)("array access", () => {
+            (0, vitest_1.it)("should allow array access with valid methods", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.items.map(item => item)}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should allow numeric array index access", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.items[0]}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should allow various numeric array indices", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.items[42]} and {data.numbers[1]}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should allow nested array access with indices", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.products[0].tags[1]}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should require array indices for nested object access", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.products.tags}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("data.products.tags");
+            });
+            (0, vitest_1.it)("should detect typos on array properties", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.departments.lengdth}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].code).toBe("INVALID_DATA_ACCESS");
+                (0, vitest_1.expect)(result.errors[0].suggestions).toContain("length");
+            });
+            (0, vitest_1.it)("should allow string members on array elements", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.items[0].length}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should allow array.at() method with positive index", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.items.at(0)}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should allow array.at() method with negative index", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.items.at(-1)}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should allow array.at() method in complex expressions", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.products.at(-1).name}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should block dynamic array access with variables", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.items[variable]}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors.some((e) => e.message.includes("variable") || e.message.includes("not allowed"))).toBe(true);
+            });
+            (0, vitest_1.it)("should block string-based computed access on objects", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.user['name']}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors.some((e) => e.message.includes("computed member access not allowed"))).toBe(true);
+            });
+            (0, vitest_1.it)("should block mutating array methods", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.items.push('new')}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("method .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 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 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 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 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 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 result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain("Cannot access property 'invalid' on number type");
-            });
-            it("should handle complex nested scenarios", () => {
-                const ast = parse("<Text>{data.departments.map((dept) => dept.employees.map((employee) => employee.salary))}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(false);
-            });
-            it("should detect typos in complex nested scenarios", () => {
-                const ast = parse("<Text>{data.departments.map((dept) => dept.employees.map((employee) => employee.saladry))}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain("Property 'saladry' does not exist on parameter 'employee'");
-                expect(result.errors[0].suggestions).toEqual(["name", "role", "salary"]);
+        (0, vitest_1.describe)("arrow function parameter validation", () => {
+            (0, vitest_1.it)("should validate arrow function parameters - valid access", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.products.map((product, i) => product.name)}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should validate arrow function parameters - invalid property", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.products.map((product, i) => product.invalid)}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("Property 'invalid' does not exist on parameter 'product'");
+            });
+            (0, vitest_1.it)("should validate nested arrow functions", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.products.map(product => product.tags.map(tag => tag))}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should catch errors in nested arrow functions", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.products.map(product => product.tags.map(tag => tag.invalid))}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("Cannot access property 'invalid' on string type");
+            });
+            (0, vitest_1.it)("should validate index parameters", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.items.map((item, i) => i + 1)}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should catch invalid index parameter access", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.items.map((item, i) => i.invalid)}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("Cannot access property 'invalid' on number type");
+            });
+            (0, vitest_1.it)("should handle complex nested scenarios", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.departments.map((dept) => dept.employees.map((employee) => employee.salary))}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should detect typos in complex nested scenarios", () => {
+                const ast = (0, index_js_1.parse)("<Text>{data.departments.map((dept) => dept.employees.map((employee) => employee.saladry))}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("Property 'saladry' does not exist on parameter 'employee'");
+                (0, vitest_1.expect)(result.errors[0].suggestions).toEqual(["name", "role", "salary"]);
             });
         });
     });
-    describe("method calls validation", () => {
+    (0, vitest_1.describe)("method calls validation", () => {
         // Dynamic builtin schema tests - generates tests for all methods in BUILTINS
-        describe("builtin methods - dynamic validation", () => {
-            const builtins = getBuiltins();
+        (0, vitest_1.describe)("builtin methods - dynamic validation", () => {
+            const builtins = (0, builtins_js_1.getBuiltins)();
             // Test each builtin object (Math, Array.prototype, String.prototype)
             Object.entries(builtins).forEach(([objectName, schema]) => {
                 if (!schema.methods)
                     return;
-                describe(`${objectName} methods`, () => {
+                (0, vitest_1.describe)(`${objectName} methods`, () => {
                     Object.entries(schema.methods).forEach(([methodName, methodDef]) => {
                         const displayName = objectName === "Math" ? `Math.${methodName}` : methodName;
-                        it(`should allow ${displayName} with valid parameters`, () => {
+                        (0, vitest_1.it)(`should allow ${displayName} with valid parameters`, () => {
                             let testExpression;
                             if (objectName === "Math") {
                                 // Math methods
@@ -294,15 +296,15 @@ describe("analyze - consolidated tests", () => {
                                 // Fallback
                                 testExpression = `<Text>{${objectName}.${methodName}()}</Text>`;
                             }
-                            const ast = parse(testExpression);
-                            const result = analyze(ast, baseSchema);
-                            expect(result.hasErrors).toBe(false);
+                            const ast = (0, index_js_1.parse)(testExpression);
+                            const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                            (0, vitest_1.expect)(result.hasErrors).toBe(false);
                         });
                         // Test parameter validation for methods that have parameter constraints
                         const requiredParams = methodDef.params.filter((p) => p.required);
                         const nonVariadicParams = methodDef.params.filter((p) => !p.variadic);
                         if (requiredParams.length > 0) {
-                            it(`should validate ${displayName} minimum parameters`, () => {
+                            (0, vitest_1.it)(`should validate ${displayName} minimum parameters`, () => {
                                 let testExpression;
                                 if (objectName === "Math") {
                                     testExpression = `<Text>{Math.${methodName}()}</Text>`;
@@ -316,15 +318,15 @@ describe("analyze - consolidated tests", () => {
                                 else {
                                     testExpression = `<Text>{${objectName}.${methodName}()}</Text>`;
                                 }
-                                const ast = parse(testExpression);
-                                const result = analyze(ast, baseSchema);
-                                expect(result.hasWarnings).toBe(true);
-                                expect(result.warnings[0].message).toContain(`${displayName} expects at least ${requiredParams.length} parameter`);
+                                const ast = (0, index_js_1.parse)(testExpression);
+                                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                                (0, vitest_1.expect)(result.hasWarnings).toBe(true);
+                                (0, vitest_1.expect)(result.warnings[0].message).toContain(`${displayName} expects at least ${requiredParams.length} parameter`);
                             });
                         }
                         // Test maximum parameters for non-variadic methods
                         if (nonVariadicParams.length === methodDef.params.length && methodDef.params.length > 0) {
-                            it(`should validate ${displayName} maximum parameters`, () => {
+                            (0, vitest_1.it)(`should validate ${displayName} maximum parameters`, () => {
                                 // Create a call with too many parameters
                                 const maxParams = methodDef.params.length;
                                 const extraParams = Array(maxParams + 2)
@@ -348,24 +350,24 @@ describe("analyze - consolidated tests", () => {
                                 else {
                                     testExpression = `<Text>{${objectName}.${methodName}(${extraParams})}</Text>`;
                                 }
-                                const ast = parse(testExpression);
-                                const result = analyze(ast, baseSchema);
-                                expect(result.hasWarnings).toBe(true);
-                                expect(result.warnings[0].message).toContain(`${displayName} expects at most ${maxParams} parameter`);
+                                const ast = (0, index_js_1.parse)(testExpression);
+                                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                                (0, vitest_1.expect)(result.hasWarnings).toBe(true);
+                                (0, vitest_1.expect)(result.warnings[0].message).toContain(`${displayName} expects at most ${maxParams} parameter`);
                             });
                         }
                     });
                 });
             });
         });
-        describe("builtin properties - dynamic validation", () => {
-            const builtins = getBuiltins();
+        (0, vitest_1.describe)("builtin properties - dynamic validation", () => {
+            const builtins = (0, builtins_js_1.getBuiltins)();
             Object.entries(builtins).forEach(([objectName, schema]) => {
                 if (!schema.properties)
                     return;
-                describe(`${objectName} properties`, () => {
+                (0, vitest_1.describe)(`${objectName} properties`, () => {
                     Object.entries(schema.properties).forEach(([propName, propDef]) => {
-                        it(`should allow ${objectName}.${propName} property access`, () => {
+                        (0, vitest_1.it)(`should allow ${objectName}.${propName} property access`, () => {
                             let testExpression;
                             if (objectName === "Array.prototype") {
                                 testExpression = `<Text>{data.items.${propName}}</Text>`;
@@ -376,39 +378,39 @@ describe("analyze - consolidated tests", () => {
                             else {
                                 testExpression = `<Text>{${objectName}.${propName}}</Text>`;
                             }
-                            const ast = parse(testExpression);
-                            const result = analyze(ast, baseSchema);
-                            expect(result.hasErrors).toBe(false);
+                            const ast = (0, index_js_1.parse)(testExpression);
+                            const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                            (0, vitest_1.expect)(result.hasErrors).toBe(false);
                         });
                     });
                 });
             });
         });
-        describe("blocked methods", () => {
-            it("should block mutating array methods", () => {
+        (0, vitest_1.describe)("blocked methods", () => {
+            (0, vitest_1.it)("should block mutating array methods", () => {
                 const blockedMethods = ["push", "pop", "shift", "unshift", "splice", "reverse", "sort"];
                 blockedMethods.forEach((method) => {
-                    const ast = parse(`<Text>{data.items.${method}()}</Text>`);
-                    const result = analyze(ast, baseSchema);
-                    expect(result.hasErrors).toBe(true);
-                    expect(result.errors[0].message).toContain(`method .${method} not allowed`);
+                    const ast = (0, index_js_1.parse)(`<Text>{data.items.${method}()}</Text>`);
+                    const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                    (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                    (0, vitest_1.expect)(result.errors[0].message).toContain(`method .${method} not allowed`);
                 });
             });
-            it("should block Math.random (non-deterministic)", () => {
-                const ast = parse("<Text>{Math.random()}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain("method Math.random not allowed");
+            (0, vitest_1.it)("should block Math.random (non-deterministic)", () => {
+                const ast = (0, index_js_1.parse)("<Text>{Math.random()}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("method Math.random not allowed");
             });
-            it("should block unknown methods", () => {
-                const ast = parse("<Text>{Math.unknownMethod()}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain("method Math.unknownMethod not allowed");
+            (0, vitest_1.it)("should block unknown methods", () => {
+                const ast = (0, index_js_1.parse)("<Text>{Math.unknownMethod()}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("method Math.unknownMethod not allowed");
             });
         });
-        describe("custom builtin schema", () => {
-            it("should work with custom builtin schema", () => {
+        (0, vitest_1.describe)("custom builtin schema", () => {
+            (0, vitest_1.it)("should work with custom builtin schema", () => {
                 const customSchema = {
                     data: {
                         value: { type: "number" },
@@ -418,15 +420,15 @@ describe("analyze - consolidated tests", () => {
                     },
                 };
                 // Math.max should work with default builtins
-                const ast1 = parse("<Text>{Math.max(data.value, 10)}</Text>");
-                const result1 = analyze(ast1, customSchema);
-                expect(result1.hasErrors).toBe(false);
+                const ast1 = (0, index_js_1.parse)("<Text>{Math.max(data.value, 10)}</Text>");
+                const result1 = (0, analyze_js_1.analyze)(ast1, customSchema);
+                (0, vitest_1.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 result2 = analyze(ast2, customSchema);
-                expect(result2.hasErrors).toBe(false);
+                const ast2 = (0, index_js_1.parse)("<Text>{Math.min(data.value, 10)}</Text>");
+                const result2 = (0, analyze_js_1.analyze)(ast2, customSchema);
+                (0, vitest_1.expect)(result2.hasErrors).toBe(false);
             });
-            it("should allow custom String methods in builtin schema", () => {
+            (0, vitest_1.it)("should allow custom String methods in builtin schema", () => {
                 const customSchema = {
                     data: {
                         text: { type: "string" },
@@ -435,14 +437,14 @@ describe("analyze - consolidated tests", () => {
                         Text: { props: {} },
                     },
                 };
-                const ast1 = parse("<Text>{data.text.toUpperCase()}</Text>");
-                const result1 = analyze(ast1, customSchema);
-                expect(result1.hasErrors).toBe(false);
-                const ast2 = parse("<Text>{data.text.toLowerCase()}</Text>");
-                const result2 = analyze(ast2, customSchema);
-                expect(result2.hasErrors).toBe(false);
-            });
-            it("should fall back to default builtin schema when not specified", () => {
+                const ast1 = (0, index_js_1.parse)("<Text>{data.text.toUpperCase()}</Text>");
+                const result1 = (0, analyze_js_1.analyze)(ast1, customSchema);
+                (0, vitest_1.expect)(result1.hasErrors).toBe(false);
+                const ast2 = (0, index_js_1.parse)("<Text>{data.text.toLowerCase()}</Text>");
+                const result2 = (0, analyze_js_1.analyze)(ast2, customSchema);
+                (0, vitest_1.expect)(result2.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should fall back to default builtin schema when not specified", () => {
                 const schemaWithoutBuiltins = {
                     data: {
                         x: { type: "number" },
@@ -453,20 +455,20 @@ describe("analyze - consolidated tests", () => {
                     // No builtins specified - should use default
                 };
                 // Should work with default builtin schema
-                const ast = parse("<Text>{Math.max(data.x, 10)}</Text>");
-                const result = analyze(ast, schemaWithoutBuiltins);
-                expect(result.hasErrors).toBe(false);
+                const ast = (0, index_js_1.parse)("<Text>{Math.max(data.x, 10)}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, schemaWithoutBuiltins);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
             });
         });
     });
-    describe("JSX validation", () => {
-        describe("elements", () => {
-            it("should allow valid elements", () => {
-                const ast = parse("<Text>Hello</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(false);
-            });
-            it("should accept enum-constrained attribute values", () => {
+    (0, vitest_1.describe)("JSX validation", () => {
+        (0, vitest_1.describe)("elements", () => {
+            (0, vitest_1.it)("should allow valid elements", () => {
+                const ast = (0, index_js_1.parse)("<Text>Hello</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should accept enum-constrained attribute values", () => {
                 const schema = {
                     ...baseSchema,
                     elements: {
@@ -478,12 +480,12 @@ describe("analyze - consolidated tests", () => {
                         },
                     },
                 };
-                const ast = parse('<Badge variant="primary" />');
-                const result = analyze(ast, schema);
-                expect(result.hasWarnings).toBe(false);
-                expect(result.hasErrors).toBe(false);
+                const ast = (0, index_js_1.parse)('<Badge variant="primary" />');
+                const result = (0, analyze_js_1.analyze)(ast, schema);
+                (0, vitest_1.expect)(result.hasWarnings).toBe(false);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
             });
-            it("should report invalid enum attribute values", () => {
+            (0, vitest_1.it)("should report invalid enum attribute values", () => {
                 const schema = {
                     ...baseSchema,
                     elements: {
@@ -495,31 +497,31 @@ describe("analyze - consolidated tests", () => {
                         },
                     },
                 };
-                const ast = parse('<Badge variant="danger" />');
-                const result = analyze(ast, schema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].code).toBe("INVALID_ATTRIBUTE_VALUE");
-                expect(result.errors[0].suggestions).toEqual(["primary", "secondary"]);
-            });
-            it("should block invalid elements", () => {
-                const ast = parse("<InvalidElement>Hello</InvalidElement>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain("Element <InvalidElement> not allowed");
-            });
-            it("should allow nested valid elements", () => {
-                const ast = parse(`
+                const ast = (0, index_js_1.parse)('<Badge variant="danger" />');
+                const result = (0, analyze_js_1.analyze)(ast, schema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].code).toBe("INVALID_ATTRIBUTE_VALUE");
+                (0, vitest_1.expect)(result.errors[0].suggestions).toEqual(["primary", "secondary"]);
+            });
+            (0, vitest_1.it)("should block invalid elements", () => {
+                const ast = (0, index_js_1.parse)("<InvalidElement>Hello</InvalidElement>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain("Element <InvalidElement> not allowed");
+            });
+            (0, vitest_1.it)("should allow nested valid elements", () => {
+                const ast = (0, index_js_1.parse)(`
           <div>
             <Text>Hello</Text>
             <span>World</span>
           </div>
         `);
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(false);
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
             });
         });
-        describe("spread attributes", () => {
-            it("should allow spread with data object", () => {
+        (0, vitest_1.describe)("spread attributes", () => {
+            (0, vitest_1.it)("should allow spread with data object", () => {
                 const schema = {
                     data: {
                         props: {
@@ -539,11 +541,11 @@ describe("analyze - consolidated tests", () => {
                         },
                     },
                 };
-                const ast = parse("<Card {...data.props} />");
-                const result = analyze(ast, schema);
-                expect(result.hasErrors).toBe(false);
+                const ast = (0, index_js_1.parse)("<Card {...data.props} />");
+                const result = (0, analyze_js_1.analyze)(ast, schema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
             });
-            it("should allow spread with nested data object", () => {
+            (0, vitest_1.it)("should allow spread with nested data object", () => {
                 const schema = {
                     data: {
                         user: {
@@ -568,11 +570,11 @@ describe("analyze - consolidated tests", () => {
                         },
                     },
                 };
-                const ast = parse("<Text {...data.user.attributes} />");
-                const result = analyze(ast, schema);
-                expect(result.hasErrors).toBe(false);
+                const ast = (0, index_js_1.parse)("<Text {...data.user.attributes} />");
+                const result = (0, analyze_js_1.analyze)(ast, schema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
             });
-            it("should allow spread with arrow function parameter", () => {
+            (0, vitest_1.it)("should allow spread with arrow function parameter", () => {
                 const schema = {
                     data: {
                         items: {
@@ -604,11 +606,11 @@ describe("analyze - consolidated tests", () => {
                         },
                     },
                 };
-                const ast = parse("<div>{data.items.map(item => <Item {...item.props} />)}</div>");
-                const result = analyze(ast, schema);
-                expect(result.hasErrors).toBe(false);
+                const ast = (0, index_js_1.parse)("<div>{data.items.map(item => <Item {...item.props} />)}</div>");
+                const result = (0, analyze_js_1.analyze)(ast, schema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
             });
-            it("should allow spread with the parameter itself", () => {
+            (0, vitest_1.it)("should allow spread with the parameter itself", () => {
                 const schema = {
                     data: {
                         items: {
@@ -634,11 +636,11 @@ describe("analyze - consolidated tests", () => {
                         },
                     },
                 };
-                const ast = parse("<div>{data.items.map(item => <Item {...item} />)}</div>");
-                const result = analyze(ast, schema);
-                expect(result.hasErrors).toBe(false);
+                const ast = (0, index_js_1.parse)("<div>{data.items.map(item => <Item {...item} />)}</div>");
+                const result = (0, analyze_js_1.analyze)(ast, schema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
             });
-            it("should allow spread combined with regular attributes", () => {
+            (0, vitest_1.it)("should allow spread combined with regular attributes", () => {
                 const schema = {
                     data: {
                         props: {
@@ -657,11 +659,11 @@ describe("analyze - consolidated tests", () => {
                         },
                     },
                 };
-                const ast = parse("<Card {...data.props} highlighted={true} />");
-                const result = analyze(ast, schema);
-                expect(result.hasErrors).toBe(false);
+                const ast = (0, index_js_1.parse)("<Card {...data.props} highlighted={true} />");
+                const result = (0, analyze_js_1.analyze)(ast, schema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
             });
-            it("should allow multiple spreads", () => {
+            (0, vitest_1.it)("should allow multiple spreads", () => {
                 const schema = {
                     data: {
                         baseProps: {
@@ -686,77 +688,77 @@ describe("analyze - consolidated tests", () => {
                         },
                     },
                 };
-                const ast = parse("<Card {...data.baseProps} {...data.extraProps} />");
-                const result = analyze(ast, schema);
-                expect(result.hasErrors).toBe(false);
+                const ast = (0, index_js_1.parse)("<Card {...data.baseProps} {...data.extraProps} />");
+                const result = (0, analyze_js_1.analyze)(ast, schema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
             });
         });
-        describe("empty expressions", () => {
-            it("should allow empty JSX expressions {} in children", () => {
-                const ast = parse("<Text>{}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(false);
-            });
-            it("should allow multiple empty expressions in children", () => {
-                const ast = parse("<Text>{}{}{}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(false);
-            });
-            it("should allow empty expressions mixed with content in children", () => {
-                const ast = parse("<Text>Hello {}{data.user.name}{} World</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(false);
-            });
-            it("should handle empty expressions without compile errors", () => {
-                const ast = parse("<Text>{}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(false);
-                expect(ast).toBeDefined();
-                expect(ast.body).toHaveLength(1);
+        (0, vitest_1.describe)("empty expressions", () => {
+            (0, vitest_1.it)("should allow empty JSX expressions {} in children", () => {
+                const ast = (0, index_js_1.parse)("<Text>{}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should allow multiple empty expressions in children", () => {
+                const ast = (0, index_js_1.parse)("<Text>{}{}{}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should allow empty expressions mixed with content in children", () => {
+                const ast = (0, index_js_1.parse)("<Text>Hello {}{data.user.name}{} World</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+            });
+            (0, vitest_1.it)("should handle empty expressions without compile errors", () => {
+                const ast = (0, index_js_1.parse)("<Text>{}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(false);
+                (0, vitest_1.expect)(ast).toBeDefined();
+                (0, vitest_1.expect)(ast.body).toHaveLength(1);
             });
         });
     });
-    describe("security validation", () => {
-        describe("disallowed identifiers", () => {
-            it("should block window access", () => {
-                const ast = parse("<Text>{window.alert('hack')}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain('Identifier "window" not allowed');
-            });
-            it("should block document access", () => {
-                const ast = parse("<Text>{document.body}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain('Identifier "document" not allowed');
+    (0, vitest_1.describe)("security validation", () => {
+        (0, vitest_1.describe)("disallowed identifiers", () => {
+            (0, vitest_1.it)("should block window access", () => {
+                const ast = (0, index_js_1.parse)("<Text>{window.alert('hack')}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain('Identifier "window" not allowed');
+            });
+            (0, vitest_1.it)("should block document access", () => {
+                const ast = (0, index_js_1.parse)("<Text>{document.body}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain('Identifier "document" not allowed');
             });
         });
-        describe("dangerous expressions", () => {
-            it("should block eval", () => {
-                const ast = parse("<Text>{eval('alert(1)')}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain('Identifier "eval" not allowed');
-            });
-            it("should block Function constructor", () => {
-                const ast = parse("<Text>{new Function('return 1')()}</Text>");
-                const result = analyze(ast, baseSchema);
-                expect(result.hasErrors).toBe(true);
-                expect(result.errors[0].message).toContain('Identifier "Function" not allowed');
+        (0, vitest_1.describe)("dangerous expressions", () => {
+            (0, vitest_1.it)("should block eval", () => {
+                const ast = (0, index_js_1.parse)("<Text>{eval('alert(1)')}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain('Identifier "eval" not allowed');
+            });
+            (0, vitest_1.it)("should block Function constructor", () => {
+                const ast = (0, index_js_1.parse)("<Text>{new Function('return 1')()}</Text>");
+                const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+                (0, vitest_1.expect)(result.hasErrors).toBe(true);
+                (0, vitest_1.expect)(result.errors[0].message).toContain('Identifier "Function" not allowed');
             });
         });
     });
-    describe("integration scenarios", () => {
-        it("should catch multiple errors in complex expressions", () => {
-            const ast = parse(`
+    (0, vitest_1.describe)("integration scenarios", () => {
+        (0, vitest_1.it)("should catch multiple errors in complex expressions", () => {
+            const ast = (0, index_js_1.parse)(`
         <InvalidElement>
           <Text>{data.user.invalid}</Text>
           <span>{window.location}</span>
         </InvalidElement>
       `);
-            const result = analyze(ast, baseSchema);
-            expect(result.hasErrors).toBe(true);
-            expect(result.errors.length).toBeGreaterThan(1);
+            const result = (0, analyze_js_1.analyze)(ast, baseSchema);
+            (0, vitest_1.expect)(result.hasErrors).toBe(true);
+            (0, vitest_1.expect)(result.errors.length).toBeGreaterThan(1);
         });
     });
 });