@windrun-huaiin/third-ui 13.1.4 → 13.1.5

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

@@ -1,287 +0,0 @@
-import { isLinkingError, isAstNode, isAstNodeDescription } from '../syntax-tree.mjs';
-import { streamAst, streamReferences, findRootNode } from '../utils/ast-utils.mjs';
-import { interruptAndCheck } from '../utils/promise-utils.mjs';
-import { DocumentState } from '../workspace/documents.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 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 = cancellationExports.CancellationToken.None) {
-        if (this.profiler?.isActive('linking')) {
-            const task = this.profiler.createTask('linking', this.languageId);
-            task.start();
-            try {
-                for (const node of streamAst(document.parseResult.value)) {
-                    await interruptAndCheck(cancelToken);
-                    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 streamAst(document.parseResult.value)) {
-                await interruptAndCheck(cancelToken);
-                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 (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 (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 (isAstNode(this._ref)) {
-                    // Most frequent case: the target is already resolved.
-                    return this._ref;
-                }
-                else if (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 = findRootNode(node).$document;
-                    const refData = linker.getLinkedNode({ reference, container: node, property });
-                    if (refData.error && document && document.state < 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 isAstNode(this._ref) ? this._ref : undefined;
-            },
-            get $nodeDescription() {
-                return this._nodeDescription;
-            },
-            get error() {
-                return 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 = findRootNode(node).$document;
-                    const descriptions = linker.getCandidates({
-                        reference,
-                        container: node,
-                        property
-                    });
-                    const items = [];
-                    if (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 (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 = findRootNode(refInfo.container).$document;
-        if (document && document.state < 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
-        };
-    }
-}
-
-export { DefaultLinker, RefResolving };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/references/name-provider.js

@@ -1,26 +0,0 @@
-'use strict';
-
-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.
- ******************************************************************************/
-function isNamed(node) {
-    return typeof node.name === 'string';
-}
-class DefaultNameProvider {
-    getName(node) {
-        if (isNamed(node)) {
-            return node.name;
-        }
-        return undefined;
-    }
-    getNameNode(node) {
-        return grammarUtils.findNodeForProperty(node.$cstNode, 'name');
-    }
-}
-
-exports.DefaultNameProvider = DefaultNameProvider;
-exports.isNamed = isNamed;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/references/name-provider.mjs

@@ -1,23 +0,0 @@
-import { findNodeForProperty } 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.
- ******************************************************************************/
-function isNamed(node) {
-    return typeof node.name === 'string';
-}
-class DefaultNameProvider {
-    getName(node) {
-        if (isNamed(node)) {
-            return node.name;
-        }
-        return undefined;
-    }
-    getNameNode(node) {
-        return findNodeForProperty(node.$cstNode, 'name');
-    }
-}
-
-export { DefaultNameProvider, isNamed };

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

@@ -1,136 +0,0 @@
-'use strict';
-
-var grammarUtils = require('../utils/grammar-utils.js');
-var syntaxTree = require('../syntax-tree.js');
-var astUtils = require('../utils/ast-utils.js');
-var cstUtils = require('../utils/cst-utils.js');
-var stream = require('../utils/stream.js');
-var uriUtils = require('../utils/uri-utils.js');
-var ast = require('../languages/generated/ast.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 DefaultReferences {
-    constructor(services) {
-        this.nameProvider = services.references.NameProvider;
-        this.index = services.shared.workspace.IndexManager;
-        this.nodeLocator = services.workspace.AstNodeLocator;
-        this.documents = services.shared.workspace.LangiumDocuments;
-        this.hasMultiReference = astUtils.streamAst(services.Grammar).some(node => ast.isCrossReference(node) && node.isMulti);
-    }
-    findDeclarations(sourceCstNode) {
-        if (sourceCstNode) {
-            const assignment = grammarUtils.findAssignment(sourceCstNode);
-            const nodeElem = sourceCstNode.astNode;
-            if (assignment && nodeElem) {
-                const reference = nodeElem[assignment.feature];
-                if (syntaxTree.isReference(reference) || syntaxTree.isMultiReference(reference)) {
-                    return astUtils.getReferenceNodes(reference);
-                }
-                else if (Array.isArray(reference)) {
-                    for (const ref of reference) {
-                        if ((syntaxTree.isReference(ref) || syntaxTree.isMultiReference(ref)) && ref.$refNode
-                            && ref.$refNode.offset <= sourceCstNode.offset
-                            && ref.$refNode.end >= sourceCstNode.end) {
-                            return astUtils.getReferenceNodes(ref);
-                        }
-                    }
-                }
-            }
-            if (nodeElem) {
-                const nameNode = this.nameProvider.getNameNode(nodeElem);
-                // Only return the targeted node in case the targeted cst node is the name node or part of it
-                if (nameNode && (nameNode === sourceCstNode || cstUtils.isChildNode(sourceCstNode, nameNode))) {
-                    return this.getSelfNodes(nodeElem);
-                }
-            }
-        }
-        return [];
-    }
-    /**
-     * Returns all self-references for the specified node.
-     * Since the node can be part of a multi-reference, this method returns all nodes that are part of the same multi-reference.
-     */
-    getSelfNodes(node) {
-        if (!this.hasMultiReference) {
-            return [node];
-        }
-        else {
-            // In order to find all nodes that are part of the same multi-reference,
-            // we need to find a reference that points to the node.
-            // It will also point to the logical siblings of the node.
-            const references = this.index.findAllReferences(node, this.nodeLocator.getAstNodePath(node));
-            // We can simply use the first reference to find all logical siblings.
-            // Looking through all references is not necessary and very inefficient.
-            const headNode = this.getNodeFromReferenceDescription(references.head());
-            if (headNode) {
-                // We need to iterate over all references to find the one that points to the node.
-                for (const ref of astUtils.streamReferences(headNode)) {
-                    if (syntaxTree.isMultiReference(ref.reference) && ref.reference.items.some(item => item.ref === node)) {
-                        // Once we found the reference, simply return all items of the multi-reference.
-                        return ref.reference.items.map(item => item.ref);
-                    }
-                }
-            }
-            return [node];
-        }
-    }
-    getNodeFromReferenceDescription(ref) {
-        if (!ref) {
-            return undefined;
-        }
-        const doc = this.documents.getDocument(ref.sourceUri);
-        if (doc) {
-            return this.nodeLocator.getAstNode(doc.parseResult.value, ref.sourcePath);
-        }
-        return undefined;
-    }
-    findDeclarationNodes(sourceCstNode) {
-        const astNodes = this.findDeclarations(sourceCstNode);
-        const cstNodes = [];
-        for (const astNode of astNodes) {
-            const cstNode = this.nameProvider.getNameNode(astNode) ?? astNode.$cstNode;
-            if (cstNode) {
-                cstNodes.push(cstNode);
-            }
-        }
-        return cstNodes;
-    }
-    findReferences(targetNode, options) {
-        const refs = [];
-        if (options.includeDeclaration) {
-            refs.push(...this.getSelfReferences(targetNode));
-        }
-        let indexReferences = this.index.findAllReferences(targetNode, this.nodeLocator.getAstNodePath(targetNode));
-        if (options.documentUri) {
-            indexReferences = indexReferences.filter(ref => uriUtils.UriUtils.equals(ref.sourceUri, options.documentUri));
-        }
-        refs.push(...indexReferences);
-        return stream.stream(refs);
-    }
-    getSelfReferences(targetNode) {
-        const selfNodes = this.getSelfNodes(targetNode);
-        const references = [];
-        for (const selfNode of selfNodes) {
-            const nameNode = this.nameProvider.getNameNode(selfNode);
-            if (nameNode) {
-                const doc = astUtils.getDocument(selfNode);
-                const path = this.nodeLocator.getAstNodePath(selfNode);
-                references.push({
-                    sourceUri: doc.uri,
-                    sourcePath: path,
-                    targetUri: doc.uri,
-                    targetPath: path,
-                    segment: cstUtils.toDocumentSegment(nameNode),
-                    local: true
-                });
-            }
-        }
-        return references;
-    }
-}
-
-exports.DefaultReferences = DefaultReferences;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/references/references.mjs

@@ -1,134 +0,0 @@
-import { findAssignment } from '../utils/grammar-utils.mjs';
-import { isReference, isMultiReference } from '../syntax-tree.mjs';
-import { streamAst, getReferenceNodes, streamReferences, getDocument } from '../utils/ast-utils.mjs';
-import { isChildNode, toDocumentSegment } from '../utils/cst-utils.mjs';
-import { stream } from '../utils/stream.mjs';
-import { UriUtils } from '../utils/uri-utils.mjs';
-import { isCrossReference } from '../languages/generated/ast.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 DefaultReferences {
-    constructor(services) {
-        this.nameProvider = services.references.NameProvider;
-        this.index = services.shared.workspace.IndexManager;
-        this.nodeLocator = services.workspace.AstNodeLocator;
-        this.documents = services.shared.workspace.LangiumDocuments;
-        this.hasMultiReference = streamAst(services.Grammar).some(node => isCrossReference(node) && node.isMulti);
-    }
-    findDeclarations(sourceCstNode) {
-        if (sourceCstNode) {
-            const assignment = findAssignment(sourceCstNode);
-            const nodeElem = sourceCstNode.astNode;
-            if (assignment && nodeElem) {
-                const reference = nodeElem[assignment.feature];
-                if (isReference(reference) || isMultiReference(reference)) {
-                    return getReferenceNodes(reference);
-                }
-                else if (Array.isArray(reference)) {
-                    for (const ref of reference) {
-                        if ((isReference(ref) || isMultiReference(ref)) && ref.$refNode
-                            && ref.$refNode.offset <= sourceCstNode.offset
-                            && ref.$refNode.end >= sourceCstNode.end) {
-                            return getReferenceNodes(ref);
-                        }
-                    }
-                }
-            }
-            if (nodeElem) {
-                const nameNode = this.nameProvider.getNameNode(nodeElem);
-                // Only return the targeted node in case the targeted cst node is the name node or part of it
-                if (nameNode && (nameNode === sourceCstNode || isChildNode(sourceCstNode, nameNode))) {
-                    return this.getSelfNodes(nodeElem);
-                }
-            }
-        }
-        return [];
-    }
-    /**
-     * Returns all self-references for the specified node.
-     * Since the node can be part of a multi-reference, this method returns all nodes that are part of the same multi-reference.
-     */
-    getSelfNodes(node) {
-        if (!this.hasMultiReference) {
-            return [node];
-        }
-        else {
-            // In order to find all nodes that are part of the same multi-reference,
-            // we need to find a reference that points to the node.
-            // It will also point to the logical siblings of the node.
-            const references = this.index.findAllReferences(node, this.nodeLocator.getAstNodePath(node));
-            // We can simply use the first reference to find all logical siblings.
-            // Looking through all references is not necessary and very inefficient.
-            const headNode = this.getNodeFromReferenceDescription(references.head());
-            if (headNode) {
-                // We need to iterate over all references to find the one that points to the node.
-                for (const ref of streamReferences(headNode)) {
-                    if (isMultiReference(ref.reference) && ref.reference.items.some(item => item.ref === node)) {
-                        // Once we found the reference, simply return all items of the multi-reference.
-                        return ref.reference.items.map(item => item.ref);
-                    }
-                }
-            }
-            return [node];
-        }
-    }
-    getNodeFromReferenceDescription(ref) {
-        if (!ref) {
-            return undefined;
-        }
-        const doc = this.documents.getDocument(ref.sourceUri);
-        if (doc) {
-            return this.nodeLocator.getAstNode(doc.parseResult.value, ref.sourcePath);
-        }
-        return undefined;
-    }
-    findDeclarationNodes(sourceCstNode) {
-        const astNodes = this.findDeclarations(sourceCstNode);
-        const cstNodes = [];
-        for (const astNode of astNodes) {
-            const cstNode = this.nameProvider.getNameNode(astNode) ?? astNode.$cstNode;
-            if (cstNode) {
-                cstNodes.push(cstNode);
-            }
-        }
-        return cstNodes;
-    }
-    findReferences(targetNode, options) {
-        const refs = [];
-        if (options.includeDeclaration) {
-            refs.push(...this.getSelfReferences(targetNode));
-        }
-        let indexReferences = this.index.findAllReferences(targetNode, this.nodeLocator.getAstNodePath(targetNode));
-        if (options.documentUri) {
-            indexReferences = indexReferences.filter(ref => UriUtils.equals(ref.sourceUri, options.documentUri));
-        }
-        refs.push(...indexReferences);
-        return stream(refs);
-    }
-    getSelfReferences(targetNode) {
-        const selfNodes = this.getSelfNodes(targetNode);
-        const references = [];
-        for (const selfNode of selfNodes) {
-            const nameNode = this.nameProvider.getNameNode(selfNode);
-            if (nameNode) {
-                const doc = getDocument(selfNode);
-                const path = this.nodeLocator.getAstNodePath(selfNode);
-                references.push({
-                    sourceUri: doc.uri,
-                    sourcePath: path,
-                    targetUri: doc.uri,
-                    targetPath: path,
-                    segment: toDocumentSegment(nameNode),
-                    local: true
-                });
-            }
-        }
-        return references;
-    }
-}
-
-export { DefaultReferences };