dot-language-support 1.5.4

package/lib/service/completion.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompletions = void 0;
+const lst = require("vscode-languageserver-types");
+const types_1 = require("../types");
+const checker_1 = require("../checker");
+const util_1 = require("./util");
+const __1 = require("../");
+const languageFacts = require("./languageFacts");
+function getCompletions(doc, sourceFile, position) {
+    const symbols = sourceFile.symbols;
+    if (!symbols)
+        throw "sourceFile is not bound";
+    const g = sourceFile.graph;
+    if (!g)
+        return [];
+    const offset = doc.offsetAt(position);
+    const node = (0, checker_1.findNodeAtOffset)(g, offset, true);
+    if (!node)
+        return [];
+    const prevOffsetNode = (0, checker_1.findNodeAtOffset)(g, offset - 1, true);
+    const parent = node.parent;
+    const prevOffsetNodeParent = prevOffsetNode === null || prevOffsetNode === void 0 ? void 0 : prevOffsetNode.parent;
+    if (((parent === null || parent === void 0 ? void 0 : parent.parent) && (0, checker_1.isEdgeStatement)(parent.parent))
+        || ((prevOffsetNodeParent === null || prevOffsetNodeParent === void 0 ? void 0 : prevOffsetNodeParent.parent) && (0, checker_1.isEdgeStatement)(prevOffsetNodeParent.parent))) {
+        return getNodeCompletions(symbols);
+    }
+    if (node.kind === types_1.SyntaxKind.AttributeContainer) {
+        const openingBracket = node.openBracket;
+        if (openingBracket.end - 1 > offset - 1) {
+            const exclusions = (prevOffsetNode === null || prevOffsetNode === void 0 ? void 0 : prevOffsetNode.kind) === types_1.SyntaxKind.TextIdentifier && prevOffsetNode.symbol
+                ? [prevOffsetNode.symbol.name]
+                : undefined;
+            return getNodeCompletions(symbols, exclusions);
+        }
+    }
+    if (node.kind === types_1.SyntaxKind.TextIdentifier && (parent === null || parent === void 0 ? void 0 : parent.kind) === types_1.SyntaxKind.NodeId) {
+        const exclusions = node.symbol
+            ? [node.symbol.name]
+            : undefined;
+        return getNodeCompletions(symbols, exclusions);
+    }
+    if (node.kind === types_1.SyntaxKind.AttributeContainer
+        || (node.kind == types_1.SyntaxKind.CommaToken && (parent === null || parent === void 0 ? void 0 : parent.kind) === types_1.SyntaxKind.Assignment)) {
+        return getAttributeCompletions(position);
+    }
+    const prevNode = (0, checker_1.findNodeAtOffset)(g, node.pos - 1, true);
+    if (!prevNode)
+        return [];
+    if ((0, __1.isIdentifierNode)(prevNode)) {
+        const p = prevNode.parent;
+        if (p) {
+            switch (p.kind) {
+                case types_1.SyntaxKind.NodeId: {
+                    return getNodeCompletions(symbols);
+                }
+                case types_1.SyntaxKind.Assignment: {
+                    return getAssignmentCompletion(p);
+                }
+            }
+        }
+    }
+    if ((node.flags & 2) || node.end === node.pos) {
+        const attribute = prevNode;
+        if (!attribute)
+            return [];
+        if (!attribute.parent)
+            throw "sourceFile is not bound";
+        const parent = attribute.parent;
+        if (parent.kind === types_1.SyntaxKind.Assignment) {
+            return getAssignmentCompletion(parent);
+        }
+    }
+    return [];
+}
+exports.getCompletions = getCompletions;
+function getAssignmentCompletion(assignment) {
+    const property = (0, checker_1.getIdentifierText)(assignment.leftId);
+    if (!property)
+        return [];
+    switch (property.toLowerCase()) {
+        case "shape": return getShapeCompletions();
+        case "color": return getColorCompletions();
+        default: return [];
+    }
+}
+function getShapeCompletions() {
+    const kind = lst.CompletionItemKind.EnumMember;
+    return languageFacts.shapes.map(s => ({
+        kind,
+        label: (0, util_1.escapeIdentifierText)(s),
+    }));
+}
+function getColorCompletions() {
+    const kind = lst.CompletionItemKind.Color;
+    const colors = languageFacts.colors;
+    return Object.keys(colors)
+        .map(label => ({
+        kind,
+        label,
+        documentation: colors[label],
+    }));
+}
+function getAttributeCompletions(posistion) {
+    const kind = lst.CompletionItemKind.Property;
+    const range = {
+        start: posistion,
+        end: posistion,
+    };
+    return languageFacts.attributes.map(label => ({
+        kind,
+        label,
+        textEdit: {
+            range,
+            newText: (0, util_1.escapeIdentifierText)(label) + "=",
+        },
+    }));
+}
+function getNodeCompletions(symbols, exlucdedSymbols) {
+    const res = new Array();
+    for (const [key, value] of symbols) {
+        if (exlucdedSymbols === null || exlucdedSymbols === void 0 ? void 0 : exlucdedSymbols.includes(key))
+            continue;
+        let kind = lst.CompletionItemKind.Variable;
+        const a = value.firstMention.parent;
+        if (a) {
+            switch (a.kind) {
+                case types_1.SyntaxKind.DirectedGraph:
+                case types_1.SyntaxKind.UndirectedGraph:
+                    kind = lst.CompletionItemKind.Class;
+                    break;
+            }
+        }
+        res.push({
+            label: (0, util_1.escapeIdentifierText)(key),
+            kind: kind,
+        });
+    }
+    return res;
+}
+//# sourceMappingURL=completion.js.map

