dot-language-support 1.6.2 → 2.0.2

package/lib/esm/checker.d.ts

@@ -0,0 +1,14 @@
+import { SyntaxNode, Identifier, SyntaxKind, Graph, EdgeStatement, EdgeRhs, SourceFile, SubGraphStatement, NodeId, AttributeStatement, Statement, StatementOf, Token } from "./types.js";
+export declare function checkSourceFile(file: SourceFile): void;
+export declare function findNodeAtOffset(root: SyntaxNode, offset: number, inclusiveEnd?: boolean): SyntaxNode | undefined;
+export declare function getAllowedEdgeOperation(graph: Graph): SyntaxKind.DirectedEdgeOp | SyntaxKind.UndirectedEdgeOp;
+export declare function findAllEdges(node: SyntaxNode): EdgeRhs[];
+export declare function findOptionalSemicolons(node: SyntaxNode): Token<SyntaxKind.SemicolonToken>[];
+export declare function findAllStatements<T extends Statement["kind"]>(node: SyntaxNode, kind?: T): StatementOf<T>[];
+export declare function isAttrStatement(node: SyntaxNode): node is AttributeStatement;
+export declare function isEdgeStatement(node: SyntaxNode): node is EdgeStatement;
+export declare function isSubGraphStatement(node: SyntaxNode): node is SubGraphStatement;
+export declare function isNodeId(node: SyntaxNode): node is NodeId;
+export declare function edgeStatementHasAttributes(es: EdgeStatement): boolean;
+export declare function getIdentifierText(n: Identifier): string;
+export declare function nodeContainsErrors(node: SyntaxNode): boolean;

package/lib/esm/checker.js

