@tachui/cli 0.8.11 → 0.8.12

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

@@ -0,0 +1,702 @@
+/**
+ * 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