@windrun-huaiin/third-ui 12.1.0 → 13.0.1

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/serializer/json-serializer.js

@@ -0,0 +1,271 @@
+'use strict';
+
+var index = require('../../../../../vscode-uri@3.1.0/node_modules/vscode-uri/lib/esm/index.js');
+var syntaxTree = require('../syntax-tree.js');
+var astUtils = require('../utils/ast-utils.js');
+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 isAstNodeWithComment(node) {
+    return typeof node.$comment === 'string';
+}
+function isIntermediateReference(obj) {
+    return typeof obj === 'object' && !!obj && ('$ref' in obj || '$error' in obj);
+}
+class DefaultJsonSerializer {
+    constructor(services) {
+        /** The set of AstNode properties to be ignored by the serializer. */
+        this.ignoreProperties = new Set(['$container', '$containerProperty', '$containerIndex', '$document', '$cstNode']);
+        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+        this.astNodeLocator = services.workspace.AstNodeLocator;
+        this.nameProvider = services.references.NameProvider;
+        this.commentProvider = services.documentation.CommentProvider;
+    }
+    serialize(node, options) {
+        const serializeOptions = options ?? {};
+        const specificReplacer = options?.replacer;
+        const defaultReplacer = (key, value) => this.replacer(key, value, serializeOptions);
+        const replacer = specificReplacer ? (key, value) => specificReplacer(key, value, defaultReplacer) : defaultReplacer;
+        try {
+            this.currentDocument = astUtils.getDocument(node);
+            return JSON.stringify(node, replacer, options?.space);
+        }
+        finally {
+            this.currentDocument = undefined;
+        }
+    }
+    deserialize(content, options) {
+        const deserializeOptions = options ?? {};
+        const root = JSON.parse(content);
+        this.linkNode(root, root, deserializeOptions);
+        return root;
+    }
+    replacer(key, value, { refText, sourceText, textRegions, comments, uriConverter }) {
+        if (this.ignoreProperties.has(key)) {
+            return undefined;
+        }
+        else if (syntaxTree.isReference(value)) {
+            const refValue = value.ref;
+            const $refText = refText ? value.$refText : undefined;
+            if (refValue) {
+                const targetDocument = astUtils.getDocument(refValue);
+                let targetUri = '';
+                if (this.currentDocument && this.currentDocument !== targetDocument) {
+                    if (uriConverter) {
+                        targetUri = uriConverter(targetDocument.uri, refValue);
+                    }
+                    else {
+                        targetUri = targetDocument.uri.toString();
+                    }
+                }
+                const targetPath = this.astNodeLocator.getAstNodePath(refValue);
+                return {
+                    $ref: `${targetUri}#${targetPath}`,
+                    $refText
+                };
+            }
+            else {
+                return {
+                    $error: value.error?.message ?? 'Could not resolve reference',
+                    $refText
+                };
+            }
+        }
+        else if (syntaxTree.isMultiReference(value)) {
+            const $refText = refText ? value.$refText : undefined;
+            const $refs = [];
+            for (const item of value.items) {
+                const refValue = item.ref;
+                const targetDocument = astUtils.getDocument(item.ref);
+                let targetUri = '';
+                if (this.currentDocument && this.currentDocument !== targetDocument) {
+                    if (uriConverter) {
+                        targetUri = uriConverter(targetDocument.uri, refValue);
+                    }
+                    else {
+                        targetUri = targetDocument.uri.toString();
+                    }
+                }
+                const targetPath = this.astNodeLocator.getAstNodePath(refValue);
+                $refs.push(`${targetUri}#${targetPath}`);
+            }
+            return {
+                $refs,
+                $refText
+            };
+        }
+        else if (syntaxTree.isAstNode(value)) {
+            let astNode = undefined;
+            if (textRegions) {
+                astNode = this.addAstNodeRegionWithAssignmentsTo({ ...value });
+                if ((!key || value.$document) && astNode?.$textRegion) {
+                    // The document URI is added to the root node of the resulting JSON tree
+                    astNode.$textRegion.documentURI = this.currentDocument?.uri.toString();
+                }
+            }
+            if (sourceText && !key) {
+                astNode ?? (astNode = { ...value });
+                astNode.$sourceText = value.$cstNode?.text;
+            }
+            if (comments) {
+                astNode ?? (astNode = { ...value });
+                const comment = this.commentProvider.getComment(value);
+                if (comment) {
+                    astNode.$comment = comment.replace(/\r/g, '');
+                }
+            }
+            return astNode ?? value;
+        }
+        else {
+            return value;
+        }
+    }
+    addAstNodeRegionWithAssignmentsTo(node) {
+        const createDocumentSegment = cstNode => ({
+            offset: cstNode.offset,
+            end: cstNode.end,
+            length: cstNode.length,
+            range: cstNode.range,
+        });
+        if (node.$cstNode) {
+            const textRegion = node.$textRegion = createDocumentSegment(node.$cstNode);
+            const assignments = textRegion.assignments = {};
+            Object.keys(node).filter(key => !key.startsWith('$')).forEach(key => {
+                const propertyAssignments = grammarUtils.findNodesForProperty(node.$cstNode, key).map(createDocumentSegment);
+                if (propertyAssignments.length !== 0) {
+                    assignments[key] = propertyAssignments;
+                }
+            });
+            return node;
+        }
+        return undefined;
+    }
+    linkNode(node, root, options, container, containerProperty, containerIndex) {
+        for (const [propertyName, item] of Object.entries(node)) {
+            if (Array.isArray(item)) {
+                for (let index = 0; index < item.length; index++) {
+                    const element = item[index];
+                    if (isIntermediateReference(element)) {
+                        item[index] = this.reviveReference(node, propertyName, root, element, options);
+                    }
+                    else if (syntaxTree.isAstNode(element)) {
+                        this.linkNode(element, root, options, node, propertyName, index);
+                    }
+                }
+            }
+            else if (isIntermediateReference(item)) {
+                node[propertyName] = this.reviveReference(node, propertyName, root, item, options);
+            }
+            else if (syntaxTree.isAstNode(item)) {
+                this.linkNode(item, root, options, node, propertyName);
+            }
+        }
+        const mutable = node;
+        mutable.$container = container;
+        mutable.$containerProperty = containerProperty;
+        mutable.$containerIndex = containerIndex;
+    }
+    reviveReference(container, property, root, reference, options) {
+        let refText = reference.$refText;
+        let error = reference.$error;
+        let ref;
+        if (reference.$ref) {
+            const refNode = this.getRefNode(root, reference.$ref, options.uriConverter);
+            if (syntaxTree.isAstNode(refNode)) {
+                if (!refText) {
+                    refText = this.nameProvider.getName(refNode);
+                }
+                return {
+                    $refText: refText ?? '',
+                    ref: refNode
+                };
+            }
+            else {
+                error = refNode;
+            }
+        }
+        else if (reference.$refs) {
+            const refs = [];
+            for (const refUri of reference.$refs) {
+                const refNode = this.getRefNode(root, refUri, options.uriConverter);
+                if (syntaxTree.isAstNode(refNode)) {
+                    refs.push({ ref: refNode });
+                }
+            }
+            if (refs.length === 0) {
+                ref = {
+                    $refText: refText ?? '',
+                    items: refs
+                };
+                error ?? (error = 'Could not resolve multi-reference');
+            }
+            else {
+                return {
+                    $refText: refText ?? '',
+                    items: refs
+                };
+            }
+        }
+        if (error) {
+            ref ?? (ref = {
+                $refText: refText ?? '',
+                ref: undefined
+            });
+            ref.error = {
+                info: {
+                    container,
+                    property,
+                    reference: ref
+                },
+                message: error
+            };
+            return ref;
+        }
+        else {
+            return undefined;
+        }
+    }
+    getRefNode(root, uri, uriConverter) {
+        try {
+            const fragmentIndex = uri.indexOf('#');
+            if (fragmentIndex === 0) {
+                const node = this.astNodeLocator.getAstNode(root, uri.substring(1));
+                if (!node) {
+                    return 'Could not resolve path: ' + uri;
+                }
+                return node;
+            }
+            if (fragmentIndex < 0) {
+                const documentUri = uriConverter ? uriConverter(uri) : index.URI.parse(uri);
+                const document = this.langiumDocuments.getDocument(documentUri);
+                if (!document) {
+                    return 'Could not find document for URI: ' + uri;
+                }
+                return document.parseResult.value;
+            }
+            const documentUri = uriConverter ? uriConverter(uri.substring(0, fragmentIndex)) : index.URI.parse(uri.substring(0, fragmentIndex));
+            const document = this.langiumDocuments.getDocument(documentUri);
+            if (!document) {
+                return 'Could not find document for URI: ' + uri;
+            }
+            if (fragmentIndex === uri.length - 1) {
+                return document.parseResult.value;
+            }
+            const node = this.astNodeLocator.getAstNode(document.parseResult.value, uri.substring(fragmentIndex + 1));
+            if (!node) {
+                return 'Could not resolve URI: ' + uri;
+            }
+            return node;
+        }
+        catch (err) {
+            return String(err);
+        }
+    }
+}
+
+exports.DefaultJsonSerializer = DefaultJsonSerializer;
+exports.isAstNodeWithComment = isAstNodeWithComment;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/serializer/json-serializer.mjs