@@ -0,0 +1,169 @@
+import { SyntaxKind, DiagnosticCategory, } from "./types.js";
+import { assertNever, getStart } from "./service/util.js";
+import { forEachChild } from "./visitor.js";
+export function checkSourceFile(file) {
+    const g = file.graph;
+    if (g) {
+        const messages = checkGraphSemantics(file, g);
+        if (messages) {
+            file.diagnostics.push.apply(file.diagnostics, messages);
+        }
+    }
+}
+function getNarrowerNode(offset, prev, toCheck) {
+    const prevRange = prev.end - prev.pos;
+    if (toCheck.pos <= offset && offset <= toCheck.end) {
+        let nrange = toCheck.end - toCheck.pos;
+        if (nrange < prevRange) {
+            return toCheck;
+        }
+    }
+    return prev;
+}
+function rangeContainsOffset(range, offset, inclusiveEnd) {
+    return inclusiveEnd
+        ? range.pos <= offset && offset <= range.end
+        : range.pos <= offset && offset < range.end;
+}
+export function findNodeAtOffset(root, offset, inclusiveEnd = false) {
+    if (root.pos === offset && root.pos === root.end)
+        return root;
+    if (rangeContainsOffset(root, offset, inclusiveEnd)) {
+        const narrowerChild = forEachChild(root, child => findNodeAtOffset(child, offset, inclusiveEnd));
+        return narrowerChild ? narrowerChild : root;
+    }
+    return undefined;
+}
+export function getAllowedEdgeOperation(graph) {
+    return graph.kind === SyntaxKind.DirectedGraph
+        ? SyntaxKind.DirectedEdgeOp
+        : SyntaxKind.UndirectedEdgeOp;
+}
+function checkGraphSemantics(file, root) {
+    const expectedEdgeOp = getAllowedEdgeOperation(root);
+    const invalidEdgeRhses = findEdgeErrors(expectedEdgeOp, root);
+    return invalidEdgeRhses == undefined || invalidEdgeRhses.length === 0
+        ? undefined
+        : createEdgeViolationDiagnostics(file, expectedEdgeOp, invalidEdgeRhses);
+}
+export function findAllEdges(node) {
+    const allEdges = [];
+    forEachChild(node, child => {
+        if (isEdgeStatement(child)) {
+            if (child.rhs && child.rhs.length > 0) {
+                for (const edgeRhs of child.rhs)
+                    allEdges.push(edgeRhs);
+            }
+        }
+        const childEdges = findAllEdges(child);
+        if (childEdges && childEdges.length > 0)
+            allEdges.push.apply(allEdges, childEdges);
+    });
+    return allEdges;
+}
+export function findOptionalSemicolons(node) {
+    const statements = findAllStatements(node);
+    const terminators = statements.map(p => p.terminator);
+    return terminators.filter(t => !!t);
+}
+function isStatement(node) {
+    return node.kind === SyntaxKind.SubGraphStatement
+        || node.kind === SyntaxKind.EdgeStatement
+        || node.kind === SyntaxKind.NodeStatement
+        || node.kind === SyntaxKind.IdEqualsIdStatement
+        || node.kind === SyntaxKind.AttributeStatement;
+}
+export function findAllStatements(node, kind) {
+    const allStatements = [];
+    forEachChild(node, child => {
+        if ((kind === undefined && isStatement(child)) || (child.kind === kind)) {
+            allStatements.push(child);
+        }
+        const childStatements = findAllStatements(child, kind);
+        if (childStatements && childStatements.length > 0)
+            allStatements.push.apply(allStatements, childStatements);
+    });
+    return allStatements;
+}
+function findEdgeErrors(expectedEdgeOp, node) {
+    const edges = findAllEdges(node);
+    const wrongEdges = edges && edges.length > 0
+        ? edges.filter(e => e.operation.kind !== expectedEdgeOp)
+        : undefined;
+    if (wrongEdges && wrongEdges.length > 0) {
+        wrongEdges.forEach(e => e.operation.flags |= 2);
+        return wrongEdges;
+    }
+    return undefined;
+}
+function createEdgeViolationDiagnostics(file, expectedEdgeOp, violators) {
+    const op = expectedEdgeOp === SyntaxKind.UndirectedEdgeOp ? "--" : "->";
+    const graphType = expectedEdgeOp === SyntaxKind.UndirectedEdgeOp ? "undirected" : "directed";
+    const message = `Invalid edge operation, use "${op}" in ${graphType} graph`;
+    const code = createCheckerError(0);
+    const category = DiagnosticCategory.Error;
+    violators.forEach(edge => edge.operation.flags |= 2);
+    return violators.map(edge => {
+        const start = getStart(file, edge.operation);
+        const end = edge.operation.end;
+        return {
+            message,
+            code,
+            category,
+            start,
+            end,
+        };
+    });
+}
+function getInvalidEdgeRhs(allowedOp, edges) {
+    const res = [];
+    for (const e of edges) {
+        if (e.operation.kind !== allowedOp)
+            res.push(e);
+    }
+    return res;
+}
+export function isAttrStatement(node) {
+    return node.kind === SyntaxKind.AttributeStatement;
+}
+export function isEdgeStatement(node) {
+    return node.kind === SyntaxKind.EdgeStatement;
+}
+export function isSubGraphStatement(node) {
+    return node.kind === SyntaxKind.SubGraphStatement;
+}
+function isGraph(node) {
+    return node.kind === SyntaxKind.DirectedGraph || node.kind === SyntaxKind.UndirectedGraph;
+}
+export function isNodeId(node) {
+    return node.kind === SyntaxKind.NodeId;
+}
+export function edgeStatementHasAttributes(es) {
+    return es.attributes
+        && es.attributes.length > 0
+        && es.attributes.some(a => a.assignments && a.assignments.length > 0);
+}
+export function getIdentifierText(n) {
+    switch (n.kind) {
+        case SyntaxKind.HtmlIdentifier:
+            return n.htmlContent;
+        case SyntaxKind.TextIdentifier:
+            return n.text;
+        case SyntaxKind.NumericIdentifier:
+            return n.text;
+        case SyntaxKind.QuotedTextIdentifier:
+            return n.concatenation;
+        default:
+            return assertNever(n);
+    }
+}
+function createCheckerError(sub) {
+    return {
+        source: 4,
+        sub,
+    };
+}
+export function nodeContainsErrors(node) {
+    return (node.flags & 2) === 2;
+}
+//# sourceMappingURL=checker.js.map

package/lib/esm/core.d.ts

@@ -0,0 +1 @@
+export declare function createMapFromTemplate<T>(template: Record<string, T>): Map<string, T>;

package/lib/esm/core.js

