@gooddata/sdk-maql-language-server 0.0.0-stage → 11.65.0-alpha.4

package/esm/findObjects.js

@@ -0,0 +1,72 @@
+// (C) 2021-2026 GoodData Corporation
+import { ParseTreeWalker } from "antlr4ts/tree/index.js";
+import MaqlPkg from "@gooddata/maql-antlr4ts";
+const { AttributeTypeContext, MaqlParser, NumericTypeContext } = MaqlPkg;
+import { isTigerType, tigerIdTypeToObjectType } from "@gooddata/sdk-backend-tiger";
+import { normalizeMaqlObjectType } from "./maqlObjectTypes.js";
+import { MaqlMetric } from "./parseMaql.js";
+import { antlrContextRange } from "./tokenRanges.js";
+export function findAllObjects(metric) {
+    const finder = new ObjectFinder();
+    ParseTreeWalker.DEFAULT.walk(finder, metric.tree);
+    return finder.objects;
+}
+// TODO rewrite using AbstractAstVisitor
+class ObjectFinder {
+    objects;
+    visitTerminal; // to satisfy TS2559 - weak type detection
+    constructor(objects = []) {
+        this.objects = objects;
+    }
+    pushObject(ctx, type) {
+        const lbrace = ctx.tryGetToken(MaqlParser.LBRACE, 0);
+        const sep = ctx.tryGetToken(MaqlParser.SEP, 0);
+        const id = ctx.tryGetToken(MaqlParser.ID, 0);
+        const rbrace = ctx.tryGetToken(MaqlParser.RBRACE, 0);
+        // check that the object is complete
+        if (lbrace === undefined ||
+            lbrace.symbol.tokenIndex === -1 ||
+            sep === undefined ||
+            sep.symbol.tokenIndex === -1 ||
+            id === undefined ||
+            id.symbol.tokenIndex === -1 ||
+            rbrace === undefined ||
+            rbrace.symbol.tokenIndex === -1 ||
+            type === undefined) {
+            return;
+        }
+        const range = antlrContextRange(ctx.start, ctx.stop);
+        // `actualType` keeps the MAQL spelling so diagnostics quote what the author wrote.
+        //NOTE: The lexer accepts any casing, so fold it before the type is looked up.
+        const tigerType = normalizeMaqlObjectType(type.toLowerCase());
+        this.objects.push({
+            tigerType: isTigerType(tigerType) ? tigerType : undefined,
+            actualType: type,
+            id: ctx.ID().text,
+            ref: {
+                type: tigerIdTypeToObjectType[tigerType],
+                identifier: ctx.ID().text,
+            },
+            range: range,
+            offsets: {
+                start: MaqlMetric.rawOffset(ctx.start.startIndex),
+                end: MaqlMetric.rawOffset((ctx.stop?.stopIndex ?? ctx.start.stopIndex) + 1),
+            },
+        });
+    }
+    exitAttribute(ctx) {
+        this.pushObject(ctx, ctx.tryGetRuleContext(0, AttributeTypeContext)?.text);
+    }
+    exitNumeric(ctx) {
+        this.pushObject(ctx, ctx.tryGetRuleContext(0, NumericTypeContext)?.text);
+    }
+    exitFact(ctx) {
+        this.pushObject(ctx, ctx.tryGetToken(MaqlParser.FACT, 0)?.text);
+    }
+    exitPrompt(ctx) {
+        this.pushObject(ctx, ctx.tryGetToken(MaqlParser.PROMPT, 0)?.text);
+    }
+    exitParameter(ctx) {
+        this.pushObject(ctx, ctx.tryGetToken(MaqlParser.PARAMETER, 0)?.text);
+    }
+}

package/esm/format.d.ts

@@ -0,0 +1,4 @@
+import { type FormattingOptions, type Range, TextEdit } from "vscode-languageserver";
+export declare function format(query: string, options: FormattingOptions): TextEdit[];
+export declare function formatRange(query: string, range: Range, options: FormattingOptions): TextEdit[];
+//# sourceMappingURL=format.d.ts.map

package/esm/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,iBAAiB,EAAiB,KAAK,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAQpG,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,QAAQ,EAAE,CAI5E;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,iBAAiB,GAAG,QAAQ,EAAE,CAI/F"}

package/esm/format.js

