@windrun-huaiin/third-ui 13.1.3 → 13.1.5

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/workspace/document-builder.js

@@ -1,500 +0,0 @@
-'use strict';
-
-var main = require('../../../../../../../_virtual/main.js');
-var disposable = require('../utils/disposable.js');
-var collections = require('../utils/collections.js');
-var promiseUtils = require('../utils/promise-utils.js');
-var stream = require('../utils/stream.js');
-var uriUtils = require('../utils/uri-utils.js');
-var documents = require('./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.
- ******************************************************************************/
-class DefaultDocumentBuilder {
-    constructor(services) {
-        this.updateBuildOptions = {
-            // Default: run only the built-in validation checks and those in the _fast_ category (includes those without category)
-            validation: {
-                categories: ['built-in', 'fast']
-            }
-        };
-        this.updateListeners = [];
-        this.buildPhaseListeners = new collections.MultiMap();
-        this.documentPhaseListeners = new collections.MultiMap();
-        this.buildState = new Map();
-        this.documentBuildWaiters = new Map();
-        this.currentState = documents.DocumentState.Changed;
-        this.langiumDocuments = services.workspace.LangiumDocuments;
-        this.langiumDocumentFactory = services.workspace.LangiumDocumentFactory;
-        this.textDocuments = services.workspace.TextDocuments;
-        this.indexManager = services.workspace.IndexManager;
-        this.fileSystemProvider = services.workspace.FileSystemProvider;
-        this.workspaceManager = () => services.workspace.WorkspaceManager;
-        this.serviceRegistry = services.ServiceRegistry;
-    }
-    async build(documents$1, options = {}, cancelToken = cancellation.cancellationExports.CancellationToken.None) {
-        for (const document of documents$1) {
-            const key = document.uri.toString();
-            if (document.state === documents.DocumentState.Validated) {
-                if (typeof options.validation === 'boolean' && options.validation) {
-                    // Force re-running all validation checks
-                    this.resetToState(document, documents.DocumentState.IndexedReferences);
-                }
-                else if (typeof options.validation === 'object') {
-                    // Validation with explicit options was requested for a document that has already been partly validated.
-                    // In this case, we need to execute only the missing validation categories.
-                    const categories = this.findMissingValidationCategories(document, options);
-                    if (categories.length > 0) {
-                        // Validate this document, since some of the requested validation categories are not executed yet.
-                        //  In all other cases/else-branches, the document is not build at all.
-                        this.buildState.set(key, {
-                            completed: false,
-                            options: {
-                                validation: {
-                                    categories
-                                }
-                            },
-                            result: this.buildState.get(key)?.result,
-                        });
-                        // Reset the state, but keep the existing validation markers of the already completed validation categories.
-                        document.state = documents.DocumentState.IndexedReferences;
-                    }
-                }
-            }
-            else {
-                // Default: forget any previous build options
-                this.buildState.delete(key);
-            }
-        }
-        this.currentState = documents.DocumentState.Changed;
-        await this.emitUpdate(documents$1.map(e => e.uri), []);
-        await this.buildDocuments(documents$1, options, cancelToken);
-    }
-    async update(changed, deleted, cancelToken = cancellation.cancellationExports.CancellationToken.None) {
-        this.currentState = documents.DocumentState.Changed;
-        // Remove all metadata of documents that are reported as deleted
-        const deletedUris = [];
-        for (const deletedUri of deleted) {
-            // Since the deleted URI might point to a directory, we delete all documents within
-            const deletedDocs = this.langiumDocuments.deleteDocuments(deletedUri);
-            for (const doc of deletedDocs) {
-                deletedUris.push(doc.uri);
-                this.cleanUpDeleted(doc);
-            }
-        }
-        // Since the changed URI might point to a directory, we need to check all (nested) documents in that directory
-        const changedUris = (await Promise.all(changed.map(uri => this.findChangedUris(uri)))).flat();
-        // Set the state of all changed documents to `Changed` so they are completely rebuilt
-        for (const changedUri of changedUris) {
-            let changedDocument = this.langiumDocuments.getDocument(changedUri);
-            if (changedDocument === undefined) {
-                // We create an unparsed, invalid document.
-                // This will be parsed as soon as we reach the first document builder phase.
-                // This allows to cancel the parsing process later in case we need it.
-                changedDocument = this.langiumDocumentFactory.fromModel({ $type: 'INVALID' }, changedUri);
-                changedDocument.state = documents.DocumentState.Changed; // required, since `langiumDocumentFactory.fromModel` marks the new document as `DocumentState.Parsed`
-                this.langiumDocuments.addDocument(changedDocument);
-            }
-            this.resetToState(changedDocument, documents.DocumentState.Changed);
-        }
-        // Set the state of all documents that should be relinked to `ComputedScopes` (if not already lower)
-        const allChangedUris = stream.stream(changedUris).concat(deletedUris).map(uri => uri.toString()).toSet();
-        this.langiumDocuments.all
-            .filter(doc => !allChangedUris.has(doc.uri.toString()) && this.shouldRelink(doc, allChangedUris))
-            .forEach(doc => this.resetToState(doc, documents.DocumentState.ComputedScopes));
-        // Notify listeners of the update
-        await this.emitUpdate(changedUris, deletedUris);
-        // Only allow interrupting the execution after all state changes are done
-        await promiseUtils.interruptAndCheck(cancelToken);
-        // Collect and sort all documents that we should rebuild
-        const rebuildDocuments = this.sortDocuments(this.langiumDocuments.all
-            .filter(doc => 
-        // This includes those that were reported as changed and those that we selected for relinking
-        doc.state < documents.DocumentState.Validated
-            // This includes those for which a previous build has been cancelled
-            || !this.buildState.get(doc.uri.toString())?.completed
-            // `updateBuildOptions` changed between the last build (which is completed) and the current build,
-            //  leading to incomplete results, e.g. some validation categories are requested, which are not executed during the last build
-            || this.resultsAreIncomplete(doc, this.updateBuildOptions))
-            .toArray());
-        await this.buildDocuments(rebuildDocuments, this.updateBuildOptions, cancelToken);
-    }
-    resultsAreIncomplete(document, options) {
-        return this.findMissingValidationCategories(document, options).length >= 1;
-    }
-    findMissingValidationCategories(document, options) {
-        const state = this.buildState.get(document.uri.toString());
-        const allCategories = this.serviceRegistry.getServices(document.uri).validation.ValidationRegistry.getAllValidationCategories(document);
-        const executedCategories = state?.result?.validationChecks ? new Set(state?.result?.validationChecks) : state?.completed ? allCategories : new Set();
-        const requestedCategories = (options === undefined || options.validation === true) ? allCategories
-            : typeof options.validation === 'object' ? (options.validation.categories ?? allCategories) : [];
-        return stream.stream(requestedCategories).filter(requested => !executedCategories.has(requested)).toArray();
-    }
-    async findChangedUris(changed) {
-        // Most common case is that the document/textDocument at the specified URI has changed
-        const document = this.langiumDocuments.getDocument(changed) ?? this.textDocuments?.get(changed);
-        if (document) {
-            return [changed];
-        }
-        // If the document doesn't exist yet, we need to check what kind of file has changed
-        try {
-            const stat = await this.fileSystemProvider.stat(changed);
-            if (stat.isDirectory) {
-                // If a directory has changed, we need to check all documents in that directory
-                const uris = await this.workspaceManager().searchFolder(changed);
-                return uris;
-            }
-            else if (this.workspaceManager().shouldIncludeEntry(stat)) {
-                // Return the changed URI if it's a file that we can handle
-                return [changed];
-            }
-        }
-        catch {
-            // If we can't determine the file type, we discard the change
-        }
-        return [];
-    }
-    async emitUpdate(changed, deleted) {
-        await Promise.all(this.updateListeners.map(listener => listener(changed, deleted)));
-    }
-    /**
-     * Sort the given documents by priority. By default, documents with an open text document are prioritized.
-     * This is useful to ensure that visible documents show their diagnostics before all other documents.
-     *
-     * This improves the responsiveness in large workspaces as users usually don't care about diagnostics
-     * in files that are currently not opened in the editor.
-     */
-    sortDocuments(documents) {
-        let left = 0;
-        let right = documents.length - 1;
-        while (left < right) {
-            while (left < documents.length && this.hasTextDocument(documents[left])) {
-                left++;
-            }
-            while (right >= 0 && !this.hasTextDocument(documents[right])) {
-                right--;
-            }
-            if (left < right) {
-                [documents[left], documents[right]] = [documents[right], documents[left]];
-            }
-        }
-        return documents;
-    }
-    hasTextDocument(doc) {
-        return Boolean(this.textDocuments?.get(doc.uri));
-    }
-    /**
-     * Check whether the given document should be relinked after changes were found in the given URIs.
-     */
-    shouldRelink(document, changedUris) {
-        // Relink documents with linking errors -- maybe those references can be resolved now
-        if (document.references.some(ref => ref.error !== undefined)) {
-            return true;
-        }
-        // Check whether the document is affected by any of the changed URIs
-        return this.indexManager.isAffected(document, changedUris);
-    }
-    onUpdate(callback) {
-        this.updateListeners.push(callback);
-        return disposable.Disposable.create(() => {
-            const index = this.updateListeners.indexOf(callback);
-            if (index >= 0) {
-                this.updateListeners.splice(index, 1);
-            }
-        });
-    }
-    resetToState(document, state) {
-        switch (state) {
-            case documents.DocumentState.Changed:            case documents.DocumentState.Parsed:
-                this.indexManager.removeContent(document.uri);
-            // Fall through
-            case documents.DocumentState.IndexedContent:
-                document.localSymbols = undefined;
-            // Fall through
-            case documents.DocumentState.ComputedScopes: {
-                const linker = this.serviceRegistry.getServices(document.uri).references.Linker;
-                linker.unlink(document);
-                // Fall through
-            }
-            case documents.DocumentState.Linked:
-                this.indexManager.removeReferences(document.uri);
-            // Fall through
-            case documents.DocumentState.IndexedReferences:
-                document.diagnostics = undefined;
-                this.buildState.delete(document.uri.toString());
-            // Fall through
-            case documents.DocumentState.Validated:
-            // do nothing and keep the buildState
-        }
-        if (document.state > state) {
-            document.state = state;
-        }
-    }
-    cleanUpDeleted(document) {
-        this.buildState.delete(document.uri.toString());
-        this.indexManager.remove(document.uri);
-        // Since this method `cleanUpDeleted` is not available from outside, the following line is not necessary, since the state is already set before.
-        //  This line does not hurt and makes the code to be in sync with `resetToState`.
-        //  If `cleanUpDeleted` is called in custom document builders at some more places, this line becomes necessary.
-        document.state = documents.DocumentState.Changed;
-    }
-    /**
-     * Build the given documents by stepping through all build phases. If a document's state indicates
-     * that a certain build phase is already done, the phase is skipped for that document.
-     *
-     * @param documents The documents to build.
-     * @param options the {@link BuildOptions} to use.
-     * @param cancelToken A cancellation token that can be used to cancel the build.
-     * @returns A promise that resolves when the build is done.
-     */
-    async buildDocuments(documents$1, options, cancelToken) {
-        this.prepareBuild(documents$1, options);
-        // 0. Parse content
-        await this.runCancelable(documents$1, documents.DocumentState.Parsed, cancelToken, doc => this.langiumDocumentFactory.update(doc, cancelToken));
-        // 1. Index content: collect the documents' symbols being accessible by other documents
-        await this.runCancelable(documents$1, documents.DocumentState.IndexedContent, cancelToken, doc => this.indexManager.updateContent(doc, cancelToken));
-        // 2. Local symbols: collect each documents' symbols being accessible within the document (only)
-        await this.runCancelable(documents$1, documents.DocumentState.ComputedScopes, cancelToken, async (doc) => {
-            const scopeComputation = this.serviceRegistry.getServices(doc.uri).references.ScopeComputation;
-            doc.localSymbols = await scopeComputation.collectLocalSymbols(doc, cancelToken);
-        });
-        // 3. Linking
-        const toBeLinked = documents$1.filter(doc => this.shouldLink(doc));
-        await this.runCancelable(toBeLinked, documents.DocumentState.Linked, cancelToken, doc => {
-            const linker = this.serviceRegistry.getServices(doc.uri).references.Linker;
-            return linker.link(doc, cancelToken);
-        });
-        // 4. Index references
-        await this.runCancelable(toBeLinked, documents.DocumentState.IndexedReferences, cancelToken, doc => this.indexManager.updateReferences(doc, cancelToken));
-        // 5. Validation
-        const toBeValidated = documents$1.filter(doc => {
-            if (this.shouldValidate(doc)) {
-                return true; // the build state is marked as completed after finishing the validation for the current document
-            }
-            else {
-                this.markAsCompleted(doc); // since the validation is skipped for this document, it is already completed now
-                return false;
-            }
-        });
-        await this.runCancelable(toBeValidated, documents.DocumentState.Validated, cancelToken, async (doc) => {
-            await this.validate(doc, cancelToken);
-            this.markAsCompleted(doc);
-        });
-    }
-    markAsCompleted(document) {
-        const state = this.buildState.get(document.uri.toString());
-        if (state) {
-            state.completed = true;
-        }
-    }
-    /**
-     * Runs prior to beginning the build process to update the {@link DocumentBuildState} for each document
-     *
-     * @param documents collection of documents to be built
-     * @param options the {@link BuildOptions} to use
-     */
-    prepareBuild(documents, options) {
-        for (const doc of documents) {
-            const key = doc.uri.toString();
-            const state = this.buildState.get(key);
-            if (!state // If the document has no previous build state, we set it.
-                || state.completed // If it has one, but it's already marked as completed, we overwrite it.
-            ) {
-                this.buildState.set(key, {
-                    completed: false,
-                    options,
-                    result: state?.result
-                });
-            }
-        }
-    }
-    /**
-     * Runs a cancelable operation on a set of documents to bring them to a specified {@link DocumentState}.
-     *
-     * @param documents The array of documents to process.
-     * @param targetState The target {@link DocumentState} to bring the documents to.
-     * @param cancelToken A token that can be used to cancel the operation.
-     * @param callback A function to be called for each document.
-     * @returns A promise that resolves when all documents have been processed or the operation is canceled.
-     * @throws Will throw `OperationCancelled` if the operation is canceled via a `CancellationToken`.
-     */
-    async runCancelable(documents, targetState, cancelToken, callback) {
-        for (const document of documents) {
-            if (document.state < targetState) {
-                await promiseUtils.interruptAndCheck(cancelToken);
-                await callback(document);
-                document.state = targetState;
-                await this.notifyDocumentPhase(document, targetState, cancelToken);
-            }
-        }
-        // Do not use `filtered` here, as that will miss documents that have previously reached the current target state.
-        // For example, this happens in case the cancellation triggers between the processing of two documents
-        // or files that were picked up during the workspace initialization.
-        const targetStateDocs = documents.filter(doc => doc.state === targetState);
-        await this.notifyBuildPhase(targetStateDocs, targetState, cancelToken);
-        this.currentState = targetState;
-    }
-    onBuildPhase(targetState, callback) {
-        this.buildPhaseListeners.add(targetState, callback);
-        return disposable.Disposable.create(() => {
-            this.buildPhaseListeners.delete(targetState, callback);
-        });
-    }
-    onDocumentPhase(targetState, callback) {
-        this.documentPhaseListeners.add(targetState, callback);
-        return disposable.Disposable.create(() => {
-            this.documentPhaseListeners.delete(targetState, callback);
-        });
-    }
-    waitUntil(state, uriOrToken, cancelToken) {
-        let uri = undefined;
-        if (uriOrToken && 'path' in uriOrToken) {
-            uri = uriOrToken;
-        }
-        else {
-            cancelToken = uriOrToken;
-        }
-        cancelToken ?? (cancelToken = cancellation.cancellationExports.CancellationToken.None);
-        if (uri) {
-            return this.awaitDocumentState(state, uri, cancelToken);
-        }
-        else {
-            return this.awaitBuilderState(state, cancelToken);
-        }
-    }
-    awaitDocumentState(state, uri, cancelToken) {
-        const document = this.langiumDocuments.getDocument(uri);
-        if (!document) {
-            return Promise.reject(new main.mainExports.ResponseError(main.mainExports.LSPErrorCodes.ServerCancelled, `No document found for URI: ${uri.toString()}`));
-        }
-        else if (document.state >= state) {
-            return Promise.resolve(uri);
-        }
-        else if (cancelToken.isCancellationRequested) {
-            return Promise.reject(promiseUtils.OperationCancelled);
-        }
-        else if (this.currentState >= state && state > document.state) {
-            // this would imply that the document has been excluded from linking or validation, for example;
-            // this should never occur, the LS need to make sure that the affected document is properly built,
-            //  alternatively, the build state requirement need to be relaxed.
-            return Promise.reject(new main.mainExports.ResponseError(main.mainExports.LSPErrorCodes.RequestFailed, `Document state of ${uri.toString()} is ${documents.DocumentState[document.state]}, requiring ${documents.DocumentState[state]}, but workspace state is already ${documents.DocumentState[this.currentState]}. Returning undefined.`));
-        }
-        return new Promise((resolve, reject) => {
-            const buildDisposable = this.onDocumentPhase(state, (doc) => {
-                if (uriUtils.UriUtils.equals(doc.uri, uri)) {
-                    buildDisposable.dispose();
-                    cancelDisposable.dispose();
-                    resolve(doc.uri);
-                }
-            });
-            const cancelDisposable = cancelToken.onCancellationRequested(() => {
-                buildDisposable.dispose();
-                cancelDisposable.dispose();
-                reject(promiseUtils.OperationCancelled);
-            });
-        });
-    }
-    awaitBuilderState(state, cancelToken) {
-        if (this.currentState >= state) {
-            return Promise.resolve();
-        }
-        else if (cancelToken.isCancellationRequested) {
-            return Promise.reject(promiseUtils.OperationCancelled);
-        }
-        return new Promise((resolve, reject) => {
-            const buildDisposable = this.onBuildPhase(state, () => {
-                buildDisposable.dispose();
-                cancelDisposable.dispose();
-                resolve();
-            });
-            const cancelDisposable = cancelToken.onCancellationRequested(() => {
-                buildDisposable.dispose();
-                cancelDisposable.dispose();
-                reject(promiseUtils.OperationCancelled);
-            });
-        });
-    }
-    async notifyDocumentPhase(document, state, cancelToken) {
-        const listeners = this.documentPhaseListeners.get(state);
-        const listenersCopy = listeners.slice();
-        for (const listener of listenersCopy) {
-            try {
-                await promiseUtils.interruptAndCheck(cancelToken);
-                await listener(document, cancelToken);
-            }
-            catch (err) {
-                // Ignore cancellation errors
-                // We want to finish the listeners before throwing
-                if (!promiseUtils.isOperationCancelled(err)) {
-                    throw err;
-                }
-            }
-        }
-    }
-    async notifyBuildPhase(documents, state, cancelToken) {
-        if (documents.length === 0) {
-            // Don't notify when no document has been processed
-            return;
-        }
-        const listeners = this.buildPhaseListeners.get(state);
-        const listenersCopy = listeners.slice();
-        for (const listener of listenersCopy) {
-            await promiseUtils.interruptAndCheck(cancelToken);
-            await listener(documents, cancelToken);
-        }
-    }
-    /**
-     * Determine whether the given document should be linked during a build. The default
-     * implementation checks the `eagerLinking` property of the build options. If it's set to `true`
-     * or `undefined`, the document is included in the linking phase. This also affects the
-     * references indexing phase, which depends on eager linking.
-     */
-    shouldLink(document) {
-        return this.getBuildOptions(document).eagerLinking ?? true;
-    }
-    /**
-     * Determine whether the given document should be validated during a build. The default
-     * implementation checks the `validation` property of the build options. If it's set to `true`
-     * or a `ValidationOptions` object, the document is included in the validation phase.
-     */
-    shouldValidate(document) {
-        return Boolean(this.getBuildOptions(document).validation);
-    }
-    /**
-     * Run validation checks on the given document and store the resulting diagnostics in the document.
-     * If the document already contains diagnostics, the new ones are added to the list.
-     */
-    async validate(document, cancelToken) {
-        const validator = this.serviceRegistry.getServices(document.uri).validation.DocumentValidator;
-        const options = this.getBuildOptions(document);
-        const validationOptions = typeof options.validation === 'object' ? { ...options.validation } : {};
-        validationOptions.categories = this.findMissingValidationCategories(document, options); // execute only not-yet-executed categories
-        const diagnostics = await validator.validateDocument(document, validationOptions, cancelToken);
-        if (document.diagnostics) {
-            document.diagnostics.push(...diagnostics); // keep diagnostics of previously executed categories
-        }
-        else {
-            document.diagnostics = diagnostics;
-        }
-        // Store information about the executed validation in the build state
-        const state = this.buildState.get(document.uri.toString());
-        if (state) {
-            state.result ?? (state.result = {});
-            if (state.result.validationChecks) {
-                state.result.validationChecks = stream.stream(state.result.validationChecks).concat(validationOptions.categories).distinct().toArray();
-            }
-            else {
-                state.result.validationChecks = [...validationOptions.categories];
-            }
-        }
-    }
-    getBuildOptions(document) {
-        return this.buildState.get(document.uri.toString())?.options ?? {};
-    }
-}
-
-exports.DefaultDocumentBuilder = DefaultDocumentBuilder;