agency-lang 0.0.1

package/dist/parsers/typeHints.js

@@ -0,0 +1,59 @@
+import { optionalSpaces, varNameChar } from "./utils.js";
+import { capture, captureCaptures, char, count, digit, many1Till, many1WithJoin, or, sepBy, seqC, seqR, set, space, spaces, str, trace, } from "tarsec";
+import { optionalSemicolon } from "./parserUtils.js";
+export const primitiveTypeParser = trace("primitiveTypeParser", seqC(set("type", "primitiveType"), capture(or(str("number"), str("string"), str("boolean")), "value")));
+export const typeAliasVariableParser = trace("typeAliasVariableParser", seqC(set("type", "typeAliasVariable"), capture(many1WithJoin(varNameChar), "aliasName")));
+export const arrayTypeParser = (input) => {
+    const parser = trace("arrayTypeParser", seqC(set("type", "arrayType"), capture(or(objectTypeParser, primitiveTypeParser), "elementType"), capture(count(str("[]")), "arrayDepth")));
+    const result = parser(input);
+    if (result.success) {
+        // Wrap the elementType in ArrayType according to arrayDepth
+        let wrappedType = result.result.elementType;
+        for (let i = 0; i < result.result.arrayDepth; i++) {
+            wrappedType = {
+                type: "arrayType",
+                elementType: wrappedType,
+            };
+        }
+        return {
+            success: true,
+            rest: result.rest,
+            result: wrappedType,
+        };
+    }
+    return result;
+};
+export const angleBracketsArrayTypeParser = trace("angleBracketsArrayTypeParser", seqC(set("type", "arrayType"), str("array"), char("<"), capture(primitiveTypeParser, "elementType"), char(">")));
+export const stringLiteralTypeParser = trace("stringLiteralTypeParser", seqC(set("type", "stringLiteralType"), char('"'), capture(many1Till(char('"')), "value"), char('"')));
+export const numberLiteralTypeParser = trace("numberLiteralTypeParser", seqC(set("type", "numberLiteralType"), capture(many1WithJoin(or(char("-"), char("."), digit)), "value")));
+export const booleanLiteralTypeParser = trace("booleanLiteralTypeParser", seqC(set("type", "booleanLiteralType"), capture(or(str("true"), str("false")), "value")));
+export const objectPropertyDelimiter = seqR(optionalSpaces, char(";"), optionalSpaces);
+export const objectPropertyParser = trace("objectPropertyParser", (input) => {
+    const parser = seqC(capture(many1WithJoin(varNameChar), "key"), optionalSpaces, char(":"), optionalSpaces, capture(variableTypeParser, "value"));
+    return parser(input);
+});
+export const objectPropertyDescriptionParser = seqC(char("#"), optionalSpaces, capture(many1Till(char(";")), "description"));
+export const objectPropertyWithDescriptionParser = trace("objectPropertyWithDescriptionParser", seqC(captureCaptures(objectPropertyParser), spaces, captureCaptures(objectPropertyDescriptionParser)));
+export const objectTypeParser = trace("objectTypeParser", (input) => {
+    const parser = seqC(set("type", "objectType"), char("{"), optionalSpaces, capture(sepBy(objectPropertyDelimiter, or(objectPropertyWithDescriptionParser, objectPropertyParser)), "properties"), optionalSpaces, char("}"));
+    return parser(input);
+});
+export const unionItemParser = trace("unionItemParser", or(objectTypeParser, angleBracketsArrayTypeParser, arrayTypeParser, stringLiteralTypeParser, numberLiteralTypeParser, booleanLiteralTypeParser, primitiveTypeParser, typeAliasVariableParser));
+const pipe = seqR(optionalSpaces, str("|"), optionalSpaces);
+export const _unionTypeParser = (input) => {
+    const parser = seqC(set("type", "unionType"), capture(sepBy(pipe, unionItemParser), "types"));
+    const result = parser(input);
+    // Union types must have at least 2 types (i.e., at least one "|")
+    if (result.success && result.result.types.length < 2) {
+        return {
+            success: false,
+            rest: input,
+            message: "Union type must have at least 2 types",
+        };
+    }
+    return result;
+};
+export const unionTypeParser = trace("unionTypeParser", _unionTypeParser);
+export const variableTypeParser = trace("variableTypeParser", or(unionTypeParser, arrayTypeParser, objectTypeParser, angleBracketsArrayTypeParser, stringLiteralTypeParser, numberLiteralTypeParser, booleanLiteralTypeParser, primitiveTypeParser, typeAliasVariableParser));
+export const typeHintParser = trace("typeHintParser", seqC(set("type", "typeHint"), capture(many1Till(space), "variableName"), optionalSpaces, str("::"), optionalSpaces, capture(variableTypeParser, "variableType"), optionalSemicolon));
+export const typeAliasParser = trace("typeAliasParser", seqC(set("type", "typeAlias"), str("type"), spaces, capture(many1WithJoin(varNameChar), "aliasName"), optionalSpaces, str("="), optionalSpaces, capture(variableTypeParser, "aliasedType"), optionalSemicolon));