@windrun-huaiin/third-ui 12.1.0 → 13.0.1

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/token-builder.mjs

@@ -0,0 +1,121 @@
+import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/parser/parser.mjs';
+import { Lexer } from '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/lexer_public.mjs';
+import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/tokens_public.mjs';
+import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs';
+import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/errors_public.mjs';
+import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs';
+import { isTerminalRule, isAbstractParserRule, isKeyword } from '../languages/generated/ast.mjs';
+import { streamAllContents } from '../utils/ast-utils.mjs';
+import { getAllReachableRules, terminalRegex } from '../utils/grammar-utils.mjs';
+import { isWhitespace, escapeRegExp, partialMatches } from '../utils/regexp-utils.mjs';
+import { stream } from '../utils/stream.mjs';
+
+/******************************************************************************
+ * 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.
+ ******************************************************************************/
+class DefaultTokenBuilder {
+    constructor() {
+        /**
+         * The list of diagnostics stored during the lexing process of a single text.
+         */
+        this.diagnostics = [];
+    }
+    buildTokens(grammar, options) {
+        const reachableRules = stream(getAllReachableRules(grammar, false));
+        const terminalTokens = this.buildTerminalTokens(reachableRules);
+        const tokens = this.buildKeywordTokens(reachableRules, terminalTokens, options);
+        // Add all terminals tokens to the end in the order they were defined
+        // Chevrotain documentation recommends to add Whitespace-like tokens at the start
+        // However, assuming the lexer is able to optimize the tokens, it should not matter
+        tokens.push(...terminalTokens);
+        // We don't need to add the EOF token explicitly.
+        // It is automatically available at the end of the token stream.
+        return tokens;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    flushLexingReport(text) {
+        return { diagnostics: this.popDiagnostics() };
+    }
+    popDiagnostics() {
+        const diagnostics = [...this.diagnostics];
+        this.diagnostics = [];
+        return diagnostics;
+    }
+    buildTerminalTokens(rules) {
+        return rules.filter(isTerminalRule).filter(e => !e.fragment)
+            .map(terminal => this.buildTerminalToken(terminal)).toArray();
+    }
+    buildTerminalToken(terminal) {
+        const regex = terminalRegex(terminal);
+        const pattern = this.requiresCustomPattern(regex) ? this.regexPatternFunction(regex) : regex;
+        const tokenType = {
+            name: terminal.name,
+            PATTERN: pattern,
+        };
+        if (typeof pattern === 'function') {
+            tokenType.LINE_BREAKS = true;
+        }
+        if (terminal.hidden) {
+            // Only skip tokens that are able to accept whitespace
+            tokenType.GROUP = isWhitespace(regex) ? Lexer.SKIPPED : 'hidden';
+        }
+        return tokenType;
+    }
+    requiresCustomPattern(regex) {
+        if (regex.flags.includes('u') || regex.flags.includes('s')) {
+            // Unicode and dotall regexes are not supported by Chevrotain.
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    regexPatternFunction(regex) {
+        const stickyRegex = new RegExp(regex, regex.flags + 'y');
+        return (text, offset) => {
+            stickyRegex.lastIndex = offset;
+            const execResult = stickyRegex.exec(text);
+            return execResult;
+        };
+    }
+    buildKeywordTokens(rules, terminalTokens, options) {
+        return rules
+            // We filter by parser rules, since keywords in terminal rules get transformed into regex and are not actual tokens
+            .filter(isAbstractParserRule)
+            .flatMap(rule => streamAllContents(rule).filter(isKeyword))
+            .distinct(e => e.value).toArray()
+            // Sort keywords by descending length
+            .sort((a, b) => b.value.length - a.value.length)
+            .map(keyword => this.buildKeywordToken(keyword, terminalTokens, Boolean(options?.caseInsensitive)));
+    }
+    buildKeywordToken(keyword, terminalTokens, caseInsensitive) {
+        const keywordPattern = this.buildKeywordPattern(keyword, caseInsensitive);
+        const tokenType = {
+            name: keyword.value,
+            PATTERN: keywordPattern,
+            LONGER_ALT: this.findLongerAlt(keyword, terminalTokens)
+        };
+        if (typeof keywordPattern === 'function') {
+            tokenType.LINE_BREAKS = true;
+        }
+        return tokenType;
+    }
+    buildKeywordPattern(keyword, caseInsensitive) {
+        return caseInsensitive ?
+            new RegExp(escapeRegExp(keyword.value), 'i') :
+            keyword.value;
+    }
+    findLongerAlt(keyword, terminalTokens) {
+        return terminalTokens.reduce((longerAlts, token) => {
+            const pattern = token?.PATTERN;
+            if (pattern?.source && partialMatches('^' + pattern.source + '$', keyword.value)) {
+                longerAlts.push(token);
+            }
+            return longerAlts;
+        }, []);
+    }
+}
+
+export { DefaultTokenBuilder };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/value-converter.js

@@ -0,0 +1,102 @@
+'use strict';
+
+var ast = require('../languages/generated/ast.js');
+var grammarUtils = require('../utils/grammar-utils.js');
+
+/******************************************************************************
+ * 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.
+ ******************************************************************************/
+class DefaultValueConverter {
+    convert(input, cstNode) {
+        let feature = cstNode.grammarSource;
+        if (ast.isCrossReference(feature)) {
+            feature = grammarUtils.getCrossReferenceTerminal(feature);
+        }
+        if (ast.isRuleCall(feature)) {
+            const rule = feature.rule.ref;
+            if (!rule) {
+                throw new Error('This cst node was not parsed by a rule.');
+            }
+            return this.runConverter(rule, input, cstNode);
+        }
+        return input;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    runConverter(rule, input, cstNode) {
+        switch (rule.name.toUpperCase()) {
+            case 'INT': return exports.ValueConverter.convertInt(input);
+            case 'STRING': return exports.ValueConverter.convertString(input);
+            case 'ID': return exports.ValueConverter.convertID(input);
+        }
+        switch (grammarUtils.getRuleType(rule)?.toLowerCase()) {
+            case 'number': return exports.ValueConverter.convertNumber(input);
+            case 'boolean': return exports.ValueConverter.convertBoolean(input);
+            case 'bigint': return exports.ValueConverter.convertBigint(input);
+            case 'date': return exports.ValueConverter.convertDate(input);
+            default: return input;
+        }
+    }
+}
+exports.ValueConverter = void 0;
+(function (ValueConverter) {
+    function convertString(input) {
+        let result = '';
+        for (let i = 1; i < input.length - 1; i++) {
+            const c = input.charAt(i);
+            if (c === '\\') {
+                const c1 = input.charAt(++i);
+                result += convertEscapeCharacter(c1);
+            }
+            else {
+                result += c;
+            }
+        }
+        return result;
+    }
+    ValueConverter.convertString = convertString;
+    function convertEscapeCharacter(char) {
+        switch (char) {
+            case 'b': return '\b';
+            case 'f': return '\f';
+            case 'n': return '\n';
+            case 'r': return '\r';
+            case 't': return '\t';
+            case 'v': return '\v';
+            case '0': return '\0';
+            default: return char;
+        }
+    }
+    function convertID(input) {
+        if (input.charAt(0) === '^') {
+            return input.substring(1);
+        }
+        else {
+            return input;
+        }
+    }
+    ValueConverter.convertID = convertID;
+    function convertInt(input) {
+        return parseInt(input);
+    }
+    ValueConverter.convertInt = convertInt;
+    function convertBigint(input) {
+        return BigInt(input);
+    }
+    ValueConverter.convertBigint = convertBigint;
+    function convertDate(input) {
+        return new Date(input);
+    }
+    ValueConverter.convertDate = convertDate;
+    function convertNumber(input) {
+        return Number(input);
+    }
+    ValueConverter.convertNumber = convertNumber;
+    function convertBoolean(input) {
+        return input.toLowerCase() === 'true';
+    }
+    ValueConverter.convertBoolean = convertBoolean;
+})(exports.ValueConverter || (exports.ValueConverter = {}));
+
+exports.DefaultValueConverter = DefaultValueConverter;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/value-converter.mjs

@@ -0,0 +1,100 @@
+import { isCrossReference, isRuleCall } from '../languages/generated/ast.mjs';
+import { getCrossReferenceTerminal, getRuleType } from '../utils/grammar-utils.mjs';
+
+/******************************************************************************
+ * 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.
+ ******************************************************************************/
+class DefaultValueConverter {
+    convert(input, cstNode) {
+        let feature = cstNode.grammarSource;
+        if (isCrossReference(feature)) {
+            feature = getCrossReferenceTerminal(feature);
+        }
+        if (isRuleCall(feature)) {
+            const rule = feature.rule.ref;
+            if (!rule) {
+                throw new Error('This cst node was not parsed by a rule.');
+            }
+            return this.runConverter(rule, input, cstNode);
+        }
+        return input;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    runConverter(rule, input, cstNode) {
+        switch (rule.name.toUpperCase()) {
+            case 'INT': return ValueConverter.convertInt(input);
+            case 'STRING': return ValueConverter.convertString(input);
+            case 'ID': return ValueConverter.convertID(input);
+        }
+        switch (getRuleType(rule)?.toLowerCase()) {
+            case 'number': return ValueConverter.convertNumber(input);
+            case 'boolean': return ValueConverter.convertBoolean(input);
+            case 'bigint': return ValueConverter.convertBigint(input);
+            case 'date': return ValueConverter.convertDate(input);
+            default: return input;
+        }
+    }
+}
+var ValueConverter;
+(function (ValueConverter) {
+    function convertString(input) {
+        let result = '';
+        for (let i = 1; i < input.length - 1; i++) {
+            const c = input.charAt(i);
+            if (c === '\\') {
+                const c1 = input.charAt(++i);
+                result += convertEscapeCharacter(c1);
+            }
+            else {
+                result += c;
+            }
+        }
+        return result;
+    }
+    ValueConverter.convertString = convertString;
+    function convertEscapeCharacter(char) {
+        switch (char) {
+            case 'b': return '\b';
+            case 'f': return '\f';
+            case 'n': return '\n';
+            case 'r': return '\r';
+            case 't': return '\t';
+            case 'v': return '\v';
+            case '0': return '\0';
+            default: return char;
+        }
+    }
+    function convertID(input) {
+        if (input.charAt(0) === '^') {
+            return input.substring(1);
+        }
+        else {
+            return input;
+        }
+    }
+    ValueConverter.convertID = convertID;
+    function convertInt(input) {
+        return parseInt(input);
+    }
+    ValueConverter.convertInt = convertInt;
+    function convertBigint(input) {
+        return BigInt(input);
+    }
+    ValueConverter.convertBigint = convertBigint;
+    function convertDate(input) {
+        return new Date(input);
+    }
+    ValueConverter.convertDate = convertDate;
+    function convertNumber(input) {
+        return Number(input);
+    }
+    ValueConverter.convertNumber = convertNumber;
+    function convertBoolean(input) {
+        return input.toLowerCase() === 'true';
+    }
+    ValueConverter.convertBoolean = convertBoolean;
+})(ValueConverter || (ValueConverter = {}));
+
+export { DefaultValueConverter, ValueConverter };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/references/linker.js

@@ -0,0 +1,290 @@
+'use strict';
+
+var syntaxTree = require('../syntax-tree.js');
+var astUtils = require('../utils/ast-utils.js');
+var promiseUtils = require('../utils/promise-utils.js');
+var documents = require('../workspace/documents.js');
+var cancellation = require('../../../../../../../_virtual/cancellation.js');
+
+/******************************************************************************
+ * 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.
+ ******************************************************************************/
+const RefResolving = Symbol('RefResolving');
+class DefaultLinker {
+    constructor(services) {
+        this.reflection = services.shared.AstReflection;
+        this.langiumDocuments = () => services.shared.workspace.LangiumDocuments;
+        this.scopeProvider = services.references.ScopeProvider;
+        this.astNodeLocator = services.workspace.AstNodeLocator;
+        this.profiler = services.shared.profilers.LangiumProfiler;
+        this.languageId = services.LanguageMetaData.languageId;
+    }
+    async link(document, cancelToken = cancellation.cancellationExports.CancellationToken.None) {
+        if (this.profiler?.isActive('linking')) {
+            const task = this.profiler.createTask('linking', this.languageId);
+            task.start();
+            try {
+                for (const node of astUtils.streamAst(document.parseResult.value)) {
+                    await promiseUtils.interruptAndCheck(cancelToken);
+                    astUtils.streamReferences(node).forEach(ref => {
+                        const name = `${node.$type}:${ref.property}`;
+                        task.startSubTask(name);
+                        try {
+                            this.doLink(ref, document);
+                        }
+                        finally {
+                            task.stopSubTask(name);
+                        }
+                    });
+                }
+            }
+            finally {
+                task.stop();
+            }
+        }
+        else {
+            for (const node of astUtils.streamAst(document.parseResult.value)) {
+                await promiseUtils.interruptAndCheck(cancelToken);
+                astUtils.streamReferences(node).forEach(ref => this.doLink(ref, document));
+            }
+        }
+    }
+    doLink(refInfo, document) {
+        const ref = refInfo.reference;
+        // The reference may already have been resolved lazily by accessing its `ref` property.
+        if ('_ref' in ref && ref._ref === undefined) {
+            ref._ref = RefResolving;
+            try {
+                const description = this.getCandidate(refInfo);
+                if (syntaxTree.isLinkingError(description)) {
+                    ref._ref = description;
+                }
+                else {
+                    ref._nodeDescription = description;
+                    const linkedNode = this.loadAstNode(description);
+                    ref._ref = linkedNode ?? this.createLinkingError(refInfo, description);
+                }
+            }
+            catch (err) {
+                console.error(`An error occurred while resolving reference to '${ref.$refText}':`, err);
+                const errorMessage = err.message ?? String(err);
+                ref._ref = {
+                    info: refInfo,
+                    message: `An error occurred while resolving reference to '${ref.$refText}': ${errorMessage}`
+                };
+            }
+            document.references.push(ref);
+        }
+        else if ('_items' in ref && ref._items === undefined) {
+            ref._items = RefResolving;
+            try {
+                const descriptions = this.getCandidates(refInfo);
+                const items = [];
+                if (syntaxTree.isLinkingError(descriptions)) {
+                    ref._linkingError = descriptions;
+                }
+                else {
+                    for (const description of descriptions) {
+                        const linkedNode = this.loadAstNode(description);
+                        if (linkedNode) {
+                            items.push({ ref: linkedNode, $nodeDescription: description });
+                        }
+                    }
+                }
+                ref._items = items;
+            }
+            catch (err) {
+                ref._linkingError = {
+                    info: refInfo,
+                    message: `An error occurred while resolving reference to '${ref.$refText}': ${err}`
+                };
+                ref._items = [];
+            }
+            document.references.push(ref);
+        }
+    }
+    unlink(document) {
+        for (const ref of document.references) {
+            if ('_ref' in ref) {
+                ref._ref = undefined;
+                delete ref._nodeDescription;
+            }
+            else if ('_items' in ref) {
+                ref._items = undefined;
+                delete ref._linkingError;
+            }
+        }
+        document.references = [];
+    }
+    getCandidate(refInfo) {
+        const scope = this.scopeProvider.getScope(refInfo);
+        const description = scope.getElement(refInfo.reference.$refText);
+        return description ?? this.createLinkingError(refInfo);
+    }
+    getCandidates(refInfo) {
+        const scope = this.scopeProvider.getScope(refInfo);
+        const descriptions = scope.getElements(refInfo.reference.$refText).distinct(desc => `${desc.documentUri}#${desc.path}`).toArray();
+        return descriptions.length > 0 ? descriptions : this.createLinkingError(refInfo);
+    }
+    buildReference(node, property, refNode, refText) {
+        // See behavior description in doc of Linker, update that on changes in here.
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const linker = this;
+        const reference = {
+            $refNode: refNode,
+            $refText: refText,
+            _ref: undefined,
+            get ref() {
+                if (syntaxTree.isAstNode(this._ref)) {
+                    // Most frequent case: the target is already resolved.
+                    return this._ref;
+                }
+                else if (syntaxTree.isAstNodeDescription(this._nodeDescription)) {
+                    // A candidate has been found before, but it is not loaded yet.
+                    const linkedNode = linker.loadAstNode(this._nodeDescription);
+                    this._ref = linkedNode ??
+                        linker.createLinkingError({ reference, container: node, property }, this._nodeDescription);
+                }
+                else if (this._ref === undefined) {
+                    // The reference has not been linked yet, so do that now.
+                    this._ref = RefResolving;
+                    const document = astUtils.findRootNode(node).$document;
+                    const refData = linker.getLinkedNode({ reference, container: node, property });
+                    if (refData.error && document && document.state < documents.DocumentState.ComputedScopes) {
+                        // Document scope is not ready, don't set `this._ref` so linker can retry later.
+                        return this._ref = undefined;
+                    }
+                    this._ref = refData.node ?? refData.error;
+                    this._nodeDescription = refData.descr;
+                    document?.references.push(this);
+                }
+                else if (this._ref === RefResolving) {
+                    linker.throwCyclicReferenceError(node, property, refText);
+                }
+                return syntaxTree.isAstNode(this._ref) ? this._ref : undefined;
+            },
+            get $nodeDescription() {
+                return this._nodeDescription;
+            },
+            get error() {
+                return syntaxTree.isLinkingError(this._ref) ? this._ref : undefined;
+            }
+        };
+        return reference;
+    }
+    buildMultiReference(node, property, refNode, refText) {
+        // See behavior description in doc of Linker, update that on changes in here.
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const linker = this;
+        const reference = {
+            $refNode: refNode,
+            $refText: refText,
+            _items: undefined,
+            get items() {
+                if (Array.isArray(this._items)) {
+                    return this._items;
+                }
+                else if (this._items === undefined) {
+                    this._items = RefResolving;
+                    const document = astUtils.findRootNode(node).$document;
+                    const descriptions = linker.getCandidates({
+                        reference,
+                        container: node,
+                        property
+                    });
+                    const items = [];
+                    if (syntaxTree.isLinkingError(descriptions)) {
+                        this._linkingError = descriptions;
+                    }
+                    else {
+                        for (const description of descriptions) {
+                            const linkedNode = linker.loadAstNode(description);
+                            if (linkedNode) {
+                                items.push({ ref: linkedNode, $nodeDescription: description });
+                            }
+                        }
+                    }
+                    this._items = items;
+                    document?.references.push(this);
+                }
+                else if (this._items === RefResolving) {
+                    linker.throwCyclicReferenceError(node, property, refText);
+                }
+                return Array.isArray(this._items) ? this._items : [];
+            },
+            get error() {
+                if (this._linkingError) {
+                    return this._linkingError;
+                }
+                const refs = this.items;
+                if (refs.length > 0) {
+                    return undefined;
+                }
+                else {
+                    return (this._linkingError = linker.createLinkingError({ reference, container: node, property }));
+                }
+            }
+        };
+        return reference;
+    }
+    throwCyclicReferenceError(node, property, refText) {
+        throw new Error(`Cyclic reference resolution detected: ${this.astNodeLocator.getAstNodePath(node)}/${property} (symbol '${refText}')`);
+    }
+    getLinkedNode(refInfo) {
+        try {
+            const description = this.getCandidate(refInfo);
+            if (syntaxTree.isLinkingError(description)) {
+                return { error: description };
+            }
+            const linkedNode = this.loadAstNode(description);
+            if (linkedNode) {
+                return { node: linkedNode, descr: description };
+            }
+            else {
+                return {
+                    descr: description,
+                    error: this.createLinkingError(refInfo, description)
+                };
+            }
+        }
+        catch (err) {
+            console.error(`An error occurred while resolving reference to '${refInfo.reference.$refText}':`, err);
+            const errorMessage = err.message ?? String(err);
+            return {
+                error: {
+                    info: refInfo,
+                    message: `An error occurred while resolving reference to '${refInfo.reference.$refText}': ${errorMessage}`
+                }
+            };
+        }
+    }
+    loadAstNode(nodeDescription) {
+        if (nodeDescription.node) {
+            return nodeDescription.node;
+        }
+        const doc = this.langiumDocuments().getDocument(nodeDescription.documentUri);
+        if (!doc) {
+            return undefined;
+        }
+        return this.astNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);
+    }
+    createLinkingError(refInfo, targetDescription) {
+        // Check whether the document is sufficiently processed by the DocumentBuilder. If not, this is a hint for a bug
+        // in the language implementation.
+        const document = astUtils.findRootNode(refInfo.container).$document;
+        if (document && document.state < documents.DocumentState.ComputedScopes) {
+            console.warn(`Attempted reference resolution before document reached ComputedScopes state (${document.uri}).`);
+        }
+        const referenceType = this.reflection.getReferenceType(refInfo);
+        return {
+            info: refInfo,
+            message: `Could not resolve reference to ${referenceType} named '${refInfo.reference.$refText}'.`,
+            targetDescription
+        };
+    }
+}
+
+exports.DefaultLinker = DefaultLinker;
+exports.RefResolving = RefResolving;