@windrun-huaiin/third-ui 13.1.3 → 13.1.5

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

@@ -1,80 +0,0 @@
-import { UriUtils } from './utils/uri-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.
- ******************************************************************************/
-/**
- * Generic registry for Langium services, but capable of being used with extending service sets as well (such as the lsp-complete LangiumCoreServices set)
- */
-class DefaultServiceRegistry {
-    /**
-     * @deprecated Since 3.1.0. Use the new `fileExtensionMap` (or `languageIdMap`) property instead.
-     */
-    get map() {
-        return this.fileExtensionMap;
-    }
-    constructor(services) {
-        this.languageIdMap = new Map();
-        this.fileExtensionMap = new Map();
-        this.fileNameMap = new Map();
-        this.textDocuments = services?.workspace.TextDocuments;
-    }
-    register(language) {
-        const data = language.LanguageMetaData;
-        for (const ext of data.fileExtensions) {
-            if (this.fileExtensionMap.has(ext)) {
-                console.warn(`The file extension ${ext} is used by multiple languages. It is now assigned to '${data.languageId}'.`);
-            }
-            this.fileExtensionMap.set(ext, language);
-        }
-        if (data.fileNames) {
-            for (const name of data.fileNames) {
-                if (this.fileNameMap.has(name)) {
-                    console.warn(`The file name ${name} is used by multiple languages. It is now assigned to '${data.languageId}'.`);
-                }
-                this.fileNameMap.set(name, language);
-            }
-        }
-        this.languageIdMap.set(data.languageId, language);
-    }
-    getServices(uri) {
-        if (this.languageIdMap.size === 0) {
-            throw new Error('The service registry is empty. Use `register` to register the services of a language.');
-        }
-        const languageId = this.textDocuments?.get(uri)?.languageId;
-        if (languageId !== undefined) {
-            const services = this.languageIdMap.get(languageId);
-            if (services) {
-                return services;
-            }
-        }
-        const ext = UriUtils.extname(uri);
-        const name = UriUtils.basename(uri);
-        const services = this.fileNameMap.get(name) ?? this.fileExtensionMap.get(ext);
-        if (!services) {
-            if (languageId) {
-                throw new Error(`The service registry contains no services for the extension '${ext}' for language '${languageId}'.`);
-            }
-            else {
-                throw new Error(`The service registry contains no services for the extension '${ext}'.`);
-            }
-        }
-        return services;
-    }
-    hasServices(uri) {
-        try {
-            this.getServices(uri);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    get all() {
-        return Array.from(this.languageIdMap.values());
-    }
-}
-
-export { DefaultServiceRegistry };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/syntax-tree.js

@@ -1,120 +0,0 @@
-'use strict';
-
-/******************************************************************************
- * 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 isAstNode(obj) {
-    return typeof obj === 'object' && obj !== null && typeof obj.$type === 'string';
-}
-function isReference(obj) {
-    return typeof obj === 'object' && obj !== null && typeof obj.$refText === 'string' && 'ref' in obj;
-}
-function isMultiReference(obj) {
-    return typeof obj === 'object' && obj !== null && typeof obj.$refText === 'string' && 'items' in obj;
-}
-function isAstNodeDescription(obj) {
-    return typeof obj === 'object' && obj !== null
-        && typeof obj.name === 'string'
-        && typeof obj.type === 'string'
-        && typeof obj.path === 'string';
-}
-function isLinkingError(obj) {
-    return typeof obj === 'object' && obj !== null
-        && typeof obj.info === 'object'
-        && typeof obj.message === 'string';
-}
-/**
- * An abstract implementation of the {@link AstReflection} interface.
- * Serves to cache subtype computation results to improve performance throughout different parts of Langium.
- */
-class AbstractAstReflection {
-    constructor() {
-        this.subtypes = {};
-        this.allSubtypes = {};
-    }
-    getAllTypes() {
-        return Object.keys(this.types);
-    }
-    getReferenceType(refInfo) {
-        const metaData = this.types[refInfo.container.$type];
-        if (!metaData) {
-            throw new Error(`Type ${refInfo.container.$type || 'undefined'} not found.`);
-        }
-        const referenceType = metaData.properties[refInfo.property]?.referenceType;
-        if (!referenceType) {
-            throw new Error(`Property ${refInfo.property || 'undefined'} of type ${refInfo.container.$type} is not a reference.`);
-        }
-        return referenceType;
-    }
-    getTypeMetaData(type) {
-        const result = this.types[type];
-        if (!result) {
-            return {
-                name: type,
-                properties: {},
-                superTypes: []
-            };
-        }
-        return result;
-    }
-    isInstance(node, type) {
-        return isAstNode(node) && this.isSubtype(node.$type, type);
-    }
-    isSubtype(subtype, supertype) {
-        if (subtype === supertype) {
-            return true;
-        }
-        let nested = this.subtypes[subtype];
-        if (!nested) {
-            nested = this.subtypes[subtype] = {};
-        }
-        const existing = nested[supertype];
-        if (existing !== undefined) {
-            return existing;
-        }
-        else {
-            const metaData = this.types[subtype];
-            const result = metaData ? metaData.superTypes.some(s => this.isSubtype(s, supertype)) : false;
-            nested[supertype] = result;
-            return result;
-        }
-    }
-    getAllSubTypes(type) {
-        const existing = this.allSubtypes[type];
-        if (existing) {
-            return existing;
-        }
-        else {
-            const allTypes = this.getAllTypes();
-            const types = [];
-            for (const possibleSubType of allTypes) {
-                if (this.isSubtype(possibleSubType, type)) {
-                    types.push(possibleSubType);
-                }
-            }
-            this.allSubtypes[type] = types;
-            return types;
-        }
-    }
-}
-function isCompositeCstNode(node) {
-    return typeof node === 'object' && node !== null && Array.isArray(node.content);
-}
-function isLeafCstNode(node) {
-    return typeof node === 'object' && node !== null && typeof node.tokenType === 'object';
-}
-function isRootCstNode(node) {
-    return isCompositeCstNode(node) && typeof node.fullText === 'string';
-}
-
-exports.AbstractAstReflection = AbstractAstReflection;
-exports.isAstNode = isAstNode;
-exports.isAstNodeDescription = isAstNodeDescription;
-exports.isCompositeCstNode = isCompositeCstNode;
-exports.isLeafCstNode = isLeafCstNode;
-exports.isLinkingError = isLinkingError;
-exports.isMultiReference = isMultiReference;
-exports.isReference = isReference;
-exports.isRootCstNode = isRootCstNode;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/syntax-tree.mjs

@@ -1,110 +0,0 @@
-/******************************************************************************
- * 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 isAstNode(obj) {
-    return typeof obj === 'object' && obj !== null && typeof obj.$type === 'string';
-}
-function isReference(obj) {
-    return typeof obj === 'object' && obj !== null && typeof obj.$refText === 'string' && 'ref' in obj;
-}
-function isMultiReference(obj) {
-    return typeof obj === 'object' && obj !== null && typeof obj.$refText === 'string' && 'items' in obj;
-}
-function isAstNodeDescription(obj) {
-    return typeof obj === 'object' && obj !== null
-        && typeof obj.name === 'string'
-        && typeof obj.type === 'string'
-        && typeof obj.path === 'string';
-}
-function isLinkingError(obj) {
-    return typeof obj === 'object' && obj !== null
-        && typeof obj.info === 'object'
-        && typeof obj.message === 'string';
-}
-/**
- * An abstract implementation of the {@link AstReflection} interface.
- * Serves to cache subtype computation results to improve performance throughout different parts of Langium.
- */
-class AbstractAstReflection {
-    constructor() {
-        this.subtypes = {};
-        this.allSubtypes = {};
-    }
-    getAllTypes() {
-        return Object.keys(this.types);
-    }
-    getReferenceType(refInfo) {
-        const metaData = this.types[refInfo.container.$type];
-        if (!metaData) {
-            throw new Error(`Type ${refInfo.container.$type || 'undefined'} not found.`);
-        }
-        const referenceType = metaData.properties[refInfo.property]?.referenceType;
-        if (!referenceType) {
-            throw new Error(`Property ${refInfo.property || 'undefined'} of type ${refInfo.container.$type} is not a reference.`);
-        }
-        return referenceType;
-    }
-    getTypeMetaData(type) {
-        const result = this.types[type];
-        if (!result) {
-            return {
-                name: type,
-                properties: {},
-                superTypes: []
-            };
-        }
-        return result;
-    }
-    isInstance(node, type) {
-        return isAstNode(node) && this.isSubtype(node.$type, type);
-    }
-    isSubtype(subtype, supertype) {
-        if (subtype === supertype) {
-            return true;
-        }
-        let nested = this.subtypes[subtype];
-        if (!nested) {
-            nested = this.subtypes[subtype] = {};
-        }
-        const existing = nested[supertype];
-        if (existing !== undefined) {
-            return existing;
-        }
-        else {
-            const metaData = this.types[subtype];
-            const result = metaData ? metaData.superTypes.some(s => this.isSubtype(s, supertype)) : false;
-            nested[supertype] = result;
-            return result;
-        }
-    }
-    getAllSubTypes(type) {
-        const existing = this.allSubtypes[type];
-        if (existing) {
-            return existing;
-        }
-        else {
-            const allTypes = this.getAllTypes();
-            const types = [];
-            for (const possibleSubType of allTypes) {
-                if (this.isSubtype(possibleSubType, type)) {
-                    types.push(possibleSubType);
-                }
-            }
-            this.allSubtypes[type] = types;
-            return types;
-        }
-    }
-}
-function isCompositeCstNode(node) {
-    return typeof node === 'object' && node !== null && Array.isArray(node.content);
-}
-function isLeafCstNode(node) {
-    return typeof node === 'object' && node !== null && typeof node.tokenType === 'object';
-}
-function isRootCstNode(node) {
-    return isCompositeCstNode(node) && typeof node.fullText === 'string';
-}
-
-export { AbstractAstReflection, isAstNode, isAstNodeDescription, isCompositeCstNode, isLeafCstNode, isLinkingError, isMultiReference, isReference, isRootCstNode };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/ast-utils.js

@@ -1,229 +0,0 @@
-'use strict';
-
-var syntaxTree = require('../syntax-tree.js');
-var stream = require('./stream.js');
-var cstUtils = require('./cst-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.
- ******************************************************************************/
-/**
- * Link the `$container` and other related properties of every AST node that is directly contained
- * in the given `node`.
- */
-function linkContentToContainer(node, options = {}) {
-    for (const [name, value] of Object.entries(node)) {
-        if (!name.startsWith('$')) {
-            if (Array.isArray(value)) {
-                value.forEach((item, index) => {
-                    if (syntaxTree.isAstNode(item)) {
-                        item.$container = node;
-                        item.$containerProperty = name;
-                        item.$containerIndex = index;
-                        if (options.deep) {
-                            linkContentToContainer(item, options);
-                        }
-                    }
-                });
-            }
-            else if (syntaxTree.isAstNode(value)) {
-                value.$container = node;
-                value.$containerProperty = name;
-                if (options.deep) {
-                    linkContentToContainer(value, options);
-                }
-            }
-        }
-    }
-}
-/**
- * Walk along the hierarchy of containers from the given AST node to the root and return the first
- * node that matches the type predicate. If the start node itself matches, it is returned.
- * If no container matches, `undefined` is returned.
- */
-function getContainerOfType(node, typePredicate) {
-    let item = node;
-    while (item) {
-        if (typePredicate(item)) {
-            return item;
-        }
-        item = item.$container;
-    }
-    return undefined;
-}
-/**
- * Retrieve the document in which the given AST node is contained. A reference to the document is
- * usually held by the root node of the AST.
- *
- * @throws an error if the node is not contained in a document.
- */
-function getDocument(node) {
-    const rootNode = findRootNode(node);
-    const result = rootNode.$document;
-    if (!result) {
-        throw new Error('AST node has no document.');
-    }
-    return result;
-}
-/**
- * Returns the root node of the given AST node by following the `$container` references.
- */
-function findRootNode(node) {
-    while (node.$container) {
-        node = node.$container;
-    }
-    return node;
-}
-/**
- * Returns all AST nodes that are referenced by the given reference or multi-reference.
- */
-function getReferenceNodes(reference) {
-    if (syntaxTree.isReference(reference)) {
-        return reference.ref ? [reference.ref] : [];
-    }
-    else if (syntaxTree.isMultiReference(reference)) {
-        return reference.items.map(item => item.ref);
-    }
-    return [];
-}
-/**
- * Create a stream of all AST nodes that are directly contained in the given node. This includes
- * single-valued as well as multi-valued (array) properties.
- */
-function streamContents(node, options) {
-    if (!node) {
-        throw new Error('Node must be an AstNode.');
-    }
-    const range = options?.range;
-    return new stream.StreamImpl(() => ({
-        keys: Object.keys(node),
-        keyIndex: 0,
-        arrayIndex: 0
-    }), state => {
-        while (state.keyIndex < state.keys.length) {
-            const property = state.keys[state.keyIndex];
-            if (!property.startsWith('$')) {
-                const value = node[property];
-                if (syntaxTree.isAstNode(value)) {
-                    state.keyIndex++;
-                    if (isAstNodeInRange(value, range)) {
-                        return { done: false, value };
-                    }
-                }
-                else if (Array.isArray(value)) {
-                    while (state.arrayIndex < value.length) {
-                        const index = state.arrayIndex++;
-                        const element = value[index];
-                        if (syntaxTree.isAstNode(element) && isAstNodeInRange(element, range)) {
-                            return { done: false, value: element };
-                        }
-                    }
-                    state.arrayIndex = 0;
-                }
-            }
-            state.keyIndex++;
-        }
-        return stream.DONE_RESULT;
-    });
-}
-/**
- * Create a stream of all AST nodes that are directly and indirectly contained in the given root node.
- * This does not include the root node itself.
- */
-function streamAllContents(root, options) {
-    if (!root) {
-        throw new Error('Root node must be an AstNode.');
-    }
-    return new stream.TreeStreamImpl(root, node => streamContents(node, options));
-}
-/**
- * Create a stream of all AST nodes that are directly and indirectly contained in the given root node,
- * including the root node itself.
- */
-function streamAst(root, options) {
-    if (!root) {
-        throw new Error('Root node must be an AstNode.');
-    }
-    return new stream.TreeStreamImpl(root, node => streamContents(node, options), { includeRoot: true });
-}
-function isAstNodeInRange(astNode, range) {
-    if (!range) {
-        return true;
-    }
-    const nodeRange = astNode.$cstNode?.range;
-    if (!nodeRange) {
-        return false;
-    }
-    return cstUtils.inRange(nodeRange, range);
-}
-/**
- * Create a stream of all cross-references that are held by the given AST node. This includes
- * single-valued as well as multi-valued (array) properties.
- */
-function streamReferences(node) {
-    return new stream.StreamImpl(() => ({
-        keys: Object.keys(node),
-        keyIndex: 0,
-        arrayIndex: 0
-    }), state => {
-        while (state.keyIndex < state.keys.length) {
-            const property = state.keys[state.keyIndex];
-            if (!property.startsWith('$')) {
-                const value = node[property];
-                if (syntaxTree.isReference(value) || syntaxTree.isMultiReference(value)) {
-                    state.keyIndex++;
-                    return { done: false, value: { reference: value, container: node, property } };
-                }
-                else if (Array.isArray(value)) {
-                    while (state.arrayIndex < value.length) {
-                        const index = state.arrayIndex++;
-                        const element = value[index];
-                        if (syntaxTree.isReference(element) || syntaxTree.isMultiReference(value)) {
-                            return { done: false, value: { reference: element, container: node, property, index } };
-                        }
-                    }
-                    state.arrayIndex = 0;
-                }
-            }
-            state.keyIndex++;
-        }
-        return stream.DONE_RESULT;
-    });
-}
-/**
- * Assigns all mandatory AST properties to the specified node.
- *
- * @param reflection Reflection object used to gather mandatory properties for the node.
- * @param node Specified node is modified in place and properties are directly assigned.
- */
-function assignMandatoryProperties(reflection, node) {
-    const typeMetaData = reflection.getTypeMetaData(node.$type);
-    const genericNode = node;
-    for (const property of Object.values(typeMetaData.properties)) {
-        // Only set the value if the property is not already set and if it has a default value
-        if (property.defaultValue !== undefined && genericNode[property.name] === undefined) {
-            genericNode[property.name] = copyDefaultValue(property.defaultValue);
-        }
-    }
-}
-function copyDefaultValue(propertyType) {
-    if (Array.isArray(propertyType)) {
-        return [...propertyType.map(copyDefaultValue)];
-    }
-    else {
-        return propertyType;
-    }
-}
-
-exports.assignMandatoryProperties = assignMandatoryProperties;
-exports.findRootNode = findRootNode;
-exports.getContainerOfType = getContainerOfType;
-exports.getDocument = getDocument;
-exports.getReferenceNodes = getReferenceNodes;
-exports.linkContentToContainer = linkContentToContainer;
-exports.streamAllContents = streamAllContents;
-exports.streamAst = streamAst;
-exports.streamContents = streamContents;
-exports.streamReferences = streamReferences;