feat(app): create NodeVariable interface

Author: zzhenryquezz

packages/app/modules/evaluation/parser/parser.spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest'
 
 import { createParser } from './parser'
-import { NodeType } from '../types/node'
+import { NodeType, NodeVariable } from '../types/node'
 
 describe('Parser', () => {
     const parser = createParser()
@@ -18,11 +18,16 @@ describe('Parser', () => {
     ])('should convert %o to variable node', (code) => {
         const result = parser.toNodes(code)
 
+        const node = result[0] as NodeVariable
+
         expect(result.length).toBe(1)
-        expect(result[0].start).toEqual(0)
-        expect(result[0].end).toEqual(code.length)
-        expect(result[0].type).toEqual(NodeType.Variable)
-        expect(result[0].tokens).toEqual(parser.toTokens(code))
+
+        expect(node.name).toEqual('code')
+        expect(node.value).toBe(code.slice(13))
+        expect(node.start).toEqual(0)
+        expect(node.end).toEqual(code.length)
+        expect(node.type).toEqual(NodeType.Variable)
+        expect(node.tokens).toEqual(parser.toTokens(code))
     })
 
     it.each([

packages/app/modules/evaluation/parser/processor.variable.ts

@@ -1,6 +1,21 @@
 import { TokenType } from '@language-kit/lexer'
 import { defineProcessor } from '../helpers/define-processor'
-import { Node, NodeType } from '../types/node'
+import { Node, NodeType, NodeVariable } from '../types/node'
+import { ParserToken } from '../types/token'
+
+function findName(tokens: ParserToken[]) {
+    return tokens.slice(1).find((t) => t.type === TokenType.Word)
+}
+
+function findDeclaration(tokens: ParserToken[]) {
+    const declarationIndex = tokens.findIndex((t, i) => {
+        const prev = tokens[i - 2]
+
+        return prev && prev.value === '='
+    })
+
+    return tokens[declarationIndex]
+}
 
 export default defineProcessor({
     process(options) {
@@ -13,20 +28,17 @@ export default defineProcessor({
         }
 
         const current = tokens[0]
+        const name = findName(tokens)
+        const declaration = findDeclaration(tokens)
+        const declarationIndex = tokens.indexOf(declaration)
 
-        const isVariable = ['const', 'let', 'var'].includes(current.value)
-
-        if (!isVariable) return result
-
-        const declarationIndex = tokens.findIndex((t, i) => {
-            const prev = tokens[i - 2]
-
-            return prev && prev.value === '='
-        })
-
-        const declaration = tokens[declarationIndex]
+        if (!current || !declaration || !name) {
+            return result
+        }
 
-        if (!declaration) return result
+        if (!['const', 'let', 'var'].includes(current.value)) {
+            return result
+        }
 
         const openCloseCases = [
             { open: '"', close: '"' },
@@ -67,11 +79,20 @@ export default defineProcessor({
 
         if (endIndex === -1) return result
 
-        const node: Node = {
+        const nodeTokens = tokens.slice(0, endIndex + 1)
+
+        const value = nodeTokens
+            .slice(declarationIndex)
+            .map((t) => t.value)
+            .join('')
+
+        const node: NodeVariable = {
             start: current.start,
+            name: name.value,
+            value: value,
             end: tokens[endIndex].end,
             type: NodeType.Variable,
-            tokens: tokens.slice(0, endIndex + 1),
+            tokens: nodeTokens,
         }
 
         result.processed = true

packages/app/modules/evaluation/types/node.ts

@@ -12,3 +12,9 @@ export interface Node {
     type: NodeType
     tokens: ParserToken[]
 }
+
+export interface NodeVariable extends Node {
+    type: NodeType.Variable
+    name: string
+    value: string
+}