@qrvey/formula-lang 0.0.2 → 0.0.3

package/dist/index.d.ts

@@ -1 +1,2 @@
 export * from "./grammar/qformula.grammar";
+export * from "./parser/json-parser";

package/dist/index.js

@@ -1 +1,2 @@
 export * from "./grammar/qformula.grammar";
+export * from "./parser/json-parser";

package/dist/models/ast.models.d.ts

@@ -0,0 +1,29 @@
+export interface AstNode {
+    type: string;
+}
+export interface AstBinaryExpressionNode extends AstNode {
+    operator: string;
+    left: AstNode;
+    right: AstNode;
+}
+export interface AstUnaryExpressionNode extends AstNode {
+    operator: string;
+    right: AstNode;
+}
+export interface AstValueNode extends AstNode {
+    value: string | boolean | number | AstNode[];
+    dataType: string;
+}
+export interface AstVariableNode extends AstNode {
+    value: string;
+}
+export interface AstFunctionNode extends AstNode {
+    name: string;
+    arguments: AstNode[];
+}
+export interface AstProgramNode extends AstNode {
+    exp: string;
+    lang: string;
+    version: string;
+    body: AstNode;
+}

package/dist/models/ast.models.js

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

package/dist/parser/json-parser.d.ts

@@ -0,0 +1,3 @@
+import { AstNode } from "../models/ast.models";
+import { SyntaxNode } from "@lezer/common";
+export declare function calculateAST(program: string, startNode: SyntaxNode): AstNode;

package/dist/parser/json-parser.js

@@ -0,0 +1,90 @@
+import { getNodeValue } from "../utils/utils";
+const PARSER_VERSION = "0.0.0";
+const LANG_NAME = "QrveyLang";
+export function calculateAST(program, startNode) {
+    if (!startNode)
+        return { type: 'undefined' };
+    return {
+        "type": "Program",
+        "exp": program,
+        "lang": LANG_NAME,
+        "version": PARSER_VERSION,
+        "body": transformNode(program, startNode)
+    };
+}
+function transformNode(program, node) {
+    if (!node)
+        return { type: 'undefined' };
+    switch (node.name) {
+        case 'BinaryExpression':
+            return transformBinaryExpression(program, node);
+        case 'UnaryExpression':
+            return transformUnaryExpression(program, node);
+        case 'Function':
+            return transformFunctionExpression(program, node);
+        case 'Number':
+            return {
+                type: "Literal",
+                dataType: "number",
+                value: parseFloat(getNodeValue(program, node))
+            };
+        case 'String':
+            return {
+                type: "Literal",
+                dataType: "string",
+                value: getNodeValue(program, node).slice(1, -1)
+            };
+        case 'Boolean':
+            return {
+                type: "Literal",
+                dataType: "boolean",
+                value: getNodeValue(program, node) === 'true'
+            };
+        case 'Array':
+            return {
+                type: "Literal",
+                dataType: "array",
+                value: node.getChildren('Value')
+                    .map(node => {
+                    return transformNode(program, node);
+                })
+            };
+        case 'Variable':
+            return {
+                type: "Variable",
+                value: getNodeValue(program, node).slice(1, -1)
+            };
+        default:
+            return transformNode(program, node.firstChild);
+    }
+}
+function transformBinaryExpression(program, node) {
+    const [left, right] = node.getChildren('Expression');
+    const operator = node.getChild('ArithOp');
+    return {
+        operator: getNodeValue(program, operator),
+        type: "BinaryExpression",
+        left: transformNode(program, left),
+        right: transformNode(program, right)
+    };
+}
+function transformUnaryExpression(program, node) {
+    const [right] = node.getChildren('Expression');
+    const operator = node.getChild('ArithOp');
+    return {
+        operator: getNodeValue(program, operator),
+        type: "UnaryExpression",
+        right: transformNode(program, right)
+    };
+}
+function transformFunctionExpression(program, node) {
+    const args = node.getChild('FunctionArguments');
+    const nodeValue = node.getChild('FunctionIdentifier');
+    return {
+        type: "FunctionCall",
+        name: getNodeValue(program, nodeValue),
+        arguments: !!args ? args
+            .getChildren('Expression')
+            .map(node => transformNode(program, node)) : []
+    };
+}

package/dist/utils/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function getNodeValue(str: string, { from, to }: {
+    from: number;
+    to: number;
+}): string;

package/dist/utils/utils.js

@@ -0,0 +1,3 @@
+export function getNodeValue(str, { from, to }) {
+    return str.slice(from, to);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qrvey/formula-lang",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "QFormula support for qrvey projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,6 +26,7 @@
   "homepage": "https://bitbucket.org/qrvey/qrvey_formula_lang#readme",
   "dependencies": {
     "@codemirror/language": "^6.6.0",
+    "@lezer/common": "^1.0.2",
     "@lezer/highlight": "^1.1.4"
   },
   "devDependencies": {
@@ -35,4 +36,4 @@
     "rollup-plugin-ts": "^3.2.0",
     "typescript": "^5.0.4"
   }
-}
+}