@windrun-huaiin/third-ui 12.0.3 → 13.0.0

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/uri-utils.mjs

@@ -0,0 +1,189 @@
+import { URI, Utils } from '../../../../../vscode-uri@3.1.0/node_modules/vscode-uri/lib/esm/index.mjs';
+
+/******************************************************************************
+ * Copyright 2022 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.
+ ******************************************************************************/
+var UriUtils;
+(function (UriUtils) {
+    UriUtils.basename = Utils.basename;
+    UriUtils.dirname = Utils.dirname;
+    UriUtils.extname = Utils.extname;
+    UriUtils.joinPath = Utils.joinPath;
+    UriUtils.resolvePath = Utils.resolvePath;
+    const isWindows = typeof process === 'object' && process?.platform === 'win32';
+    function equals(a, b) {
+        return a?.toString() === b?.toString();
+    }
+    UriUtils.equals = equals;
+    function relative(from, to) {
+        const fromPath = typeof from === 'string' ? URI.parse(from).path : from.path;
+        const toPath = typeof to === 'string' ? URI.parse(to).path : to.path;
+        const fromParts = fromPath.split('/').filter(e => e.length > 0);
+        const toParts = toPath.split('/').filter(e => e.length > 0);
+        if (isWindows) {
+            const upperCaseDriveLetter = /^[A-Z]:$/;
+            if (fromParts[0] && upperCaseDriveLetter.test(fromParts[0])) {
+                fromParts[0] = fromParts[0].toLowerCase();
+            }
+            if (toParts[0] && upperCaseDriveLetter.test(toParts[0])) {
+                toParts[0] = toParts[0].toLowerCase();
+            }
+            if (fromParts[0] !== toParts[0]) {
+                // in case of different drive letters, we cannot compute a relative path, so...
+                return toPath.substring(1); // fall back to full 'to' path, drop the leading '/', keep everything else as is for good comparability
+            }
+        }
+        let i = 0;
+        for (; i < fromParts.length; i++) {
+            if (fromParts[i] !== toParts[i]) {
+                break;
+            }
+        }
+        const backPart = '../'.repeat(fromParts.length - i);
+        const toPart = toParts.slice(i).join('/');
+        return backPart + toPart;
+    }
+    UriUtils.relative = relative;
+    function normalize(uri) {
+        return URI.parse(uri.toString()).toString();
+    }
+    UriUtils.normalize = normalize;
+    function contains(parent, child) {
+        let parentPath = typeof parent === 'string' ? parent : parent.path;
+        let childPath = typeof child === 'string' ? child : child.path;
+        // Trim trailing slashes
+        if (childPath.charAt(childPath.length - 1) === '/') {
+            childPath = childPath.slice(0, -1);
+        }
+        if (parentPath.charAt(parentPath.length - 1) === '/') {
+            parentPath = parentPath.slice(0, -1);
+        }
+        // If the paths are equal, simply return true
+        if (childPath === parentPath) {
+            return true;
+        }
+        // If the child path is shorter than the parent path, it can't be a child
+        if (childPath.length < parentPath.length) {
+            return false;
+        }
+        // If the path does not feature a slash after the parent path, it can't be a child
+        if (childPath.charAt(parentPath.length) !== '/') {
+            return false;
+        }
+        // Check if the child path starts with the parent path
+        return childPath.startsWith(parentPath);
+    }
+    UriUtils.contains = contains;
+})(UriUtils || (UriUtils = {}));
+/**
+ * A trie structure for URIs. It allows to insert, delete and find elements by their URI.
+ * More specifically, it allows to efficiently find all elements that are children of a given URI.
+ *
+ * Unlike a regular trie, this implementation uses the name of the URI segments as keys.
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Trie}
+ */
+class UriTrie {
+    constructor() {
+        this.root = { name: '', children: new Map() };
+    }
+    normalizeUri(uri) {
+        return UriUtils.normalize(uri);
+    }
+    clear() {
+        this.root.children.clear();
+    }
+    insert(uri, element) {
+        const node = this.getNode(this.normalizeUri(uri), true);
+        node.element = element;
+    }
+    delete(uri) {
+        const nodeToDelete = this.getNode(this.normalizeUri(uri), false);
+        if (nodeToDelete?.parent) {
+            nodeToDelete.parent.children.delete(nodeToDelete.name);
+        }
+    }
+    has(uri) {
+        return this.getNode(this.normalizeUri(uri), false)?.element !== undefined;
+    }
+    hasNode(uri) {
+        return this.getNode(this.normalizeUri(uri), false) !== undefined;
+    }
+    find(uri) {
+        return this.getNode(this.normalizeUri(uri), false)?.element;
+    }
+    findNode(uri) {
+        const uriString = this.normalizeUri(uri);
+        const node = this.getNode(uriString, false);
+        if (!node) {
+            return undefined;
+        }
+        return {
+            name: node.name,
+            uri: UriUtils.joinPath(URI.parse(uriString), node.name).toString(),
+            element: node.element
+        };
+    }
+    findChildren(uri) {
+        const uriString = this.normalizeUri(uri);
+        const node = this.getNode(uriString, false);
+        if (!node) {
+            return [];
+        }
+        return Array.from(node.children.values()).map(child => ({
+            name: child.name,
+            uri: UriUtils.joinPath(URI.parse(uriString), child.name).toString(),
+            element: child.element
+        }));
+    }
+    all() {
+        return this.collectValues(this.root);
+    }
+    findAll(prefix) {
+        const node = this.getNode(UriUtils.normalize(prefix), false);
+        if (!node) {
+            return [];
+        }
+        return this.collectValues(node);
+    }
+    getNode(uri, create) {
+        const parts = uri.split('/');
+        if (uri.charAt(uri.length - 1) === '/') {
+            // Remove the last part if the URI ends with a slash
+            parts.pop();
+        }
+        let current = this.root;
+        for (const part of parts) {
+            let child = current.children.get(part);
+            if (!child) {
+                if (create) {
+                    child = {
+                        name: part,
+                        children: new Map(),
+                        parent: current
+                    };
+                    current.children.set(part, child);
+                }
+                else {
+                    return undefined;
+                }
+            }
+            current = child;
+        }
+        return current;
+    }
+    collectValues(node) {
+        const result = [];
+        if (node.element) {
+            result.push(node.element);
+        }
+        for (const child of node.children.values()) {
+            result.push(...this.collectValues(child));
+        }
+        return result;
+    }
+}
+
+export { URI, UriTrie, UriUtils };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/validation/document-validator.js

