@tachui/cli 0.8.12 → 0.8.13

package/dist/core/src/compiler/advanced-parser.js

@@ -1,702 +0,0 @@
-/**
- * Advanced SwiftUI Syntax Parser (Phase 2.1.2)
- *
- * Enhanced parser with support for:
- * - Conditional rendering (@if, @else)
- * - List iteration (@forEach)
- * - State bindings ($variable)
- * - Property wrappers (@State, @Computed)
- * - Complex expressions and function calls
- * - Nested modifier chains
- */
-/**
- * Enhanced SwiftUI syntax parser with advanced features
- */
-export class AdvancedSwiftUIParser {
-    code;
-    filename;
-    position = 0;
-    line = 1;
-    column = 1;
-    constructor(code, filename) {
-        this.code = code;
-        this.filename = filename;
-    }
-    /**
-     * Parse advanced SwiftUI syntax into enhanced AST
-     */
-    parse() {
-        const nodes = [];
-        while (!this.isAtEnd()) {
-            this.skipWhitespace();
-            if (this.isAtEnd())
-                break;
-            const node = this.parseAdvancedNode();
-            if (node) {
-                nodes.push(node);
-            }
-        }
-        return nodes;
-    }
-    /**
-     * Parse advanced AST nodes including conditionals and loops
-     */
-    parseAdvancedNode() {
-        const start = this.currentPosition();
-        // Save position to detect infinite loops
-        const initialPosition = this.position;
-        // Check for conditional rendering
-        if (this.match('if')) {
-            return this.parseConditional(start);
-        }
-        // Check for forEach loops
-        if (this.match('ForEach')) {
-            return this.parseForEach(start);
-        }
-        // Check for property wrappers
-        if (this.peek() === '@') {
-            return this.parsePropertyWrapper(start);
-        }
-        // Check for state bindings
-        if (this.peek() === '$') {
-            return this.parseStateBinding(start);
-        }
-        // Standard component parsing
-        if (this.isComponentStart()) {
-            return this.parseEnhancedComponent(start);
-        }
-        // Skip unrecognized tokens - ensure we always advance
-        if (this.position === initialPosition) {
-            this.advance();
-        }
-        return null;
-    }
-    /**
-     * Parse conditional rendering (if/else)
-     */
-    parseConditional(start) {
-        // 'if' already consumed by match()
-        this.skipWhitespace();
-        const condition = this.parseComplexExpression();
-        if (!condition) {
-            throw new Error(`Expected condition after 'if' at line ${this.line}`);
-        }
-        this.skipWhitespace();
-        // Parse then body
-        const thenBody = [];
-        if (this.peek() === '{') {
-            this.advance(); // consume '{'
-            this.skipWhitespace();
-            while (!this.isAtEnd() && this.peek() !== '}') {
-                const node = this.parseAdvancedNode();
-                if (node) {
-                    thenBody.push(node);
-                }
-                this.skipWhitespace();
-            }
-            if (this.peek() === '}') {
-                this.advance(); // consume '}'
-            }
-        }
-        // Parse optional else body
-        let elseBody;
-        this.skipWhitespace();
-        if (this.match('else')) {
-            elseBody = [];
-            this.skipWhitespace();
-            if (this.peek() === '{') {
-                this.advance(); // consume '{'
-                this.skipWhitespace();
-                while (!this.isAtEnd() && this.peek() !== '}') {
-                    const node = this.parseAdvancedNode();
-                    if (node) {
-                        elseBody.push(node);
-                    }
-                    this.skipWhitespace();
-                }
-                if (this.peek() === '}') {
-                    this.advance(); // consume '}'
-                }
-            }
-        }
-        const result = {
-            type: 'Conditional',
-            condition,
-            thenBody,
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-        if (elseBody !== undefined) {
-            result.elseBody = elseBody;
-        }
-        return result;
-    }
-    /**
-     * Parse ForEach loops for list rendering
-     */
-    parseForEach(start) {
-        // 'ForEach' already consumed by match()
-        this.skipWhitespace();
-        if (this.peek() !== '(') {
-            throw new Error(`Expected '(' after ForEach at line ${this.line}`);
-        }
-        this.advance(); // consume '('
-        this.skipWhitespace();
-        // Parse iterable expression
-        const iterable = this.parseComplexExpression();
-        if (!iterable) {
-            throw new Error(`Expected iterable expression in ForEach at line ${this.line}`);
-        }
-        this.skipWhitespace();
-        if (this.peek() === ',') {
-            this.advance(); // consume ','
-            this.skipWhitespace();
-        }
-        // Parse item identifier (id: \.self or id: \.id)
-        if (this.match('id:')) {
-            this.skipWhitespace();
-            // Skip id specification for now
-            this.parseComplexExpression();
-        }
-        this.skipWhitespace();
-        if (this.peek() === ')') {
-            this.advance(); // consume ')'
-        }
-        this.skipWhitespace();
-        // Parse closure parameter
-        let itemIdentifier = 'item';
-        if (this.peek() === '{') {
-            this.advance(); // consume '{'
-            this.skipWhitespace();
-            // Look for closure parameter (item in { item in ... })
-            const savedPos = this.position;
-            const identifier = this.parseIdentifier();
-            if (identifier && this.match('in')) {
-                itemIdentifier = identifier;
-            }
-            else {
-                // Restore position if not a closure parameter
-                this.position = savedPos;
-            }
-        }
-        // Parse body
-        const body = [];
-        while (!this.isAtEnd() && this.peek() !== '}') {
-            const node = this.parseAdvancedNode();
-            if (node) {
-                body.push(node);
-            }
-            this.skipWhitespace();
-        }
-        if (this.peek() === '}') {
-            this.advance(); // consume '}'
-        }
-        return {
-            type: 'ForEach',
-            iterable,
-            itemIdentifier,
-            body,
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-    }
-    /**
-     * Parse property wrappers (@State, @Computed, etc.)
-     */
-    parsePropertyWrapper(start) {
-        this.advance(); // consume '@'
-        const wrapperName = this.parseIdentifier();
-        if (!wrapperName ||
-            !['State', 'Computed', 'Effect'].includes(wrapperName)) {
-            throw new Error(`Unknown property wrapper @${wrapperName} at line ${this.line}`);
-        }
-        this.skipWhitespace();
-        // Parse variable declaration
-        const identifier = this.parseIdentifier();
-        if (!identifier) {
-            throw new Error(`Expected identifier after @${wrapperName} at line ${this.line}`);
-        }
-        // Parse optional initial value
-        let initialValue;
-        this.skipWhitespace();
-        if (this.peek() === '=') {
-            this.advance(); // consume '='
-            this.skipWhitespace();
-            const expr = this.parseComplexExpression();
-            if (expr) {
-                initialValue = expr;
-            }
-        }
-        const result = {
-            type: 'PropertyWrapper',
-            wrapper: wrapperName,
-            identifier,
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-        if (initialValue !== undefined) {
-            result.initialValue = initialValue;
-        }
-        return result;
-    }
-    /**
-     * Parse state bindings ($variable)
-     */
-    parseStateBinding(start) {
-        this.advance(); // consume '$'
-        const identifier = this.parseIdentifier();
-        if (!identifier) {
-            throw new Error(`Expected identifier after '$' at line ${this.line}`);
-        }
-        return {
-            type: 'StateBinding',
-            identifier,
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-    }
-    /**
-     * Parse enhanced components with complex modifier chains
-     */
-    parseEnhancedComponent(start) {
-        const name = this.parseIdentifier();
-        this.skipWhitespace();
-        const children = [];
-        const modifiers = [];
-        // Parse component content (arguments or body)
-        if (this.peek() === '(') {
-            // Component with arguments
-            this.advance(); // consume '('
-            this.skipWhitespace();
-            while (!this.isAtEnd() && this.peek() !== ')') {
-                const arg = this.parseComplexExpression();
-                if (arg) {
-                    children.push(arg);
-                }
-                this.skipWhitespace();
-                if (this.peek() === ',') {
-                    this.advance(); // consume ','
-                    this.skipWhitespace();
-                }
-            }
-            if (this.peek() === ')') {
-                this.advance(); // consume ')'
-            }
-        }
-        else if (this.peek() === '{') {
-            // Component with body
-            this.advance(); // consume '{'
-            this.skipWhitespace();
-            while (!this.isAtEnd() && this.peek() !== '}') {
-                const child = this.parseAdvancedNode();
-                if (child) {
-                    children.push(child);
-                }
-                this.skipWhitespace();
-            }
-            if (this.peek() === '}') {
-                this.advance(); // consume '}'
-            }
-        }
-        // Parse complex modifier chains
-        this.skipWhitespace();
-        while (this.peek() === '.') {
-            const modifier = this.parseAdvancedModifier();
-            if (modifier) {
-                modifiers.push(modifier);
-            }
-            this.skipWhitespace();
-        }
-        return {
-            type: 'Component',
-            name,
-            children,
-            modifiers,
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-    }
-    /**
-     * Parse advanced modifiers with complex expressions
-     */
-    parseAdvancedModifier() {
-        if (this.peek() !== '.')
-            return null;
-        const start = this.currentPosition();
-        this.advance(); // consume '.'
-        const name = this.parseIdentifier();
-        if (!name)
-            return null;
-        const args = [];
-        // Parse modifier arguments with complex expressions
-        if (this.peek() === '(') {
-            this.advance(); // consume '('
-            this.skipWhitespace();
-            while (!this.isAtEnd() && this.peek() !== ')') {
-                const arg = this.parseComplexExpression();
-                if (arg) {
-                    args.push(arg);
-                }
-                this.skipWhitespace();
-                if (this.peek() === ',') {
-                    this.advance(); // consume ','
-                    this.skipWhitespace();
-                }
-            }
-            if (this.peek() === ')') {
-                this.advance(); // consume ')'
-            }
-        }
-        return {
-            type: 'Modifier',
-            name,
-            arguments: args,
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-    }
-    /**
-     * Parse complex expressions including function calls, property access, etc.
-     */
-    parseComplexExpression() {
-        this.skipWhitespace();
-        const start = this.currentPosition();
-        // String literals
-        if (this.peek() === '"' || this.peek() === "'") {
-            return this.parseStringLiteral(start);
-        }
-        // Number literals
-        if (this.isDigit(this.peek())) {
-            return this.parseNumberLiteral(start);
-        }
-        // Boolean and null literals
-        if (this.match('true') || this.match('false') || this.match('null')) {
-            const value = this.code.slice(start.offset, this.position);
-            return {
-                type: 'Literal',
-                value: value === 'true' ? true : value === 'false' ? false : null,
-                raw: value,
-                loc: {
-                    start,
-                    end: this.currentPosition(),
-                    source: this.filename,
-                },
-            };
-        }
-        // Function calls and identifiers
-        const identifier = this.parseIdentifier();
-        if (identifier) {
-            this.skipWhitespace();
-            // Check for function call
-            if (this.peek() === '(') {
-                return this.parseFunctionCall(identifier, start);
-            }
-            // Check for property access
-            if (this.peek() === '.') {
-                return this.parsePropertyAccess(identifier, start);
-            }
-            // Simple identifier
-            return {
-                type: 'Identifier',
-                name: identifier,
-                loc: {
-                    start,
-                    end: this.currentPosition(),
-                    source: this.filename,
-                },
-            };
-        }
-        // Array literals
-        if (this.peek() === '[') {
-            return this.parseArrayLiteral(start);
-        }
-        return null;
-    }
-    /**
-     * Parse function calls with arguments
-     */
-    parseFunctionCall(name, start) {
-        this.advance(); // consume '('
-        this.skipWhitespace();
-        const args = [];
-        while (!this.isAtEnd() && this.peek() !== ')') {
-            const arg = this.parseComplexExpression();
-            if (arg) {
-                args.push(arg);
-            }
-            this.skipWhitespace();
-            if (this.peek() === ',') {
-                this.advance(); // consume ','
-                this.skipWhitespace();
-            }
-        }
-        if (this.peek() === ')') {
-            this.advance(); // consume ')'
-        }
-        return {
-            type: 'CallExpression',
-            callee: { type: 'Identifier', name },
-            arguments: args,
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-    }
-    /**
-     * Parse property access (obj.prop)
-     */
-    parsePropertyAccess(object, start) {
-        let current = object;
-        while (this.peek() === '.') {
-            this.advance(); // consume '.'
-            const property = this.parseIdentifier();
-            if (property) {
-                current = `${current}.${property}`;
-            }
-        }
-        return {
-            type: 'MemberExpression',
-            object: object,
-            property: current.split('.').slice(1).join('.'),
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-    }
-    /**
-     * Parse array literals [1, 2, 3]
-     */
-    parseArrayLiteral(start) {
-        this.advance(); // consume '['
-        this.skipWhitespace();
-        const elements = [];
-        while (!this.isAtEnd() && this.peek() !== ']') {
-            const element = this.parseComplexExpression();
-            if (element) {
-                elements.push(element);
-            }
-            this.skipWhitespace();
-            if (this.peek() === ',') {
-                this.advance(); // consume ','
-                this.skipWhitespace();
-            }
-        }
-        if (this.peek() === ']') {
-            this.advance(); // consume ']'
-        }
-        return {
-            type: 'ArrayExpression',
-            elements,
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-    }
-    // Helper methods (reuse from basic parser with enhancements)
-    parseStringLiteral(start) {
-        const quote = this.peek();
-        this.advance(); // consume opening quote
-        let value = '';
-        while (!this.isAtEnd() && this.peek() !== quote) {
-            if (this.peek() === '\\') {
-                this.advance(); // consume backslash
-                const escaped = this.peek();
-                switch (escaped) {
-                    case 'n':
-                        value += '\n';
-                        break;
-                    case 't':
-                        value += '\t';
-                        break;
-                    case 'r':
-                        value += '\r';
-                        break;
-                    case '\\':
-                        value += '\\';
-                        break;
-                    case '"':
-                        value += '"';
-                        break;
-                    case "'":
-                        value += "'";
-                        break;
-                    default:
-                        value += escaped;
-                        break;
-                }
-                this.advance();
-            }
-            else {
-                value += this.peek();
-                this.advance();
-            }
-        }
-        if (this.peek() === quote) {
-            this.advance(); // consume closing quote
-        }
-        return {
-            type: 'Literal',
-            value,
-            raw: this.code.slice(start.offset, this.position),
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-    }
-    parseNumberLiteral(start) {
-        let numStr = '';
-        while (!this.isAtEnd() &&
-            (this.isDigit(this.peek()) || this.peek() === '.')) {
-            numStr += this.peek();
-            this.advance();
-        }
-        const value = numStr.includes('.')
-            ? parseFloat(numStr)
-            : parseInt(numStr, 10);
-        return {
-            type: 'Literal',
-            value,
-            raw: numStr,
-            loc: {
-                start,
-                end: this.currentPosition(),
-                source: this.filename,
-            },
-        };
-    }
-    parseIdentifier() {
-        if (!this.isAlpha(this.peek()) && this.peek() !== '_') {
-            return null;
-        }
-        let identifier = '';
-        while (!this.isAtEnd() &&
-            (this.isAlphaNumeric(this.peek()) || this.peek() === '_')) {
-            identifier += this.peek();
-            this.advance();
-        }
-        return identifier;
-    }
-    // Utility methods
-    isComponentStart() {
-        const savedPos = this.position;
-        const savedLine = this.line;
-        const savedColumn = this.column;
-        const identifier = this.parseIdentifier();
-        // Always restore position
-        this.position = savedPos;
-        this.line = savedLine;
-        this.column = savedColumn;
-        const components = [
-            'VStack',
-            'HStack',
-            'ZStack',
-            'List',
-            'Form',
-            'NavigationStack',
-            'Text',
-            'Button',
-            'Image',
-            'TextField',
-            'Toggle',
-            'Slider',
-            // ScrollView moved to @tachui/mobile
-            'LazyVStack',
-            'LazyHStack',
-        ];
-        return identifier ? components.includes(identifier) : false;
-    }
-    match(expected) {
-        if (this.code.slice(this.position, this.position + expected.length) ===
-            expected) {
-            this.position += expected.length;
-            this.column += expected.length;
-            return true;
-        }
-        return false;
-    }
-    skipWhitespace() {
-        while (!this.isAtEnd() && this.isWhitespace(this.peek())) {
-            if (this.peek() === '\n') {
-                this.line++;
-                this.column = 1;
-            }
-            else {
-                this.column++;
-            }
-            this.position++;
-        }
-    }
-    peek() {
-        return this.isAtEnd() ? '\0' : this.code[this.position];
-    }
-    advance() {
-        const char = this.peek();
-        if (!this.isAtEnd()) {
-            this.position++;
-            if (char === '\n') {
-                this.line++;
-                this.column = 1;
-            }
-            else {
-                this.column++;
-            }
-        }
-        return char;
-    }
-    isAtEnd() {
-        return this.position >= this.code.length;
-    }
-    isWhitespace(char) {
-        return /\s/.test(char);
-    }
-    isAlpha(char) {
-        return /[a-zA-Z]/.test(char);
-    }
-    isDigit(char) {
-        return /[0-9]/.test(char);
-    }
-    isAlphaNumeric(char) {
-        return this.isAlpha(char) || this.isDigit(char);
-    }
-    currentPosition() {
-        return {
-            line: this.line,
-            column: this.column,
-            offset: this.position,
-        };
-    }
-}
-/**
- * Enhanced parsing function using the advanced parser
- */
-export function parseAdvancedSwiftUISyntax(code, filename) {
-    const parser = new AdvancedSwiftUIParser(code, filename);
-    return parser.parse();
-}
-//# sourceMappingURL=advanced-parser.js.map