agency-lang 0.0.15 → 0.0.17

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.d.ts

@@ -1,9 +1,10 @@
-import { InterpolationSegment, Literal, NumberLiteral, PromptLiteral, StringLiteral, TextSegment, VariableNameLiteral } from "../types.js";
+import { InterpolationSegment, Literal, MultiLineStringLiteral, NumberLiteral, PromptLiteral, StringLiteral, TextSegment, VariableNameLiteral } from "../types.js";
 import { Parser } from "tarsec";
 export declare const textSegmentParser: Parser<TextSegment>;
 export declare const interpolationSegmentParser: Parser<InterpolationSegment>;
 export declare const promptParser: Parser<PromptLiteral>;
 export declare const numberParser: Parser<NumberLiteral>;
 export declare const stringParser: Parser<StringLiteral>;
+export declare const multiLineStringParser: Parser<MultiLineStringLiteral>;
 export declare const variableNameParser: Parser<VariableNameLiteral>;
 export declare const literalParser: Parser<Literal>;

package/dist/lib/parsers/literals.js

@@ -1,12 +1,22 @@
 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, manyTillOneOf, manyTillStr, manyWithJoin, map, or, seq, seqC, set, str, } from "tarsec";
 export const textSegmentParser = map(many1Till(or(backtick, char("$"))), (text) => ({
     type: "text",
     value: text,
 }));
-export const interpolationSegmentParser = seqC(set("type", "interpolation"), char("$"), char("{"), capture(many1Till(char("}")), "variableName"), char("}"));
+export const interpolationSegmentParser = seqC(set("type", "interpolation"), char("$"), char("{"), capture(manyTillStr("}"), "variableName"), char("}"));
 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 literalParser = or(promptParser, numberParser, stringParser, variableNameParser);
+export const stringParser = seqC(set("type", "string"), char('"'), capture(manyTillOneOf(['"', "\n"]), "value"), char('"'));
+export const multiLineStringParser = seqC(set("type", "multiLineString"), str('"""'), capture(manyTillStr('"""'), "value"), str('"""'));
+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, multiLineStringParser, stringParser, variableNameParser);

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { textSegmentParser, interpolationSegmentParser, promptParser, numberParser, stringParser, variableNameParser, literalParser, } from "./literals.js";
+import { textSegmentParser, interpolationSegmentParser, promptParser, numberParser, stringParser, multiLineStringParser, variableNameParser, literalParser, } from "./literals.js";
 describe("literals parsers", () => {
     describe("textSegmentParser", () => {
         const testCases = [
@@ -112,7 +112,16 @@ describe("literals parsers", () => {
             { input: "${foo", expected: { success: false } },
             { input: "$foo}", expected: { success: false } },
             { input: "{foo}", expected: { success: false } },
-            { input: "${}", expected: { success: false } },
+            {
+                input: "${}",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "interpolation",
+                        variableName: "",
+                    },
+                },
+            },
             { input: "", expected: { success: false } },
             { input: "foo", expected: { success: false } },
         ];
@@ -391,13 +400,6 @@ describe("literals parsers", () => {
                     result: { type: "string", value: "tab\there" },
                 },
             },
-            {
-                input: '"newline\nhere"',
-                expected: {
-                    success: true,
-                    result: { type: "string", value: "newline\nhere" },
-                },
-            },
             {
                 input: '"special!@#$%^&*()"',
                 expected: {
@@ -425,6 +427,13 @@ describe("literals parsers", () => {
             { input: "'hello'", expected: { success: false } },
             { input: "", expected: { success: false } },
             { input: "hello", expected: { success: false } },
+            /// use """ for multi-line strings
+            {
+                input: '"newline\nhere"',
+                expected: {
+                    success: false,
+                },
+            },
         ];
         testCases.forEach(({ input, expected }) => {
             if (expected.success) {
@@ -444,6 +453,170 @@ describe("literals parsers", () => {
             }
         });
     });
+    describe("multiLineStringParser", () => {
+        const testCases = [
+            // Happy path - simple strings
+            {
+                input: '"""hello"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "hello" },
+                },
+            },
+            {
+                input: '"""world"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "world" },
+                },
+            },
+            // Empty multi-line string
+            {
+                input: '""""""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "" },
+                },
+            },
+            // Multi-line strings with actual newlines
+            {
+                input: '"""line1\nline2"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "line1\nline2" },
+                },
+            },
+            {
+                input: '"""line1\nline2\nline3"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "line1\nline2\nline3" },
+                },
+            },
+            {
+                input: '"""\nstarts with newline"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "\nstarts with newline" },
+                },
+            },
+            {
+                input: '"""ends with newline\n"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "ends with newline\n" },
+                },
+            },
+            // Strings with special characters
+            {
+                input: '"""Hello, World!"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "Hello, World!" },
+                },
+            },
+            {
+                input: '"""123"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "123" },
+                },
+            },
+            {
+                input: '"""  spaces  and  tabs\t\t"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "  spaces  and  tabs\t\t" },
+                },
+            },
+            {
+                input: '"""special!@#$%^&*()"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "special!@#$%^&*()" },
+                },
+            },
+            // Strings containing single and double quotes
+            {
+                input: '"""single\'quotes\'here"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "single'quotes'here" },
+                },
+            },
+            {
+                input: '"""double"quotes"here"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: 'double"quotes"here' },
+                },
+            },
+            {
+                input: '"""mixed"and\'quotes"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: `mixed"and'quotes` },
+                },
+            },
+            // Strings containing backticks and interpolation-like syntax
+            {
+                input: '"""`backtick`"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "`backtick`" },
+                },
+            },
+            {
+                input: '"""${notInterpolation}"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "${notInterpolation}" },
+                },
+            },
+            // Multiple consecutive newlines
+            {
+                input: '"""line1\n\n\nline2"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "line1\n\n\nline2" },
+                },
+            },
+            // Mixed whitespace
+            {
+                input: '"""  \n\t\n  """',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "  \n\t\n  " },
+                },
+            },
+            // Failure cases
+            { input: '"""hello', expected: { success: false } },
+            { input: 'hello"""', expected: { success: false } },
+            { input: '""hello"""', expected: { success: false } },
+            { input: '"""hello""', expected: { success: false } },
+            { input: '"hello"', expected: { success: false } },
+            { input: "'hello'", expected: { success: false } },
+            { input: "", expected: { success: false } },
+            { input: "hello", expected: { success: false } },
+        ];
+        testCases.forEach(({ input, expected }) => {
+            if (expected.success) {
+                it(`should parse ${JSON.stringify(input)} successfully`, () => {
+                    const result = multiLineStringParser(input);
+                    expect(result.success).toBe(true);
+                    if (result.success) {
+                        expect(result.result).toEqual(expected.result);
+                    }
+                });
+            }
+            else {
+                it(`should fail to parse ${JSON.stringify(input)}`, () => {
+                    const result = multiLineStringParser(input);
+                    expect(result.success).toBe(false);
+                });
+            }
+        });
+    });
     describe("variableNameParser", () => {
         const testCases = [
             // Happy path
@@ -497,13 +670,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 +694,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 {};