dot-language-support 1.7.0 → 2.0.0

package/lib/esm/service/completion.js

@@ -0,0 +1,137 @@
+import * as lst from "vscode-languageserver-types";
+import { SyntaxKind } from "../types.js";
+import { findNodeAtOffset, getIdentifierText, isEdgeStatement } from "../checker.js";
+import { escapeIdentifierText } from "./util.js";
+import { isIdentifierNode } from "../index.js";
+import * as languageFacts from "./languageFacts.js";
+export 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 = findNodeAtOffset(g, offset, true);
+    if (!node)
+        return [];
+    const prevOffsetNode = findNodeAtOffset(g, offset - 1, true);
+    const parent = node.parent;
+    const prevOffsetNodeParent = prevOffsetNode?.parent;
+    if ((parent?.parent && isEdgeStatement(parent.parent))
+        || (prevOffsetNodeParent?.parent && isEdgeStatement(prevOffsetNodeParent.parent))) {
+        return getNodeCompletions(symbols);
+    }
+    if (node.kind === SyntaxKind.AttributeContainer) {
+        const openingBracket = node.openBracket;
+        if (openingBracket.end - 1 > offset - 1) {
+            const exclusions = prevOffsetNode?.kind === SyntaxKind.TextIdentifier && prevOffsetNode.symbol
+                ? [prevOffsetNode.symbol.name]
+                : undefined;
+            return getNodeCompletions(symbols, exclusions);
+        }
+    }
+    if (node.kind === SyntaxKind.TextIdentifier && parent?.kind === SyntaxKind.NodeId) {
+        const exclusions = node.symbol
+            ? [node.symbol.name]
+            : undefined;
+        return getNodeCompletions(symbols, exclusions);
+    }
+    if (node.kind === SyntaxKind.AttributeContainer
+        || (node.kind == SyntaxKind.CommaToken && parent?.kind === SyntaxKind.Assignment)) {
+        return getAttributeCompletions(position);
+    }
+    const prevNode = findNodeAtOffset(g, node.pos - 1, true);
+    if (!prevNode)
+        return [];
+    if (isIdentifierNode(prevNode)) {
+        const p = prevNode.parent;
+        if (p) {
+            switch (p.kind) {
+                case SyntaxKind.NodeId: {
+                    return getNodeCompletions(symbols);
+                }
+                case 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 === SyntaxKind.Assignment) {
+            return getAssignmentCompletion(parent);
+        }
+    }
+    return [];
+}
+function getAssignmentCompletion(assignment) {
+    const property = 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: 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: escapeIdentifierText(label) + "=",
+        },
+    }));
+}
+function getNodeCompletions(symbols, exlucdedSymbols) {
+    const res = new Array();
+    for (const [key, value] of symbols) {
+        if (exlucdedSymbols?.includes(key))
+            continue;
+        let kind = lst.CompletionItemKind.Variable;
+        const a = value.firstMention.parent;
+        if (a) {
+            switch (a.kind) {
+                case SyntaxKind.DirectedGraph:
+                case SyntaxKind.UndirectedGraph:
+                    kind = lst.CompletionItemKind.Class;
+                    break;
+            }
+        }
+        res.push({
+            label: escapeIdentifierText(key),
+            kind: kind,
+        });
+    }
+    return res;
+}
+//# sourceMappingURL=completion.js.map

package/lib/esm/service/hover.d.ts

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

package/lib/esm/service/hover.js

@@ -0,0 +1,119 @@
+import { SyntaxKind } from "../types.js";
+import { getIdentifierText, findNodeAtOffset } from "../checker.js";
+import { isIdentifierNode } from "../parser.js";
+import { syntaxNodeToRange } from "./util.js";
+import { getEdgeStr } from "./command/common.js";
+export function hover(doc, sourceFile, position) {
+    const offset = doc.offsetAt(position);
+    const g = sourceFile.graph;
+    if (!g)
+        return undefined;
+    const node = findNodeAtOffset(g, offset);
+    if (node === undefined)
+        return undefined;
+    return getNodeHover(doc, sourceFile, node);
+}
+function getNodeHover(doc, sf, n) {
+    const contents = getHoverContents(n);
+    if (contents) {
+        return {
+            contents,
+            range: syntaxNodeToRange(doc, sf, n),
+        };
+    }
+    return undefined;
+}
+function getHoverContents(n) {
+    if (isIdentifierNode(n)) {
+        const parent = n.parent;
+        if (parent) {
+            switch (parent.kind) {
+                case SyntaxKind.NodeId:
+                    return `(node) ${getIdentifierText(n)}`;
+                case SyntaxKind.Assignment: {
+                    const assignment = parent;
+                    const left = getIdentifierText(assignment.leftId);
+                    const right = getIdentifierText(assignment.rightId);
+                    return `(assignment) \`${left}\` = \`${right}\``;
+                }
+                case SyntaxKind.DirectedGraph:
+                    return getGraphHover(parent);
+                case SyntaxKind.UndirectedGraph:
+                    return getGraphHover(parent);
+                case SyntaxKind.SubGraphStatement: {
+                    const sgs = parent;
+                    const sg = sgs.subgraph;
+                    return !!sg.id
+                        ? `(sub graph) ${getIdentifierText(sg.id)}`
+                        : `(sub graph)`;
+                }
+                case SyntaxKind.SubGraph: {
+                    const sg = parent;
+                    return !!sg.id
+                        ? `(sub graph) ${getIdentifierText(sg.id)}`
+                        : `(sub graph)`;
+                }
+                case SyntaxKind.IdEqualsIdStatement: {
+                    const idEqId = parent;
+                    const left = getIdentifierText(idEqId.leftId);
+                    const right = getIdentifierText(idEqId.rightId);
+                    return `(graph property) \`${left}\` = \`${right}\``;
+                }
+                case SyntaxKind.EdgeRhs:
+                    return getEdgeHover(parent);
+            }
+            return SyntaxKind[parent.kind];
+        }
+        const fallback = SyntaxKind[n.kind];
+        return fallback
+            ? "(" + fallback.toLowerCase() + ")"
+            : undefined;
+    }
+    switch (n.kind) {
+        case SyntaxKind.GraphKeyword:
+        case SyntaxKind.DigraphKeyword:
+        case SyntaxKind.StrictKeyword:
+            return getGraphHover(n.parent);
+        case SyntaxKind.DirectedGraph:
+        case SyntaxKind.UndirectedGraph:
+            return getGraphHover(n);
+        case SyntaxKind.DirectedEdgeOp:
+        case SyntaxKind.UndirectedEdgeOp:
+            return getEdgeHover(n.parent);
+        default:
+            return undefined;
+    }
+}
+function getGraphHover(g) {
+    const direction = g.kind === SyntaxKind.DirectedGraph ? "directed" : "undirected";
+    const graphId = g.id;
+    const strict = g.strict ? "strict " : "";
+    return !!graphId
+        ? `(${strict}${direction} graph) ${(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 = getEdgeStr(n.operation.kind);
+    return source === undefined
+        ? undefined
+        : `(edge) ${getEdgeSourceOrTargetText(source)} ${edgeOpStr} ${getEdgeSourceOrTargetText(n.target)}`;
+}
+function getEdgeSourceOrTargetText(n) {
+    return n.kind === SyntaxKind.NodeId
+        ? getIdentifierText(n.id)
+        : n.id !== undefined
+            ? `${getIdentifierText(n.id)}`
+            : "sub graph";
+}
+//# sourceMappingURL=hover.js.map