@@ -0,0 +1,268 @@
+import { URI } from '../../../../../vscode-uri@3.1.0/node_modules/vscode-uri/lib/esm/index.mjs';
+import { isReference, isMultiReference, isAstNode } from '../syntax-tree.mjs';
+import { getDocument } from '../utils/ast-utils.mjs';
+import { findNodesForProperty } 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 isAstNodeWithComment(node) {
+    return typeof node.$comment === 'string';
+}
+function isIntermediateReference(obj) {
+    return typeof obj === 'object' && !!obj && ('$ref' in obj || '$error' in obj);
+}
+class DefaultJsonSerializer {
+    constructor(services) {
+        /** The set of AstNode properties to be ignored by the serializer. */
+        this.ignoreProperties = new Set(['$container', '$containerProperty', '$containerIndex', '$document', '$cstNode']);
+        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+        this.astNodeLocator = services.workspace.AstNodeLocator;
+        this.nameProvider = services.references.NameProvider;
+        this.commentProvider = services.documentation.CommentProvider;
+    }
+    serialize(node, options) {
+        const serializeOptions = options ?? {};
+        const specificReplacer = options?.replacer;
+        const defaultReplacer = (key, value) => this.replacer(key, value, serializeOptions);
+        const replacer = specificReplacer ? (key, value) => specificReplacer(key, value, defaultReplacer) : defaultReplacer;
+        try {
+            this.currentDocument = getDocument(node);
+            return JSON.stringify(node, replacer, options?.space);
+        }
+        finally {
+            this.currentDocument = undefined;
+        }
+    }
+    deserialize(content, options) {
+        const deserializeOptions = options ?? {};
+        const root = JSON.parse(content);
+        this.linkNode(root, root, deserializeOptions);
+        return root;
+    }
+    replacer(key, value, { refText, sourceText, textRegions, comments, uriConverter }) {
+        if (this.ignoreProperties.has(key)) {
+            return undefined;
+        }
+        else if (isReference(value)) {
+            const refValue = value.ref;
+            const $refText = refText ? value.$refText : undefined;
+            if (refValue) {
+                const targetDocument = getDocument(refValue);
+                let targetUri = '';
+                if (this.currentDocument && this.currentDocument !== targetDocument) {
+                    if (uriConverter) {
+                        targetUri = uriConverter(targetDocument.uri, refValue);
+                    }
+                    else {
+                        targetUri = targetDocument.uri.toString();
+                    }
+                }
+                const targetPath = this.astNodeLocator.getAstNodePath(refValue);
+                return {
+                    $ref: `${targetUri}#${targetPath}`,
+                    $refText
+                };
+            }
+            else {
+                return {
+                    $error: value.error?.message ?? 'Could not resolve reference',
+                    $refText
+                };
+            }
+        }
+        else if (isMultiReference(value)) {
+            const $refText = refText ? value.$refText : undefined;
+            const $refs = [];
+            for (const item of value.items) {
+                const refValue = item.ref;
+                const targetDocument = getDocument(item.ref);
+                let targetUri = '';
+                if (this.currentDocument && this.currentDocument !== targetDocument) {
+                    if (uriConverter) {
+                        targetUri = uriConverter(targetDocument.uri, refValue);
+                    }
+                    else {
+                        targetUri = targetDocument.uri.toString();
+                    }
+                }
+                const targetPath = this.astNodeLocator.getAstNodePath(refValue);
+                $refs.push(`${targetUri}#${targetPath}`);
+            }
+            return {
+                $refs,
+                $refText
+            };
+        }
+        else if (isAstNode(value)) {
+            let astNode = undefined;
+            if (textRegions) {
+                astNode = this.addAstNodeRegionWithAssignmentsTo({ ...value });
+                if ((!key || value.$document) && astNode?.$textRegion) {
+                    // The document URI is added to the root node of the resulting JSON tree
+                    astNode.$textRegion.documentURI = this.currentDocument?.uri.toString();
+                }
+            }
+            if (sourceText && !key) {
+                astNode ?? (astNode = { ...value });
+                astNode.$sourceText = value.$cstNode?.text;
+            }
+            if (comments) {
+                astNode ?? (astNode = { ...value });
+                const comment = this.commentProvider.getComment(value);
+                if (comment) {
+                    astNode.$comment = comment.replace(/\r/g, '');
+                }
+            }
+            return astNode ?? value;
+        }
+        else {
+            return value;
+        }
+    }
+    addAstNodeRegionWithAssignmentsTo(node) {
+        const createDocumentSegment = cstNode => ({
+            offset: cstNode.offset,
+            end: cstNode.end,
+            length: cstNode.length,
+            range: cstNode.range,
+        });
+        if (node.$cstNode) {
+            const textRegion = node.$textRegion = createDocumentSegment(node.$cstNode);
+            const assignments = textRegion.assignments = {};
+            Object.keys(node).filter(key => !key.startsWith('$')).forEach(key => {
+                const propertyAssignments = findNodesForProperty(node.$cstNode, key).map(createDocumentSegment);
+                if (propertyAssignments.length !== 0) {
+                    assignments[key] = propertyAssignments;
+                }
+            });
+            return node;
+        }
+        return undefined;
+    }
+    linkNode(node, root, options, container, containerProperty, containerIndex) {
+        for (const [propertyName, item] of Object.entries(node)) {
+            if (Array.isArray(item)) {
+                for (let index = 0; index < item.length; index++) {
+                    const element = item[index];
+                    if (isIntermediateReference(element)) {
+                        item[index] = this.reviveReference(node, propertyName, root, element, options);
+                    }
+                    else if (isAstNode(element)) {
+                        this.linkNode(element, root, options, node, propertyName, index);
+                    }
+                }
+            }
+            else if (isIntermediateReference(item)) {
+                node[propertyName] = this.reviveReference(node, propertyName, root, item, options);
+            }
+            else if (isAstNode(item)) {
+                this.linkNode(item, root, options, node, propertyName);
+            }
+        }
+        const mutable = node;
+        mutable.$container = container;
+        mutable.$containerProperty = containerProperty;
+        mutable.$containerIndex = containerIndex;
+    }
+    reviveReference(container, property, root, reference, options) {
+        let refText = reference.$refText;
+        let error = reference.$error;
+        let ref;
+        if (reference.$ref) {
+            const refNode = this.getRefNode(root, reference.$ref, options.uriConverter);
+            if (isAstNode(refNode)) {
+                if (!refText) {
+                    refText = this.nameProvider.getName(refNode);
+                }
+                return {
+                    $refText: refText ?? '',
+                    ref: refNode
+                };
+            }
+            else {
+                error = refNode;
+            }
+        }
+        else if (reference.$refs) {
+            const refs = [];
+            for (const refUri of reference.$refs) {
+                const refNode = this.getRefNode(root, refUri, options.uriConverter);
+                if (isAstNode(refNode)) {
+                    refs.push({ ref: refNode });
+                }
+            }
+            if (refs.length === 0) {
+                ref = {
+                    $refText: refText ?? '',
+                    items: refs
+                };
+                error ?? (error = 'Could not resolve multi-reference');
+            }
+            else {
+                return {
+                    $refText: refText ?? '',
+                    items: refs
+                };
+            }
+        }
+        if (error) {
+            ref ?? (ref = {
+                $refText: refText ?? '',
+                ref: undefined
+            });
+            ref.error = {
+                info: {
+                    container,
+                    property,
+                    reference: ref
+                },
+                message: error
+            };
+            return ref;
+        }
+        else {
+            return undefined;
+        }
+    }
+    getRefNode(root, uri, uriConverter) {
+        try {
+            const fragmentIndex = uri.indexOf('#');
+            if (fragmentIndex === 0) {
+                const node = this.astNodeLocator.getAstNode(root, uri.substring(1));
+                if (!node) {
+                    return 'Could not resolve path: ' + uri;
+                }
+                return node;
+            }
+            if (fragmentIndex < 0) {
+                const documentUri = uriConverter ? uriConverter(uri) : URI.parse(uri);
+                const document = this.langiumDocuments.getDocument(documentUri);
+                if (!document) {
+                    return 'Could not find document for URI: ' + uri;
+                }
+                return document.parseResult.value;
+            }
+            const documentUri = uriConverter ? uriConverter(uri.substring(0, fragmentIndex)) : URI.parse(uri.substring(0, fragmentIndex));
+            const document = this.langiumDocuments.getDocument(documentUri);
+            if (!document) {
+                return 'Could not find document for URI: ' + uri;
+            }
+            if (fragmentIndex === uri.length - 1) {
+                return document.parseResult.value;
+            }
+            const node = this.astNodeLocator.getAstNode(document.parseResult.value, uri.substring(fragmentIndex + 1));
+            if (!node) {
+                return 'Could not resolve URI: ' + uri;
+            }
+            return node;
+        }
+        catch (err) {
+            return String(err);
+        }
+    }
+}
+
+export { DefaultJsonSerializer, isAstNodeWithComment };

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

@@ -0,0 +1,82 @@
+'use strict';
+
+var uriUtils = require('./utils/uri-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.
+ ******************************************************************************/
+/**
+ * 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.UriUtils.extname(uri);
+        const name = uriUtils.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());
+    }
+}
+
+exports.DefaultServiceRegistry = DefaultServiceRegistry;