@@ -0,0 +1,296 @@
+'use strict';
+
+var grammarUtils = require('../utils/grammar-utils.js');
+var astUtils = require('../utils/ast-utils.js');
+var cstUtils = require('../utils/cst-utils.js');
+var promiseUtils = require('../utils/promise-utils.js');
+var validationRegistry = require('./validation-registry.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 VALIDATE_EACH_NODE = Object.freeze({
+    validateNode: true,
+    validateChildren: true,
+});
+class DefaultDocumentValidator {
+    constructor(services) {
+        this.validationRegistry = services.validation.ValidationRegistry;
+        this.metadata = services.LanguageMetaData;
+        this.profiler = services.shared.profilers.LangiumProfiler;
+        this.languageId = services.LanguageMetaData.languageId;
+    }
+    async validateDocument(document, options = {}, cancelToken = cancellation.cancellationExports.CancellationToken.None) {
+        const parseResult = document.parseResult;
+        const diagnostics = [];
+        await promiseUtils.interruptAndCheck(cancelToken);
+        if (!options.categories || options.categories.includes('built-in')) {
+            this.processLexingErrors(parseResult, diagnostics, options);
+            if (options.stopAfterLexingErrors && diagnostics.some(d => d.data?.code === exports.DocumentValidator.LexingError)) {
+                return diagnostics;
+            }
+            this.processParsingErrors(parseResult, diagnostics, options);
+            if (options.stopAfterParsingErrors && diagnostics.some(d => d.data?.code === exports.DocumentValidator.ParsingError)) {
+                return diagnostics;
+            }
+            this.processLinkingErrors(document, diagnostics, options);
+            if (options.stopAfterLinkingErrors && diagnostics.some(d => d.data?.code === exports.DocumentValidator.LinkingError)) {
+                return diagnostics;
+            }
+        }
+        // Process custom validations
+        try {
+            diagnostics.push(...await this.validateAst(parseResult.value, options, cancelToken));
+        }
+        catch (err) {
+            if (promiseUtils.isOperationCancelled(err)) {
+                throw err;
+            }
+            console.error('An error occurred during validation:', err);
+        }
+        await promiseUtils.interruptAndCheck(cancelToken);
+        return diagnostics;
+    }
+    processLexingErrors(parseResult, diagnostics, _options) {
+        const lexerDiagnostics = [...parseResult.lexerErrors, ...parseResult.lexerReport?.diagnostics ?? []];
+        for (const lexerDiagnostic of lexerDiagnostics) {
+            const severity = lexerDiagnostic.severity ?? 'error';
+            const diagnostic = {
+                severity: toDiagnosticSeverity(severity),
+                range: {
+                    start: {
+                        line: lexerDiagnostic.line - 1,
+                        character: lexerDiagnostic.column - 1
+                    },
+                    end: {
+                        line: lexerDiagnostic.line - 1,
+                        character: lexerDiagnostic.column + lexerDiagnostic.length - 1
+                    }
+                },
+                message: lexerDiagnostic.message,
+                data: toDiagnosticData(severity),
+                source: this.getSource()
+            };
+            diagnostics.push(diagnostic);
+        }
+    }
+    processParsingErrors(parseResult, diagnostics, _options) {
+        for (const parserError of parseResult.parserErrors) {
+            let range = undefined;
+            // We can run into the chevrotain error recovery here
+            // The token contained in the parser error might be automatically inserted
+            // In this case every position value will be `NaN`
+            if (isNaN(parserError.token.startOffset)) {
+                // Some special parser error types contain a `previousToken`
+                // We can simply append our diagnostic to that token
+                if ('previousToken' in parserError) {
+                    const token = parserError.previousToken;
+                    if (!isNaN(token.startOffset)) {
+                        const position = { line: token.endLine - 1, character: token.endColumn };
+                        range = { start: position, end: position };
+                    }
+                    else {
+                        // No valid prev token. Might be empty document or containing only hidden tokens.
+                        // Point to document start
+                        const position = { line: 0, character: 0 };
+                        range = { start: position, end: position };
+                    }
+                }
+            }
+            else {
+                range = cstUtils.tokenToRange(parserError.token);
+            }
+            if (range) {
+                const diagnostic = {
+                    severity: toDiagnosticSeverity('error'),
+                    range,
+                    message: parserError.message,
+                    data: validationRegistry.diagnosticData(exports.DocumentValidator.ParsingError),
+                    source: this.getSource()
+                };
+                diagnostics.push(diagnostic);
+            }
+        }
+    }
+    processLinkingErrors(document, diagnostics, _options) {
+        for (const reference of document.references) {
+            const linkingError = reference.error;
+            if (linkingError) {
+                const info = {
+                    node: linkingError.info.container,
+                    range: reference.$refNode?.range,
+                    property: linkingError.info.property,
+                    index: linkingError.info.index,
+                    data: {
+                        code: exports.DocumentValidator.LinkingError,
+                        containerType: linkingError.info.container.$type,
+                        property: linkingError.info.property,
+                        refText: linkingError.info.reference.$refText
+                    }
+                };
+                diagnostics.push(this.toDiagnostic('error', linkingError.message, info));
+            }
+        }
+    }
+    async validateAst(rootNode, options, cancelToken = cancellation.cancellationExports.CancellationToken.None) {
+        const validationItems = [];
+        const acceptor = (severity, message, info) => {
+            validationItems.push(this.toDiagnostic(severity, message, info));
+        };
+        await this.validateAstBefore(rootNode, options, acceptor, cancelToken);
+        await this.validateAstNodes(rootNode, options, acceptor, cancelToken);
+        await this.validateAstAfter(rootNode, options, acceptor, cancelToken);
+        return validationItems;
+    }
+    async validateAstBefore(rootNode, options, acceptor, cancelToken = cancellation.cancellationExports.CancellationToken.None) {
+        const checksBefore = this.validationRegistry.checksBefore;
+        for (const checkBefore of checksBefore) {
+            await promiseUtils.interruptAndCheck(cancelToken);
+            await checkBefore(rootNode, acceptor, options.categories ?? [], cancelToken);
+        }
+    }
+    async validateAstNodes(rootNode, options, acceptor, cancelToken = cancellation.cancellationExports.CancellationToken.None) {
+        if (this.profiler?.isActive('validating')) {
+            const task = this.profiler.createTask('validating', this.languageId);
+            task.start();
+            try {
+                const nodes = astUtils.streamAst(rootNode).iterator();
+                for (const node of nodes) {
+                    task.startSubTask(node.$type);
+                    const nodeOptions = this.validateSingleNodeOptions(node, options);
+                    if (nodeOptions.validateNode) {
+                        try {
+                            const checks = this.validationRegistry.getChecks(node.$type, options.categories);
+                            for (const check of checks) {
+                                await check(node, acceptor, cancelToken);
+                            }
+                        }
+                        finally {
+                            task.stopSubTask(node.$type);
+                        }
+                    }
+                    if (!nodeOptions.validateChildren) {
+                        nodes.prune();
+                    }
+                }
+            }
+            finally {
+                task.stop();
+            }
+        }
+        else {
+            const nodes = astUtils.streamAst(rootNode).iterator();
+            for (const node of nodes) {
+                await promiseUtils.interruptAndCheck(cancelToken);
+                const nodeOptions = this.validateSingleNodeOptions(node, options);
+                if (nodeOptions.validateNode) {
+                    const checks = this.validationRegistry.getChecks(node.$type, options.categories);
+                    for (const check of checks) {
+                        await check(node, acceptor, cancelToken);
+                    }
+                }
+                if (!nodeOptions.validateChildren) {
+                    nodes.prune();
+                }
+            }
+        }
+    }
+    validateSingleNodeOptions(_node, _options) {
+        return VALIDATE_EACH_NODE;
+    }
+    async validateAstAfter(rootNode, options, acceptor, cancelToken = cancellation.cancellationExports.CancellationToken.None) {
+        const checksAfter = this.validationRegistry.checksAfter;
+        for (const checkAfter of checksAfter) {
+            await promiseUtils.interruptAndCheck(cancelToken);
+            await checkAfter(rootNode, acceptor, options.categories ?? [], cancelToken);
+        }
+    }
+    toDiagnostic(severity, message, info) {
+        return {
+            message,
+            range: getDiagnosticRange(info),
+            severity: toDiagnosticSeverity(severity),
+            code: info.code,
+            codeDescription: info.codeDescription,
+            tags: info.tags,
+            relatedInformation: info.relatedInformation,
+            data: info.data,
+            source: this.getSource()
+        };
+    }
+    getSource() {
+        return this.metadata.languageId;
+    }
+}
+function getDiagnosticRange(info) {
+    if (info.range) {
+        return info.range;
+    }
+    let cstNode;
+    if (typeof info.property === 'string') {
+        cstNode = grammarUtils.findNodeForProperty(info.node.$cstNode, info.property, info.index);
+    }
+    else if (typeof info.keyword === 'string') {
+        cstNode = grammarUtils.findNodeForKeyword(info.node.$cstNode, info.keyword, info.index);
+    }
+    cstNode ?? (cstNode = info.node.$cstNode);
+    if (!cstNode) {
+        return {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: 0 }
+        };
+    }
+    return cstNode.range;
+}
+/**
+ * Transforms the diagnostic severity from the {@link LexingDiagnosticSeverity} format to LSP's `DiagnosticSeverity` format.
+ *
+ * @param severity The lexing diagnostic severity
+ * @returns Diagnostic severity according to `vscode-languageserver-types/lib/esm/main.js#DiagnosticSeverity`
+ */
+function toDiagnosticSeverity(severity) {
+    switch (severity) {
+        case 'error':
+            return 1;
+        case 'warning':
+            return 2;
+        case 'info':
+            return 3;
+        case 'hint':
+            return 4;
+        default:
+            throw new Error('Invalid diagnostic severity: ' + severity);
+    }
+}
+function toDiagnosticData(severity) {
+    switch (severity) {
+        case 'error':
+            return validationRegistry.diagnosticData(exports.DocumentValidator.LexingError);
+        case 'warning':
+            return validationRegistry.diagnosticData(exports.DocumentValidator.LexingWarning);
+        case 'info':
+            return validationRegistry.diagnosticData(exports.DocumentValidator.LexingInfo);
+        case 'hint':
+            return validationRegistry.diagnosticData(exports.DocumentValidator.LexingHint);
+        default:
+            throw new Error('Invalid diagnostic severity: ' + severity);
+    }
+}
+exports.DocumentValidator = void 0;
+(function (DocumentValidator) {
+    DocumentValidator.LexingError = 'lexing-error';
+    DocumentValidator.LexingWarning = 'lexing-warning';
+    DocumentValidator.LexingInfo = 'lexing-info';
+    DocumentValidator.LexingHint = 'lexing-hint';
+    DocumentValidator.ParsingError = 'parsing-error';
+    DocumentValidator.LinkingError = 'linking-error';
+})(exports.DocumentValidator || (exports.DocumentValidator = {}));
+
+exports.DefaultDocumentValidator = DefaultDocumentValidator;
+exports.VALIDATE_EACH_NODE = VALIDATE_EACH_NODE;
+exports.getDiagnosticRange = getDiagnosticRange;
+exports.toDiagnosticData = toDiagnosticData;
+exports.toDiagnosticSeverity = toDiagnosticSeverity;