@windrun-huaiin/third-ui 13.1.4 → 14.0.0

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

@@ -1,290 +0,0 @@
-import { findNodeForProperty, findNodeForKeyword } from '../utils/grammar-utils.mjs';
-import { streamAst } from '../utils/ast-utils.mjs';
-import { tokenToRange } from '../utils/cst-utils.mjs';
-import { interruptAndCheck, isOperationCancelled } from '../utils/promise-utils.mjs';
-import { diagnosticData } from './validation-registry.mjs';
-import { c as cancellationExports } from '../../../../../../../_virtual/cancellation.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.
- ******************************************************************************/
-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 = cancellationExports.CancellationToken.None) {
-        const parseResult = document.parseResult;
-        const diagnostics = [];
-        await interruptAndCheck(cancelToken);
-        if (!options.categories || options.categories.includes('built-in')) {
-            this.processLexingErrors(parseResult, diagnostics, options);
-            if (options.stopAfterLexingErrors && diagnostics.some(d => d.data?.code === DocumentValidator.LexingError)) {
-                return diagnostics;
-            }
-            this.processParsingErrors(parseResult, diagnostics, options);
-            if (options.stopAfterParsingErrors && diagnostics.some(d => d.data?.code === DocumentValidator.ParsingError)) {
-                return diagnostics;
-            }
-            this.processLinkingErrors(document, diagnostics, options);
-            if (options.stopAfterLinkingErrors && diagnostics.some(d => d.data?.code === DocumentValidator.LinkingError)) {
-                return diagnostics;
-            }
-        }
-        // Process custom validations
-        try {
-            diagnostics.push(...await this.validateAst(parseResult.value, options, cancelToken));
-        }
-        catch (err) {
-            if (isOperationCancelled(err)) {
-                throw err;
-            }
-            console.error('An error occurred during validation:', err);
-        }
-        await 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 = tokenToRange(parserError.token);
-            }
-            if (range) {
-                const diagnostic = {
-                    severity: toDiagnosticSeverity('error'),
-                    range,
-                    message: parserError.message,
-                    data: diagnosticData(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: 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 = 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 = cancellationExports.CancellationToken.None) {
-        const checksBefore = this.validationRegistry.checksBefore;
-        for (const checkBefore of checksBefore) {
-            await interruptAndCheck(cancelToken);
-            await checkBefore(rootNode, acceptor, options.categories ?? [], cancelToken);
-        }
-    }
-    async validateAstNodes(rootNode, options, acceptor, cancelToken = cancellationExports.CancellationToken.None) {
-        if (this.profiler?.isActive('validating')) {
-            const task = this.profiler.createTask('validating', this.languageId);
-            task.start();
-            try {
-                const nodes = 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 = streamAst(rootNode).iterator();
-            for (const node of nodes) {
-                await 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 = cancellationExports.CancellationToken.None) {
-        const checksAfter = this.validationRegistry.checksAfter;
-        for (const checkAfter of checksAfter) {
-            await 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 = findNodeForProperty(info.node.$cstNode, info.property, info.index);
-    }
-    else if (typeof info.keyword === 'string') {
-        cstNode = 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 diagnosticData(DocumentValidator.LexingError);
-        case 'warning':
-            return diagnosticData(DocumentValidator.LexingWarning);
-        case 'info':
-            return diagnosticData(DocumentValidator.LexingInfo);
-        case 'hint':
-            return diagnosticData(DocumentValidator.LexingHint);
-        default:
-            throw new Error('Invalid diagnostic severity: ' + severity);
-    }
-}
-var DocumentValidator;
-(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';
-})(DocumentValidator || (DocumentValidator = {}));
-
-export { DefaultDocumentValidator, DocumentValidator, VALIDATE_EACH_NODE, getDiagnosticRange, toDiagnosticData, toDiagnosticSeverity };

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

@@ -1,168 +0,0 @@
-'use strict';
-
-var collections = require('../utils/collections.js');
-var promiseUtils = require('../utils/promise-utils.js');
-var stream = require('../utils/stream.js');
-var errors = require('../utils/errors.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.
- ******************************************************************************/
-/**
- * Create DiagnosticData for a given diagnostic code. The result can be put into the `data` field of a DiagnosticInfo.
- */
-function diagnosticData(code) {
-    return { code };
-}
-exports.ValidationCategory = void 0;
-(function (ValidationCategory) {
-    ValidationCategory.defaults = ['fast', 'slow', 'built-in'];
-    /**
-     * @deprecated since 4.2 Use `ValidationCategory.defaults` instead,
-     * since "all" does not include user-defined, custom validation categories.
-     */
-    ValidationCategory.all = ValidationCategory.defaults;
-})(exports.ValidationCategory || (exports.ValidationCategory = {}));
-/**
- * Manages a set of `ValidationCheck`s to be applied when documents are validated.
- */
-class ValidationRegistry {
-    constructor(services) {
-        this.entries = new collections.MultiMap();
-        this.knownCategories = new Set(exports.ValidationCategory.defaults);
-        this.entriesBefore = [];
-        this.entriesAfter = [];
-        this.reflection = services.shared.AstReflection;
-    }
-    /**
-     * Register a set of validation checks. Each value in the record can be either a single validation check (i.e. a function)
-     * or an array of validation checks.
-     *
-     * @param checksRecord Set of validation checks to register.
-     * @param thisObj Optional object to be used as `this` when calling the validation check functions.
-     * @param category Optional category for the validation checks (defaults to `'fast'`).
-     */
-    register(checksRecord, thisObj = this, category = 'fast') {
-        if (category === 'built-in') {
-            throw new Error("The 'built-in' category is reserved for lexer, parser, and linker errors.");
-        }
-        this.knownCategories.add(category); // remember custom/user-defined categories
-        for (const [type, ch] of Object.entries(checksRecord)) {
-            const callbacks = ch;
-            if (Array.isArray(callbacks)) {
-                for (const check of callbacks) {
-                    const entry = {
-                        check: this.wrapValidationException(check, thisObj),
-                        category
-                    };
-                    this.addEntry(type, entry);
-                }
-            }
-            else if (typeof callbacks === 'function') {
-                const entry = {
-                    check: this.wrapValidationException(callbacks, thisObj),
-                    category
-                };
-                this.addEntry(type, entry);
-            }
-            else {
-                errors.assertUnreachable();
-            }
-        }
-    }
-    wrapValidationException(check, thisObj) {
-        return async (node, accept, cancelToken) => {
-            await this.handleException(() => check.call(thisObj, node, accept, cancelToken), 'An error occurred during validation', accept, node);
-        };
-    }
-    async handleException(functionality, messageContext, accept, node) {
-        try {
-            await functionality();
-        }
-        catch (err) {
-            if (promiseUtils.isOperationCancelled(err)) {
-                throw err;
-            }
-            console.error(`${messageContext}:`, err);
-            if (err instanceof Error && err.stack) {
-                console.error(err.stack);
-            }
-            const messageDetails = err instanceof Error ? err.message : String(err);
-            accept('error', `${messageContext}: ${messageDetails}`, { node });
-        }
-    }
-    addEntry(type, entry) {
-        if (type === 'AstNode') {
-            this.entries.add('AstNode', entry);
-            return;
-        }
-        for (const subtype of this.reflection.getAllSubTypes(type)) {
-            this.entries.add(subtype, entry);
-        }
-    }
-    getChecks(type, categories) {
-        let checks = stream.stream(this.entries.get(type))
-            .concat(this.entries.get('AstNode'));
-        if (categories) {
-            checks = checks.filter(entry => categories.includes(entry.category));
-        }
-        return checks.map(entry => entry.check);
-    }
-    /**
-     * Register logic which will be executed once before validating all the nodes of an AST/Langium document.
-     * This helps to prepare or initialize some information which are required or reusable for the following checks on the AstNodes.
-     *
-     * As an example, for validating unique fully-qualified names of nodes in the AST,
-     * here the map for mapping names to nodes could be established.
-     * During the usual checks on the nodes, they are put into this map with their name.
-     *
-     * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
-     * Therefore it is recommended to clear stored information
-     * _before_ validating an AST to validate each AST unaffected from other ASTs
-     * AND _after_ validating the AST to free memory by information which are no longer used.
-     *
-     * @param checkBefore a set-up function which will be called once before actually validating an AST
-     * @param thisObj Optional object to be used as `this` when calling the validation check functions.
-     */
-    registerBeforeDocument(checkBefore, thisObj = this) {
-        this.entriesBefore.push(this.wrapPreparationException(checkBefore, 'An error occurred during set-up of the validation', thisObj));
-    }
-    /**
-     * Register logic which will be executed once after validating all the nodes of an AST/Langium document.
-     * This helps to finally evaluate information which are collected during the checks on the AstNodes.
-     *
-     * As an example, for validating unique fully-qualified names of nodes in the AST,
-     * here the map with all the collected nodes and their names is checked
-     * and validation hints are created for all nodes with the same name.
-     *
-     * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
-     * Therefore it is recommended to clear stored information
-     * _before_ validating an AST to validate each AST unaffected from other ASTs
-     * AND _after_ validating the AST to free memory by information which are no longer used.
-     *
-     * @param checkBefore a set-up function which will be called once before actually validating an AST
-     * @param thisObj Optional object to be used as `this` when calling the validation check functions.
-     */
-    registerAfterDocument(checkAfter, thisObj = this) {
-        this.entriesAfter.push(this.wrapPreparationException(checkAfter, 'An error occurred during tear-down of the validation', thisObj));
-    }
-    wrapPreparationException(check, messageContext, thisObj) {
-        return async (rootNode, accept, categories, cancelToken) => {
-            await this.handleException(() => check.call(thisObj, rootNode, accept, categories, cancelToken), messageContext, accept, rootNode);
-        };
-    }
-    get checksBefore() {
-        return this.entriesBefore;
-    }
-    get checksAfter() {
-        return this.entriesAfter;
-    }
-    getAllValidationCategories(_document) {
-        return this.knownCategories;
-    }
-}
-
-exports.ValidationRegistry = ValidationRegistry;
-exports.diagnosticData = diagnosticData;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/validation/validation-registry.mjs

@@ -1,165 +0,0 @@
-import { MultiMap } from '../utils/collections.mjs';
-import { isOperationCancelled } from '../utils/promise-utils.mjs';
-import { stream } from '../utils/stream.mjs';
-import { assertUnreachable } from '../utils/errors.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.
- ******************************************************************************/
-/**
- * Create DiagnosticData for a given diagnostic code. The result can be put into the `data` field of a DiagnosticInfo.
- */
-function diagnosticData(code) {
-    return { code };
-}
-var ValidationCategory;
-(function (ValidationCategory) {
-    ValidationCategory.defaults = ['fast', 'slow', 'built-in'];
-    /**
-     * @deprecated since 4.2 Use `ValidationCategory.defaults` instead,
-     * since "all" does not include user-defined, custom validation categories.
-     */
-    ValidationCategory.all = ValidationCategory.defaults;
-})(ValidationCategory || (ValidationCategory = {}));
-/**
- * Manages a set of `ValidationCheck`s to be applied when documents are validated.
- */
-class ValidationRegistry {
-    constructor(services) {
-        this.entries = new MultiMap();
-        this.knownCategories = new Set(ValidationCategory.defaults);
-        this.entriesBefore = [];
-        this.entriesAfter = [];
-        this.reflection = services.shared.AstReflection;
-    }
-    /**
-     * Register a set of validation checks. Each value in the record can be either a single validation check (i.e. a function)
-     * or an array of validation checks.
-     *
-     * @param checksRecord Set of validation checks to register.
-     * @param thisObj Optional object to be used as `this` when calling the validation check functions.
-     * @param category Optional category for the validation checks (defaults to `'fast'`).
-     */
-    register(checksRecord, thisObj = this, category = 'fast') {
-        if (category === 'built-in') {
-            throw new Error("The 'built-in' category is reserved for lexer, parser, and linker errors.");
-        }
-        this.knownCategories.add(category); // remember custom/user-defined categories
-        for (const [type, ch] of Object.entries(checksRecord)) {
-            const callbacks = ch;
-            if (Array.isArray(callbacks)) {
-                for (const check of callbacks) {
-                    const entry = {
-                        check: this.wrapValidationException(check, thisObj),
-                        category
-                    };
-                    this.addEntry(type, entry);
-                }
-            }
-            else if (typeof callbacks === 'function') {
-                const entry = {
-                    check: this.wrapValidationException(callbacks, thisObj),
-                    category
-                };
-                this.addEntry(type, entry);
-            }
-            else {
-                assertUnreachable();
-            }
-        }
-    }
-    wrapValidationException(check, thisObj) {
-        return async (node, accept, cancelToken) => {
-            await this.handleException(() => check.call(thisObj, node, accept, cancelToken), 'An error occurred during validation', accept, node);
-        };
-    }
-    async handleException(functionality, messageContext, accept, node) {
-        try {
-            await functionality();
-        }
-        catch (err) {
-            if (isOperationCancelled(err)) {
-                throw err;
-            }
-            console.error(`${messageContext}:`, err);
-            if (err instanceof Error && err.stack) {
-                console.error(err.stack);
-            }
-            const messageDetails = err instanceof Error ? err.message : String(err);
-            accept('error', `${messageContext}: ${messageDetails}`, { node });
-        }
-    }
-    addEntry(type, entry) {
-        if (type === 'AstNode') {
-            this.entries.add('AstNode', entry);
-            return;
-        }
-        for (const subtype of this.reflection.getAllSubTypes(type)) {
-            this.entries.add(subtype, entry);
-        }
-    }
-    getChecks(type, categories) {
-        let checks = stream(this.entries.get(type))
-            .concat(this.entries.get('AstNode'));
-        if (categories) {
-            checks = checks.filter(entry => categories.includes(entry.category));
-        }
-        return checks.map(entry => entry.check);
-    }
-    /**
-     * Register logic which will be executed once before validating all the nodes of an AST/Langium document.
-     * This helps to prepare or initialize some information which are required or reusable for the following checks on the AstNodes.
-     *
-     * As an example, for validating unique fully-qualified names of nodes in the AST,
-     * here the map for mapping names to nodes could be established.
-     * During the usual checks on the nodes, they are put into this map with their name.
-     *
-     * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
-     * Therefore it is recommended to clear stored information
-     * _before_ validating an AST to validate each AST unaffected from other ASTs
-     * AND _after_ validating the AST to free memory by information which are no longer used.
-     *
-     * @param checkBefore a set-up function which will be called once before actually validating an AST
-     * @param thisObj Optional object to be used as `this` when calling the validation check functions.
-     */
-    registerBeforeDocument(checkBefore, thisObj = this) {
-        this.entriesBefore.push(this.wrapPreparationException(checkBefore, 'An error occurred during set-up of the validation', thisObj));
-    }
-    /**
-     * Register logic which will be executed once after validating all the nodes of an AST/Langium document.
-     * This helps to finally evaluate information which are collected during the checks on the AstNodes.
-     *
-     * As an example, for validating unique fully-qualified names of nodes in the AST,
-     * here the map with all the collected nodes and their names is checked
-     * and validation hints are created for all nodes with the same name.
-     *
-     * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
-     * Therefore it is recommended to clear stored information
-     * _before_ validating an AST to validate each AST unaffected from other ASTs
-     * AND _after_ validating the AST to free memory by information which are no longer used.
-     *
-     * @param checkBefore a set-up function which will be called once before actually validating an AST
-     * @param thisObj Optional object to be used as `this` when calling the validation check functions.
-     */
-    registerAfterDocument(checkAfter, thisObj = this) {
-        this.entriesAfter.push(this.wrapPreparationException(checkAfter, 'An error occurred during tear-down of the validation', thisObj));
-    }
-    wrapPreparationException(check, messageContext, thisObj) {
-        return async (rootNode, accept, categories, cancelToken) => {
-            await this.handleException(() => check.call(thisObj, rootNode, accept, categories, cancelToken), messageContext, accept, rootNode);
-        };
-    }
-    get checksBefore() {
-        return this.entriesBefore;
-    }
-    get checksAfter() {
-        return this.entriesAfter;
-    }
-    getAllValidationCategories(_document) {
-        return this.knownCategories;
-    }
-}
-
-export { ValidationCategory, ValidationRegistry, diagnosticData };