dot-language-support 2.3.0 → 3.0.0

package/lib/esm/service/completion.js

@@ -1,137 +0,0 @@
-import * as lst from "vscode-languageserver-types";
-import { findNodeAtOffset, getIdentifierText, isEdgeStatement } from "../checker.js";
-import { isIdentifierNode } from "../index.js";
-import { SyntaxKind, } from "../types.js";
-import * as languageFacts from "./languageFacts.js";
-import { escapeIdentifierText } from "./util.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 = [];
-    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

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

package/lib/esm/service/hover.js

@@ -1,135 +0,0 @@
-import { findNodeAtOffset, getIdentifierText } from "../checker.js";
-import { isIdentifierNode } from "../parser.js";
-import { SyntaxKind, } from "../types.js";
-import { getEdgeStr } from "./command/common.js";
-import { syntaxNodeToRange } from "./util.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 getAssignedLabel(statement) {
-    const assignments = statement.attributes.flatMap(a => a.assignments);
-    const assignedLabel = assignments?.find(a => getIdentifierText(a.leftId) === "label");
-    return assignedLabel?.rightId ? getIdentifierText(assignedLabel.rightId) : undefined;
-}
-function getHoverContents(n) {
-    if (isIdentifierNode(n)) {
-        const parent = n.parent;
-        if (parent) {
-            switch (parent.kind) {
-                case SyntaxKind.NodeId: {
-                    if (n.symbol?.references) {
-                        const nodeIdentifierRefs = n.symbol?.references;
-                        const labelMentions = nodeIdentifierRefs.map(e => e.symbol?.members?.get("label")?.firstMention.parent);
-                        for (let i = labelMentions.length; i >= 0; i--) {
-                            const s = labelMentions[i];
-                            if (s?.rightId) {
-                                return `(node) ${getIdentifierText(n)}: ${getIdentifierText(s.rightId)}`;
-                            }
-                        }
-                    }
-                    else if (parent.parent?.kind === SyntaxKind.NodeStatement) {
-                        const label = getAssignedLabel(parent.parent);
-                        if (label) {
-                            return `(node) ${getIdentifierText(n)}: ${label}`;
-                        }
-                    }
-                    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;
-    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