@bikky/replication 1.0.1

package/Expressions/Compiler/__tests__/Replicable.Expressions.Parser.test.js

@@ -0,0 +1,516 @@
+import { describe, expect, test } from "vitest";
+import { TokenType } from "../Tokenizer.js";
+import { CreateASTFromString, ExpressionParser, MatchGrammar, MatchRepeatingRule, MatchRule } from "../Parser.js";
+import { GetVersionIndex, Versions } from "../../../Constants/Versions.js";
+import { ExpressionGrammar } from "../ExpressionGrammar.js";
+import { BikPath } from "@bikky/path";
+import "../BuiltinGrammar.js";
+var NodeType = ExpressionGrammar.NodeType;
+describe(" 1. Parsing Functions", () => {
+    let version = Versions.v1_0_0;
+    let sourceFile = BikPath.getCurrentFilepath();
+    let versionIndex = GetVersionIndex(version);
+    let singleText = "value";
+    // let single = TokenizeExpression(singleText, version);
+    let multipartText = "value.second";
+    // let multipart = TokenizeExpression(multipartText, version);
+    let fooText = "value()";
+    // let foo = TokenizeExpression(fooText, version);
+    let fooParamsText = "value(first, second)";
+    // let fooParams = TokenizeExpression(fooParamsText, version);
+    let castText = "value:=number";
+    // let cast = TokenizeExpression(castText, version);
+    let castMultipartText = "value:=number.second";
+    // let castMultipart = TokenizeExpression(castMultipartText, version);
+    let multipartCastText = "value.second:=number";
+    // let multipartCast = TokenizeExpression(multipartCastText, version);
+    let castRule = ExpressionGrammar.getRule(versionIndex, NodeType.FORCE_CAST);
+    let multipartRule = ExpressionGrammar.getRule(versionIndex, NodeType.MEMBER_ACCESS);
+    let fooRule = ExpressionGrammar.getRule(versionIndex, NodeType.FUNCTION_CALL);
+    let expressionRule = ExpressionGrammar.getRule(versionIndex, NodeType.EXPRESSION);
+    function MakeNextMatchDetails(text) {
+        return {
+            parser: new ExpressionParser(version, text, sourceFile),
+            debugTabs: "",
+            extraTypes: []
+        };
+    }
+    function MakePartialNode(type) {
+        return {
+            type: type,
+            debugName: NodeType[type],
+            values: {}
+        };
+    }
+    test(" 1. MatchRule Single", () => {
+        let details = MakeNextMatchDetails(singleText);
+        let result = MatchRule(details, expressionRule.rules[0], MakePartialNode(NodeType.EXPRESSION), []);
+        expect(result).not.toBeUndefined();
+        expect(result).toContainAtLeast({
+            type: NodeType.EXPRESSION,
+            values: {
+                expression: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(1);
+    });
+    test(" 2. MatchRule Multipart", () => {
+        let details = MakeNextMatchDetails(multipartText);
+        let result = MatchRule(details, multipartRule.rules[0], MakePartialNode(NodeType.MEMBER_ACCESS), []);
+        expect(result).toContainAtLeast({
+            type: NodeType.MEMBER_ACCESS,
+            values: {
+                context: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(1);
+        result = MatchRule(details, multipartRule.rules[1], result, []);
+        expect(result).not.toBeUndefined();
+        expect(details.parser.currentNodeIndex).toBe(2);
+        result = MatchRule(details, multipartRule.rules[2], result, []);
+        expect(result).toContainAtLeast({
+            type: NodeType.MEMBER_ACCESS,
+            values: {
+                context: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                },
+                memberName: {
+                    type: TokenType.IDENTIFIER,
+                    data: "second"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(3);
+    });
+    test(" 3. MatchGrammar Single", () => {
+        let details = MakeNextMatchDetails(singleText);
+        let result = MatchGrammar(details, NodeType.EXPRESSION, []);
+        expect(result).toContainAtLeast({
+            type: NodeType.EXPRESSION,
+            values: {
+                expression: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(1);
+    });
+    test(" 4. MatchGrammar Multipart", () => {
+        let details = MakeNextMatchDetails(multipartText);
+        let result = MatchGrammar(details, NodeType.EXPRESSION, []);
+        expect(result).toContainAtLeast({
+            type: NodeType.EXPRESSION,
+            values: {
+                expression: {
+                    type: NodeType.MEMBER_ACCESS,
+                    values: {
+                        context: {
+                            type: TokenType.IDENTIFIER,
+                            data: "value"
+                        },
+                        memberName: {
+                            type: TokenType.IDENTIFIER,
+                            data: "second"
+                        }
+                    }
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(3);
+    });
+    test(" 5. MatchRule Function Call", () => {
+        let details = MakeNextMatchDetails(fooText);
+        let result = MatchRule(details, fooRule.rules[0], MakePartialNode(NodeType.FUNCTION_CALL), []);
+        expect(result).toContainAtLeast({
+            type: NodeType.FUNCTION_CALL,
+            values: {
+                name: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(1);
+        result = MatchRule(details, fooRule.rules[1], result, []);
+        expect(result).not.toBeUndefined();
+        expect(details.parser.currentNodeIndex).toBe(2);
+        result = MatchRepeatingRule(details, fooRule.rules[2], result, []);
+        expect(result).toContainAtLeast({
+            type: NodeType.FUNCTION_CALL,
+            values: {
+                name: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(2);
+    });
+    test(" 6. MatchRule Function with Parameters", () => {
+        let details = MakeNextMatchDetails(fooParamsText);
+        let result = MatchRule(details, fooRule.rules[0], MakePartialNode(NodeType.FUNCTION_CALL), []);
+        expect(result).toContainAtLeast({
+            type: NodeType.FUNCTION_CALL,
+            values: {
+                name: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(1);
+        result = MatchRule(details, fooRule.rules[1], result, []);
+        expect(result).not.toBeUndefined();
+        expect(details.parser.currentNodeIndex).toBe(2);
+        result = MatchRepeatingRule(details, fooRule.rules[2], result, []);
+        expect(result).toContainAtLeast({
+            type: NodeType.FUNCTION_CALL,
+            values: {
+                name: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                },
+                arguments: [{
+                        type: NodeType.EXPRESSION,
+                        values: {
+                            expression: {
+                                type: TokenType.IDENTIFIER,
+                                data: "first"
+                            }
+                        }
+                    }, {
+                        type: NodeType.EXPRESSION,
+                        values: {
+                            expression: {
+                                type: TokenType.IDENTIFIER,
+                                data: "second"
+                            }
+                        }
+                    }]
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(6);
+    });
+    test(" 7. MatchRule Cast", () => {
+        let details = MakeNextMatchDetails(castText);
+        let result = MatchRule(details, castRule.rules[0], MakePartialNode(NodeType.FORCE_CAST), []);
+        expect(result).toContainAtLeast({
+            type: NodeType.FORCE_CAST,
+            values: {
+                expression: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(1);
+        result = MatchRule(details, castRule.rules[1], result, []);
+        result = MatchRule(details, castRule.rules[2], result, []);
+        result = MatchRule(details, castRule.rules[3], result, []);
+        expect(result).toContainAtLeast({
+            type: NodeType.FORCE_CAST,
+            values: {
+                expression: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                },
+                castType: {
+                    type: TokenType.IDENTIFIER,
+                    data: "number"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(4);
+    });
+    test(" 8. MatchRule Cast Multipart", () => {
+        let details = MakeNextMatchDetails(castMultipartText);
+        let result = MatchRule(details, multipartRule.rules[0], MakePartialNode(NodeType.MEMBER_ACCESS), []);
+        expect(result).toContainAtLeast({
+            type: NodeType.MEMBER_ACCESS,
+            values: {
+                context: {
+                    type: NodeType.FORCE_CAST,
+                    values: {
+                        expression: {
+                            type: TokenType.IDENTIFIER,
+                            data: "value"
+                        },
+                        castType: {
+                            type: TokenType.IDENTIFIER,
+                            data: "number"
+                        }
+                    }
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(4);
+        result = MatchRule(details, multipartRule.rules[1], result, []);
+        result = MatchRule(details, multipartRule.rules[2], result, []);
+        expect(result).toContainAtLeast({
+            type: NodeType.MEMBER_ACCESS,
+            values: {
+                context: {
+                    type: NodeType.FORCE_CAST,
+                    values: {
+                        expression: {
+                            type: TokenType.IDENTIFIER,
+                            data: "value"
+                        },
+                        castType: {
+                            type: TokenType.IDENTIFIER,
+                            data: "number"
+                        }
+                    }
+                },
+                memberName: {
+                    type: TokenType.IDENTIFIER,
+                    data: "second"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(6);
+    });
+    test(" 9. MatchRule Multipart Cast", () => {
+        let details = MakeNextMatchDetails(multipartCastText);
+        let result = MatchRule(details, multipartRule.rules[0], MakePartialNode(NodeType.MEMBER_ACCESS), []);
+        expect(result).toContainAtLeast({
+            type: NodeType.MEMBER_ACCESS,
+            values: {
+                context: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(1);
+        result = MatchRule(details, multipartRule.rules[1], result, []);
+        result = MatchRule(details, multipartRule.rules[2], result, []);
+        expect(result).toContainAtLeast({
+            type: NodeType.MEMBER_ACCESS,
+            values: {
+                context: {
+                    type: TokenType.IDENTIFIER,
+                    data: "value"
+                },
+                memberName: {
+                    type: NodeType.FORCE_CAST,
+                    values: {
+                        expression: {
+                            type: TokenType.IDENTIFIER,
+                            data: "second"
+                        },
+                        castType: {
+                            type: TokenType.IDENTIFIER,
+                            data: "number"
+                        }
+                    }
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(6);
+    });
+    test(" 10. MatchGrammar Function result cast", () => {
+        let details = MakeNextMatchDetails("value():=number");
+        let result = MatchGrammar(details, NodeType.EXPRESSION, []);
+        expect(result).toContainAtLeast({
+            type: NodeType.EXPRESSION,
+            values: {
+                expression: {
+                    type: NodeType.FORCE_CAST,
+                    values: {
+                        expression: {
+                            type: NodeType.FUNCTION_CALL,
+                            values: {
+                                name: {
+                                    type: TokenType.IDENTIFIER,
+                                    data: "value"
+                                },
+                            }
+                        },
+                        castType: {
+                            type: TokenType.IDENTIFIER,
+                            data: "number"
+                        }
+                    }
+                }
+            }
+        });
+        expect(details.parser.currentNodeIndex).toBe(6);
+    });
+    test(" 11. MatchGrammar Multipart Cast Function result cast", () => {
+        let details = MakeNextMatchDetails("value:=Entity.second():=number");
+        let result = MatchGrammar(details, NodeType.EXPRESSION, []);
+        expect(result).toContainAtLeast({
+            type: NodeType.EXPRESSION,
+            values: {
+                expression: {
+                    type: NodeType.MEMBER_ACCESS,
+                    values: {
+                        context: {
+                            type: NodeType.FORCE_CAST,
+                            values: {
+                                expression: {
+                                    type: TokenType.IDENTIFIER,
+                                    data: "value"
+                                },
+                                castType: {
+                                    type: TokenType.IDENTIFIER,
+                                    data: "Entity"
+                                }
+                            }
+                        },
+                        memberName: {
+                            type: NodeType.FORCE_CAST,
+                            values: {
+                                expression: {
+                                    type: NodeType.FUNCTION_CALL,
+                                    values: {
+                                        name: {
+                                            type: TokenType.IDENTIFIER,
+                                            data: "second"
+                                        },
+                                    }
+                                },
+                                castType: {
+                                    type: TokenType.IDENTIFIER,
+                                    data: "number"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    });
+});
+describe(" 2. Parser Class", () => {
+    test(" 1. Parse simple expression", () => {
+        let result = CreateASTFromString(Versions.v1_0_0, "value", "test");
+        expect(result).not.toBeUndefined();
+        expect(result.type, "First node should be file").toBe(NodeType.FILE);
+        expect(result.values.lines).not.toBeUndefined();
+        expect(result.values.lines, "File node should have 1 line").toHaveLength(1);
+        let expressionNode = result.values.lines[0];
+        expect(expressionNode.type, "Second node should be expression").toBe(NodeType.EXPRESSION);
+        expect(expressionNode.values.expression).not.toBeUndefined();
+        let identifierNode = expressionNode.values.expression;
+        expect(identifierNode.type, "Third node should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(identifierNode.data, "Identifier token's data should be 'value'").toBe("value");
+    });
+    test(" 2. Parse multipart expression", () => {
+        let result = CreateASTFromString(Versions.v1_0_0, "value.second", "test");
+        expect(result).not.toBeUndefined();
+        expect(result.type, "First node should be file").toBe(NodeType.FILE);
+        expect(result.values.lines).not.toBeUndefined();
+        expect(result.values.lines, "File node should have 1 line").toHaveLength(1);
+        let expressionNode = result.values.lines[0];
+        expect(expressionNode.type, "Second node should be expression").toBe(NodeType.EXPRESSION);
+        expect(expressionNode.values.expression).not.toBeUndefined();
+        let memberAccessNode = expressionNode.values.expression;
+        expect(memberAccessNode.type, "Third node should be member access node").toBe(NodeType.MEMBER_ACCESS);
+        expect(memberAccessNode.values.context.type, "Context should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(memberAccessNode.values.context.data, "Identifier token's data should be 'value'").toBe("value");
+        expect(memberAccessNode.values.memberName.type, "MemberName should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(memberAccessNode.values.memberName.data, "MemberName token's data should be 'second'").toBe("second");
+    });
+    test(" 3. Parse multipart multipart expression", () => {
+        let result = CreateASTFromString(Versions.v1_0_0, "value.second.third", "test");
+        expect(result).not.toBeUndefined();
+        expect(result.type, "First node should be file").toBe(NodeType.FILE);
+        expect(result.values.lines).not.toBeUndefined();
+        expect(result.values.lines, "File node should have 1 line").toHaveLength(1);
+        let expressionNode = result.values.lines[0];
+        expect(expressionNode.type, "Second node should be expression").toBe(NodeType.EXPRESSION);
+        expect(expressionNode.values.expression).not.toBeUndefined();
+        let memberAccessNode = expressionNode.values.expression;
+        expect(memberAccessNode.type, "Third node should be member access node").toBe(NodeType.MEMBER_ACCESS);
+        expect(memberAccessNode.values.context.type, "Context should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(memberAccessNode.values.context.data, "Identifier token's data should be 'value'").toBe("value");
+        let memberAccessNode2 = memberAccessNode.values.memberName;
+        expect(memberAccessNode2.type, "MemberName should be member access node").toBe(NodeType.MEMBER_ACCESS);
+        expect(memberAccessNode2.values.context.type, "Context2 should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(memberAccessNode2.values.context.data, "Identifier token's data should be 'second'").toBe("second");
+        expect(memberAccessNode2.values.memberName.type, "MemberName should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(memberAccessNode2.values.memberName.data, "MemberName token's data should be 'second'").toBe("third");
+    });
+    test(" 4. Parse cast expression", () => {
+        let result = CreateASTFromString(Versions.v1_0_0, "value:cast", "test");
+        expect(result).not.toBeUndefined();
+        expect(result.type, "First node should be file").toBe(NodeType.FILE);
+        expect(result.values.lines).not.toBeUndefined();
+        expect(result.values.lines, "File node should have 1 line").toHaveLength(1);
+        let expressionNode = result.values.lines[0];
+        expect(expressionNode.type, "Second node should be expression").toBe(NodeType.EXPRESSION);
+        expect(expressionNode.values.expression).not.toBeUndefined();
+        let castNode = expressionNode.values.expression;
+        expect(castNode.type, "Third node should be cast node").toBe(NodeType.CAST);
+        let identifierNode = castNode.values.expression;
+        expect(identifierNode.type, "Third node's left hand should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(identifierNode.data, "Identifier token's data should be 'value'").toBe("value");
+        let identifierNode2 = castNode.values.castType;
+        expect(identifierNode2.type, "Third node's right hand should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(identifierNode2.data, "Identifier token's data should be 'value'").toBe("cast");
+    });
+    test(" 5. Parse multipart cast expression", () => {
+        let result = CreateASTFromString(Versions.v1_0_0, "value.second:cast", "test");
+        expect(result).not.toBeUndefined();
+        expect(result.type, "First node should be file").toBe(NodeType.FILE);
+        expect(result.values.lines).not.toBeUndefined();
+        expect(result.values.lines, "File node should have 1 line").toHaveLength(1);
+        let expressionNode = result.values.lines[0];
+        expect(expressionNode.type, "Second node should be expression").toBe(NodeType.EXPRESSION);
+        expect(expressionNode.values.expression).not.toBeUndefined();
+        let memberAccessNode = expressionNode.values.expression;
+        expect(memberAccessNode.type, "Third node should be member access node").toBe(NodeType.MEMBER_ACCESS);
+        expect(memberAccessNode.values.context.type, "Context should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(memberAccessNode.values.context.data, "Identifier token's data should be 'value'").toBe("value");
+        expect(memberAccessNode.values.memberName.type, "MemberName should be cast node").toBe(NodeType.CAST);
+        let castNode = memberAccessNode.values.memberName;
+        expect(castNode.type, "Fourth node should be cast node").toBe(NodeType.CAST);
+        expect(castNode.values.expression.type, "Cast node token's lhs should be a token").toBe(TokenType.IDENTIFIER);
+        expect(castNode.values.expression.data, "Cast node token's lhs should be 'second'").toBe("second");
+        let identifierNode2 = castNode.values.castType;
+        expect(identifierNode2.type, "Third node's right hand should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(identifierNode2.data, "Identifier token's data should be 'value'").toBe("cast");
+    });
+    test(" 6. Parse multipart double cast expression", () => {
+        let result = CreateASTFromString(Versions.v1_0_0, "value.second:cast.third:cast2", "test");
+        expect(result).not.toBeUndefined();
+        expect(result.type, "First node should be file").toBe(NodeType.FILE);
+        expect(result.values.lines).not.toBeUndefined();
+        expect(result.values.lines, "File node should have 1 line").toHaveLength(1);
+        let expressionNode = result.values.lines[0];
+        expect(expressionNode.type, "Second node should be expression").toBe(NodeType.EXPRESSION);
+        expect(expressionNode.values.expression).not.toBeUndefined();
+        let valueDOTsecond = expressionNode.values.expression;
+        expect(valueDOTsecond.type, "Third node should be member access node").toBe(NodeType.MEMBER_ACCESS);
+        expect(valueDOTsecond.values.context.type, "Context should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(valueDOTsecond.values.context.data, "Identifier token's data should be 'value'").toBe("value");
+        expect(valueDOTsecond.values.memberName.type, "MemberName should be cast node").toBe(NodeType.MEMBER_ACCESS);
+        let secondDOTthird = valueDOTsecond.values.memberName;
+        expect(secondDOTthird.type, "Fourth node should be member access node").toBe(NodeType.MEMBER_ACCESS);
+        expect(secondDOTthird.values.context.type, "Context should be cast token").toBe(NodeType.CAST);
+        let secondCOLONcast = secondDOTthird.values.context;
+        expect(secondCOLONcast.type, "Fourth node lhs should be cast node").toBe(NodeType.CAST);
+        expect(secondCOLONcast.values.expression.type, "Cast node token's lhs should be a token").toBe(TokenType.IDENTIFIER);
+        expect(secondCOLONcast.values.expression.data, "Cast node token's lhs should be 'second'").toBe("second");
+        let cast = secondCOLONcast.values.castType;
+        expect(cast.type, "Fourth node's cast's rhs should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(cast.data, "Identifier token's data should be 'value'").toBe("cast");
+        let thirdCOLONcast2 = secondDOTthird.values.memberName;
+        expect(thirdCOLONcast2.type, "Fourth node lhs should be cast node").toBe(NodeType.CAST);
+        expect(thirdCOLONcast2.values.expression.type, "Cast node token's lhs should be a token").toBe(TokenType.IDENTIFIER);
+        expect(thirdCOLONcast2.values.expression.data, "Cast node token's lhs should be 'third'").toBe("third");
+        let cast2 = thirdCOLONcast2.values.castType;
+        expect(cast2.type, "Fourth node's cast's rhs should be identifier token").toBe(TokenType.IDENTIFIER);
+        expect(cast2.data, "Identifier token's data should be 'value'").toBe("cast2");
+    });
+});

package/Expressions/Compiler/__tests__/Replicable.Expressions.Tokenizer.test.d.ts

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

package/Expressions/Compiler/__tests__/Replicable.Expressions.Tokenizer.test.js

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "vitest";
+import { TokenizeExpression, TokenType } from "../Tokenizer.js";
+import { Versions } from "../../../Constants/Versions.js";
+describe("Tokenizer", () => {
+    let version = Versions.v1_0_0;
+    test(" 1. Tokenize simple expression", () => {
+        let result = TokenizeExpression("value", version);
+        expect(result).toHaveLength(1);
+        expect(result[0].type).toBe(TokenType.IDENTIFIER);
+    });
+    test(" 2. Tokenize multipart expression", () => {
+        let result = TokenizeExpression("value.second", version);
+        expect(result).toHaveLength(3);
+        expect(result).toContainAtLeast([{ type: TokenType.IDENTIFIER }, { type: TokenType.OPERATOR }, { type: TokenType.IDENTIFIER }]);
+    });
+    test(" 3. Tokenize function", () => {
+        let result = TokenizeExpression("value()", version);
+        expect(result).toHaveLength(3);
+        expect(result).toContainAtLeast([{ type: TokenType.IDENTIFIER }, { type: TokenType.OPERATOR }, { type: TokenType.OPERATOR }]);
+    });
+    test(" 4. Tokenize function with parameters", () => {
+        let result = TokenizeExpression("value(first, second)", version);
+        expect(result).toHaveLength(7);
+        expect(result).toContainAtLeast([
+            { type: TokenType.IDENTIFIER },
+            { type: TokenType.OPERATOR },
+            { type: TokenType.IDENTIFIER },
+            { type: TokenType.WHITESPACE },
+            { type: TokenType.OPERATOR },
+            { type: TokenType.IDENTIFIER },
+            { type: TokenType.OPERATOR },
+        ]);
+    });
+    test(" 5. Tokenize cast", () => {
+        let result = TokenizeExpression("value:=number", version);
+        expect(result).toHaveLength(4);
+        expect(result).toContainAtLeast([
+            { type: TokenType.IDENTIFIER },
+            { type: TokenType.OPERATOR },
+            { type: TokenType.OPERATOR },
+            { type: TokenType.IDENTIFIER },
+        ]);
+    });
+    test(" 6. Tokenize cast multipart", () => {
+        let result = TokenizeExpression("value:=number.second", version);
+        expect(result).toHaveLength(6);
+        expect(result).toContainAtLeast([
+            { type: TokenType.IDENTIFIER },
+            { type: TokenType.OPERATOR },
+            { type: TokenType.OPERATOR },
+            { type: TokenType.IDENTIFIER },
+            { type: TokenType.OPERATOR },
+            { type: TokenType.IDENTIFIER },
+        ]);
+    });
+    test(" 7. Tokenize multipart cast", () => {
+        let result = TokenizeExpression("value.second:=number", version);
+        expect(result).toHaveLength(6);
+        expect(result).toContainAtLeast([
+            { type: TokenType.IDENTIFIER },
+            { type: TokenType.OPERATOR },
+            { type: TokenType.IDENTIFIER },
+            { type: TokenType.OPERATOR },
+            { type: TokenType.OPERATOR },
+            { type: TokenType.IDENTIFIER },
+        ]);
+    });
+});

package/Expressions/CreateEvaluator.d.ts

@@ -0,0 +1,4 @@
+import { EvaluationChain } from "./EvaluatorChain.js";
+import { EvaluationString } from "./EvaluatorString.js";
+import { ExpressionConfiguration } from "./EvaluatorSteps.js";
+export declare function CreateExpression(rawText: string, sourceFile: string, config: Required<ExpressionConfiguration>): EvaluationString | EvaluationChain;

package/Expressions/CreateEvaluator.js

@@ -0,0 +1,85 @@
+import { CreateASTFromString } from "./Compiler/Parser.js";
+import { OrderASTSequentially, OrderedNodeSequencesToTrees } from "./Traverser.js";
+import { EvaluationString } from "./EvaluatorString.js";
+import { ExpressionType, matchExpression } from "./EvaluatorSteps.js";
+import { ExpressionSyntaxError } from "../Constants/Errors.js";
+const expressionCache = new Map();
+function CompareConfigs(a, b) {
+    if (a.startType === b.startType &&
+        a.outputTypes.length === b.outputTypes.length &&
+        a.duringLoad === b.duringLoad &&
+        a.version === b.version &&
+        a.cacheable === b.cacheable) {
+        for (let i = 0; i < a.outputTypes.length; i++) {
+            if (a.outputTypes[i] !== b.outputTypes[i])
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+export function CreateExpression(rawText, sourceFile, config) {
+    if (rawText.includes("${")) {
+        console.warn(`Expression contains deprecated syntax, use @ instead of $: ${rawText}`);
+    }
+    const cached = expressionCache.get(rawText);
+    if (cached) {
+        for (let entry of cached) {
+            if (CompareConfigs(entry.config, config)) {
+                return entry.expression;
+            }
+        }
+    }
+    let sources = [];
+    let expressions = [];
+    let type;
+    let i = 0;
+    let prepared_text = rawText
+        .replace(matchExpression, (match, index) => {
+        let ast = CreateASTFromString(config.version, match.slice(2, -1), sourceFile);
+        if (!ast)
+            throw new ExpressionSyntaxError(`Failed to parse expression: ${rawText}`, {
+                file: sourceFile,
+                text: rawText,
+                line: 0
+            }, index);
+        sources.push(ast);
+        let orderedAST = OrderASTSequentially(ast);
+        expressions.push({
+            //result is one per line but we only have one line.
+            expression: OrderedNodeSequencesToTrees(orderedAST, config)[0],
+            offset: index
+        });
+        expressions[expressions.length - 1].expression.rawText = rawText;
+        return "@{" + i++ + "}";
+    })
+        .trim();
+    let finalExpression;
+    if (prepared_text === "@{0}") {
+        finalExpression = expressions[0].expression;
+        if (config.outputArray || config.outputMap) {
+            finalExpression.type = ExpressionType.Collection;
+        }
+        else if (config.outputTypes[0] === "Function" || config.outputTypes[0] === Function) {
+            finalExpression.type = ExpressionType.Function;
+        }
+        else {
+            finalExpression.type = ExpressionType.Value;
+        }
+    }
+    else {
+        finalExpression = new EvaluationString(rawText, prepared_text, expressions, config);
+    }
+    //Non-string output types may only have one expression within.
+    if ((config.outputTypes.length !== 1 || (config.outputTypes[0] !== "String" && config.outputTypes[0] !== String))
+        && prepared_text != "@{0}") {
+        throw new Error(`Expressions returning non-string results must not contain non-expression syntax.`);
+    }
+    if (!cached) {
+        expressionCache.set(rawText, [{ expression: finalExpression, config }]);
+    }
+    else {
+        cached.push({ expression: finalExpression, config });
+    }
+    return finalExpression;
+}