@@ -0,0 +1,581 @@
+// (C) 2022-2026 GoodData Corporation
+import { AbstractParseTreeVisitor, } from "antlr4ts/tree/index.js";
+import { TextEdit } from "vscode-languageserver";
+import Maql from "@gooddata/maql-antlr4ts";
+import { TokenTypes, tokenTypeMap } from "./highlight/semanticsHighlight.js";
+import { MaqlMetric } from "./parseMaql.js";
+import { antlrContextRange, tokenRange } from "./tokenRanges.js";
+export function format(query, options) {
+    const metric = new MaqlMetric(query);
+    const formatter = new MaqlFormatter(options, metric);
+    return formatter.visit(metric.tree);
+}
+export function formatRange(query, range, options) {
+    const metric = new MaqlMetric(query);
+    const formatter = new MaqlFormatter(options, metric, range);
+    return formatter.visit(metric.tree);
+}
+/**
+ * Automatic formatting for MAQL metrics
+ * MaqlFormatter class is a parse tree visitor that analyzes a MAQL metric and finds necessary text edits
+ * to transform the metric into the preferred formatting.
+ * The found text edits are not sorted. However, they are guaranteed to not be overlapping.
+ *
+ * The basic principle is to apply a text edit on each token only once. Take this query as an example
+ * ```
+ * SELECT AVG({fact/budget})
+ *   WHERE {label/country.code}="US"
+ * ```
+ * the tokens here would be
+ * ```
+ * SELECT WS AVG LPAREN <fact tokens> RPAREN WS WHERE WS <label tokens> RELOP STRING
+ * ```
+ * From the tokens and the MAQL grammar a parse tree is constructed.
+ * When traversing the parse tree, edits are added based on the defined rules. If multiple rules should be applied
+ * using the same token, the first rule triggered has precedence.
+ * Most important are the whitespace (WS) tokens, which are strings of whitespace characters - spaces, new lines, tabs etc.
+ */
+class MaqlFormatter extends AbstractParseTreeVisitor {
+    options;
+    indentationLevel = 0;
+    formattedTokens;
+    stream;
+    get indentSpaces() {
+        return " ".repeat(this.indentationLevel * this.options.tabSize);
+    }
+    constructor(options, metric, range) {
+        super();
+        this.options = options;
+        this.formattedTokens = new Set();
+        this.stream = metric.tokenStream;
+        if (range) {
+            // if a range is specified do not enter contexts where the intersection with the context range is empty
+            this.visit = (tree) => this.visitInRange(tree, range);
+        }
+    }
+    defaultResult() {
+        return [];
+    }
+    aggregateResult(aggregate, nextResult) {
+        return aggregate.concat(nextResult);
+    }
+    visitInRange(tree, range) {
+        const treeRange = antlrContextRange(this.stream.get(tree.sourceInterval.a), this.stream.get(tree.sourceInterval.b)).toRange();
+        if (!this.intersects(treeRange, range)) {
+            return this.defaultResult();
+        }
+        return super.visit(tree).filter((edit) => this.intersects(edit.range, range));
+    }
+    visitChildren(node, firstChild = 0, lastChild = node.childCount - 1) {
+        let result = this.defaultResult();
+        for (let i = firstChild; i <= lastChild; i++) {
+            if (!this.shouldVisitNextChild(node, result)) {
+                break;
+            }
+            const child = node.getChild(i);
+            if (!child)
+                continue;
+            const childResult = this.visit(child);
+            result = this.aggregateResult(result, childResult);
+        }
+        return result;
+    }
+    visitTerminal(node) {
+        const token = node.symbol;
+        const wsEdits = this.ensureWhitespace(this.getHiddenToLeft(token), undefined, this.indentSpaces);
+        const edits = this.formatToken(token);
+        return wsEdits.concat(edits);
+    }
+    visitErrorNode(node) {
+        if (node.symbol.tokenIndex === -1)
+            return this.defaultResult(); // conjured up symbol -> skip
+        return this.visitTerminal(node); // format error nodes anyway if possible
+    }
+    formatToken(token) {
+        if (this.formattedTokens.has(token.tokenIndex))
+            return this.defaultResult();
+        this.formattedTokens.add(token.tokenIndex);
+        const semanticType = tokenTypeMap.get(token.type);
+        const edits = [];
+        const range = tokenRange(token);
+        if (!this.inRange(range) || !token.text)
+            return this.defaultResult();
+        if (semanticType === TokenTypes.Keyword || semanticType === TokenTypes.Function) {
+            const edited = token.text.toUpperCase();
+            if (token.text !== edited) {
+                edits.push(TextEdit.replace(range, edited));
+            }
+        }
+        return edits;
+    }
+    visitMaqlMeasure = this.visitMaqlQuery;
+    visitMaqlComputedAttribute = this.visitMaqlQuery;
+    visitMaqlFilter = this.visitMaqlQuery;
+    visitMaqlQuery(ctx) {
+        const edits = [];
+        const eof = ctx.EOF().symbol;
+        const eofPosition = tokenRange(eof).start;
+        const hidden = this.getHiddenToLeft(eof);
+        if (this.options.trimFinalNewlines) {
+            const final = this.options.insertFinalNewline ? "\n" : "";
+            edits.push(...this.removeWhitespace(hidden, " ", final));
+        }
+        else if (this.options.insertFinalNewline) {
+            edits.push(...this.ensureNewline(hidden, eofPosition));
+        }
+        else {
+            edits.push(...this.ensureWhitespace(hidden, "", "", eofPosition));
+        }
+        edits.push(...this.visitChildren(ctx));
+        return edits;
+    }
+    visitFunctionCall = this.visitFunctionCallCommon;
+    visitFunctionCallRun(ctx) {
+        const edits = [];
+        edits.push(...this.visitFunctionCallCommon(ctx));
+        const withinCtx = ctx.within();
+        if (withinCtx) {
+            edits.push(...this.visitFunctionCallClause(withinCtx));
+        }
+        const rollWindowCtx = ctx.rollWindow();
+        if (rollWindowCtx) {
+            edits.push(...this.visitFunctionCallClause(rollWindowCtx));
+        }
+        return edits;
+    }
+    visitFunctionCallRank(ctx) {
+        const edits = [];
+        edits.push(...this.visitFunctionCallCommon(ctx));
+        const rankDirCtx = ctx.rankDir();
+        if (rankDirCtx) {
+            edits.push(...this.visitFunctionCallClause(rankDirCtx));
+        }
+        const withinCtx = ctx.within();
+        if (withinCtx) {
+            edits.push(...this.visitFunctionCallClause(withinCtx));
+        }
+        return edits;
+    }
+    visitFunctionCallLastFirstValue(ctx) {
+        const edits = [];
+        edits.push(...this.visitFunctionCallCommon(ctx));
+        const orderByCtx = ctx.orderby();
+        if (orderByCtx) {
+            edits.push(...this.visitFunctionCallClause(orderByCtx));
+        }
+        const withinCtx = ctx.within();
+        if (withinCtx) {
+            edits.push(...this.visitFunctionCallClause(withinCtx));
+        }
+        return edits;
+    }
+    /**
+     * Ensure new line before function modifying clauses e.g. WITHIN
+     */
+    visitFunctionCallClause(ctx) {
+        const edits = [];
+        edits.push(...this.ensureNewline(this.getHiddenToLeft(ctx.start), tokenRange(ctx.start).start));
+        edits.push(...this.visit(ctx));
+        return edits;
+    }
+    visitFunctionCallCommon(ctx) {
+        const edits = [];
+        edits.push(...this.visit(ctx.getChild(0)));
+        const lparen = ctx.tryGetToken(Maql.MaqlParser.LPAREN, 0)?.symbol;
+        if (lparen) {
+            edits.push(...this.removeWhitespace(this.getHiddenToLeft(lparen)));
+        }
+        if (lparen) {
+            edits.push(...this.ensureWhitespace(this.getHiddenToRight(lparen), "", undefined, tokenRange(lparen).end));
+        }
+        this.indent();
+        const argsCtx = ctx.tryGetRuleContext(0, Maql.ExpressionListContext) ??
+            ctx.tryGetRuleContext(0, Maql.MaqlExpressionContext);
+        if (argsCtx) {
+            edits.push(...this.visit(argsCtx));
+        }
+        const rparen = ctx.tryGetToken(Maql.MaqlParser.RPAREN, 0)?.symbol;
+        if (rparen) {
+            edits.push(...this.removeWhitespace(this.getHiddenToLeft(rparen)));
+        }
+        this.dedent();
+        if (rparen) {
+            edits.push(...this.visit(ctx.RPAREN()));
+        }
+        return edits;
+    }
+    visitTimeMacro(ctx) {
+        const edits = [];
+        edits.push(...this.visit(ctx.getChild(0)));
+        const lparen = ctx.LPAREN().symbol;
+        edits.push(...this.removeWhitespace(this.getHiddenToLeft(lparen)));
+        edits.push(...this.ensureWhitespace(this.getHiddenToRight(lparen), "", undefined, tokenRange(lparen).end));
+        this.indent();
+        const rparen = ctx.RPAREN().symbol;
+        edits.push(...this.removeWhitespace(this.getHiddenToLeft(rparen)));
+        this.dedent();
+        edits.push(...this.visit(ctx.RPAREN()));
+        const comma = ctx.COMMA()?.symbol;
+        if (comma) {
+            edits.push(...this.removeWhitespace(this.getHiddenToLeft(comma)));
+            const commaRange = tokenRange(comma);
+            edits.push(...this.ensureSpace(this.getHiddenToRight(comma), commaRange.end));
+        }
+        edits.push(...this.visit(ctx.granularity()));
+        const amountCtx = ctx.integer();
+        if (amountCtx) {
+            edits.push(...this.visit(amountCtx));
+        }
+        return edits;
+    }
+    visitExpressionList(ctx) {
+        const edits = [];
+        const commaContext = ctx.COMMA();
+        const commas = (Array.isArray(commaContext) ? commaContext : [commaContext])
+            .map((c) => c?.symbol)
+            .filter((c) => c !== undefined);
+        for (const comma of commas) {
+            edits.push(...this.removeWhitespace(this.getHiddenToLeft(comma)));
+            const commaRange = tokenRange(comma);
+            edits.push(...this.ensureSpace(this.getHiddenToRight(comma), commaRange.end));
+        }
+        edits.push(...this.visitChildren(ctx));
+        return edits;
+    }
+    visitDisjunction(ctx) {
+        return this.visitLogicalOperatorExpression(ctx, () => ctx.OR());
+    }
+    visitConjunction(ctx) {
+        return this.visitLogicalOperatorExpression(ctx, () => ctx.AND());
+    }
+    visitLogicalOperatorExpression(ctx, ops) {
+        const edits = [];
+        for (const opNode of ops()) {
+            const op = opNode.symbol;
+            const opRange = tokenRange(op);
+            edits.push(...this.ensureNewline(this.getHiddenToLeft(op), opRange.start));
+            edits.push(...this.removeWhitespace(this.getHiddenToRight(op), " ", " ", opRange.end));
+        }
+        edits.push(...this.visitChildren(ctx));
+        return edits;
+    }
+    visitAddition(ctx) {
+        return this.visitArithmeticOperatorExpression(ctx, () => ctx
+            .additiveOperator()
+            .map((it) => it.PLUS() ?? it.MINUS())
+            .filter((it) => !!it));
+    }
+    visitMultiplication(ctx) {
+        return this.visitArithmeticOperatorExpression(ctx, () => ctx
+            .multiplicativeOperator()
+            .map((it) => it.MUL() ?? it.DIV())
+            .filter((it) => !!it));
+    }
+    visitArithmeticOperatorExpression(ctx, ops) {
+        const edits = [];
+        for (const opNode of ops()) {
+            const op = opNode.symbol;
+            const opRange = tokenRange(op);
+            edits.push(...this.ensureSpace(this.getHiddenToLeft(op), opRange.start));
+            edits.push(...this.ensureSpace(this.getHiddenToRight(op), opRange.end));
+        }
+        edits.push(...this.visitChildren(ctx));
+        return edits;
+    }
+    visitRelationRelop(ctx) {
+        const edits = [];
+        const relop = ctx.RELOP().symbol;
+        const relopRange = tokenRange(relop);
+        edits.push(...this.ensureSpace(this.getHiddenToLeft(relop), relopRange.start));
+        edits.push(...this.ensureSpace(this.getHiddenToRight(relop), relopRange.end));
+        edits.push(...this.visitChildren(ctx));
+        return edits;
+    }
+    visitRelationLike(ctx) {
+        const edits = [];
+        const likeCtx = ctx.like();
+        const item = likeCtx.LIKE() || likeCtx.ILIKE();
+        const like = item.symbol;
+        const likeRange = tokenRange(like);
+        edits.push(...this.ensureSpace(this.getHiddenToLeft(like), likeRange.start));
+        edits.push(...this.ensureSpace(this.getHiddenToRight(like), likeRange.end));
+        edits.push(...this.visit(likeCtx));
+        return edits;
+    }
+    visitRelationBetween(ctx) {
+        const edits = [];
+        const between = ctx.BETWEEN().symbol;
+        const betweenRange = tokenRange(between);
+        edits.push(...this.ensureSpace(this.getHiddenToLeft(between), betweenRange.start));
+        edits.push(...this.ensureSpace(this.getHiddenToRight(between), betweenRange.end));
+        const and = ctx.AND().symbol;
+        const andRange = tokenRange(and);
+        edits.push(...this.ensureSpace(this.getHiddenToLeft(and), andRange.start));
+        edits.push(...this.ensureSpace(this.getHiddenToRight(and), andRange.end));
+        edits.push(...this.visitChildren(ctx));
+        return edits;
+    }
+    visitRelationNot(ctx) {
+        const not = ctx.NOT();
+        const edits = [];
+        if (not) {
+            const token = not.symbol;
+            const range = tokenRange(token);
+            edits.push(...this.ensureSpace(this.getHiddenToLeft(token), range.start));
+            edits.push(...this.ensureSpace(this.getHiddenToRight(token), range.end));
+            edits.push(...this.visit(not));
+        }
+        edits.push(...this.visit(ctx.relationNegatable()));
+        return edits;
+    }
+    visitRelationIn(ctx) {
+        const edits = [];
+        const int = ctx.IN().symbol;
+        const range = tokenRange(int);
+        edits.push(...this.ensureSpace(this.getHiddenToLeft(int), range.start));
+        edits.push(...this.ensureSpace(this.getHiddenToRight(int), range.end));
+        edits.push(...this.visit(ctx.IN()));
+        const lparen = ctx.LPAREN().symbol;
+        const lparenRange = tokenRange(lparen);
+        if (ctx.listLiteral() === undefined) {
+            edits.push(...this.removeWhitespace(this.getHiddenToLeft(ctx.RPAREN().symbol)));
+        }
+        else {
+            this.indent();
+            edits.push(...this.ensureNewline(this.getHiddenToRight(lparen), lparenRange.end));
+            edits.push(...this.visitChildren(ctx, 1, ctx.childCount - 2));
+            this.dedent();
+        }
+        edits.push(...this.visit(ctx.RPAREN()));
+        return edits;
+    }
+    visitSelectExpression(ctx) {
+        const edits = [];
+        const select = ctx.SELECT().symbol;
+        const selectRange = tokenRange(select);
+        edits.push(...this.ensureNewline(this.getHiddenToLeft(select), selectRange.start));
+        edits.push(...this.visit(ctx.SELECT()));
+        this.indent();
+        edits.push(...this.ensureSpace(this.getHiddenToRight(select), selectRange.end));
+        edits.push(...this.visitChildren(ctx, 1));
+        this.dedent();
+        return edits;
+    }
+    visitBy(ctx) {
+        return this.visitKeywordOfStatement(ctx, () => ctx.BY());
+    }
+    visitForEach(ctx) {
+        const edits = [];
+        const forEach = ctx.FOR().symbol;
+        const forEachRange = tokenRange(forEach);
+        edits.push(...this.ensureNewline(this.getHiddenToLeft(forEach), forEachRange.start));
+        this.indent();
+        edits.push(...this.visitChildren(ctx, 1));
+        this.dedent();
+        return edits;
+    }
+    visitForTransformation(ctx) {
+        return this.visitKeywordOfStatement(ctx, () => ctx.FOR());
+    }
+    visitWhere(ctx) {
+        return this.visitKeywordOfStatement(ctx, () => ctx.WHERE());
+    }
+    visitHaving(ctx) {
+        return this.visitKeywordOfStatement(ctx, () => ctx.HAVING());
+    }
+    visitUsing(ctx) {
+        return this.visitKeywordOfStatement(ctx, () => ctx.USING());
+    }
+    visitWithPf(ctx) {
+        return this.visitKeywordOfStatement(ctx, () => ctx.WITH());
+    }
+    visitWithoutPf(ctx) {
+        return this.visitKeywordOfStatement(ctx, () => ctx.WITHOUT());
+    }
+    visitKeywordOfStatement(ctx, keyword) {
+        const edits = [];
+        const kw = keyword().symbol;
+        const kwRange = tokenRange(kw);
+        edits.push(...this.ensureNewline(this.getHiddenToLeft(kw), kwRange.start));
+        edits.push(...this.ensureSpace(this.getHiddenToRight(kw), kwRange.end));
+        edits.push(...this.visit(keyword()));
+        edits.push(...this.visitChildren(ctx, 1));
+        return edits;
+    }
+    visitAttributeList(ctx) {
+        return this.visitNewlineSeparatedCommaList(ctx);
+    }
+    // oxlint-disable-next-line sonarjs/no-identical-functions -- distinct ANTLR visitor override with intentionally identical formatting behavior
+    visitListLiteral(ctx) {
+        return this.visitNewlineSeparatedCommaList(ctx);
+    }
+    visitNewlineSeparatedCommaList(ctx) {
+        const edits = [];
+        for (const comma of ctx.COMMA()) {
+            const token = comma.symbol;
+            edits.push(...this.removeWhitespace(this.getHiddenToLeft(token)));
+            edits.push(...this.ensureNewline(this.getHiddenToRight(token), tokenRange(token).end));
+        }
+        edits.push(...this.visitChildren(ctx));
+        return edits;
+    }
+    visitIf(ctx) {
+        const edits = [];
+        edits.push(...this.visit(ctx.IF()));
+        edits.push(...this.visitElse(ctx));
+        return edits;
+    }
+    visitCase(ctx) {
+        const edits = [];
+        edits.push(...this.visit(ctx.CASE()));
+        edits.push(...this.visitElse(ctx));
+        return edits;
+    }
+    visitElse(ctx) {
+        const edits = [];
+        this.indent();
+        const elseCtx = ctx.ELSE();
+        if (elseCtx) {
+            edits.push(...this.ensureNewline(this.getHiddenToLeft(elseCtx.symbol), tokenRange(elseCtx.symbol).start));
+            edits.push(...this.visit(elseCtx));
+        }
+        edits.push(...this.visitChildren(ctx, 1, ctx.childCount - 2));
+        this.dedent();
+        const end = ctx.END()?.symbol;
+        edits.push(...this.ensureNewline(this.getHiddenToLeft(end), tokenRange(end).start));
+        edits.push(...this.visit(ctx.END()));
+        return edits;
+    }
+    visitCaseConditional(ctx) {
+        const edits = this.defaultResult();
+        for (const when of ctx.WHEN()) {
+            const token = when.symbol;
+            edits.push(...this.ensureNewline(this.getHiddenToLeft(token), tokenRange(token).start));
+        }
+        edits.push(...this.visitChildren(ctx));
+        return edits;
+    }
+    visitTransFunction(ctx) {
+        const token = ctx.NEXT() ?? ctx.NEXTPERIOD() ?? ctx.PREVIOUS() ?? ctx.PREVIOUSPERIOD();
+        const text = token?.text;
+        const edited = text ? formatTransFunction(text) : undefined;
+        if (!token || !edited || text === edited)
+            return this.defaultResult();
+        const range = tokenRange(token.symbol);
+        if (!this.inRange(range))
+            return this.defaultResult();
+        return [TextEdit.replace(range, edited)];
+    }
+    /**
+     * Shortens whitespace, trims trailing spaces, inserts string at the start of the last line
+     * @param whitespace - is assumed to be the token text of a MaqlParser.WS token
+     * @param finalInline - is the value to be used if there are no line breaks in the whitespace
+     *  if undefined then by default trim the whitespace to at most one space
+     * @param finalNewline - is the value to be after the last line break
+     */
+    formatWhitespace(whitespace, finalInline, finalNewline) {
+        const lines = whitespace.split("\n");
+        if (lines.length === 1)
+            return finalInline === undefined ? (whitespace.length > 0 ? " " : "") : finalInline;
+        if (this.options.trimTrailingWhitespace) {
+            lines.slice(0, -1).forEach((_, idx) => (lines[idx] = ""));
+        }
+        if (finalNewline !== undefined) {
+            lines[lines.length - 1] = finalNewline;
+        }
+        return lines.join("\n");
+    }
+    ensureWhitespace(tokens, finalInline, finalNewline, position) {
+        if (tokens.length === 0 && finalInline) {
+            return [TextEdit.insert(position, finalInline)];
+        }
+        return tokens
+            .map((token) => {
+            if (!token.text || this.formattedTokens.has(token.tokenIndex))
+                return null;
+            if (token.type === Maql.MaqlParser.WS) {
+                const range = tokenRange(token);
+                const edited = this.formatWhitespace(token.text, finalInline, finalNewline);
+                if (token.text !== edited) {
+                    this.formattedTokens.add(token.tokenIndex);
+                    return TextEdit.replace(range, edited);
+                }
+            }
+            return null;
+        })
+            .filter((edit) => !!edit);
+    }
+    ensureSpace(tokens, position) {
+        return this.ensureWhitespace(tokens, " ", this.indentSpaces, position);
+    }
+    ensureNewline(tokens, position) {
+        return this.ensureWhitespace(tokens, "\n" + this.indentSpaces, this.indentSpaces, position);
+    }
+    /**
+     * Removes all whitespace if there are no preceding line comments
+     */
+    removeWhitespace(tokens, separator = " ", final = "", position) {
+        if (tokens.length === 0 && position && final !== "") {
+            return [TextEdit.insert(position, final)];
+        }
+        let prevIsLineComment = false;
+        const edits = this.defaultResult();
+        tokens.forEach((token, idx) => {
+            if (!token.text || this.formattedTokens.has(token.tokenIndex))
+                return;
+            this.formattedTokens.add(token.tokenIndex);
+            if (token.type === Maql.MaqlParser.WS) {
+                const range = tokenRange(token);
+                const edited = prevIsLineComment
+                    ? "\n" + this.indentSpaces
+                    : idx < tokens.length - 1
+                        ? separator
+                        : final;
+                if (token.text !== edited) {
+                    edits.push(TextEdit.replace(range, edited));
+                }
+            }
+            prevIsLineComment = token.type === Maql.MaqlParser.Comment;
+        });
+        return edits;
+    }
+    indent() {
+        this.indentationLevel += 1;
+    }
+    dedent() {
+        this.indentationLevel -= 1;
+    }
+    inRange(range) {
+        return range.start.line >= 0; // skip "PARSE METRIC\n"
+    }
+    intersects(a, b) {
+        const { start: startA, end: endA } = a;
+        const { start: startB, end: endB } = b;
+        return ((endA.line > startB.line || (endA.line === startB.line && endA.character > startB.character)) &&
+            (startA.line < endB.line || (startA.line === endB.line && startA.character < endB.character)));
+    }
+    getHiddenToLeft(token) {
+        if (token.tokenIndex < 0 || token.tokenIndex >= this.stream.size)
+            return [];
+        return this.stream.getHiddenTokensToLeft(token.tokenIndex, -1);
+    }
+    getHiddenToRight(token) {
+        if (token.tokenIndex < 0 || token.tokenIndex >= this.stream.size)
+            return [];
+        return this.stream.getHiddenTokensToRight(token.tokenIndex, -1);
+    }
+}
+function formatTransFunction(func) {
+    switch (func.toUpperCase()) {
+        case "NEXT":
+            return "Next";
+        case "NEXTPERIOD":
+            return "NextPeriod";
+        case "PREVIOUS":
+            return "Previous";
+        case "PREVIOUSPERIOD":
+            return "PreviousPeriod";
+        default:
+            return func.charAt(0).toUpperCase() + func.slice(1);
+    }
+}

package/esm/highlight/convert.d.ts

@@ -0,0 +1,3 @@
+import { type HighlightToken } from "./semanticsHighlight.js";
+export declare function convertToSemanticTokens(tokens: HighlightToken[]): import("vscode-languageserver").SemanticTokens;
+//# sourceMappingURL=convert.d.ts.map

package/esm/highlight/convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/highlight/convert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,yBAAyB,CAAC;AAGpF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,cAAc,EAAE,kDAa/D"}

package/esm/highlight/convert.js

@@ -0,0 +1,12 @@
+// (C) 2023-2026 GoodData Corporation
+import { SemanticTokensBuilder } from "vscode-languageserver";
+import { semanticTokensLegend } from "./semanticsHighlight.js";
+import { getModifiers, getType } from "./utils.js";
+export function convertToSemanticTokens(tokens) {
+    const builder = new SemanticTokensBuilder();
+    tokens.forEach(({ position, type, modifiers }) => {
+        const length = position.end.character - position.start.character;
+        builder.push(position.start.line, position.start.character, length, getType(semanticTokensLegend.tokenTypes, type), getModifiers(semanticTokensLegend.tokenModifiers, modifiers));
+    });
+    return builder.build();
+}