完成世界书、骰子、apiconfig页面处理

frontend/node_modules/langium/lib/generate/generator-tracing.d.ts

@@ -0,0 +1,40 @@
+/******************************************************************************
+ * Copyright 2023 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+import type { Range } from 'vscode-languageserver-textdocument';
+import type { AstNode, CstNode } from '../syntax-tree.js';
+import type { DocumentSegment } from '../workspace/documents.js';
+export interface TraceSourceSpec {
+    astNode: AstNode;
+    property?: string;
+    index?: number;
+}
+export type SourceRegion = TextRegion | TextRegion2 | DocumentSegmentWithFileURI;
+export interface TextRegion {
+    fileURI?: string;
+    offset: number;
+    end: number;
+    length?: number;
+    range?: Range;
+}
+interface TextRegion2 {
+    fileURI?: string;
+    offset: number;
+    length: number;
+    end?: number;
+    range?: Range;
+}
+export interface TraceRegion {
+    sourceRegion?: TextRegion;
+    targetRegion: TextRegion;
+    children?: TraceRegion[];
+}
+interface DocumentSegmentWithFileURI extends Omit<DocumentSegment, 'range'> {
+    fileURI?: string;
+    range?: Range;
+}
+export declare function getSourceRegion(sourceSpec: TraceSourceSpec | undefined | SourceRegion | SourceRegion[]): DocumentSegmentWithFileURI | CstNode | undefined;
+export {};
+//# sourceMappingURL=generator-tracing.d.ts.map

frontend/node_modules/langium/lib/generate/generator-tracing.js

@@ -0,0 +1,135 @@
+/******************************************************************************
+ * Copyright 2023 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+import { getDocument } from '../utils/ast-utils.js';
+import { findNodesForProperty } from '../utils/grammar-utils.js';
+import { TreeStreamImpl } from '../utils/stream.js';
+export function getSourceRegion(sourceSpec) {
+    if (!sourceSpec) {
+        return undefined;
+    }
+    else if ('astNode' in sourceSpec) {
+        return getSourceRegionOfAstNode(sourceSpec);
+    }
+    else if (Array.isArray(sourceSpec)) {
+        return sourceSpec.reduce(mergeDocumentSegment, undefined); // apply mergeDocumentSegment for single entry sourcSpec lists, too, thus start with 'undefined' as initial value
+    }
+    else {
+        // some special treatment of cstNodes for revealing the uri of the defining DSL text file
+        //  is currently only done for single cstNode tracings, like "expandTracedToNode(source.$cstNode)`...`",
+        //  is _not done_ for multi node tracings like below, see if case above
+        //    joinTracedToNode( [
+        //        findNodeForKeyword(source.$cstNode, '{')!,
+        //        findNodeForKeyword(source.$cstNode, '}')!
+        //    ] )(source.children, c => c.name)
+        const sourceRegion = sourceSpec;
+        const sourceFileURIviaCstNode = isCstNode(sourceRegion)
+            ? getDocumentURIOrUndefined(sourceRegion?.root?.astNode ?? sourceRegion?.astNode) : undefined;
+        return copyDocumentSegment(sourceRegion, sourceFileURIviaCstNode);
+    }
+}
+function isCstNode(segment) {
+    return typeof segment !== 'undefined' && 'element' in segment && 'text' in segment;
+}
+function getDocumentURIOrUndefined(astNode) {
+    try {
+        return getDocument(astNode).uri.toString();
+    }
+    catch (_error) {
+        return undefined;
+    }
+}
+function getSourceRegionOfAstNode(sourceSpec) {
+    const { astNode, property, index } = sourceSpec ?? {};
+    const textRegion = astNode?.$cstNode ?? astNode?.$textRegion;
+    if (astNode === undefined || textRegion === undefined) {
+        return undefined;
+    }
+    else if (property === undefined) {
+        return copyDocumentSegment(textRegion, getDocumentURI(astNode));
+    }
+    else {
+        const getSingleOrCompoundRegion = (regions) => {
+            if (index !== undefined && index > -1 && Array.isArray(astNode[property])) {
+                return index < regions.length ? regions[index] : undefined;
+            }
+            else {
+                return regions.reduce(mergeDocumentSegment, undefined);
+            }
+        };
+        if (textRegion.assignments?.[property]) {
+            const region = getSingleOrCompoundRegion(textRegion.assignments[property]);
+            return region && copyDocumentSegment(region, getDocumentURI(astNode));
+        }
+        else if (astNode.$cstNode) {
+            const region = getSingleOrCompoundRegion(findNodesForProperty(astNode.$cstNode, property));
+            return region && copyDocumentSegment(region, getDocumentURI(astNode));
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+function getDocumentURI(astNode) {
+    if (astNode.$cstNode) {
+        return getDocument(astNode)?.uri?.toString();
+    }
+    else if (astNode.$textRegion) {
+        return astNode.$textRegion.documentURI
+            || new TreeStreamImpl(astNode, n => n.$container ? [n.$container] : []).find(n => n.$textRegion?.documentURI)?.$textRegion?.documentURI;
+    }
+    else {
+        return undefined;
+    }
+}
+function copyDocumentSegment(region, fileURI) {
+    const result = {
+        offset: region.offset,
+        end: region.end ?? region.offset + region.length,
+        length: region.length ?? region.end - region.offset,
+    };
+    if (region.range) {
+        result.range = region.range;
+    }
+    fileURI ?? (fileURI = region.fileURI);
+    if (fileURI) {
+        result.fileURI = fileURI;
+    }
+    return result;
+}
+function mergeDocumentSegment(prev, curr) {
+    if (!prev) {
+        return curr && copyDocumentSegment(curr);
+    }
+    else if (!curr) {
+        return prev && copyDocumentSegment(prev);
+    }
+    const prevEnd = prev.end ?? prev.offset + prev.length;
+    const currEnd = curr.end ?? curr.offset + curr.length;
+    const offset = Math.min(prev.offset, curr.offset);
+    const end = Math.max(prevEnd, currEnd);
+    const length = end - offset;
+    const result = {
+        offset, end, length,
+    };
+    if (prev.range && curr.range) {
+        result.range = {
+            start: curr.range.start.line < prev.range.start.line
+                || curr.range.start.line === prev.range.start.line && curr.range.start.character < prev.range.start.character
+                ? curr.range.start : prev.range.start,
+            end: curr.range.end.line > prev.range.end.line
+                || curr.range.end.line === prev.range.end.line && curr.range.end.character > prev.range.end.character
+                ? curr.range.end : prev.range.end
+        };
+    }
+    if (prev.fileURI || curr.fileURI) {
+        const prevURI = prev.fileURI;
+        const currURI = curr.fileURI;
+        const fileURI = prevURI && currURI && prevURI !== currURI ? `<unmergable text regions of ${prevURI}, ${currURI}>` : prevURI ?? currURI;
+        result.fileURI = fileURI;
+    }
+    return result;
+}
+//# sourceMappingURL=generator-tracing.js.map

frontend/node_modules/langium/lib/generate/node-processor.js

@@ -0,0 +1,258 @@
+/******************************************************************************
+ * Copyright 2021 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+import { CompositeGeneratorNode, IndentNode, NewLineNode } from './generator-node.js';
+import { getSourceRegion } from './generator-tracing.js';
+class Context {
+    constructor(defaultIndent) {
+        this.defaultIndentation = '    ';
+        this.pendingIndent = true;
+        this.currentIndents = [];
+        this.recentNonImmediateIndents = [];
+        this.traceData = [];
+        this.lines = [[]];
+        this.length = 0;
+        if (typeof defaultIndent === 'string') {
+            this.defaultIndentation = defaultIndent;
+        }
+        else if (typeof defaultIndent === 'number') {
+            this.defaultIndentation = ''.padStart(defaultIndent);
+        }
+    }
+    get content() {
+        return this.lines.map(e => e.join('')).join('');
+    }
+    get contentLength() {
+        return this.length;
+    }
+    get currentLineNumber() {
+        return this.lines.length - 1;
+    }
+    get currentLineContent() {
+        return this.lines[this.currentLineNumber].join('');
+    }
+    get currentPosition() {
+        return {
+            offset: this.contentLength,
+            line: this.currentLineNumber,
+            character: this.currentLineContent.length
+        };
+    }
+    append(value, isIndent) {
+        if (value.length > 0) {
+            const beforePos = isIndent && this.currentPosition;
+            this.lines[this.currentLineNumber].push(value);
+            this.length += value.length;
+            if (beforePos) {
+                this.indentPendingTraceRegions(beforePos);
+            }
+        }
+    }
+    indentPendingTraceRegions(before) {
+        for (let i = this.traceData.length - 1; i >= 0; i--) {
+            const tr = this.traceData[i];
+            if (tr.targetStart && tr.targetStart.offset === before.offset /* tr.targetStart.line == before.line && tr.targetStart.character === before.character*/)
+                tr.targetStart = this.currentPosition;
+        }
+    }
+    increaseIndent(node) {
+        this.currentIndents.push(node);
+        if (!node.indentImmediately) {
+            this.recentNonImmediateIndents.push(node);
+        }
+    }
+    decreaseIndent() {
+        this.currentIndents.pop();
+    }
+    get relevantIndents() {
+        return this.currentIndents.filter(i => !this.recentNonImmediateIndents.includes(i));
+    }
+    resetCurrentLine() {
+        this.length -= this.lines[this.currentLineNumber].join('').length;
+        this.lines[this.currentLineNumber] = [];
+        this.pendingIndent = true;
+        this.recentNonImmediateIndents.length = 0;
+    }
+    addNewLine() {
+        this.lines.push([]);
+        this.pendingIndent = true;
+        this.recentNonImmediateIndents.length = 0;
+    }
+    pushTraceRegion(sourceRegion) {
+        const region = createTraceRegion(sourceRegion, this.currentPosition, it => this.traceData[this.traceData.length - 1]?.children?.push(it));
+        this.traceData.push(region);
+        return region;
+    }
+    popTraceRegion(expected) {
+        const traceRegion = this.traceData.pop();
+        // the following assertion can be dropped once the tracing is considered stable
+        this.assertTrue(traceRegion === expected, 'Trace region mismatch!');
+        return traceRegion;
+    }
+    getParentTraceSourceFileURI() {
+        for (let i = this.traceData.length - 1; i > -1; i--) {
+            const fileUri = this.traceData[i].sourceRegion?.fileURI;
+            if (fileUri)
+                return fileUri;
+        }
+        return undefined;
+    }
+    assertTrue(condition, msg) {
+        if (!condition) {
+            throw new Error(msg);
+        }
+    }
+}
+function createTraceRegion(sourceRegion, targetStart, accept) {
+    const result = {
+        sourceRegion,
+        targetRegion: undefined,
+        children: [],
+        targetStart,
+        complete: (targetEnd) => {
+            result.targetRegion = {
+                offset: result.targetStart.offset,
+                end: targetEnd.offset,
+                length: targetEnd.offset - result.targetStart.offset,
+                range: {
+                    start: {
+                        line: result.targetStart.line,
+                        character: result.targetStart.character
+                    },
+                    end: {
+                        line: targetEnd.line,
+                        character: targetEnd.character
+                    },
+                }
+            };
+            delete result.targetStart;
+            if (result.children?.length === 0) {
+                delete result.children;
+            }
+            if (result.targetRegion?.length) {
+                accept(result);
+            }
+            delete result.complete;
+            return result;
+        }
+    };
+    return result;
+}
+export function processGeneratorNode(node, defaultIndentation) {
+    const context = new Context(defaultIndentation);
+    const trace = context.pushTraceRegion(undefined);
+    processNodeInternal(node, context);
+    context.popTraceRegion(trace);
+    trace.complete && trace.complete(context.currentPosition);
+    const singleChild = trace.children && trace.children.length === 1 ? trace.children[0] : undefined;
+    const singleChildTargetRegion = singleChild?.targetRegion;
+    const rootTargetRegion = trace.targetRegion;
+    if (singleChildTargetRegion && singleChild.sourceRegion
+        && singleChildTargetRegion.offset === rootTargetRegion.offset
+        && singleChildTargetRegion.length === rootTargetRegion.length) {
+        // some optimization:
+        // if (the root) `node` is traced (`singleChild.sourceRegion` !== undefined) and spans the entire `context.content`
+        //  we skip the wrapping root trace object created above at the beginning of this method
+        return { text: context.content, trace: singleChild };
+    }
+    else {
+        return { text: context.content, trace };
+    }
+}
+function processNodeInternal(node, context) {
+    if (typeof (node) === 'string') {
+        processStringNode(node, context);
+    }
+    else if (node instanceof IndentNode) {
+        processIndentNode(node, context);
+    }
+    else if (node instanceof CompositeGeneratorNode) {
+        processCompositeNode(node, context);
+    }
+    else if (node instanceof NewLineNode) {
+        processNewLineNode(node, context);
+    }
+}
+function hasContent(node, ctx) {
+    if (typeof (node) === 'string') {
+        return node.length !== 0; // cs: do not ignore ws only content here, enclosed within other nodes it will matter!
+    }
+    else if (node instanceof CompositeGeneratorNode) {
+        return node.contents.some(e => hasContent(e, ctx));
+    }
+    else if (node instanceof NewLineNode) {
+        return !(node.ifNotEmpty && ctx.currentLineContent.length === 0);
+    }
+    else {
+        return false;
+    }
+}
+function processStringNode(node, context) {
+    if (node) {
+        handlePendingIndent(context, false);
+        context.append(node);
+    }
+}
+function handlePendingIndent(ctx, endOfLine) {
+    if (ctx.pendingIndent) {
+        let indent = '';
+        for (const indentNode of ctx.relevantIndents.filter(e => e.indentEmptyLines || !endOfLine)) {
+            indent += indentNode.indentation ?? ctx.defaultIndentation;
+        }
+        ctx.append(indent, true);
+        ctx.pendingIndent = false;
+    }
+}
+function processCompositeNode(node, context) {
+    let traceRegion = undefined;
+    const sourceRegion = getSourceRegion(node.tracedSource);
+    if (sourceRegion) {
+        traceRegion = context.pushTraceRegion(sourceRegion);
+    }
+    for (const child of node.contents) {
+        processNodeInternal(child, context);
+    }
+    if (traceRegion) {
+        context.popTraceRegion(traceRegion);
+        const parentsFileURI = context.getParentTraceSourceFileURI();
+        if (parentsFileURI && sourceRegion?.fileURI === parentsFileURI) {
+            // if some parent's sourceRegion refers to the same source file uri (and no other source file was referenced inbetween)
+            // we can drop the file uri in order to reduce repeated strings
+            delete sourceRegion.fileURI;
+        }
+        traceRegion.complete && traceRegion.complete(context.currentPosition);
+    }
+}
+function processIndentNode(node, context) {
+    if (hasContent(node, context)) {
+        if (node.indentImmediately && !context.pendingIndent) {
+            context.append(node.indentation ?? context.defaultIndentation, true);
+        }
+        try {
+            context.increaseIndent(node);
+            processCompositeNode(node, context);
+        }
+        finally {
+            context.decreaseIndent();
+        }
+    }
+}
+function processNewLineNode(node, context) {
+    if (node.ifNotEmpty && !hasNonWhitespace(context.currentLineContent)) {
+        context.resetCurrentLine();
+    }
+    else {
+        handlePendingIndent(context, true);
+        let count = node.count;
+        while (count-- > 0) {
+            context.append(node.lineDelimiter);
+            context.addNewLine();
+        }
+    }
+}
+function hasNonWhitespace(text) {
+    return text.trimStart() !== '';
+}
+//# sourceMappingURL=node-processor.js.map

frontend/node_modules/langium/lib/generate/template-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-string.d.ts","sourceRoot":"","sources":["../../src/generate/template-string.ts"],"names":[],"mappings":"AAAA;;;;gFAIgF;AAKhF,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,oBAAoB,EAAE,GAAG,aAAa,EAAE,OAAO,EAAE,GAAG,MAAM,CAE3G;AAED,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,oBAAoB,EAAE,GAAG,aAAa,EAAE,OAAO,EAAE,GAAG,MAAM,CAE7G;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,oBAAoB,EAAE,GAAG,aAAa,EAAE,OAAO,EAAE,GAAG,MAAM,CAErG;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,oBAAoB,EAAE,GAAG,aAAa,EAAE,OAAO,EAAE,GAAG,MAAM,CAEvG;AAyCD,eAAO,MAAM,IAAI,QAAgD,CAAC;AAWlE,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAIvD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD"}