dot-language-support 1.7.0 → 2.0.0

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

@@ -0,0 +1,16 @@
+import type { Range, TextEdit } from "vscode-languageserver-types";
+export interface ColorInformation {
+    range: Range;
+    color: Color;
+}
+export interface Color {
+    readonly red: number;
+    readonly green: number;
+    readonly blue: number;
+    readonly alpha: number;
+}
+export interface ColorPresentation {
+    label: string;
+    textEdit?: TextEdit;
+    additionalTextEdits?: TextEdit[];
+}

package/lib/esm/service/polyfill.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=polyfill.js.map

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

@@ -0,0 +1,5 @@
+import type { Position, ReferenceContext, Location } from "vscode-languageserver-types";
+import type { SourceFile } from "../types.js";
+import { type DocumentLike } from "../index.js";
+export declare function findReferences(doc: DocumentLike, sourceFile: SourceFile, position: Position, context: ReferenceContext): Location[];
+export declare function findDefinition(doc: DocumentLike, sourceFile: SourceFile, position: Position): Location | undefined;

package/lib/esm/service/reference.js

@@ -0,0 +1,66 @@
+import { isIdentifierNode } from "../index.js";
+import { findNodeAtOffset } from "../checker.js";
+import { syntaxNodesToRanges, syntaxNodeToRange } from "./util.js";
+export function findReferences(doc, sourceFile, position, context) {
+    if (!sourceFile.symbols)
+        throw "sourceFile is not bound";
+    const g = sourceFile.graph;
+    if (!g)
+        return [];
+    const offset = doc.offsetAt(position);
+    const node = findNodeAtOffset(g, offset);
+    if (!node)
+        return [];
+    if (isIdentifierNode(node)) {
+        const nodeSymbol = node.symbol;
+        if (!nodeSymbol)
+            throw "node.symbol is not bound";
+        const refs = nodeSymbol.references || [];
+        let symbolRefs;
+        if (context.includeDeclaration) {
+            symbolRefs = [nodeSymbol.firstMention, ...refs];
+        }
+        else {
+            if (nodeSymbol.firstMention === node) {
+                symbolRefs = refs;
+            }
+            else {
+                symbolRefs = [
+                    nodeSymbol.firstMention,
+                    ...refs.filter(r => r !== node),
+                ];
+            }
+        }
+        const ranges = syntaxNodesToRanges(doc, sourceFile, symbolRefs);
+        const uri = doc.uri;
+        return ranges.map(range => {
+            return { uri, range };
+        });
+    }
+    debugger;
+    return [];
+}
+export function findDefinition(doc, sourceFile, position) {
+    if (!sourceFile.symbols)
+        throw "sourceFile is not bound";
+    const g = sourceFile.graph;
+    if (!g)
+        return undefined;
+    const offset = doc.offsetAt(position);
+    const node = findNodeAtOffset(g, offset);
+    if (!node)
+        return undefined;
+    if (isIdentifierNode(node)) {
+        const nodeSymbol = node.symbol;
+        if (!nodeSymbol)
+            throw "node.symbol is not bound";
+        const firstMention = nodeSymbol.firstMention;
+        if (!firstMention)
+            return undefined;
+        const range = syntaxNodeToRange(doc, sourceFile, firstMention);
+        return { uri: doc.uri, range };
+    }
+    debugger;
+    return undefined;
+}
+//# sourceMappingURL=reference.js.map

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

@@ -0,0 +1,4 @@
+import { Position, WorkspaceEdit } from "vscode-languageserver-types";
+import { SourceFile } from "../types.js";
+import { DocumentLike } from "../index.js";
+export declare function renameSymbol(doc: DocumentLike, sourceFile: SourceFile, position: Position, newName: string): WorkspaceEdit | undefined;

package/lib/esm/service/rename.js

