@xlabs-store/core 0.0.1 → 0.0.3

package/dist/collection/utils/code-editor/ast-parser.js

@@ -0,0 +1,378 @@
+// src/utils/ast-parser.ts
+// Lightweight JS AST parser — produces a tree for the AST Explorer panel
+const JS_KEYWORDS = new Set([
+    'const',
+    'let',
+    'var',
+    'function',
+    'class',
+    'return',
+    'if',
+    'else',
+    'for',
+    'while',
+    'do',
+    'switch',
+    'case',
+    'break',
+    'continue',
+    'new',
+    'import',
+    'export',
+    'default',
+    'from',
+    'async',
+    'await',
+    'try',
+    'catch',
+    'finally',
+    'throw',
+    'typeof',
+    'instanceof',
+    'delete',
+    'void',
+    'yield',
+]);
+function tokenize(code) {
+    const toks = [];
+    let i = 0;
+    while (i < code.length) {
+        // whitespace
+        if (/\s/.test(code[i])) {
+            i++;
+            continue;
+        }
+        // single-line comment
+        if (code.slice(i, i + 2) === '//') {
+            while (i < code.length && code[i] !== '\n')
+                i++;
+            continue;
+        }
+        // multi-line comment
+        if (code.slice(i, i + 2) === '/*') {
+            while (i < code.length && code.slice(i, i + 2) !== '*/')
+                i++;
+            i += 2;
+            continue;
+        }
+        // string / template
+        const strM = code.slice(i).match(/^("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/);
+        if (strM) {
+            toks.push({ t: 'string', v: strM[0] });
+            i += strM[0].length;
+            continue;
+        }
+        // number
+        const numM = code.slice(i).match(/^[\d.]+/);
+        if (numM) {
+            toks.push({ t: 'number', v: numM[0] });
+            i += numM[0].length;
+            continue;
+        }
+        // identifier / keyword
+        const idM = code.slice(i).match(/^[a-zA-Z_$][a-zA-Z0-9_$]*/);
+        if (idM) {
+            toks.push({ t: JS_KEYWORDS.has(idM[0]) ? 'keyword' : 'identifier', v: idM[0] });
+            i += idM[0].length;
+            continue;
+        }
+        // punctuation / operator
+        const pM = code.slice(i).match(/^(===|!==|=>|\.{3}|\?\?|[{}()\[\];,.:+\-*/%=<>!&|^~?])/);
+        if (pM) {
+            toks.push({ t: 'punct', v: pM[0] });
+            i += pM[0].length;
+            continue;
+        }
+        i++;
+    }
+    toks.push({ t: 'eof', v: '' });
+    return toks;
+}
+class Parser {
+    toks;
+    i = 0;
+    constructor(toks) {
+        this.toks = toks;
+    }
+    peek() {
+        return this.toks[this.i] ?? { t: 'eof', v: '' };
+    }
+    eat() {
+        return this.toks[this.i++] ?? { t: 'eof', v: '' };
+    }
+    parseProgram() {
+        const body = [];
+        while (this.peek().t !== 'eof' && this.i < this.toks.length - 1) {
+            try {
+                const node = this.parseStatement();
+                if (node)
+                    body.push(node);
+            }
+            catch {
+                this.i++;
+                if (body.length > 60)
+                    break;
+            }
+        }
+        return { type: 'Program', body };
+    }
+    parseStatement() {
+        const p = this.peek();
+        if (p.v === 'import')
+            return this.parseImport();
+        if (p.v === 'export')
+            return this.parseExport();
+        if (p.v === 'class')
+            return this.parseClass();
+        if (p.v === 'function' || p.v === 'async')
+            return this.parseFunction();
+        if (p.v === 'const' || p.v === 'let' || p.v === 'var')
+            return this.parseVarDecl();
+        if (p.v === 'return')
+            return this.parseReturn();
+        if (p.v === 'if')
+            return this.parseIf();
+        if (p.v === 'for')
+            return this.parseFor();
+        if (p.v === 'while')
+            return this.parseWhile();
+        if (p.v === 'try')
+            return this.parseTryCatch();
+        // expression statement — skip to semicolon or block boundary
+        return this.skipToSemicolon();
+    }
+    skipToSemicolon() {
+        let depth = 0;
+        while (this.peek().t !== 'eof') {
+            const v = this.peek().v;
+            if (v === '{' || v === '(' || v === '[')
+                depth++;
+            if (v === '}' || v === ')' || v === ']') {
+                if (depth === 0)
+                    break;
+                depth--;
+            }
+            if (depth === 0 && v === ';') {
+                this.eat();
+                break;
+            }
+            this.eat();
+        }
+        return { type: 'ExpressionStatement' };
+    }
+    parseImport() {
+        this.eat(); // import
+        const specifiers = [];
+        while (this.peek().t !== 'eof' && this.peek().v !== ';' && this.peek().v !== '\n') {
+            if (this.peek().t === 'identifier')
+                specifiers.push(this.peek().v);
+            this.eat();
+        }
+        if (this.peek().v === ';')
+            this.eat();
+        return { type: 'ImportDeclaration', specifiers };
+    }
+    parseExport() {
+        this.eat(); // export
+        const isDefault = this.peek().v === 'default';
+        if (isDefault)
+            this.eat();
+        const declaration = this.peek().t !== 'eof' ? this.parseStatement() : null;
+        return { type: 'ExportDeclaration', default: isDefault, declaration };
+    }
+    parseClass() {
+        this.eat(); // class
+        const name = this.peek().t === 'identifier' ? this.eat().v : '';
+        let superClass = null;
+        if (this.peek().v === 'extends') {
+            this.eat();
+            superClass = this.peek().t === 'identifier' ? this.eat().v : null;
+        }
+        const methods = [];
+        if (this.peek().v === '{') {
+            this.eat();
+            let depth = 1;
+            const methodStart = this.i;
+            while (this.peek().t !== 'eof' && depth > 0) {
+                const v = this.peek().v;
+                if (v === '{')
+                    depth++;
+                if (v === '}') {
+                    depth--;
+                    if (depth === 0) {
+                        this.eat();
+                        break;
+                    }
+                }
+                if (depth === 1 && this.peek().t === 'identifier' && this.toks[this.i + 1]?.v === '(') {
+                    const modifier = this.toks[this.i - 1]?.v === 'static' ? 'static' : this.toks[this.i - 1]?.v === 'async' ? 'async' : '';
+                    methods.push({ type: 'MethodDefinition', key: this.peek().v, kind: modifier || 'method' });
+                }
+                this.eat();
+            }
+            void methodStart;
+        }
+        return { type: 'ClassDeclaration', id: { name }, superClass, body: { type: 'ClassBody', body: methods } };
+    }
+    parseFunction() {
+        if (this.peek().v === 'async')
+            this.eat();
+        this.eat(); // function
+        const name = this.peek().t === 'identifier' ? this.eat().v : '(anonymous)';
+        const params = [];
+        if (this.peek().v === '(') {
+            this.eat();
+            while (this.peek().v !== ')' && this.peek().t !== 'eof') {
+                if (this.peek().t === 'identifier')
+                    params.push(this.peek().v);
+                this.eat();
+            }
+            if (this.peek().v === ')')
+                this.eat();
+        }
+        // skip body
+        this.skipBlock();
+        return { type: 'FunctionDeclaration', id: { name }, params: params.map(p => ({ type: 'Identifier', name: p })) };
+    }
+    skipBlock() {
+        if (this.peek().v !== '{')
+            return;
+        this.eat();
+        let depth = 1;
+        while (this.peek().t !== 'eof' && depth > 0) {
+            if (this.peek().v === '{')
+                depth++;
+            if (this.peek().v === '}')
+                depth--;
+            this.eat();
+        }
+    }
+    parseVarDecl() {
+        const kind = this.eat().v; // const / let / var
+        const declarations = [];
+        while (this.peek().t !== 'eof' && this.peek().v !== ';') {
+            if (this.peek().t === 'identifier') {
+                const id = this.eat().v;
+                let init = null;
+                if (this.peek().v === '=') {
+                    this.eat();
+                    // try to capture simple init expression
+                    if (this.peek().t === 'string')
+                        init = { type: 'Literal', value: this.eat().v };
+                    else if (this.peek().t === 'number')
+                        init = { type: 'Literal', value: this.eat().v };
+                    else if (this.peek().v === 'new') {
+                        this.eat();
+                        const cls = this.peek().t === 'identifier' ? this.eat().v : '';
+                        if (this.peek().v === '(') {
+                            this.eat();
+                            while (this.peek().v !== ')' && this.peek().t !== 'eof')
+                                this.eat();
+                            this.eat();
+                        }
+                        init = { type: 'NewExpression', callee: cls };
+                    }
+                    else {
+                        // skip complex init
+                        let depth = 0;
+                        while (this.peek().t !== 'eof') {
+                            const v = this.peek().v;
+                            if (v === '{' || v === '(' || v === '[')
+                                depth++;
+                            if (v === '}' || v === ')' || v === ']') {
+                                if (depth === 0)
+                                    break;
+                                depth--;
+                            }
+                            if (depth === 0 && (v === ',' || v === ';'))
+                                break;
+                            this.eat();
+                        }
+                    }
+                }
+                declarations.push({ type: 'VariableDeclarator', id: { type: 'Identifier', name: id }, init });
+                if (this.peek().v === ',')
+                    this.eat();
+            }
+            else {
+                if (this.peek().v === '{' || this.peek().v === '[') {
+                    this.skipBlock();
+                    break;
+                }
+                this.eat();
+            }
+        }
+        if (this.peek().v === ';')
+            this.eat();
+        return { type: 'VariableDeclaration', kind, declarations };
+    }
+    parseReturn() {
+        this.eat(); // return
+        return this.skipToSemicolon() && { type: 'ReturnStatement' };
+    }
+    parseIf() {
+        this.eat(); // if
+        if (this.peek().v === '(') {
+            this.eat();
+            while (this.peek().v !== ')' && this.peek().t !== 'eof')
+                this.eat();
+            this.eat();
+        }
+        this.skipBlock();
+        if (this.peek().v === 'else') {
+            this.eat();
+            this.skipBlock();
+        }
+        return { type: 'IfStatement' };
+    }
+    parseFor() {
+        this.eat(); // for
+        if (this.peek().v === '(') {
+            this.eat();
+            while (this.peek().v !== ')' && this.peek().t !== 'eof')
+                this.eat();
+            this.eat();
+        }
+        this.skipBlock();
+        return { type: 'ForStatement' };
+    }
+    parseWhile() {
+        this.eat(); // while
+        if (this.peek().v === '(') {
+            this.eat();
+            while (this.peek().v !== ')' && this.peek().t !== 'eof')
+                this.eat();
+            this.eat();
+        }
+        this.skipBlock();
+        return { type: 'WhileStatement' };
+    }
+    parseTryCatch() {
+        this.eat(); // try
+        this.skipBlock();
+        if (this.peek().v === 'catch') {
+            this.eat();
+            if (this.peek().v === '(') {
+                this.eat();
+                while (this.peek().v !== ')' && this.peek().t !== 'eof')
+                    this.eat();
+                this.eat();
+            }
+            this.skipBlock();
+        }
+        if (this.peek().v === 'finally') {
+            this.eat();
+            this.skipBlock();
+        }
+        return { type: 'TryStatement' };
+    }
+}
+export function parseAST(code) {
+    try {
+        const toks = tokenize(code);
+        return new Parser(toks).parseProgram();
+    }
+    catch (e) {
+        return { type: 'Program', body: [], error: String(e) };
+    }
+}