@@ -0,0 +1,10 @@
+export function createMapFromTemplate(template) {
+    const map = new Map();
+    for (const key in template) {
+        if (template.hasOwnProperty(key)) {
+            map.set(key, template[key]);
+        }
+    }
+    return map;
+}
+//# sourceMappingURL=core.js.map

package/lib/esm/error.d.ts

@@ -0,0 +1,3 @@
+import type { ErrorCode } from "./types.js";
+export declare const diagnosicSource = "DOT";
+export declare function formatError(error: ErrorCode): string;

package/lib/esm/error.js

@@ -0,0 +1,10 @@
+export const diagnosicSource = "DOT";
+const errorCodeLength = 4;
+const subErrorCodeLength = errorCodeLength - 1;
+export function formatError(error) {
+    const subCode = (error.sub | 0)
+        .toString()
+        .padStart(subErrorCodeLength, "0");
+    return diagnosicSource + error.source + subCode;
+}
+//# sourceMappingURL=error.js.map

package/lib/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./scanner.js";
+export * from "./parser.js";
+export * from "./visitor.js";
+export * from "./service/service.js";

package/lib/esm/index.js

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./scanner.js";
+export * from "./parser.js";
+export * from "./visitor.js";
+export * from "./service/service.js";
+//# sourceMappingURL=index.js.map

package/lib/esm/parser.d.ts

@@ -0,0 +1,84 @@
+import { Scanner } from "./scanner.js";
+import { SyntaxKind, SourceFile, Identifier, SyntaxNode, DiagnosticMessage } from "./types";
+export declare enum ParsingContext {
+    None = 0,
+    StatementList = 1,
+    AttributeContainerList = 2,
+    AssignmentList = 3,
+    EdgeRhsList = 4,
+    QuotedTextIdentifierConcatenation = 5,
+    Count = 6
+}
+export declare class Parser {
+    currentToken: SyntaxKind;
+    nodeCount: number;
+    identifiers: Set<string>;
+    identifierCount: number;
+    sourceText: string;
+    scanner: Scanner;
+    currentNodeHasError: boolean;
+    currentContext: ParsingContext;
+    diagnostics: DiagnosticMessage[];
+    constructor();
+    private resetState;
+    private nextToken;
+    private token;
+    private getLinesFromFile;
+    parse(sourceText: string): SourceFile;
+    private parseGraph;
+    private parseIdentifier;
+    private registerIdentifier;
+    private parseTextIdentifier;
+    private parseQuotedTextIdentifierConcatenation;
+    private parseQuotedTextIdentifier;
+    private isQuotedStringFollowing;
+    private parseHtmlIdentifier;
+    private parseNumericIdentifier;
+    private parseStatement;
+    private parseAttributeStatement;
+    private parseAttributeContainer;
+    private isAssignmentStart;
+    private parseIdEqualsIdStatement;
+    private isIdEqualsIdStatement;
+    private parseNodeStatement;
+    private parseEdgeStatement;
+    private parseEdgeRhs;
+    private createMissingNode;
+    private parseAssignment;
+    private parseSubGraph;
+    private parseNodeId;
+    private parseCompassPortDeclaration;
+    private parseNormalPortDeclaration;
+    private parsePortDeclaration;
+    private isCompassPort;
+    private parseList;
+    private getContextParseError;
+    private isInSomeParsingContext;
+    private abortListParsing;
+    private isListElement;
+    private isListTerminator;
+    private createEmptyArray;
+    private finishNode;
+    private createNode;
+    private createNodeArray;
+    private parseTokenNode;
+    private getLastError;
+    private parseErrorAtPosition;
+    private parseErrorAtCurrentToken;
+    private scanError;
+    private reportExpectedError;
+    private parseExpectedOneOf;
+    private parseExpectedTokenOneOf;
+    private parseExpectedToken;
+    private parseExpected;
+    private parseOptionalToken;
+    private parseOptional;
+    private isEdgeOp;
+    private isIdentifier;
+    private isCompassPortKind;
+    private speculationHelper;
+    private lookAhead;
+    private tryParse;
+}
+export declare function isIdentifier(kind: SyntaxKind): boolean;
+export declare function isIdentifierNode(node: SyntaxNode): node is Identifier;