@@ -0,0 +1,45 @@
+import { TextEdit } from "vscode-languageserver-types";
+import { SyntaxKind } from "../types.js";
+import { findNodeAtOffset } from "../checker.js";
+import { isIdentifierNode } from "../index.js";
+import { syntaxNodesToRanges } from "./util.js";
+export function renameSymbol(doc, sourceFile, position, newName) {
+    if (!sourceFile.symbols)
+        throw "sourceFile is not bound";
+    if (!newName)
+        return undefined;
+    const g = sourceFile.graph;
+    if (!g)
+        return undefined;
+    const offset = doc.offsetAt(position);
+    const node = findNodeAtOffset(g, offset);
+    if (!node)
+        return undefined;
+    const parent = node.parent;
+    if (isIdentifierNode(node) && isRenamableIdentifier(node) && !!parent && isRenameableNode(parent)) {
+        const nodeSymbol = node.symbol;
+        if (!nodeSymbol)
+            throw "node.symbol is not bound";
+        const r = nodeSymbol.references;
+        const refs = r ? [nodeSymbol.firstMention, ...r] : [nodeSymbol.firstMention];
+        const ranges = syntaxNodesToRanges(doc, sourceFile, refs);
+        const uri = doc.uri;
+        const res = {
+            changes: {
+                [uri]: ranges.map(r => TextEdit.replace(r, newName)),
+            }
+        };
+        return res;
+    }
+    debugger;
+    return undefined;
+}
+function isRenameableNode(node) {
+    return node.kind === SyntaxKind.NodeId
+        || node.kind === SyntaxKind.DirectedGraph
+        || node.kind === SyntaxKind.UndirectedGraph;
+}
+function isRenamableIdentifier(node) {
+    return node.kind !== SyntaxKind.QuotedTextIdentifier;
+}
+//# sourceMappingURL=rename.js.map

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

@@ -0,0 +1,28 @@
+import type * as lst from "vscode-languageserver-types";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import { ColorInformation, Color, ColorPresentation } from "./polyfill.js";
+import { SourceFile, Omit } from "../types.js";
+export interface DocumentLike {
+    positionAt(offset: number): lst.Position;
+    offsetAt(position: lst.Position): number;
+    readonly uri: string;
+}
+export interface CommandApplication {
+    label?: string;
+    edit: lst.WorkspaceEdit;
+}
+export interface LanguageService {
+    parseDocument(doc: TextDocument | string): SourceFile;
+    validateDocument(doc: DocumentLike, sourceFile: SourceFile): lst.Diagnostic[];
+    hover(doc: DocumentLike, sourceFile: SourceFile, position: lst.Position): lst.Hover | undefined;
+    findReferences(doc: DocumentLike, sourceFile: SourceFile, position: lst.Position, context: lst.ReferenceContext): lst.Location[];
+    findDefinition(doc: DocumentLike, sourceFile: SourceFile, position: lst.Position): lst.Location | undefined;
+    renameSymbol(doc: DocumentLike, sourceFile: SourceFile, position: lst.Position, newName: string): lst.WorkspaceEdit | undefined;
+    getCompletions(doc: DocumentLike, sourceFile: SourceFile, position: lst.Position): lst.CompletionItem[];
+    getDocumentColors(doc: DocumentLike, sourceFile: SourceFile): ColorInformation[] | undefined;
+    getColorRepresentations(doc: DocumentLike, sourceFile: SourceFile, color: Color, range: lst.Range): ColorPresentation[] | undefined;
+    getCodeActions(doc: DocumentLike, sourceFile: SourceFile, range: lst.Range, context: lst.CodeActionContext): lst.Command[] | undefined;
+    executeCommand(doc: DocumentLike, sourceFile: SourceFile, command: Omit<lst.Command, "title">): CommandApplication | undefined;
+    getAvailableCommands(): string[];
+}
+export declare function createService(): LanguageService;

package/lib/esm/service/service.js

@@ -0,0 +1,35 @@
+import { Parser } from "../index.js";
+import { bindSourceFile } from "../binder.js";
+import { hover } from "./hover.js";
+import { validateDocument } from "./validation.js";
+import { findReferences, findDefinition } from "./reference.js";
+import { renameSymbol } from "./rename.js";
+import { getCompletions } from "./completion.js";
+import { checkSourceFile } from "../checker.js";
+import { getCodeActions, executeCommand, getAvailableCommands } from "./codeAction.js";
+import { getDocumentColors, getColorRepresentations } from "./colorProvider.js";
+function parseDocument(doc) {
+    const parser = new Parser();
+    const content = typeof doc === "string" ? doc : doc.getText();
+    const sourceFile = parser.parse(content);
+    bindSourceFile(sourceFile);
+    checkSourceFile(sourceFile);
+    return sourceFile;
+}
+export function createService() {
+    return {
+        parseDocument,
+        validateDocument,
+        hover,
+        findReferences,
+        findDefinition,
+        renameSymbol,
+        getCompletions,
+        getDocumentColors,
+        getColorRepresentations,
+        getCodeActions,
+        executeCommand,
+        getAvailableCommands,
+    };
+}
+//# sourceMappingURL=service.js.map

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

