dot-language-support 2.3.0 → 3.0.0

package/lib/esm/binder.js

@@ -1,294 +0,0 @@
-import { getIdentifierText, nodeContainsErrors } from "./checker.js";
-import { isIdentifierNode } from "./parser.js";
-import { SyntaxKind, } from "./types.js";
-const binder = createBinder();
-export function bindSourceFile(file) {
-    binder.bind(file);
-}
-function createBinder() {
-    let parent;
-    let symbolTable;
-    let colorTable;
-    let graphContext = 0;
-    function bind(node) {
-        if (!node)
-            return;
-        const saveParent = parent;
-        const saveContext = graphContext;
-        node.parent = saveParent;
-        node.graphContext = saveContext;
-        parent = node;
-        innerBind(node);
-        parent = saveParent;
-        graphContext = saveContext;
-    }
-    function innerBind(node) {
-        switch (node.kind) {
-            case SyntaxKind.DirectedGraph:
-            case SyntaxKind.UndirectedGraph:
-                return bindGraph(node);
-            case SyntaxKind.AttributeStatement:
-                return bindAttributeStatement(node);
-            case SyntaxKind.EdgeStatement:
-                return bindEdgeStatement(node);
-            case SyntaxKind.NodeStatement:
-                return bindNodeStatement(node);
-            case SyntaxKind.SubGraph:
-                return bindSubGraph(node);
-            case SyntaxKind.SubGraphStatement:
-                return bindSubGraphStatement(node);
-            case SyntaxKind.IdEqualsIdStatement:
-                return bindIdEqualsIdStatement(node);
-            case SyntaxKind.QuotedTextIdentifier:
-                return bindQuotedTextIdentifier(node);
-            case SyntaxKind.EdgeRhs:
-                return bindEdgeRhs(node);
-            case SyntaxKind.AttributeContainer:
-                return bindAttributeContainer(node);
-            case SyntaxKind.Assignment:
-                return bindAssignment(node);
-            case SyntaxKind.NormalPortDeclaration:
-                return bindNormalPortDeclaration(node);
-            case SyntaxKind.CompassPortDeclaration:
-                return bindCompassPortDeclaration(node);
-            case SyntaxKind.NodeId:
-                return bindNodeId(node);
-            default:
-                if (node.kind >= SyntaxKind.FirstNode)
-                    throw "TODO";
-        }
-    }
-    function bindGraph(node) {
-        if (node.strict) {
-            graphContext |= 2;
-        }
-        switch (node.kind) {
-            case SyntaxKind.DirectedGraph:
-                graphContext |= 4;
-                break;
-            case SyntaxKind.UndirectedGraph:
-                graphContext |= 8;
-                break;
-        }
-        if (node.id) {
-            ensureGlobalSymbol(node.id);
-            bind(node.id);
-        }
-        if (node.strict)
-            bind(node.strict);
-        bindChildren(node.statements);
-    }
-    function bindAttributeStatement(node) {
-        bind(node.subject);
-        bindChildren(node.attributes);
-        if (node.terminator)
-            bind(node.terminator);
-    }
-    function bindEdgeStatement(node) {
-        bindChildren(node.attributes);
-        bindChildren(node.rhs);
-        bind(node.source);
-        if (node.terminator)
-            bind(node.terminator);
-    }
-    function bindNodeStatement(node) {
-        bind(node.id);
-        bindChildren(node.attributes);
-        if (node.terminator)
-            bind(node.terminator);
-    }
-    function bindSubGraph(node) {
-        if (node.id) {
-            bind(node.id);
-        }
-        bindChildren(node.statements);
-    }
-    function bindSubGraphStatement(node) {
-        bind(node.subgraph);
-        if (node.terminator)
-            bind(node.terminator);
-    }
-    function bindIdEqualsIdStatement(node) {
-        bind(node.leftId);
-        bind(node.rightId);
-        if (node.rightId && !nodeContainsErrors(node.rightId)) {
-            if (isAttributeName("color", node.leftId)) {
-                ensureGlobalColor(node.rightId);
-            }
-            else if (isAttributeName("fillcolor", node.leftId)) {
-                ensureGlobalColor(node.rightId);
-            }
-            else if (isAttributeName("bgcolor", node.leftId)) {
-                ensureGlobalColor(node.rightId);
-            }
-            else if (isAttributeName("fontcolor", node.leftId)) {
-                ensureGlobalColor(node.rightId);
-            }
-        }
-        if (node.terminator)
-            bind(node.terminator);
-    }
-    function bindQuotedTextIdentifier(node) {
-        bindChildren(node.values);
-        node.concatenation = node.values.map(v => v.text).join("");
-    }
-    function bindEdgeRhs(node) {
-        bind(node.operation);
-        bind(node.target);
-    }
-    function bindAttributeContainer(node) {
-        bind(node.openBracket);
-        bindChildren(node.assignments);
-        bind(node.closeBracket);
-    }
-    function bindAssignment(node) {
-        const attrContainer = node.parent;
-        console.assert(!!attrContainer);
-        const superParentStatement = attrContainer.parent;
-        console.assert(!!superParentStatement);
-        bind(node.leftId);
-        let carrierIdentifier;
-        switch (superParentStatement.kind) {
-            case SyntaxKind.NodeStatement:
-                carrierIdentifier = superParentStatement.id.id;
-                break;
-            case SyntaxKind.EdgeStatement:
-                break;
-            case SyntaxKind.SubGraphStatement:
-                break;
-            case SyntaxKind.AttributeStatement:
-                break;
-        }
-        if (carrierIdentifier)
-            ensureMemberSymbol(node.leftId, carrierIdentifier);
-        bind(node.rightId);
-        if (node.rightId && !nodeContainsErrors(node.rightId)) {
-            if (isAttributeName("color", node.leftId)) {
-                ensureGlobalColor(node.rightId);
-            }
-        }
-        if (node.terminator)
-            bind(node.terminator);
-    }
-    function bindNormalPortDeclaration(node) {
-        bind(node.colon);
-        ensureGlobalSymbol(node.id);
-        bind(node.id);
-        if (node.compassPt)
-            bind(node.compassPt);
-    }
-    function bindCompassPortDeclaration(node) {
-        bind(node.colon);
-        if (node.compassPt)
-            bind(node.compassPt);
-    }
-    function bindNodeId(node) {
-        ensureGlobalSymbol(node.id);
-        bind(node.id);
-        if (node.port)
-            bind(node.port);
-    }
-    function bindChildren(nodes) {
-        for (const n of nodes)
-            bind(n);
-    }
-    function createSymbolTable() {
-        return new Map();
-    }
-    function createColorTable() {
-        return new Map();
-    }
-    function ensureMemberSymbol(node, carrier) {
-        if (node && carrier && isIdentifierNode(node)) {
-            const name = getIdentifierText(node);
-            if (name === undefined)
-                return;
-            const carrierSymbol = carrier.symbol;
-            if (carrierSymbol === undefined)
-                throw "carrierSymbol is undefined";
-            let symbols = carrierSymbol.members;
-            if (symbols === undefined)
-                carrierSymbol.members = symbols = createSymbolTable();
-            ensureSymbolOnTable(name, node, symbols);
-            return;
-        }
-        console.warn("ensureSymbol called on non-identifier node");
-        debugger;
-    }
-    function ensureGlobalSymbol(node) {
-        if (node && isIdentifierNode(node)) {
-            const symbols = symbolTable;
-            const name = getIdentifierText(node);
-            if (name === undefined)
-                return;
-            if (symbols === undefined)
-                throw "symbolTable is undefined";
-            ensureSymbolOnTable(name, node, symbols);
-            return;
-        }
-        console.warn("ensureSymbol called on non-identifier node");
-        debugger;
-    }
-    function ensureSymbolOnTable(name, node, symbols) {
-        if (!name)
-            return;
-        let sym = symbols.get(name);
-        if (sym === undefined) {
-            sym = createSymbol(name, node);
-            symbols.set(name, sym);
-        }
-        else {
-            if (!sym.references)
-                sym.references = [node];
-            else
-                sym.references.push(node);
-        }
-        node.symbol = sym;
-    }
-    function ensureGlobalColor(node) {
-        if (node && isIdentifierNode(node)) {
-            const colors = colorTable;
-            const name = getIdentifierText(node);
-            if (name === undefined)
-                return;
-            if (colors === undefined)
-                throw "symbolTable is undefined";
-            const color = createColor(node);
-            colors.set(name, color);
-            return;
-        }
-        console.warn("ensureSymbol called on non-identifier node");
-        debugger;
-    }
-    function createSymbol(name, node) {
-        if (!name)
-            throw "name is falsy";
-        if (!node)
-            throw "node is undefined or null";
-        return {
-            name,
-            firstMention: node,
-            references: undefined,
-        };
-    }
-    function createColor(node) {
-        return {
-            node,
-        };
-    }
-    function isAttributeName(name, id) {
-        return id ? getIdentifierText(id).trim().toLowerCase() === name : false;
-    }
-    return {
-        bind: file => {
-            symbolTable = createSymbolTable();
-            colorTable = createColorTable();
-            const { graph } = file;
-            if (graph)
-                bind(graph);
-            file.symbols = symbolTable;
-            file.colors = colorTable;
-        },
-    };
-}
-//# sourceMappingURL=binder.js.map

