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

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2020-2022 GoodData Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,119 @@
-# Temporary Holding Version
+# MAQL language server
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+TS/JS implementation of Language Server that utilizes LSP.
+
+The project is part of the Rush-managed monorepo. Follow the main repository guidelines.
+
+## Browser consumers
+
+`antlr4ts` is written for Node: it requires the Node built-ins `assert` and `util` and does not
+declare them. Browser bundlers such as Vite and webpack 5 do not provide Node built-ins, so this
+package declares their browser ports, `assert` and `util`, as dependencies. A package manager that
+hoists them (npm, pnpm by default) puts them where `antlr4ts` resolves them. Without them, the
+bundle crashes when it loads `antlr4ts` (`assert is not a function`, or `Cannot read properties of
+undefined (reading 'custom')` from `util.inspect.custom`).
+
+## Build
+
+To build the MAQL language server run
+
+```shell
+rushx build
+```
+
+## Testing MAQL grammar changes
+
+To get the latest grammar, upgrade `@gooddata/maql-antlr4ts` dependency, located in gdc-nas repository.
+The npm package is not built automatically, it needs to be built by triggering the corresponding workflow
+in gdc-nas. See https://github.com/gooddata/gdc-nas/blob/master/libraries/calq/maql-antlr4ts/README.md#publishing for details.
+
+The MAQL lexer and parser are retrieved as a dependency from NPM, after build in gdc-nas
+repository.
+
+You may want to test out how changes to MAQL grammar affect the MAQL language server
+before such changes are pushed to the repository.
+
+For this purpose you may want to link the folder with the @gooddata/maql-antlr4ts source codes directly.
+
+First move into the folder containing package.json for the dependency. This may be something like
+`gdc-nas/libraries/calq/maql-parser/npm-lib`
+
+#### WARNING:
+
+Do not use `yarn link` to link `@gooddata/maql-antlr4ts`. The cause is not exactly clear, possibly library conflicts, but after
+linking, antlr4 tokens in token streams have all indices set to -1.
+
+This means that the `antlr4-c3` library will give incorrect results and completions tests will fail. There is no known
+fix so far, other than using a different linking method such as [yalc](https://github.com/wclr/yalc) or rsync.
+
+---
+
+## MAQL changes checklist
+
+After you update to a newer version of `@gooddata/maql-antlr4ts ` this checklist serves to verify that the changes
+are reflected in the language server. The checklist tries to be as exhaustive as possible while not being
+overwhelming. This also means that it can quickly become outdated, so please update any inaccuracies whenever
+you encounter them. Also, most changes to MAQL will not require all the steps here mentioned. As an extra step,
+please add test cases for new changes when possible.
+
+#### 1. Fix tests (`rushx test`)
+
+Tests may fail if any MAQL grammar rules were changed. But adding new rules will most likely not cause
+any test failures. This may also be the last step in many cases.
+
+#### 2. Add semantic highlighting to new tokens - [semantics.ts](./src/semantics.ts) - [semantics.test.ts](./test/semantics.test.ts)
+
+Any new tokens need to have semantic highlighting manually added. Choose appropriate category.
+If the highlighting depends on context (this is the case for example for curly brace tokens `{`, `}`
+in labels and facts), you need to extend the SemanticTokenizer class for those cases. If you need to
+add a new category (not recommended), you will also need to update the clients with the name and colour
+of the new category - for example in [useMaqlTheme.ts](../web-app/src/MaqlEditor/maql/hooks/useMaqlTheme.ts).
+
+#### 3. Add completions - [completions](./src/completions) - [completions.test.ts](./test/completions.test.ts)
+
+You should add new completions if you added a rule or a token to MAQL Grammar.
+
+To provide MAQL completions, we are using the [antlr4-c3](https://github.com/mike-lischke/antlr4-c3) library
+which takes the grammar and gives us a list of tokens that continue the already written query.
+However that is not enough for us as we want to be smarter.
+
+##### 3.1 Add completion descriptions - [descriptions.ts](./src/completions/descriptions.ts)
+
+Each completion item is based on a description in the file. Most things can be copied from the examples already
+there, but pay special attention to properties `triggerTokenId` and `ruleId`. Only one of those can be set for
+each description, and it signifies when the completion should be shown. If `triggerTokenId` is set, then it will
+be shown any time that token is suggested. This is good in most cases but some tokens can have multiple conflicting
+meanings. In that case you can use `ruleId` which will on encountering the grammar rule with that id ignore all
+tokens and only suggest completions that use the same `ruleId`.
+
+##### 3.2 Add special cases - [complete.ts](./src/completions/complete.ts)
+
+For most cases, adding the description is enough. If something more special is required
+(like label elements completions), you must delve into the `complete.ts` file and add that case manually.
+
+#### 4. Add diagnostics - [diagnostics.ts](./src/diagnostics.ts) - [diagnostics.test.ts](./test/diagnostics.test.ts)
+
+Diagnostics from grammar are generated automatically. Change `diagnostics.ts` only if you need a special case
+or if you added an error token to MAQL Lexer.
+
+#### 5. Add auto-format rule - [format.ts](./src/format.ts) - [format.test.ts](./test/format.test.ts)
+
+Automatic formatting is quite tightly coupled to the MAQL grammar, so there is a chance it is broken after a change.
+Try adding a test case to `format.test.ts` to see what happens.
+
+## Scripts
+
+### Documentation update
+
+```
+rushx update-docs <path/to/docs/directory/content>
+```
+
+This script, stored at `src/scripts/docsParser.ts`, will take `.md` files in `<path/to/docs/directory/content>`
+and transform them into `.ts` files in `src/docs/`, along with an `index.ts` file to easily access the documentation
+from inside the server.
+
+The path to docs should point to the directory where different language versions are stored. For
+example `docs-repository/docs/content`, where content has `en`, `es`, `fr` etc. folders.
+
+The script should be run only if there are changes to the documentation in the documentation directory.

package/esm/completions/complete.d.ts

@@ -0,0 +1,12 @@
+import { CompletionItem, CompletionList } from "vscode-languageserver";
+import { type LabelElementsFunc, type LdmObjects } from "../metadata/model.js";
+export declare function resolve(item: CompletionItem, docs: (resolveTag: string) => Promise<string | undefined>): Promise<CompletionItem>;
+/**
+ * Find completions using the antlr4-c3 module.
+ * @param query - The MAQL query to be completed
+ * @param offset - The offset of the caret in the text
+ * @param ldmObjects - LDM objects to be offered, if undefined snippets are offered instead
+ * @param labelElementsFunc - Function to get possible label elements (strings) for a given label and filter text
+ */
+export declare function complete(query: string, offset?: number, ldmObjects?: LdmObjects, labelElementsFunc?: LabelElementsFunc): Promise<CompletionList>;
+//# sourceMappingURL=complete.d.ts.map

package/esm/completions/complete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete.d.ts","sourceRoot":"","sources":["../../src/completions/complete.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,cAAc,EAEd,cAAc,EAIjB,MAAM,uBAAuB,CAAC;AAS/B,OAAO,EAGH,KAAK,iBAAiB,EACtB,KAAK,UAAU,EAClB,MAAM,sBAAsB,CAAC;AAiB9B,wBAAsB,OAAO,CACzB,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,GAC1D,OAAO,CAAC,cAAc,CAAC,CAUzB;AAED;;;;;;GAMG;AACH,wBAAsB,QAAQ,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,MAAqB,EAC7B,UAAU,CAAC,EAAE,UAAU,EACvB,iBAAiB,CAAC,EAAE,iBAAiB,GACtC,OAAO,CAAC,cAAc,CAAC,CA8CzB"}

package/esm/completions/complete.js

@@ -0,0 +1,316 @@
+// (C) 2021-2026 GoodData Corporation
+import { CodeCompletionCore } from "antlr4-c3";
+import { CompletionItem, CompletionItemKind, CompletionList, MarkupKind, Range, TextEdit, } from "vscode-languageserver";
+import MaqlPkg from "@gooddata/maql-antlr4ts";
+const { MaqlLexer, MaqlParser, escapeString } = MaqlPkg;
+import { findLabelContext } from "../labelElements.js";
+import { toMaqlObjectType } from "../maqlObjectTypes.js";
+import { parameterDefaultLabel, parameterTypeLabel } from "../metadata/parameters.js";
+import { MaqlMetric } from "../parseMaql.js";
+import { tokenRange } from "../tokenRanges.js";
+import { MaqlType, isSubtype } from "../types/hierarchy.js";
+import { descriptions, ignoredTokens, } from "./descriptions.js";
+import { findContext, isFinal } from "./findContext.js";
+import { adjustSortText } from "./sort.js";
+const [tokenCompletions, ruleCompletions] = getTokenAndRuleCompletions(descriptions);
+export async function resolve(item, docs) {
+    const data = item.data;
+    const doc = data?.resolveTag ? await docs(data.resolveTag) : undefined;
+    if (doc) {
+        item.documentation = {
+            kind: MarkupKind.Markdown,
+            value: doc,
+        };
+    }
+    return item;
+}
+/**
+ * Find completions using the antlr4-c3 module.
+ * @param query - The MAQL query to be completed
+ * @param offset - The offset of the caret in the text
+ * @param ldmObjects - LDM objects to be offered, if undefined snippets are offered instead
+ * @param labelElementsFunc - Function to get possible label elements (strings) for a given label and filter text
+ */
+export async function complete(query, offset = query.length, ldmObjects, labelElementsFunc) {
+    const metric = new MaqlMetric(query);
+    const adjustedOffset = MaqlMetric.offset(offset);
+    const lines = query.slice(0, offset).split("\n");
+    const position = {
+        line: lines.length,
+        character: lines[lines.length - 1].length,
+    };
+    const caretContext = findContext(metric, position, adjustedOffset);
+    const { leftFinalToken, caretToken, rightFinalToken } = caretContext.tokens;
+    // we do not wish to offer completions inside line comments
+    if (caretToken.type === MaqlParser.Comment) {
+        return CompletionList.create();
+    }
+    const candidates = collectCandidates(metric, caretToken.tokenIndex);
+    // "safe replacement range", which can be replaced by anything
+    const range = textEditRange(leftFinalToken, caretToken, rightFinalToken);
+    // get label elements completions if one of the candidates is a STRING token
+    let context = null; // findLabelContext function is expensive for larger queries, so we lazy-initialize context
+    const getContext = () => context ?? (context = findLabelContext(metric, position));
+    const labelElementsList = labelElementsFunc && candidates.tokens.get(MaqlParser.String)
+        ? await completeLabelElements(labelElementsFunc, range, tokenToString(caretToken, adjustedOffset), getContext())
+        : CompletionList.create();
+    // skip non-string completions if caret is inside string
+    const stringTokens = [MaqlParser.String, MaqlParser.UnterminatedString];
+    if (stringTokens.includes(caretToken.type)) {
+        return labelElementsList;
+    }
+    // static completion items from descriptions
+    const expectedTypes = caretContext.expectedTypes;
+    const staticCompletionList = completeFromCandidateTokens(candidates.tokens, range, expectedTypes);
+    // completions from preferred rules (to disambiguate tokens)
+    const ruleCompletionList = completeFromRules(candidates.rules, range, ldmObjects, expectedTypes);
+    const completionList = [labelElementsList, staticCompletionList, ruleCompletionList].reduce((accuList, currList) => ({
+        items: accuList.items.concat(currList.items),
+        isIncomplete: accuList.isIncomplete || currList.isIncomplete,
+    }));
+    return adjustSortText(completionList, caretContext);
+}
+async function completeLabelElements(labelElementsFunc, range, typedText, context) {
+    const labelElementResult = await labelElementsFunc(context.labels, context.strings.map((str) => str.string), { filter: typedText });
+    return CompletionList.create(labelElementResult.list.elements
+        .map((element) => element.title === null ? null : createStringCompletionItem(element.title, undefined, range))
+        .filter((item) => item !== null), labelElementResult.list.isIncomplete);
+}
+function completeFromCandidateTokens(tokens, range, allowedTypes) {
+    const items = [];
+    tokens.forEach((_, tokenId) => {
+        const staticCompletions = tokenCompletions.get(tokenId) ?? [];
+        if (staticCompletions.length === 0 && !ignoredTokens.has(tokenId)) {
+            // completions for tokens that do not have a description - useful when testing MAQL changes
+            staticCompletions.push(CompletionItem.create(getTokenName(tokenId)));
+        }
+        const typedStaticCompletions = staticCompletions.filter((item) => {
+            const itemType = item.maqlType;
+            return itemType === undefined || allowedTypes.some((type) => isSubtype(itemType, type));
+        });
+        typedStaticCompletions.forEach((item) => withTextEdit(item, range));
+        // filter-out descriptions with inapplicable types when known
+        items.push(...typedStaticCompletions);
+    });
+    return CompletionList.create(items, false);
+}
+function getTokenName(tokenId) {
+    const literalName = MaqlParser.VOCABULARY.getLiteralName(tokenId);
+    if (literalName !== undefined) {
+        return literalName.slice(1, literalName.length - 1).toUpperCase();
+    }
+    return MaqlParser.VOCABULARY.getDisplayName(tokenId);
+}
+/**
+ * Rule completions are necessary when the tokens to be completed are ambiguous
+ * An example in MAQL would be NEXT used after FOR and the NEXT time macro
+ * `... WHERE {label/date.day} = NEXT(DAY)` vs. `... FOR NEXT({label/date.day})`
+ * They are also used for logical data model objects (labels, facts, metrics),
+ * because using the parser rules is more explicit than checking for type tokens.
+ */
+function completeFromRules(rules, range, ldmObjects, allowedTypes) {
+    const items = [];
+    rules.forEach((_, ruleId) => {
+        if (ruleId === MaqlParser.RULE_attribute && ldmObjects && ldmObjects?.size >= 0) {
+            const attributeItems = completeAttribute(ldmObjects, range, allowedTypes);
+            items.push(...attributeItems);
+        }
+        else if ((ruleId === MaqlParser.RULE_numeric || ruleId === MaqlParser.RULE_fact) &&
+            ldmObjects &&
+            ldmObjects?.size >= 0) {
+            const numericItems = completeNumeric(ldmObjects, range, allowedTypes);
+            items.push(...numericItems);
+        }
+        else if (ruleId === MaqlParser.RULE_parameter && ldmObjects) {
+            const parameterItems = completeParameter(ldmObjects, range, allowedTypes);
+            items.push(...parameterItems);
+        }
+        else {
+            const ruleItems = ruleCompletions.get(ruleId) ?? [];
+            const typedRuleItems = ruleItems.filter((item) => {
+                const compType = item.maqlType;
+                return compType === undefined || allowedTypes.some((type) => isSubtype(compType, type));
+            });
+            typedRuleItems.forEach((item) => withTextEdit(item, range));
+            items.push(...typedRuleItems);
+        }
+    });
+    return CompletionList.create(items, false);
+}
+function completeAttribute(ldmObjects, range, allowedTypes) {
+    const items = [];
+    if (allowedTypes.some((type) => isSubtype(MaqlType.DATE, type))) {
+        items.push(...ldmObjects.get("label", "date").map((obj) => createMetadataCompletionItem(obj, range)));
+    }
+    if (allowedTypes.some((type) => isSubtype(MaqlType.STRING, type))) {
+        items.push(...ldmObjects.get("label", "regular").map((obj) => createMetadataCompletionItem(obj, range)));
+        // A computed attribute buckets rows into string values, so it completes wherever a regular
+        // label does - both in a metric and in another computed attribute's expression.
+        items.push(...ldmObjects.get("computedAttribute").map((obj) => createMetadataCompletionItem(obj, range)));
+    }
+    if (allowedTypes.some((type) => isSubtype(MaqlType.DATASET, type))) {
+        items.push(...ldmObjects.get("dataset").map((obj) => createMetadataCompletionItem(obj, range)));
+    }
+    return items;
+}
+function completeNumeric(ldmObjects, range, allowedTypes) {
+    const items = [];
+    if (allowedTypes.some((type) => isSubtype(MaqlType.NUMERIC, type))) {
+        items.push(...ldmObjects.get("fact").map((obj) => createMetadataCompletionItem(obj, range)));
+    }
+    items.push(...ldmObjects.get("metric").map((obj) => createMetadataCompletionItem(obj, range)));
+    return items;
+}
+function completeParameter(ldmObjects, range, allowedTypes) {
+    return ldmObjects
+        .get("parameter")
+        .filter((parameter) => allowedTypes.some((type) => isSubtype(parameterMaqlType(parameter.definition), type)))
+        .map((obj) => createParameterCompletionItem(obj, range));
+}
+function parameterMaqlType(definition) {
+    switch (definition.type) {
+        case "NUMBER":
+            return MaqlType.NUMERIC;
+        case "STRING":
+            return MaqlType.STRING;
+    }
+}
+function createParameterCompletionItem(parameter, range) {
+    const item = createMetadataCompletionItem(parameter, range);
+    return {
+        ...item,
+        labelDetails: { description: parameterTypeLabel(parameter.definition) },
+        detail: `${item.detail}, Default: ${parameterDefaultLabel(parameter.definition)}`,
+    };
+}
+// preferredRules specify rules where token ids alone are insufficient, because they are ambiguous
+const preferredRules = new Set([
+    MaqlParser.RULE_attribute,
+    MaqlParser.RULE_numeric,
+    ...ruleCompletions.keys(),
+]);
+function collectCandidates(metric, caretTokenIndex) {
+    const core = new CodeCompletionCore(metric.parser);
+    core.translateRulesTopDown = true;
+    core.preferredRules = preferredRules;
+    return core.collectCandidates(caretTokenIndex);
+}
+const irreplaceableTokens = new Set([MaqlLexer.WS, MaqlLexer.LPAREN, MaqlLexer.RPAREN, MaqlLexer.COMMA]);
+function textEditRange(lastValidToken, caretToken, nextValidToken) {
+    if (caretToken.channel !== MaqlLexer.DEFAULT_TOKEN_CHANNEL ||
+        lastValidToken.tokenIndex > nextValidToken.tokenIndex ||
+        irreplaceableTokens.has(caretToken.type)) {
+        return undefined;
+    }
+    if (lastValidToken === nextValidToken) {
+        return tokenRange(lastValidToken);
+    }
+    const lastRange = tokenRange(lastValidToken);
+    const nextRange = tokenRange(nextValidToken);
+    return Range.create(lastRange.end.line, lastRange.end.character, nextRange.start.line, nextRange.start.character);
+}
+function withTextEdit(item, range) {
+    item.textEdit = range ? TextEdit.replace(range, item.insertText ?? item.label) : undefined;
+    return item;
+}
+function createMetadataCompletionItem(metadataObject, range) {
+    // The completion is inserted into MAQL text, so it has to use the MAQL spelling of the type
+    // (`computed_attribute`), not the Tiger one (`computedAttribute`) the catalog object carries.
+    const maqlType = toMaqlObjectType(metadataObject.tigerType);
+    const identifier = `${maqlType}/${metadataObject.id}`;
+    const insertText = `{${identifier}}`;
+    const kind = getCompletionItemKind(metadataObject);
+    return {
+        label: metadataObject.title ?? identifier,
+        kind: kind,
+        insertText: insertText,
+        filterText: `{ ${maqlType} / ${metadataObject.id} } ${metadataObject.title}`,
+        // Sort by the bare id (no MAQL type prefix) so that object types sharing a completion kind
+        // (labels and computed attributes) interleave instead of clustering by MAQL type.
+        sortText: metadataObject.id,
+        detail: `ID: '${identifier}', Description: '${metadataObject.description}'`,
+        textEdit: range ? TextEdit.replace(range, insertText) : undefined,
+    };
+}
+/**
+ * A function to get text value of a token for the purposes of filtering completions
+ * @param token - MAQL token from Antlr4 generated parser
+ * @param offset - caret offset in the entire query
+ */
+function tokenToString(token, offset) {
+    if (token.type === MaqlParser.UnterminatedString) {
+        return token.text
+            ?.slice(1, Math.min(token.text.length, offset - token.startIndex))
+            .replace(/\\"/g, '"');
+    }
+    else if (token.type === MaqlParser.String) {
+        return token.text
+            ?.slice(1, Math.min(token.text.length - 1, offset - token.startIndex))
+            .replace(/\\"/g, '"');
+        // oxlint-disable-next-line eslint/no-negated-condition
+    }
+    else if (!isFinal(token)) {
+        return token.text?.slice(0, Math.min(token.text.length, offset - token.startIndex));
+    }
+    else {
+        return undefined; // final tokens must not be used - their text value is not useful
+    }
+}
+function createStringCompletionItem(label, detail, range) {
+    const insertText = escapeString(label, '"');
+    return {
+        label: label,
+        kind: CompletionItemKind.Text,
+        insertText: insertText,
+        sortText: label,
+        filterText: `" ${label} "`,
+        detail: detail,
+        textEdit: range ? TextEdit.replace(range, insertText) : undefined,
+    };
+}
+function getCompletionItemKind(metadataObject) {
+    switch (metadataObject.tigerType) {
+        case "fact":
+            return CompletionItemKind.Field;
+        case "metric":
+            return CompletionItemKind.Variable;
+        case "dataset":
+            return CompletionItemKind.Constant;
+        case "parameter":
+            return CompletionItemKind.Value;
+        case "label":
+        case "attribute":
+        case "computedAttribute":
+            return CompletionItemKind.Enum;
+        default:
+            return CompletionItemKind.Variable;
+    }
+}
+/**
+ * @returns [Map\<token id, CompletionDescription[]\>, Map\<rule id, CompletionDescription[]\>]
+ */
+function getTokenAndRuleCompletions(descriptions) {
+    const tokenDescriptions = new Map();
+    const ruleDescriptions = new Map();
+    descriptions.forEach((desc) => {
+        if (desc.ruleId) {
+            const list = ruleDescriptions.get(desc.ruleId) ?? [];
+            list.push(desc);
+            ruleDescriptions.set(desc.ruleId, list);
+        }
+        else if (desc.triggerTokenId) {
+            const list = tokenDescriptions.get(desc.triggerTokenId) ?? [];
+            list.push(desc);
+            tokenDescriptions.set(desc.triggerTokenId, list);
+        }
+        else {
+            throw new Error(`completion description for '${desc.label}' has neither triggerTokenId nor ruleId!`);
+        }
+        desc.data = {
+            resolveTag: desc.resolveTag,
+            ruleId: desc.ruleId,
+            triggerTokenId: desc.triggerTokenId,
+        }; // store additional info tag in 'data' property for retrieval on completion resolve
+    });
+    return [tokenDescriptions, ruleDescriptions];
+}

package/esm/completions/descriptions.d.ts

@@ -0,0 +1,42 @@
+import { type CompletionItem } from "vscode-languageserver";
+import { type ResolveTag } from "../docs/index.js";
+import { MaqlType } from "../types/hierarchy.js";
+/**
+ * Maps concepts from MAQL to completionItemKind values
+ */
+export declare const Kind: {
+    Attribute: 13;
+    Label: 13;
+    Metric: 6;
+    Parameter: 12;
+    Fact: 5;
+    Dataset: 21;
+    LabelElement: 1;
+    Function: 3;
+    Keyword: 14;
+    Operator: 24;
+    Boolean: 12;
+    Granularity: 20;
+    Snippet: 15;
+};
+/**
+ * CompletionDescription - CompletionItem with additional information so that it can be offered appropriately
+ */
+export type CompletionDescription = CompletionItem & ICompletionMaqlData;
+/**
+ * Data that links a completion item to documentation and MAQL parser objects
+ * Either triggerTokenId or ruleId must be set
+ */
+export interface ICompletionMaqlData {
+    resolveTag?: ResolveTag;
+    triggerTokenId?: number;
+    ruleId?: number;
+    maqlType?: MaqlType;
+}
+/**
+ * Tokens that will not generate any completion items
+ * Note that this can be overwritten by creating a CompletionDescription that triggers on that token
+ */
+export declare const ignoredTokens: Set<number>;
+export declare const descriptions: CompletionDescription[];
+//# sourceMappingURL=descriptions.d.ts.map

package/esm/completions/descriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptions.d.ts","sourceRoot":"","sources":["../../src/completions/descriptions.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,cAAc,EAAwC,MAAM,uBAAuB,CAAC;AAMlG,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAIjD;;GAEG;AACH,eAAO,MAAM,IAAI;IACb,SAAS;IACT,KAAK;IACL,MAAM;IACN,SAAS;IACT,IAAI;IACJ,OAAO;IACP,YAAY;IACZ,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,OAAO;IACP,WAAW;IACX,OAAO;CACV,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,cAAc,GAAG,mBAAmB,CAAC;AAEzE;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAChC,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACvB;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,aAmDxB,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,qBAAqB,EAqO/C,CAAC"}