package/lib/service/hover.d.ts

@@ -0,0 +1,4 @@
+import * as lst from "vscode-languageserver-types";
+import { SourceFile } from "../types";
+import { DocumentLike } from "../";
+export declare function hover(doc: DocumentLike, sourceFile: SourceFile, position: lst.Position): lst.Hover | undefined;

package/lib/service/hover.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hover = void 0;
+const types_1 = require("../types");
+const checker_1 = require("../checker");
+const parser_1 = require("../parser");
+const util_1 = require("./util");
+const common_1 = require("./command/common");
+function hover(doc, sourceFile, position) {
+    const offset = doc.offsetAt(position);
+    const g = sourceFile.graph;
+    if (!g)
+        return undefined;
+    const node = (0, checker_1.findNodeAtOffset)(g, offset);
+    if (node === undefined)
+        return undefined;
+    return getNodeHover(doc, sourceFile, node);
+}
+exports.hover = hover;
+function getNodeHover(doc, sf, n) {
+    const contents = getHoverContents(n);
+    if (contents) {
+        return {
+            contents,
+            range: (0, util_1.syntaxNodeToRange)(doc, sf, n),
+        };
+    }
+    return undefined;
+}
+function getHoverContents(n) {
+    if ((0, parser_1.isIdentifierNode)(n)) {
+        const parent = n.parent;
+        if (parent) {
+            switch (parent.kind) {
+                case types_1.SyntaxKind.NodeId:
+                    return `(node) ${(0, checker_1.getIdentifierText)(n)}`;
+                case types_1.SyntaxKind.Assignment: {
+                    const assignment = parent;
+                    const left = (0, checker_1.getIdentifierText)(assignment.leftId);
+                    const right = (0, checker_1.getIdentifierText)(assignment.rightId);
+                    return `(assignment) \`${left}\` = \`${right}\``;
+                }
+                case types_1.SyntaxKind.DirectedGraph:
+                    return getGraphHover(parent);
+                case types_1.SyntaxKind.UndirectedGraph:
+                    return getGraphHover(parent);
+                case types_1.SyntaxKind.SubGraphStatement: {
+                    const sgs = parent;
+                    const sg = sgs.subgraph;
+                    return !!sg.id
+                        ? `(sub graph) ${(0, checker_1.getIdentifierText)(sg.id)}`
+                        : `(sub graph)`;
+                }
+                case types_1.SyntaxKind.SubGraph: {
+                    const sg = parent;
+                    return !!sg.id
+                        ? `(sub graph) ${(0, checker_1.getIdentifierText)(sg.id)}`
+                        : `(sub graph)`;
+                }
+                case types_1.SyntaxKind.IdEqualsIdStatement: {
+                    const idEqId = parent;
+                    const left = (0, checker_1.getIdentifierText)(idEqId.leftId);
+                    const right = (0, checker_1.getIdentifierText)(idEqId.rightId);
+                    return `(graph property) \`${left}\` = \`${right}\``;
+                }
+                case types_1.SyntaxKind.EdgeRhs:
+                    return getEdgeHover(parent);
+            }
+            return types_1.SyntaxKind[parent.kind];
+        }
+        const fallback = types_1.SyntaxKind[n.kind];
+        return fallback
+            ? "(" + fallback.toLowerCase() + ")"
+            : undefined;
+    }
+    switch (n.kind) {
+        case types_1.SyntaxKind.GraphKeyword:
+        case types_1.SyntaxKind.DigraphKeyword:
+        case types_1.SyntaxKind.StrictKeyword:
+            return getGraphHover(n.parent);
+        case types_1.SyntaxKind.DirectedGraph:
+        case types_1.SyntaxKind.UndirectedGraph:
+            return getGraphHover(n);
+        case types_1.SyntaxKind.DirectedEdgeOp:
+        case types_1.SyntaxKind.UndirectedEdgeOp:
+            return getEdgeHover(n.parent);
+        default:
+            return undefined;
+    }
+}
+function getGraphHover(g) {
+    const direction = g.kind === types_1.SyntaxKind.DirectedGraph ? "directed" : "undirected";
+    const graphId = g.id;
+    const strict = g.strict ? "strict " : "";
+    return !!graphId
+        ? `(${strict}${direction} graph) ${((0, checker_1.getIdentifierText)(graphId))}`
+        : `(${strict}${direction} graph)`;
+}
+function getEdgeHover(n) {
+    const p = n.parent;
+    if (!p || p.rhs.length === 0)
+        return undefined;
+    let source = undefined;
+    for (const curr of p.rhs) {
+        if (curr === n)
+            break;
+        source = curr.target;
+    }
+    if (source === undefined)
+        source = p.source;
+    const edgeOpStr = (0, common_1.getEdgeStr)(n.operation.kind);
+    return source === undefined
+        ? undefined
+        : `(edge) ${getEdgeSourceOrTargetText(source)} ${edgeOpStr} ${getEdgeSourceOrTargetText(n.target)}`;
+}
+function getEdgeSourceOrTargetText(n) {
+    return n.kind === types_1.SyntaxKind.NodeId
+        ? (0, checker_1.getIdentifierText)(n.id)
+        : n.id !== undefined
+            ? `${(0, checker_1.getIdentifierText)(n.id)}`
+            : "sub graph";
+}
+//# sourceMappingURL=hover.js.map

