@ordojs/core/dist/compiler/parser-refactored.d.ts

Core compiler and runtime for OrdoJS framework

/**
 * @fileoverview OrdoJS Parser - Refactored modular implementation
 * @author OrdoJS Framework Team
 */
import { SyntaxError, type ComponentAST, type ComponentNode, type SourcePosition, type TokenStream, type TypeAnnotation } from '../types/index.js';
/**
 * Parser configuration options
 */
export interface ParserOptions {
    /** Enable error recovery mode */
    allowRecovery?: boolean;
    /** Maximum number of errors before stopping */
    maxErrors?: number;
    /** Enable strict mode parsing */
    strictMode?: boolean;
    /** Generate source maps */
    generateSourceMaps?: boolean;
    /** Custom AST node processors */
    nodeProcessors?: ASTNodeProcessor[];
    /** Enable experimental features */
    experimentalFeatures?: string[];
}
/**
 * AST node processor for plugin-based AST transformation
 */
export interface ASTNodeProcessor {
    /** Processor name */
    name: string;
    /** Node types this processor handles */
    handles: string[];
    /** Process AST node and return modified node */
    process<T extends {
        type: string;
    }>(node: T, context: ParserContext): T;
}
/**
 * Parser context for tracking state during parsing
 */
export interface ParserContext {
    /** Current component being parsed */
    component?: ComponentNode;
    /** Current block context */
    blockContext: 'component' | 'client' | 'server' | 'markup';
    /** Symbol table for scope tracking */
    symbolTable: Map<string, SymbolInfo>;
    /** Current scope depth */
    scopeDepth: number;
    /** Parser options */
    options: Required<ParserOptions>;
}
/**
 * Symbol information for scope tracking
 */
export interface SymbolInfo {
    name: string;
    type: 'variable' | 'function' | 'parameter' | 'prop';
    dataType?: TypeAnnotation;
    scope: number;
    position: SourcePosition;
    isConst?: boolean;
    isPublic?: boolean;
}
/**
 * Parser state for error recovery and debugging
 */
export interface ParserState {
    tokenStream: TokenStream;
    current: number;
    filename: string;
    errors: SyntaxError[];
    warnings: SyntaxError[];
    context: ParserContext;
}
/**
 * Enhanced OrdoJS Parser with modular architecture
 */
export declare class OrdoJSParser {
    private state;
    private options;
    private parseRules;
    constructor(tokenStream: TokenStream, options?: ParserOptions, filename?: string);
    /**
     * Parse token stream into Component AST
     */
    parse(): ComponentAST;
    /**
     * Get all errors encountered during parsing
     */
    getErrors(): SyntaxError[];
    /**
     * Get all warnings encountered during parsing
     */
    getWarnings(): SyntaxError[];
    /**
     * Add custom AST node processor
     */
    addNodeProcessor(processor: ASTNodeProcessor): void;
    /**
     * Remove AST node processor by name
     */
    removeNodeProcessor(name: string): boolean;
    private initializeParseRules;
    private parseComponent;
    private parseProps;
    private parseProp;
    private parseTypeAnnotation;
    private parseClientBlock;
    private parseServerBlock;
    private parseMarkupBlock;
    private parseReactiveVariable;
    private parseFunction;
    private parseServerFunction;
    private parseLifecycleHook;
    private parseParameters;
    private parseParameter;
    private parseStatements;
    private parseStatement;
    private parseExpression;
    private parsePrecedence;
    private getPrecedence;
    private parseLiteral;
    private parseIdentifier;
    private parseGrouping;
    private parseUnary;
    private parseBinary;
    private parseAssignment;
    private parseCall;
    private parseMember;
    private parseHTMLElement;
    private parseInterpolation;
    private parseTextNode;
    private enterScope;
    private exitScope;
    private addSymbol;
    private hasSymbol;
    private hasSymbolInCurrentScope;
    private getSymbol;
    private processAST;
    private processNode;
    private checkLifecycleHook;
    private isValidComponentName;
    private createDummyExpression;
    private extractDependencies;
    private extractExports;
    private generateSourceMap;
    private match;
    private check;
    private advance;
    private isAtEnd;
    private peek;
    private previous;
    private consume;
    private createEOFToken;
    private throwError;
    private addWarning;
    private synchronize;
    private getCurrentPosition;
}
/**
 * Default AST node processors
 */
export declare const defaultNodeProcessors: ASTNodeProcessor[];
//# sourceMappingURL=parser-refactored.d.ts.map