@duckcodeailabs/dql-core 0.1.0

package/dist/parser/parser.js

@@ -0,0 +1,1024 @@
+import { DiagnosticReporter, DQLSyntaxError } from '../errors/reporter.js';
+import { Lexer } from '../lexer/lexer.js';
+import { TokenType, CHART_TYPES, FILTER_TYPES, normalizeChartType } from '../lexer/token.js';
+import { NodeKind, } from '../ast/nodes.js';
+export class Parser {
+    tokens;
+    pos = 0;
+    source;
+    file;
+    reporter;
+    constructor(source, file) {
+        this.source = source;
+        this.file = file;
+        this.reporter = new DiagnosticReporter();
+        const lexer = new Lexer(source, file);
+        this.tokens = lexer.tokenize();
+    }
+    parse() {
+        const start = this.currentSpan();
+        const statements = [];
+        while (!this.isAtEnd()) {
+            try {
+                const stmt = this.parseStatement();
+                if (stmt) {
+                    statements.push(stmt);
+                }
+            }
+            catch (e) {
+                // Skip to next statement-level token on error
+                this.synchronize();
+            }
+        }
+        if (this.reporter.hasErrors()) {
+            throw new DQLSyntaxError(`Parse errors in ${this.file ?? '<input>'}`, this.reporter.getErrors());
+        }
+        return {
+            kind: NodeKind.Program,
+            statements,
+            span: this.makeSpan(start, this.currentSpan()),
+        };
+    }
+    parseStatement() {
+        // Collect leading decorators
+        const decorators = this.parseDecoratorList();
+        if (this.check(TokenType.WorkbookKeyword)) {
+            return this.parseWorkbook(decorators);
+        }
+        if (this.check(TokenType.DashboardKeyword)) {
+            return this.parseDashboard(decorators);
+        }
+        if (this.check(TokenType.ChartKeyword)) {
+            return this.parseChartCall(decorators);
+        }
+        if (this.check(TokenType.BlockKeyword)) {
+            return this.parseBlockDecl(decorators);
+        }
+        if (this.check(TokenType.ImportKeyword)) {
+            if (decorators.length > 0) {
+                this.error('Decorators cannot be applied to import statements.');
+            }
+            return this.parseImportDecl();
+        }
+        if (this.check(TokenType.EOF)) {
+            return null;
+        }
+        this.error(`Unexpected token '${this.current().value}'. Expected 'dashboard', 'workbook', 'chart', 'block', or 'import'.`);
+        return null;
+    }
+    parseFilterCall() {
+        const start = this.currentSpan();
+        this.expect(TokenType.FilterKeyword);
+        this.expect(TokenType.Dot);
+        const filterTypeToken = this.expect(TokenType.Identifier);
+        if (!FILTER_TYPES.has(filterTypeToken.value)) {
+            this.reporter.error(`Unknown filter type '${filterTypeToken.value}'. Valid types: ${[...FILTER_TYPES].join(', ')}`, filterTypeToken.span, `Did you mean one of: ${[...FILTER_TYPES].join(', ')}?`);
+        }
+        this.expect(TokenType.LeftParen);
+        // Check if there's a SQL query (SELECT/WITH) or just named args
+        let query;
+        const currentToken = this.current();
+        const tokenVal = currentToken.value.toUpperCase();
+        if (tokenVal === 'SELECT' || tokenVal === 'WITH') {
+            query = this.parseSQLQuery();
+        }
+        // Parse named arguments
+        const args = [];
+        while (this.check(TokenType.Comma) || (!query && (this.check(TokenType.Identifier) || this.isKeywordUsableAsArgName(this.current().type)))) {
+            if (this.check(TokenType.Comma)) {
+                this.advance(); // consume comma
+            }
+            if (this.check(TokenType.RightParen))
+                break; // trailing comma
+            args.push(this.parseNamedArg());
+        }
+        this.expect(TokenType.RightParen);
+        return {
+            kind: NodeKind.FilterCall,
+            filterType: filterTypeToken.value,
+            query,
+            args,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseDashboard(decorators) {
+        const start = decorators.length > 0 ? decorators[0].span : this.currentSpan();
+        this.expect(TokenType.DashboardKeyword);
+        const titleToken = this.expect(TokenType.StringLiteral);
+        this.expect(TokenType.LeftBrace);
+        const body = [];
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            // Collect decorators for items inside dashboard
+            const itemDecorators = this.parseDecoratorList();
+            if (this.check(TokenType.LetKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to variable declarations.');
+                }
+                body.push(this.parseVariableDecl());
+            }
+            else if (this.check(TokenType.ParamKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to param declarations.');
+                }
+                body.push(this.parseParamDecl());
+            }
+            else if (this.check(TokenType.ChartKeyword)) {
+                body.push(this.parseChartCall(itemDecorators));
+            }
+            else if (this.check(TokenType.FilterKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to filter declarations.');
+                }
+                body.push(this.parseFilterCall());
+            }
+            else if (this.check(TokenType.UseKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to use declarations.');
+                }
+                body.push(this.parseUseDecl());
+            }
+            else if (this.check(TokenType.LayoutKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to layout blocks.');
+                }
+                body.push(this.parseLayoutBlock());
+            }
+            else if (this.check(TokenType.RightBrace)) {
+                break;
+            }
+            else {
+                this.error(`Unexpected token '${this.current().value}' inside dashboard. Expected 'let', 'param', 'chart', 'filter', 'use', 'layout', or '}'.`);
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RightBrace);
+        return {
+            kind: NodeKind.Dashboard,
+            title: titleToken.value,
+            decorators,
+            body,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseChartCall(decorators) {
+        const start = decorators.length > 0 ? decorators[0].span : this.currentSpan();
+        this.expect(TokenType.ChartKeyword);
+        this.expect(TokenType.Dot);
+        const chartTypeStart = this.currentSpan();
+        const chartTypeToken = this.expect(TokenType.Identifier);
+        let rawChartType = chartTypeToken.value;
+        while (this.check(TokenType.Minus)) {
+            this.advance();
+            rawChartType += `-${this.expect(TokenType.Identifier).value}`;
+        }
+        const chartTypeSpan = this.makeSpan(chartTypeStart, this.previousSpan());
+        if (!CHART_TYPES.has(rawChartType)) {
+            this.reporter.error(`Unknown chart type '${rawChartType}'. Valid types: ${[...CHART_TYPES].join(', ')}`, chartTypeSpan, `Did you mean one of: ${[...CHART_TYPES].join(', ')}?`);
+        }
+        const normalizedChartType = normalizeChartType(rawChartType);
+        this.expect(TokenType.LeftParen);
+        // Parse the SQL query using boundary detection on the raw source
+        const query = this.parseSQLQuery();
+        // Parse named arguments
+        const args = [];
+        while (this.check(TokenType.Comma)) {
+            this.advance(); // consume comma
+            if (this.check(TokenType.RightParen))
+                break; // trailing comma
+            args.push(this.parseNamedArg());
+        }
+        this.expect(TokenType.RightParen);
+        return {
+            kind: NodeKind.ChartCall,
+            chartType: normalizedChartType,
+            query,
+            args,
+            decorators,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseSQLQuery() {
+        const start = this.currentSpan();
+        // We need to find the SQL text from the raw source.
+        // The current token should be the start of the SQL (SELECT, WITH, etc.)
+        // We use Lexer.scanSQLBoundary on the raw source to find where SQL ends.
+        const currentToken = this.current();
+        const sqlStartOffset = currentToken.span.start.offset;
+        // Scan the raw source for SQL boundary
+        const { sql, endOffset } = Lexer.scanSQLBoundary(this.source, sqlStartOffset, 1);
+        // Extract template interpolations from the SQL text
+        const interpolations = this.extractInterpolations(sql, start);
+        // Now advance our token position past all tokens that fall within the SQL range
+        while (!this.isAtEnd() &&
+            this.current().span.start.offset < endOffset) {
+            this.advance();
+        }
+        const span = this.makeSpan(start, this.currentSpan());
+        return {
+            kind: NodeKind.SQLQuery,
+            rawSQL: sql,
+            interpolations,
+            span,
+        };
+    }
+    extractInterpolations(sql, baseSpan) {
+        const interpolations = [];
+        const regex = /\$\{(\w+)\}|\{(\w+)\}/g;
+        let match;
+        while ((match = regex.exec(sql)) !== null) {
+            const variableName = match[1] || match[2];
+            if (!variableName)
+                continue;
+            interpolations.push({
+                variableName,
+                offsetInSQL: match.index,
+                span: baseSpan, // simplified; ideally compute exact position
+            });
+        }
+        return interpolations;
+    }
+    parseNamedArg() {
+        const start = this.currentSpan();
+        // Accept identifiers and keywords that may be used as argument names (e.g. 'param', 'label', 'from')
+        const nameToken = this.current();
+        if (nameToken.type === TokenType.Identifier || this.isKeywordUsableAsArgName(nameToken.type)) {
+            this.advance();
+        }
+        else {
+            this.error(`Expected argument name, got '${nameToken.value}'.`);
+            this.advance();
+        }
+        this.expect(TokenType.Equals);
+        const value = this.parseExpression();
+        return {
+            kind: NodeKind.NamedArg,
+            name: nameToken.value,
+            value,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    isKeywordUsableAsArgName(type) {
+        return type === TokenType.ParamKeyword
+            || type === TokenType.FromKeyword
+            || type === TokenType.LayoutKeyword
+            || type === TokenType.RowKeyword
+            || type === TokenType.UseKeyword
+            || type === TokenType.ImportKeyword;
+    }
+    parseVariableDecl() {
+        const start = this.currentSpan();
+        this.expect(TokenType.LetKeyword);
+        const nameToken = this.expect(TokenType.Identifier);
+        this.expect(TokenType.Equals);
+        const initializer = this.parseExpression();
+        return {
+            kind: NodeKind.VariableDecl,
+            name: nameToken.value,
+            initializer,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseDecoratorList() {
+        const decorators = [];
+        while (this.check(TokenType.AtSign)) {
+            decorators.push(this.parseDecorator());
+        }
+        return decorators;
+    }
+    parseDecorator() {
+        const start = this.currentSpan();
+        this.expect(TokenType.AtSign);
+        const nameToken = this.expect(TokenType.Identifier);
+        const args = [];
+        if (this.check(TokenType.LeftParen)) {
+            this.advance(); // consume (
+            if (!this.check(TokenType.RightParen)) {
+                args.push(this.parseExpression());
+                while (this.check(TokenType.Comma)) {
+                    this.advance();
+                    args.push(this.parseExpression());
+                }
+            }
+            this.expect(TokenType.RightParen);
+        }
+        return {
+            kind: NodeKind.Decorator,
+            name: nameToken.value,
+            arguments: args,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseExpression() {
+        let left = this.parsePrimary();
+        // Handle binary + and - operators
+        while (this.check(TokenType.Plus) || this.check(TokenType.Minus)) {
+            const opToken = this.advance();
+            const right = this.parsePrimary();
+            left = {
+                kind: NodeKind.BinaryExpr,
+                operator: opToken.value,
+                left,
+                right,
+                span: this.makeSpan(left.span, right.span),
+            };
+        }
+        return left;
+    }
+    parsePrimary() {
+        const token = this.current();
+        // String literal
+        if (this.check(TokenType.StringLiteral)) {
+            this.advance();
+            return {
+                kind: NodeKind.StringLiteral,
+                value: token.value,
+                span: token.span,
+            };
+        }
+        // Number literal
+        if (this.check(TokenType.NumberLiteral)) {
+            this.advance();
+            return {
+                kind: NodeKind.NumberLiteral,
+                value: Number(token.value),
+                span: token.span,
+            };
+        }
+        // Boolean literal
+        if (this.check(TokenType.BooleanLiteral)) {
+            this.advance();
+            return {
+                kind: NodeKind.BooleanLiteral,
+                value: token.value === 'true',
+                span: token.span,
+            };
+        }
+        // Array literal
+        if (this.check(TokenType.LeftBracket)) {
+            return this.parseArrayLiteral();
+        }
+        // INTERVAL expression
+        if (this.check(TokenType.IntervalKeyword)) {
+            const start = this.currentSpan();
+            this.advance(); // consume INTERVAL
+            const valueToken = this.expect(TokenType.StringLiteral);
+            return {
+                kind: NodeKind.IntervalExpr,
+                value: valueToken.value,
+                span: this.makeSpan(start, this.previousSpan()),
+            };
+        }
+        // Identifier (may be function call)
+        if (this.check(TokenType.Identifier)) {
+            this.advance();
+            const name = token.value;
+            // Check for function call: ident(
+            if (this.check(TokenType.LeftParen)) {
+                return this.parseFunctionCall(name, token.span);
+            }
+            return {
+                kind: NodeKind.Identifier,
+                name,
+                span: token.span,
+            };
+        }
+        // Negative number (minus followed by number)
+        if (this.check(TokenType.Minus)) {
+            const start = this.currentSpan();
+            this.advance();
+            const numToken = this.expect(TokenType.NumberLiteral);
+            return {
+                kind: NodeKind.NumberLiteral,
+                value: -Number(numToken.value),
+                span: this.makeSpan(start, numToken.span),
+            };
+        }
+        this.error(`Unexpected token '${token.value}'. Expected an expression.`);
+        this.advance();
+        return {
+            kind: NodeKind.Identifier,
+            name: '__error__',
+            span: token.span,
+        };
+    }
+    parseArrayLiteral() {
+        const start = this.currentSpan();
+        this.expect(TokenType.LeftBracket);
+        const elements = [];
+        if (!this.check(TokenType.RightBracket)) {
+            elements.push(this.parseExpression());
+            while (this.check(TokenType.Comma)) {
+                this.advance();
+                if (this.check(TokenType.RightBracket))
+                    break; // trailing comma
+                elements.push(this.parseExpression());
+            }
+        }
+        this.expect(TokenType.RightBracket);
+        return {
+            kind: NodeKind.ArrayLiteral,
+            elements,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseFunctionCall(callee, start) {
+        this.expect(TokenType.LeftParen);
+        const args = [];
+        if (!this.check(TokenType.RightParen)) {
+            args.push(this.parseExpression());
+            while (this.check(TokenType.Comma)) {
+                this.advance();
+                args.push(this.parseExpression());
+            }
+        }
+        this.expect(TokenType.RightParen);
+        return {
+            kind: NodeKind.FunctionCall,
+            callee,
+            arguments: args,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    // ---- Helpers ----
+    current() {
+        return this.tokens[this.pos] ?? this.tokens[this.tokens.length - 1];
+    }
+    previous() {
+        return this.tokens[this.pos - 1] ?? this.tokens[0];
+    }
+    check(type) {
+        return this.current().type === type;
+    }
+    advance() {
+        const token = this.current();
+        if (!this.isAtEnd()) {
+            this.pos++;
+        }
+        return token;
+    }
+    expect(type) {
+        if (this.check(type)) {
+            return this.advance();
+        }
+        const token = this.current();
+        this.error(`Expected ${type} but found '${token.value}' (${token.type}).`);
+        // Return a synthetic token to keep parsing
+        return {
+            type,
+            value: '',
+            span: token.span,
+        };
+    }
+    isAtEnd() {
+        return this.current().type === TokenType.EOF;
+    }
+    error(message) {
+        this.reporter.error(message, this.currentSpan());
+    }
+    currentSpan() {
+        return this.current().span;
+    }
+    previousSpan() {
+        return this.previous().span;
+    }
+    makeSpan(start, end) {
+        return { start: start.start, end: end.end };
+    }
+    // ---- Block Declaration ----
+    parseBlockDecl(decorators) {
+        const start = decorators.length > 0 ? decorators[0].span : this.currentSpan();
+        this.expect(TokenType.BlockKeyword);
+        const nameToken = this.expect(TokenType.StringLiteral);
+        this.expect(TokenType.LeftBrace);
+        let domain;
+        let blockType;
+        let metricRef;
+        let description;
+        let tags;
+        let owner;
+        let params;
+        let query;
+        let visualization;
+        let tests;
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            if (this.check(TokenType.DomainKeyword)) {
+                this.advance();
+                this.expect(TokenType.Equals);
+                const val = this.expect(TokenType.StringLiteral);
+                domain = val.value;
+            }
+            else if (this.check(TokenType.TypeKeyword)) {
+                this.advance();
+                this.expect(TokenType.Equals);
+                const val = this.expect(TokenType.StringLiteral);
+                const raw = val.value;
+                if (raw === 'semantic' || raw === 'custom') {
+                    blockType = raw;
+                }
+                else {
+                    this.error(`Block type must be "semantic" or "custom", got "${raw}". Use type = "semantic" for dbt metric blocks or type = "custom" for SQL blocks.`);
+                    blockType = 'custom'; // recover gracefully
+                }
+            }
+            else if (this.check(TokenType.MetricKeyword)) {
+                this.advance();
+                this.expect(TokenType.Equals);
+                const val = this.expect(TokenType.StringLiteral);
+                metricRef = val.value;
+            }
+            else if (this.check(TokenType.DescriptionKeyword)) {
+                this.advance();
+                this.expect(TokenType.Equals);
+                const val = this.expect(TokenType.StringLiteral);
+                description = val.value;
+            }
+            else if (this.check(TokenType.TagsKeyword)) {
+                this.advance();
+                this.expect(TokenType.Equals);
+                const arrExpr = this.parseArrayLiteral();
+                if (arrExpr.kind === NodeKind.ArrayLiteral) {
+                    tags = arrExpr.elements
+                        .filter((e) => e.kind === NodeKind.StringLiteral)
+                        .map((e) => e.value);
+                }
+            }
+            else if (this.check(TokenType.OwnerKeyword)) {
+                this.advance();
+                this.expect(TokenType.Equals);
+                const val = this.expect(TokenType.StringLiteral);
+                owner = val.value;
+            }
+            else if (this.check(TokenType.ParamsKeyword)) {
+                params = this.parseBlockParams();
+            }
+            else if (this.check(TokenType.QueryKeyword)) {
+                this.advance();
+                this.expect(TokenType.Equals);
+                if (this.check(TokenType.TripleQuoteString)) {
+                    const sqlToken = this.advance();
+                    const interpolations = this.extractInterpolations(sqlToken.value, sqlToken.span);
+                    query = {
+                        kind: NodeKind.SQLQuery,
+                        rawSQL: sqlToken.value,
+                        interpolations,
+                        span: sqlToken.span,
+                    };
+                }
+                else {
+                    // Fallback: parse as inline SQL
+                    query = this.parseSQLQuery();
+                }
+            }
+            else if (this.check(TokenType.VisualizationKeyword)) {
+                visualization = this.parseBlockVisualization();
+            }
+            else if (this.check(TokenType.TestsKeyword)) {
+                tests = this.parseBlockTests();
+            }
+            else if (this.check(TokenType.RightBrace)) {
+                break;
+            }
+            else {
+                this.error(`Unexpected token '${this.current().value}' inside block. Expected 'domain', 'type', 'metric', 'description', 'tags', 'owner', 'params', 'query', 'visualization', 'tests', or '}'.`);
+                this.advance();
+            }
+        }
+        if (!blockType) {
+            this.error(`Block "${nameToken.value}" is missing a required type declaration. Add type = "semantic" for dbt metric blocks or type = "custom" for SQL blocks.`);
+            blockType = 'custom'; // error-recovery default — keeps downstream analysis working
+        }
+        this.expect(TokenType.RightBrace);
+        return {
+            kind: NodeKind.BlockDecl,
+            name: nameToken.value,
+            domain,
+            blockType,
+            metricRef,
+            description,
+            tags,
+            owner,
+            params,
+            query,
+            visualization,
+            tests,
+            decorators,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseBlockParams() {
+        const start = this.currentSpan();
+        this.expect(TokenType.ParamsKeyword);
+        this.expect(TokenType.LeftBrace);
+        const paramEntries = [];
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            const paramStart = this.currentSpan();
+            const nameToken = this.current();
+            if (nameToken.type === TokenType.Identifier || this.isBlockFieldKeyword(nameToken.type)) {
+                this.advance();
+            }
+            else {
+                this.error(`Expected parameter name, got '${nameToken.value}'.`);
+                this.advance();
+                continue;
+            }
+            this.expect(TokenType.Equals);
+            const initializer = this.parseExpression();
+            paramEntries.push({
+                name: nameToken.value,
+                initializer,
+                span: this.makeSpan(paramStart, this.previousSpan()),
+            });
+        }
+        this.expect(TokenType.RightBrace);
+        return {
+            kind: NodeKind.BlockParams,
+            params: paramEntries,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseBlockVisualization() {
+        const start = this.currentSpan();
+        this.expect(TokenType.VisualizationKeyword);
+        this.expect(TokenType.LeftBrace);
+        const properties = [];
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            const propStart = this.currentSpan();
+            const nameToken = this.current();
+            if (nameToken.type === TokenType.Identifier || this.isBlockFieldKeyword(nameToken.type)) {
+                this.advance();
+            }
+            else {
+                this.error(`Expected property name, got '${nameToken.value}'.`);
+                this.advance();
+                continue;
+            }
+            this.expect(TokenType.Equals);
+            const value = this.parseExpression();
+            properties.push({
+                kind: NodeKind.NamedArg,
+                name: nameToken.value,
+                value,
+                span: this.makeSpan(propStart, this.previousSpan()),
+            });
+        }
+        this.expect(TokenType.RightBrace);
+        return {
+            kind: NodeKind.BlockVisualization,
+            properties,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseBlockTests() {
+        const start = this.currentSpan();
+        this.expect(TokenType.TestsKeyword);
+        this.expect(TokenType.LeftBrace);
+        const testNodes = [];
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            if (this.check(TokenType.AssertKeyword)) {
+                const assertStart = this.currentSpan();
+                this.advance(); // consume 'assert'
+                const fieldToken = this.current();
+                if (fieldToken.type === TokenType.Identifier || this.isBlockFieldKeyword(fieldToken.type)) {
+                    this.advance();
+                }
+                else {
+                    this.error(`Expected field name after 'assert', got '${fieldToken.value}'.`);
+                    this.advance();
+                    continue;
+                }
+                // Parse operator
+                let operator;
+                if (this.check(TokenType.GreaterThan)) {
+                    this.advance();
+                    operator = '>';
+                }
+                else if (this.check(TokenType.LessThan)) {
+                    this.advance();
+                    operator = '<';
+                }
+                else if (this.check(TokenType.GreaterThanOrEqual)) {
+                    this.advance();
+                    operator = '>=';
+                }
+                else if (this.check(TokenType.LessThanOrEqual)) {
+                    this.advance();
+                    operator = '<=';
+                }
+                else if (this.check(TokenType.DoubleEquals)) {
+                    this.advance();
+                    operator = '==';
+                }
+                else if (this.check(TokenType.NotEquals)) {
+                    this.advance();
+                    operator = '!=';
+                }
+                else if (this.check(TokenType.InKeyword)) {
+                    this.advance();
+                    operator = 'IN';
+                }
+                else {
+                    this.error(`Expected comparison operator (>, <, >=, <=, ==, !=, IN) after field name, got '${this.current().value}'.`);
+                    this.advance();
+                    continue;
+                }
+                const expected = this.parseExpression();
+                testNodes.push({
+                    kind: NodeKind.BlockTest,
+                    field: fieldToken.value,
+                    operator,
+                    expected,
+                    span: this.makeSpan(assertStart, this.previousSpan()),
+                });
+            }
+            else if (this.check(TokenType.RightBrace)) {
+                break;
+            }
+            else {
+                this.error(`Unexpected token '${this.current().value}' inside tests. Expected 'assert' or '}'.`);
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RightBrace);
+        return testNodes;
+    }
+    isBlockFieldKeyword(type) {
+        return type === TokenType.DomainKeyword
+            || type === TokenType.TypeKeyword
+            || type === TokenType.MetricKeyword
+            || type === TokenType.DescriptionKeyword
+            || type === TokenType.TagsKeyword
+            || type === TokenType.OwnerKeyword
+            || type === TokenType.ChartKeyword
+            || type === TokenType.QueryKeyword
+            || type === TokenType.DefaultKeyword
+            || type === TokenType.FromKeyword;
+    }
+    // ---- Workbook / Page ----
+    parseWorkbook(decorators) {
+        const start = decorators.length > 0 ? decorators[0].span : this.currentSpan();
+        this.expect(TokenType.WorkbookKeyword);
+        const titleToken = this.expect(TokenType.StringLiteral);
+        this.expect(TokenType.LeftBrace);
+        const pages = [];
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            if (this.check(TokenType.PageKeyword)) {
+                pages.push(this.parsePage());
+            }
+            else if (this.check(TokenType.RightBrace)) {
+                break;
+            }
+            else {
+                this.error(`Unexpected token '${this.current().value}' inside workbook. Expected 'page' or '}'.`);
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RightBrace);
+        return {
+            kind: NodeKind.Workbook,
+            title: titleToken.value,
+            decorators,
+            pages,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parsePage() {
+        const start = this.currentSpan();
+        this.expect(TokenType.PageKeyword);
+        const titleToken = this.expect(TokenType.StringLiteral);
+        this.expect(TokenType.LeftBrace);
+        const body = [];
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            const itemDecorators = this.parseDecoratorList();
+            if (this.check(TokenType.LetKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to variable declarations.');
+                }
+                body.push(this.parseVariableDecl());
+            }
+            else if (this.check(TokenType.ParamKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to param declarations.');
+                }
+                body.push(this.parseParamDecl());
+            }
+            else if (this.check(TokenType.ChartKeyword)) {
+                body.push(this.parseChartCall(itemDecorators));
+            }
+            else if (this.check(TokenType.FilterKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to filter declarations.');
+                }
+                body.push(this.parseFilterCall());
+            }
+            else if (this.check(TokenType.UseKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to use declarations.');
+                }
+                body.push(this.parseUseDecl());
+            }
+            else if (this.check(TokenType.LayoutKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to layout blocks.');
+                }
+                body.push(this.parseLayoutBlock());
+            }
+            else if (this.check(TokenType.RightBrace)) {
+                break;
+            }
+            else {
+                this.error(`Unexpected token '${this.current().value}' inside page. Expected 'let', 'param', 'chart', 'filter', 'use', 'layout', or '}'.`);
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RightBrace);
+        return {
+            kind: NodeKind.Page,
+            title: titleToken.value,
+            body,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    // ---- Param Declaration ----
+    parseParamDecl() {
+        const start = this.currentSpan();
+        this.expect(TokenType.ParamKeyword);
+        const nameToken = this.expect(TokenType.Identifier);
+        // Optional type annotation: param name: type
+        let paramType = 'string';
+        if (this.check(TokenType.ColonToken)) {
+            this.advance(); // consume ':'
+            const typeToken = this.expect(TokenType.Identifier);
+            const validTypes = ['string', 'number', 'boolean', 'date'];
+            if (validTypes.includes(typeToken.value)) {
+                paramType = typeToken.value;
+            }
+            else {
+                this.reporter.error(`Invalid param type '${typeToken.value}'. Valid types: ${validTypes.join(', ')}`, typeToken.span);
+            }
+        }
+        // Optional default value: = expression
+        let defaultValue;
+        if (this.check(TokenType.Equals)) {
+            this.advance(); // consume '='
+            defaultValue = this.parseExpression();
+        }
+        return {
+            kind: NodeKind.ParamDecl,
+            name: nameToken.value,
+            paramType,
+            defaultValue,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    // ---- Import / Use ----
+    parseImportDecl() {
+        const start = this.currentSpan();
+        this.expect(TokenType.ImportKeyword);
+        // import { name1, name2 } from "path"
+        this.expect(TokenType.LeftBrace);
+        const names = [];
+        if (!this.check(TokenType.RightBrace)) {
+            names.push(this.expect(TokenType.Identifier).value);
+            while (this.check(TokenType.Comma)) {
+                this.advance();
+                if (this.check(TokenType.RightBrace))
+                    break; // trailing comma
+                names.push(this.expect(TokenType.Identifier).value);
+            }
+        }
+        this.expect(TokenType.RightBrace);
+        this.expect(TokenType.FromKeyword);
+        const pathToken = this.expect(TokenType.StringLiteral);
+        return {
+            kind: NodeKind.ImportDecl,
+            names,
+            path: pathToken.value,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseUseDecl() {
+        const start = this.currentSpan();
+        this.expect(TokenType.UseKeyword);
+        let nameToken;
+        if (this.check(TokenType.Identifier) || this.check(TokenType.StringLiteral)) {
+            nameToken = this.advance();
+        }
+        else {
+            nameToken = this.expect(TokenType.Identifier);
+        }
+        return {
+            kind: NodeKind.UseDecl,
+            name: nameToken.value,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    // ---- Layout ----
+    parseLayoutBlock() {
+        const start = this.currentSpan();
+        this.expect(TokenType.LayoutKeyword);
+        // Optional: layout(columns = 12)
+        let columns = 12;
+        if (this.check(TokenType.LeftParen)) {
+            this.advance();
+            const args = [];
+            if (!this.check(TokenType.RightParen)) {
+                args.push(this.parseNamedArg());
+                while (this.check(TokenType.Comma)) {
+                    this.advance();
+                    if (this.check(TokenType.RightParen))
+                        break;
+                    args.push(this.parseNamedArg());
+                }
+            }
+            this.expect(TokenType.RightParen);
+            const colArg = args.find((a) => a.name === 'columns');
+            if (colArg && colArg.value.kind === NodeKind.NumberLiteral) {
+                columns = colArg.value.value;
+            }
+        }
+        this.expect(TokenType.LeftBrace);
+        const rows = [];
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            if (this.check(TokenType.RowKeyword)) {
+                rows.push(this.parseLayoutRow());
+            }
+            else if (this.check(TokenType.RightBrace)) {
+                break;
+            }
+            else {
+                this.error(`Unexpected token '${this.current().value}' inside layout. Expected 'row' or '}'.`);
+                this.advance();
+            }
+        }
+        this.expect(TokenType.RightBrace);
+        return {
+            kind: NodeKind.LayoutBlock,
+            columns,
+            rows,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    parseLayoutRow() {
+        const start = this.currentSpan();
+        this.expect(TokenType.RowKeyword);
+        this.expect(TokenType.LeftBrace);
+        const items = [];
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            const itemDecorators = this.parseDecoratorList();
+            let node;
+            if (this.check(TokenType.ChartKeyword)) {
+                node = this.parseChartCall(itemDecorators);
+            }
+            else if (this.check(TokenType.FilterKeyword)) {
+                if (itemDecorators.length > 0) {
+                    this.error('Decorators cannot be applied to filter declarations.');
+                }
+                node = this.parseFilterCall();
+            }
+            else if (this.check(TokenType.RightBrace)) {
+                break;
+            }
+            else {
+                this.error(`Unexpected token '${this.current().value}' inside row. Expected 'chart', 'filter', or '}'.`);
+                this.advance();
+                continue;
+            }
+            // Check for optional 'span N' after the chart/filter call
+            let span;
+            if (this.check(TokenType.Identifier) && this.current().value === 'span') {
+                this.advance(); // consume 'span'
+                const spanToken = this.expect(TokenType.NumberLiteral);
+                span = Number(spanToken.value);
+            }
+            items.push({ node, span });
+        }
+        this.expect(TokenType.RightBrace);
+        return {
+            kind: NodeKind.LayoutRow,
+            items,
+            span: this.makeSpan(start, this.previousSpan()),
+        };
+    }
+    // ---- Helpers ----
+    synchronize() {
+        while (!this.isAtEnd()) {
+            const token = this.current();
+            if (token.type === TokenType.DashboardKeyword ||
+                token.type === TokenType.WorkbookKeyword ||
+                token.type === TokenType.ChartKeyword ||
+                token.type === TokenType.FilterKeyword ||
+                token.type === TokenType.ImportKeyword ||
+                token.type === TokenType.BlockKeyword ||
+                token.type === TokenType.AtSign ||
+                token.type === TokenType.RightBrace) {
+                return;
+            }
+            this.advance();
+        }
+    }
+}
+export function parse(source, file) {
+    const parser = new Parser(source, file);
+    return parser.parse();
+}
+//# sourceMappingURL=parser.js.map