package/lib/service/interop.d.ts

@@ -0,0 +1,15 @@
+import * as lst from "vscode-languageserver-types";
+import { DiagnosticMessage } from "../types";
+import { DocumentLike } from "../";
+export interface IMarkerData {
+    code?: string;
+    severity: number;
+    message: string;
+    source?: string;
+    startLineNumber: number;
+    startColumn: number;
+    endLineNumber: number;
+    endColumn: number;
+}
+export declare function getDiagnosticMarkerData(doc: DocumentLike, source: DiagnosticMessage): IMarkerData;
+export declare function getMarkerDataDiagnostic(m: IMarkerData): lst.Diagnostic;

package/lib/service/interop.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarkerDataDiagnostic = exports.getDiagnosticMarkerData = void 0;
+const lst = require("vscode-languageserver-types");
+const types_1 = require("../types");
+function getDiagnosticMarkerData(doc, source) {
+    const start = doc.positionAt(source.start);
+    const end = doc.positionAt(source.end);
+    return {
+        message: source.message,
+        severity: source.category ? convertToMonacoSeverity(source.category) : 0,
+        startLineNumber: start.line,
+        startColumn: start.character,
+        endLineNumber: end.line,
+        endColumn: end.character,
+    };
+}
+exports.getDiagnosticMarkerData = getDiagnosticMarkerData;
+function getMarkerDataDiagnostic(m) {
+    return {
+        message: m.message,
+        range: {
+            start: {
+                line: m.startLineNumber,
+                character: m.startColumn,
+            },
+            end: {
+                line: m.endLineNumber,
+                character: m.endColumn,
+            }
+        },
+        code: m.code,
+        severity: m.severity ? convertToLspSeverity(m.severity) : types_1.DiagnosticCategory.Suggestion,
+        source: m.source,
+    };
+}
+exports.getMarkerDataDiagnostic = getMarkerDataDiagnostic;
+const lspToMonacoSeverityMap = {
+    [lst.DiagnosticSeverity.Error]: 3,
+    [lst.DiagnosticSeverity.Warning]: 2,
+    [lst.DiagnosticSeverity.Information]: 1,
+    [lst.DiagnosticSeverity.Hint]: 0,
+};
+const monacoToLspSeverityMap = {
+    [3]: lst.DiagnosticSeverity.Error,
+    [2]: lst.DiagnosticSeverity.Warning,
+    [1]: lst.DiagnosticSeverity.Information,
+    [0]: lst.DiagnosticSeverity.Hint,
+};
+function convertToMonacoSeverity(s) {
+    return lspToMonacoSeverityMap[s];
+}
+function convertToLspSeverity(n) {
+    return monacoToLspSeverityMap[n];
+}
+//# sourceMappingURL=interop.js.map