@malloydata/malloy 0.0.1

package/dist/lang/parse-tree-walkers/document-completion-walker.d.ts

@@ -0,0 +1,10 @@
+import { CommonTokenStream } from "antlr4ts";
+import { ParseTree } from "antlr4ts/tree";
+export interface DocumentCompletion {
+    type: string;
+    text: string;
+}
+export declare function walkForDocumentCompletions(tokens: CommonTokenStream, parseTree: ParseTree, position: {
+    line: number;
+    character: number;
+}): DocumentCompletion[];

package/dist/lang/parse-tree-walkers/document-completion-walker.js

@@ -0,0 +1,136 @@
+"use strict";
+/*
+ * Copyright 2021 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkForDocumentCompletions = void 0;
+const ParseTreeWalker_1 = require("antlr4ts/tree/ParseTreeWalker");
+const EXPLORE_PROPERTIES = [
+    "dimension",
+    "measure",
+    "join_one",
+    "join_many",
+    "join_cross",
+    "where",
+    "primary_key",
+    "rename",
+    "accept",
+    "except",
+    "query",
+];
+const QUERY_PROPERTIES = [
+    "group_by",
+    "project",
+    "index",
+    "aggregate",
+    "top",
+    "limit",
+    "order_by",
+    "where",
+    "having",
+    "nest",
+];
+const MODEL_PROPERTIES = ["source", "explore", "query", "sql"];
+class DocumentCompletionWalker {
+    constructor(tokens, completions, position) {
+        this.tokens = tokens;
+        this.completions = completions;
+        this.position = position;
+    }
+    rangeOf(pcx) {
+        const stopToken = pcx.stop || pcx.start;
+        return {
+            start: {
+                line: pcx.start.line - 1,
+                character: pcx.start.charPositionInLine,
+            },
+            end: {
+                line: stopToken.line - 1,
+                character: stopToken.stopIndex -
+                    (stopToken.startIndex - stopToken.charPositionInLine) +
+                    1,
+            },
+        };
+    }
+    inRange(range) {
+        const { start, end } = range;
+        const afterStart = this.position.line > start.line ||
+            (this.position.line === start.line &&
+                this.position.character >= start.character);
+        const beforeEnd = this.position.line < end.line ||
+            (this.position.line === end.line &&
+                this.position.character <= end.character);
+        return afterStart && beforeEnd;
+    }
+    enterExploreProperties(ctx) {
+        if (this.inRange(this.rangeOf(ctx))) {
+            let insideStatement = false;
+            for (const exploreStatementContext of ctx.exploreStatement()) {
+                if (this.inRange(this.rangeOf(exploreStatementContext))) {
+                    insideStatement = true;
+                }
+            }
+            if (!insideStatement) {
+                for (const property of EXPLORE_PROPERTIES) {
+                    this.completions.push({
+                        type: "explore_property",
+                        text: `${property}: `,
+                    });
+                }
+            }
+        }
+    }
+    enterQueryProperties(ctx) {
+        if (this.inRange(this.rangeOf(ctx))) {
+            let insideStatement = false;
+            for (const exploreStatementContext of ctx.queryStatement()) {
+                if (this.inRange(this.rangeOf(exploreStatementContext))) {
+                    insideStatement = true;
+                }
+            }
+            if (!insideStatement) {
+                for (const property of QUERY_PROPERTIES) {
+                    this.completions.push({
+                        type: "query_property",
+                        text: `${property}: `,
+                    });
+                }
+            }
+        }
+    }
+    enterMalloyDocument(ctx) {
+        if (this.inRange(this.rangeOf(ctx))) {
+            let insideStatement = false;
+            for (const modelStatementContext of ctx.malloyStatement()) {
+                if (this.inRange(this.rangeOf(modelStatementContext))) {
+                    insideStatement = true;
+                }
+            }
+            if (!insideStatement) {
+                for (const property of MODEL_PROPERTIES) {
+                    this.completions.push({
+                        type: "model_property",
+                        text: `${property}: `,
+                    });
+                }
+            }
+        }
+    }
+}
+function walkForDocumentCompletions(tokens, parseTree, position) {
+    const finder = new DocumentCompletionWalker(tokens, [], position);
+    const listener = finder;
+    ParseTreeWalker_1.ParseTreeWalker.DEFAULT.walk(listener, parseTree);
+    return finder.completions;
+}
+exports.walkForDocumentCompletions = walkForDocumentCompletions;
+//# sourceMappingURL=document-completion-walker.js.map

package/dist/lang/parse-tree-walkers/document-help-context-walker.d.ts

@@ -0,0 +1,9 @@
+import { ParseTree } from "antlr4ts/tree";
+export interface DocumentHelpContext {
+    type: string;
+    token: string | undefined;
+}
+export declare function walkForDocumentHelpContext(parseTree: ParseTree, position: {
+    line: number;
+    character: number;
+}): DocumentHelpContext | undefined;

package/dist/lang/parse-tree-walkers/document-help-context-walker.js

@@ -0,0 +1,97 @@
+"use strict";
+/*
+ * Copyright 2022 Google LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkForDocumentHelpContext = void 0;
+const tree_1 = require("antlr4ts/tree");
+class HelpContextVisitor extends tree_1.AbstractParseTreeVisitor {
+    constructor(position) {
+        super();
+        this.position = position;
+        this.type = "";
+    }
+    rangeOf(ctx) {
+        const stopToken = ctx.stop || ctx.start;
+        return {
+            start: {
+                line: ctx.start.line - 1,
+                character: ctx.start.charPositionInLine,
+            },
+            end: {
+                line: stopToken.line - 1,
+                character: stopToken.stopIndex -
+                    (stopToken.startIndex - stopToken.charPositionInLine) +
+                    1,
+            },
+        };
+    }
+    inRange(range) {
+        return (range.start.line <= this.position.line &&
+            range.end.line >= this.position.line &&
+            (this.position.line !== range.start.line ||
+                this.position.character >= range.start.character) &&
+            (this.position.line !== range.end.line ||
+                this.position.character <= range.end.character));
+    }
+    defaultResult() {
+        return undefined;
+    }
+    visitChildren(ctx) {
+        let result = this.defaultResult();
+        if (this.inRange(this.rangeOf(ctx))) {
+            result = {
+                type: this.type,
+                token: ctx.start.text,
+            };
+            const n = ctx.childCount;
+            for (let i = 0; i < n; i++) {
+                const c = ctx.getChild(i);
+                const childResult = c.accept(this);
+                if (childResult) {
+                    result = this.aggregateResult(result, childResult);
+                }
+            }
+        }
+        return result;
+    }
+    visitMalloyDocument(ctx) {
+        if (this.inRange(this.rangeOf(ctx))) {
+            this.type = "model_property";
+            return this.visitChildren(ctx);
+        }
+        return this.defaultResult();
+    }
+    visitExploreProperties(ctx) {
+        if (this.inRange(this.rangeOf(ctx))) {
+            this.type = "explore_property";
+            return this.visitChildren(ctx);
+        }
+        return this.defaultResult();
+    }
+    visitQueryProperties(ctx) {
+        if (this.inRange(this.rangeOf(ctx))) {
+            this.type = "query_property";
+            return this.visitChildren(ctx);
+        }
+        return this.defaultResult();
+    }
+    aggregateResult(aggregate, nextResult) {
+        return nextResult;
+    }
+}
+function walkForDocumentHelpContext(parseTree, position) {
+    const visitor = new HelpContextVisitor(position);
+    return visitor.visit(parseTree);
+}
+exports.walkForDocumentHelpContext = walkForDocumentHelpContext;
+//# sourceMappingURL=document-help-context-walker.js.map

package/dist/lang/parse-tree-walkers/document-highlight-walker.d.ts

@@ -0,0 +1,83 @@
+import { CommonTokenStream } from "antlr4ts";
+import { ParseTree } from "antlr4ts/tree";
+import { DocumentRange } from "../../model/malloy_types";
+export interface DocumentHighlight {
+    range: DocumentRange;
+    type: string;
+}
+export declare const HighlightType: {
+    Identifier: string;
+    Type: string;
+    Literal: {
+        Date: string;
+        Number: string;
+        String: string;
+        RegularExpression: string;
+        Boolean: string;
+        Null: string;
+    };
+    Call: {
+        Aggregate: string;
+        TimeFrame: string;
+        Cast: string;
+        Table: string;
+        From: string;
+        Function: string;
+        FromSQL: string;
+    };
+    Keyword: {
+        AggregateModifier: {
+            Distinct: string;
+        };
+        CastModifier: {
+            As: string;
+        };
+        Is: string;
+        On: string;
+        Desc: string;
+        Asc: string;
+        Pick: string;
+        When: string;
+        Else: string;
+        With: string;
+        JSON: string;
+        Turtle: string;
+        Import: string;
+    };
+    Operator: {
+        Comparison: string;
+        Boolean: string;
+        Date: string;
+    };
+    Comment: {
+        Line: string;
+        Block: string;
+    };
+    Property: {
+        Accept: string;
+        Aggregate: string;
+        Dimension: string;
+        Except: string;
+        Source: string;
+        GroupBy: string;
+        Having: string;
+        Index: string;
+        JoinOne: string;
+        JoinMany: string;
+        JoinCross: string;
+        Limit: string;
+        Measure: string;
+        Nest: string;
+        OrderBy: string;
+        PrimaryKey: string;
+        Project: string;
+        Query: string;
+        Rename: string;
+        Top: string;
+        Where: string;
+        SQL: string;
+    };
+};
+export declare function passForHighlights(tokens: CommonTokenStream): DocumentHighlight[];
+export declare function walkForDocumentHighlights(tokens: CommonTokenStream, parseTree: ParseTree): DocumentHighlight[];
+export declare function sortHighlights(highlights: DocumentHighlight[]): DocumentHighlight[];