feat(app): add import processor

Author: zzhenryquezz

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

@@ -2,13 +2,20 @@ import { Lexer, TokenType } from '@language-kit/lexer'
 import { Node } from '../types/node'
 import { Processor } from '../types/processor'
 import { ParserToken } from '../types/token'
+
+import importProcessor from './processor.import'
 import variableProcessor from './processor.variable'
 import functionProcessor from './processor.function'
 import eofProcessor from './processor.eof'
 
 export function createParser() {
     const lexer = new Lexer()
-    const processors: Processor[] = [variableProcessor, functionProcessor, eofProcessor]
+    const processors: Processor[] = [
+        importProcessor,
+        variableProcessor,
+        functionProcessor,
+        eofProcessor,
+    ]
 
     function toTokens(value: string) {
         const tokens = lexer.tokenize(value)

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

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest'
+
+import { createParser } from './parser'
+import { NodeImport, NodeType } from '../types/node'
+
+describe('Parser', () => {
+    const parser = createParser()
+
+    it.each([
+        ["import lodash from 'lodash'", 'lodash', 'lodash'],
+        [`import lodash from "lodash"`, 'lodash', 'lodash'],
+        ['import lodash from `lodash`', 'lodash', 'lodash'],
+        ['import { ref } from "vue"', 'vue', '{ ref }'],
+        ['import { ref, computed } from "vue"', 'vue', '{ ref, computed }'],
+    ])('should convert %o to import node', (code, moduleId, statements) => {
+        const result = parser.toNodes(code)
+
+        const node = result[0] as NodeImport
+
+        expect(result.length).toBe(1)
+
+        expect(node.moduleId).toEqual(moduleId)
+        expect(node.statements).toBe(statements)
+        expect(node.start).toEqual(0)
+        expect(node.end).toEqual(code.length)
+        expect(node.type).toEqual(NodeType.Import)
+        expect(node.tokens).toEqual(parser.toTokens(code))
+    })
+})

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

@@ -0,0 +1,102 @@
+import { TokenType } from '@language-kit/lexer'
+import { defineProcessor } from '../helpers/define-processor'
+import { NodeImport, NodeType, NodeVariable } from '../types/node'
+import { ParserToken } from '../types/token'
+
+const quotes = [`'`, `"`, '`']
+
+function findStatements(tokens: ParserToken[]) {
+    const start = tokens[2]
+
+    if (!start) {
+        return []
+    }
+
+    if (start.type == TokenType.Word) {
+        return [start]
+    }
+
+    if (start.value === '{') {
+        const end = tokens.findIndex((t) => t.value === '}')
+
+        return tokens.slice(2, end + 1)
+    }
+
+    return []
+}
+
+function findModuleId(tokens: ParserToken[]) {
+    const start = tokens.findIndex((t) => quotes.includes(t.value))
+    const end = tokens.findIndex((t, i) => {
+        if (i <= start) return false
+
+        return quotes.includes(t.value)
+    })
+
+    if (start === -1 || end === -1) {
+        return ''
+    }
+
+    return tokens
+        .slice(start + 1, end)
+        .map((t) => t.value)
+        .join('')
+}
+
+export default defineProcessor({
+    process(options) {
+        const { tokens, nodes } = options
+
+        const result = {
+            processed: false,
+            tokens,
+            nodes,
+        }
+
+        const current = tokens[0]
+        const moduleId = findModuleId(tokens)
+
+        if (current.value !== 'import') {
+            return result
+        }
+
+        const endIndex = tokens.findIndex((t, i) => {
+            const prev = tokens[i - 1]
+
+            if (!prev) return false
+
+            if (prev.type !== TokenType.Word) return false
+
+            if (prev.value !== moduleId) return false
+
+            return quotes.includes(t.value)
+        })
+
+        if (endIndex === -1) {
+            return result
+        }
+
+        const nodeTokens = tokens.slice(0, endIndex + 1)
+        const statementsTokens = findStatements(tokens)
+        const statements = statementsTokens.map((t) => t.value).join('')
+
+        if (!nodeTokens.length) {
+            return result
+        }
+
+        const node: NodeImport = {
+            type: NodeType.Import,
+            tokens: nodeTokens,
+            start: nodeTokens[0].start,
+            end: nodeTokens[nodeTokens.length - 1].end,
+            moduleId,
+            statements,
+        }
+
+        result.processed = true
+        result.nodes = [...nodes, node]
+        result.tokens = tokens.slice(endIndex + 1)
+
+        return result
+    },
+})

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

@@ -4,6 +4,7 @@ export enum NodeType {
     Unknown = 'Unknown',
     Variable = 'Variable',
     Function = 'Function',
+    Import = 'Import',
 }
 
 export interface Node {
@@ -18,3 +19,9 @@ export interface NodeVariable extends Node {
     name: string
     value: string
 }
+
+export interface NodeImport extends Node {
+    type: NodeType.Import
+    moduleId: string
+    statements: string
+}