@@ -0,0 +1,11 @@
+import type { Range } from "vscode-languageserver-types";
+import { SourceFile, SyntaxNode } from "../types.js";
+import type { DocumentLike } from "../index.js";
+export declare function getStart(sourceFile: SourceFile, node: SyntaxNode): number;
+export declare function syntaxNodesToRanges(doc: DocumentLike, sourceFile: SourceFile, nodes: SyntaxNode[]): Range[];
+export declare function syntaxNodeToRange(doc: DocumentLike, sourceFile: SourceFile, node: SyntaxNode): {
+    start: import("vscode-languageserver-types").Position;
+    end: import("vscode-languageserver-types").Position;
+};
+export declare function escapeIdentifierText(text: string): string;
+export declare function assertNever(v: never): never;

package/lib/esm/service/util.js

@@ -0,0 +1,44 @@
+import { SyntaxKind } from "../types.js";
+import { skipTrivia, isIdentifierStart } from "../scanner.js";
+export function getStart(sourceFile, node) {
+    return getTokenPosOfNode(sourceFile, node);
+}
+function getTokenPosOfNode(sourceFile, node) {
+    if (nodeIsMissing(node))
+        return node.pos;
+    return skipTrivia(sourceFile.content, node.pos);
+}
+function nodeIsMissing(node) {
+    return node === undefined
+        ? true
+        : node.pos === node.end && node.pos >= 0 && node.kind !== SyntaxKind.EndOfFileToken;
+}
+export function syntaxNodesToRanges(doc, sourceFile, nodes) {
+    return nodes.map(node => syntaxNodeToRange(doc, sourceFile, node));
+}
+export function syntaxNodeToRange(doc, sourceFile, node) {
+    const start = getStart(sourceFile, node);
+    return {
+        start: doc.positionAt(start),
+        end: doc.positionAt(node.end),
+    };
+}
+export function escapeIdentifierText(text) {
+    if (text === "")
+        return quote("");
+    if (text.includes("\"") || text.includes("\n")) {
+        const esc = text
+            .replace(/"/, "\\\"")
+            .replace(/\n/, "\\\n");
+        return quote(esc);
+    }
+    const ch = text.charCodeAt(0);
+    if (!isIdentifierStart(ch) || text.includes(" "))
+        return quote(text);
+    return text;
+}
+const quote = (s) => "\"" + s + "\"";
+export function assertNever(v) {
+    throw new Error("Should not have reached this. Value: " + (v ?? ""));
+}
+//# sourceMappingURL=util.js.map

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

@@ -0,0 +1,4 @@
+import * as lst from "vscode-languageserver-types";
+import { SourceFile } from "../types.js";
+import { DocumentLike } from "../index.js";
+export declare function validateDocument(doc: DocumentLike, sourceFile: SourceFile): lst.Diagnostic[];

package/lib/esm/service/validation.js

@@ -0,0 +1,20 @@
+import { formatError, diagnosicSource } from "../error.js";
+function convertDiagnostic(document, source) {
+    return {
+        range: {
+            start: document.positionAt(source.start),
+            end: document.positionAt(source.end),
+        },
+        severity: source.category,
+        code: formatError(source.code),
+        source: diagnosicSource,
+        message: source.message,
+    };
+}
+export function validateDocument(doc, sourceFile) {
+    const diagnostics = sourceFile.diagnostics;
+    if (!diagnostics || diagnostics.length <= 0)
+        return [];
+    return diagnostics.map(d => convertDiagnostic(doc, d));
+}
+//# sourceMappingURL=validation.js.map

package/lib/esm/tester.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/esm/tester.js

@@ -0,0 +1,21 @@
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { Parser } from "./parser.js";
+import { bindSourceFile } from "./binder.js";
+import { checkSourceFile } from "./checker.js";
+import { getCompletions } from "./service/completion.js";
+const text = `graph {
+	node_name_a -- node_name_b [color=blue,
+	];
+}`;
+function main() {
+    const parser = new Parser();
+    const sf = parser.parse(text);
+    bindSourceFile(sf);
+    checkSourceFile(sf);
+    const doc = TextDocument.create("inmemory://model.json", "DOT", 0, text);
+    const requestOffset = text.indexOf("color=blue,\n\t") + "color=blue,\n\t".length;
+    const completions = getCompletions(doc, sf, doc.positionAt(requestOffset));
+    console.dir(completions);
+}
+main();
+//# sourceMappingURL=tester.js.map