package/lib/esm/checker.d.ts

@@ -1,15 +0,0 @@
-import { type AttributeStatement, type EdgeRhs, type EdgeStatement, type Graph, type Identifier, type NodeId, type SourceFile, type Statement, type StatementOf, type SubGraphStatement, SyntaxKind, type SyntaxNode, type 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 isGraph(node: SyntaxNode): node is Graph;
-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

@@ -1,212 +0,0 @@
-import { shapes as validShapes } from "./service/languageFacts.js";
-import { assertNever, getStart } from "./service/util.js";
-import { DiagnosticCategory, SyntaxKind, } from "./types.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) {
-        const 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);
-    const invalidShapes = checkShapeLabelValues(root);
-    const invalidEdgeDiagnostics = invalidEdgeRhses === undefined || invalidEdgeRhses.length === 0
-        ? []
-        : createEdgeViolationDiagnostics(file, expectedEdgeOp, invalidEdgeRhses);
-    return [...invalidEdgeDiagnostics, ...invalidShapes];
-}
-function forEachAssignmentTransitive(root, cb) {
-    forEachChild(root, child => {
-        if (child.kind === SyntaxKind.Assignment) {
-            cb(child);
-            return;
-        }
-        forEachChild(child, c => forEachAssignmentTransitive(c, cb));
-    });
-}
-function checkShapeLabelValues(root) {
-    const invalidShapes = [];
-    forEachAssignmentTransitive(root, assignment => {
-        const { leftId, rightId } = assignment;
-        if (leftId.kind !== SyntaxKind.TextIdentifier ||
-            rightId.kind !== SyntaxKind.TextIdentifier) {
-            return;
-        }
-        const leftText = leftId.text.trim();
-        if (leftText.toLocaleLowerCase() !== "shape") {
-            return;
-        }
-        const rightText = rightId.text.trim();
-        const shapeCandidate = rightText.toLowerCase();
-        if (validShapes.includes(shapeCandidate)) {
-            return;
-        }
-        invalidShapes.push({
-            category: DiagnosticCategory.Warning,
-            code: createCheckerError(1),
-            message: `Unknown shape "${rightText}".`,
-            start: rightId.pos,
-            end: rightId.end,
-        });
-    });
-    return invalidShapes;
-}
-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) {
-        for (const edge of wrongEdges) {
-            edge.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;
-    for (const edge of violators) {
-        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;
-}
-export 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

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

package/lib/esm/core.js

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

package/lib/esm/error.d.ts

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

package/lib/esm/error.js

@@ -1,8 +0,0 @@
-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

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

package/lib/esm/index.js

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

package/lib/esm/parser.d.ts

@@ -1,27 +0,0 @@
-import { type Scanner } from "./scanner.js";
-import { type DiagnosticMessage, type Identifier, type SourceFile, SyntaxKind, type SyntaxNode } from "./types";
-export declare enum ParsingContext {
-    None = 0,
-    StatementList = 1,
-    AttributeContainerList = 2,
-    AssignmentList = 3,
-    EdgeRhsList = 4,
-    QuotedTextIdentifierConcatenation = 5,
-    Count = 6
-}
-export declare class Parser {
-    #private;
-    currentToken: SyntaxKind;
-    nodeCount: number;
-    identifiers: Set<string>;
-    identifierCount: number;
-    sourceText: string;
-    scanner: Scanner;
-    currentNodeHasError: boolean;
-    currentContext: ParsingContext;
-    diagnostics: DiagnosticMessage[];
-    constructor();
-    parse(sourceText: string): SourceFile;
-}
-export declare function isIdentifier(kind: SyntaxKind): kind is SyntaxKind.HtmlIdentifier | SyntaxKind.TextIdentifier | SyntaxKind.QuotedTextIdentifier | SyntaxKind.NumericIdentifier;
-export declare function isIdentifierNode(node: SyntaxNode): node is Identifier;