agency-lang 0.0.15 → 0.0.16

package/dist/lib/parsers/functionCall.js

@@ -1,10 +1,11 @@
 import { capture, char, many1WithJoin, or, sepBy, seqC, seqR, set, } from "tarsec";
-import { accessExpressionParser } from "./access.js";
+import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { literalParser } from "./literals.js";
 import { optionalSemicolon } from "./parserUtils.js";
 import { optionalSpaces, varNameChar } from "./utils.js";
+import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
 const comma = seqR(optionalSpaces, char(","), optionalSpaces);
 export const functionCallParser = (input) => {
-    const parser = seqC(set("type", "functionCall"), capture(many1WithJoin(varNameChar), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionCallParser, accessExpressionParser, literalParser)), "arguments"), optionalSpaces, char(")"), optionalSemicolon);
+    const parser = seqC(set("type", "functionCall"), capture(many1WithJoin(varNameChar), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, or(agencyArrayParser, agencyObjectParser, indexAccessParser, functionCallParser, accessExpressionParser, literalParser)), "arguments"), optionalSpaces, char(")"), optionalSemicolon);
     return parser(input);
 };

package/dist/lib/parsers/functionCall.test.js

@@ -98,6 +98,316 @@ describe("functionCallParser", () => {
             input: "",
             expected: { success: false },
         },
+        // Function calls with array arguments
+        {
+            input: "processArray([1, 2, 3])",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "processArray",
+                    arguments: [
+                        {
+                            type: "agencyArray",
+                            items: [
+                                { type: "number", value: "1" },
+                                { type: "number", value: "2" },
+                                { type: "number", value: "3" },
+                            ],
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            input: "processArray([1, 2, 3, 4, 5])",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "processArray",
+                    arguments: [
+                        {
+                            type: "agencyArray",
+                            items: [
+                                { type: "number", value: "1" },
+                                { type: "number", value: "2" },
+                                { type: "number", value: "3" },
+                                { type: "number", value: "4" },
+                                { type: "number", value: "5" },
+                            ],
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            input: "handleStrings([\"hello\", \"world\"])",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "handleStrings",
+                    arguments: [
+                        {
+                            type: "agencyArray",
+                            items: [
+                                { type: "string", value: "hello" },
+                                { type: "string", value: "world" },
+                            ],
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            input: "processEmpty([])",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "processEmpty",
+                    arguments: [
+                        {
+                            type: "agencyArray",
+                            items: [],
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            input: "processNested([[1, 2], [3, 4]])",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "processNested",
+                    arguments: [
+                        {
+                            type: "agencyArray",
+                            items: [
+                                {
+                                    type: "agencyArray",
+                                    items: [
+                                        { type: "number", value: "1" },
+                                        { type: "number", value: "2" },
+                                    ],
+                                },
+                                {
+                                    type: "agencyArray",
+                                    items: [
+                                        { type: "number", value: "3" },
+                                        { type: "number", value: "4" },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        },
+        // Function calls with object arguments
+        {
+            input: "configure({key: \"value\"})",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "configure",
+                    arguments: [
+                        {
+                            type: "agencyObject",
+                            entries: [
+                                {
+                                    key: "key",
+                                    value: { type: "string", value: "value" },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            input: "createUser({name: \"Alice\", age: 30})",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "createUser",
+                    arguments: [
+                        {
+                            type: "agencyObject",
+                            entries: [
+                                {
+                                    key: "name",
+                                    value: { type: "string", value: "Alice" },
+                                },
+                                {
+                                    key: "age",
+                                    value: { type: "number", value: "30" },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            input: "initialize({})",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "initialize",
+                    arguments: [
+                        {
+                            type: "agencyObject",
+                            entries: [],
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            input: "processData({items: [1, 2, 3]})",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "processData",
+                    arguments: [
+                        {
+                            type: "agencyObject",
+                            entries: [
+                                {
+                                    key: "items",
+                                    value: {
+                                        type: "agencyArray",
+                                        items: [
+                                            { type: "number", value: "1" },
+                                            { type: "number", value: "2" },
+                                            { type: "number", value: "3" },
+                                        ],
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            input: "nestedConfig({outer: {inner: 42}})",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "nestedConfig",
+                    arguments: [
+                        {
+                            type: "agencyObject",
+                            entries: [
+                                {
+                                    key: "outer",
+                                    value: {
+                                        type: "agencyObject",
+                                        entries: [
+                                            {
+                                                key: "inner",
+                                                value: { type: "number", value: "42" },
+                                            },
+                                        ],
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        },
+        // Function calls with mixed arguments
+        {
+            input: "mixed(42, [1, 2], {key: \"value\"})",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "mixed",
+                    arguments: [
+                        { type: "number", value: "42" },
+                        {
+                            type: "agencyArray",
+                            items: [
+                                { type: "number", value: "1" },
+                                { type: "number", value: "2" },
+                            ],
+                        },
+                        {
+                            type: "agencyObject",
+                            entries: [
+                                {
+                                    key: "key",
+                                    value: { type: "string", value: "value" },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            input: "complexCall(\"test\", [], {}, 100)",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "complexCall",
+                    arguments: [
+                        { type: "string", value: "test" },
+                        {
+                            type: "agencyArray",
+                            items: [],
+                        },
+                        {
+                            type: "agencyObject",
+                            entries: [],
+                        },
+                        { type: "number", value: "100" },
+                    ],
+                },
+            },
+        },
+        {
+            input: "withVariables(x, [y, z], {key: value})",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "withVariables",
+                    arguments: [
+                        { type: "variableName", value: "x" },
+                        {
+                            type: "agencyArray",
+                            items: [
+                                { type: "variableName", value: "y" },
+                                { type: "variableName", value: "z" },
+                            ],
+                        },
+                        {
+                            type: "agencyObject",
+                            entries: [
+                                {
+                                    key: "key",
+                                    value: { type: "variableName", value: "value" },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        },
     ];
     testCases.forEach(({ input, expected }) => {
         if (expected.success) {

package/dist/lib/parsers/literals.js

@@ -1,5 +1,5 @@
 import { backtick, varNameChar } from "./utils.js";
-import { capture, char, digit, many, many1Till, many1WithJoin, manyTill, map, or, seqC, set, } from "tarsec";
+import { capture, char, digit, letter, many, many1Till, many1WithJoin, manyTill, manyWithJoin, map, or, seq, seqC, set, } from "tarsec";
 export const textSegmentParser = map(many1Till(or(backtick, char("$"))), (text) => ({
     type: "text",
     value: text,
@@ -8,5 +8,14 @@ export const interpolationSegmentParser = seqC(set("type", "interpolation"), cha
 export const promptParser = seqC(set("type", "prompt"), backtick, capture(many(or(textSegmentParser, interpolationSegmentParser)), "segments"), backtick);
 export const numberParser = seqC(set("type", "number"), capture(many1WithJoin(or(char("-"), char("."), digit)), "value"));
 export const stringParser = seqC(set("type", "string"), char('"'), capture(manyTill(char('"')), "value"), char('"'));
-export const variableNameParser = seqC(set("type", "variableName"), capture(many1WithJoin(varNameChar), "value"));
+export const variableNameParser = seq([
+    set("type", "variableName"),
+    capture(letter, "init"),
+    capture(manyWithJoin(varNameChar), "value"),
+], (_, captures) => {
+    return {
+        type: "variableName",
+        value: `${captures.init}${captures.value}`,
+    };
+});
 export const literalParser = or(promptParser, numberParser, stringParser, variableNameParser);

package/dist/lib/parsers/literals.test.js

@@ -497,13 +497,6 @@ describe("literals parsers", () => {
                     result: { type: "variableName", value: "var2test" },
                 },
             },
-            {
-                input: "123",
-                expected: {
-                    success: true,
-                    result: { type: "variableName", value: "123" },
-                },
-            },
             // Mixed case
             {
                 input: "camelCase",
@@ -528,6 +521,13 @@ describe("literals parsers", () => {
             },
             // Failure cases
             { input: "", expected: { success: false } },
+            // cannot start with number
+            {
+                input: "1a",
+                expected: {
+                    success: false,
+                },
+            },
         ];
         testCases.forEach(({ input, expected }) => {
             if (expected.success) {

package/dist/lib/parsers/matchBlock.js

@@ -13,12 +13,12 @@ import { optionalSpaces } from "./utils.js";
 import { literalParser } from "./literals.js";
 import { assignmentParser } from "./assignment.js";
 import { functionCallParser } from "./functionCall.js";
-import { accessExpressionParser } from "./access.js";
+import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { optionalSemicolon } from "./parserUtils.js";
 import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
 import { commentParser } from "./comment.js";
 import { returnStatementParser } from "./returnStatement.js";
 export const defaultCaseParser = char("_");
-export const matchBlockParserCase = seqC(set("type", "matchBlockCase"), optionalSpaces, capture(or(defaultCaseParser, accessExpressionParser, literalParser), "caseValue"), optionalSpaces, str("=>"), optionalSpaces, capture(or(returnStatementParser, agencyArrayParser, agencyObjectParser, accessExpressionParser, assignmentParser, functionCallParser, literalParser), "body"));
+export const matchBlockParserCase = seqC(set("type", "matchBlockCase"), optionalSpaces, capture(or(defaultCaseParser, indexAccessParser, accessExpressionParser, literalParser), "caseValue"), optionalSpaces, str("=>"), optionalSpaces, capture(or(returnStatementParser, agencyArrayParser, agencyObjectParser, accessExpressionParser, assignmentParser, functionCallParser, literalParser), "body"));
 const semicolon = seqC(optionalSpaces, char(";"), optionalSpaces);
 export const matchBlockParser = seqC(set("type", "matchBlock"), str("match"), optionalSpaces, char("("), capture(literalParser, "expression"), char(")"), optionalSpaces, char("{"), optionalSpaces, capture(sepBy(or(semicolon, newline), or(commentParser, matchBlockParserCase)), "cases"), optionalSpaces, char("}"), optionalSemicolon);

package/dist/lib/parsers/parserUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/parsers/parserUtils.test.js

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest";
+import { optionalSemicolon } from "./parserUtils.js";
+describe("parserUtils", () => {
+    describe("optionalSemicolon", () => {
+        const testCases = [
+            // Happy path - semicolon present
+            {
+                input: ";",
+                expected: { success: true, result: ";" },
+            },
+            {
+                input: ";rest",
+                expected: { success: true, result: ";", rest: "rest" },
+            },
+            // Happy path - no semicolon (optional means success even without match)
+            {
+                input: "",
+                expected: { success: true, result: null },
+            },
+            {
+                input: "other",
+                expected: { success: true, result: null, rest: "other" },
+            },
+            {
+                input: " ;",
+                expected: { success: true, result: null, rest: " ;" },
+            },
+            {
+                input: ";;",
+                expected: { success: true, result: ";", rest: ";" },
+            },
+        ];
+        testCases.forEach(({ input, expected }) => {
+            it(`should parse "${input}" successfully`, () => {
+                const result = optionalSemicolon(input);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.result).toEqual(expected.result);
+                    if (expected.rest !== undefined) {
+                        expect(result.rest).toEqual(expected.rest);
+                    }
+                }
+            });
+        });
+    });
+});

package/dist/lib/parsers/returnStatement.js

@@ -1,8 +1,8 @@
 import { seqC, set, str, capture, or } from "tarsec";
-import { accessExpressionParser } from "./access.js";
+import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { functionCallParser } from "./functionCall.js";
 import { optionalSemicolon } from "./parserUtils.js";
 import { optionalSpaces } from "./utils.js";
 import { literalParser } from "./literals.js";
 import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
-export const returnStatementParser = seqC(set("type", "returnStatement"), str("return"), optionalSpaces, capture(or(accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser), "value"), optionalSemicolon);
+export const returnStatementParser = seqC(set("type", "returnStatement"), str("return"), optionalSpaces, capture(or(indexAccessParser, accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser), "value"), optionalSemicolon);

package/dist/lib/parsers/returnStatement.test.d.ts

@@ -0,0 +1 @@
+export {};