@windrun-huaiin/third-ui 12.1.0 → 13.0.1

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

@@ -0,0 +1,218 @@
+import { isAstNode, isReference, isMultiReference } from '../syntax-tree.mjs';
+import { TreeStreamImpl, StreamImpl, DONE_RESULT } from './stream.mjs';
+import { inRange } from './cst-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.
+ ******************************************************************************/
+/**
+ * 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 (isAstNode(item)) {
+                        item.$container = node;
+                        item.$containerProperty = name;
+                        item.$containerIndex = index;
+                        if (options.deep) {
+                            linkContentToContainer(item, options);
+                        }
+                    }
+                });
+            }
+            else if (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 (isReference(reference)) {
+        return reference.ref ? [reference.ref] : [];
+    }
+    else if (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 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 (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 (isAstNode(element) && isAstNodeInRange(element, range)) {
+                            return { done: false, value: element };
+                        }
+                    }
+                    state.arrayIndex = 0;
+                }
+            }
+            state.keyIndex++;
+        }
+        return 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 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 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 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 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 (isReference(value) || 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 (isReference(element) || isMultiReference(value)) {
+                            return { done: false, value: { reference: element, container: node, property, index } };
+                        }
+                    }
+                    state.arrayIndex = 0;
+                }
+            }
+            state.keyIndex++;
+        }
+        return 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;
+    }
+}
+
+export { assignMandatoryProperties, findRootNode, getContainerOfType, getDocument, getReferenceNodes, linkContentToContainer, streamAllContents, streamAst, streamContents, streamReferences };

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

@@ -0,0 +1,153 @@
+'use strict';
+
+/******************************************************************************
+ * Copyright 2023 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 DisposableCache {
+    constructor() {
+        this.toDispose = [];
+        this.isDisposed = false;
+    }
+    onDispose(disposable) {
+        this.toDispose.push(disposable);
+    }
+    dispose() {
+        this.throwIfDisposed();
+        this.clear();
+        this.isDisposed = true;
+        this.toDispose.forEach(disposable => disposable.dispose());
+    }
+    throwIfDisposed() {
+        if (this.isDisposed) {
+            throw new Error('This cache has already been disposed');
+        }
+    }
+}
+class SimpleCache extends DisposableCache {
+    constructor() {
+        super(...arguments);
+        this.cache = new Map();
+    }
+    has(key) {
+        this.throwIfDisposed();
+        return this.cache.has(key);
+    }
+    set(key, value) {
+        this.throwIfDisposed();
+        this.cache.set(key, value);
+    }
+    get(key, provider) {
+        this.throwIfDisposed();
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        else if (provider) {
+            const value = provider();
+            this.cache.set(key, value);
+            return value;
+        }
+        else {
+            return undefined;
+        }
+    }
+    delete(key) {
+        this.throwIfDisposed();
+        return this.cache.delete(key);
+    }
+    clear() {
+        this.throwIfDisposed();
+        this.cache.clear();
+    }
+}
+class ContextCache extends DisposableCache {
+    constructor(converter) {
+        super();
+        this.cache = new Map();
+        this.converter = converter ?? (value => value);
+    }
+    has(contextKey, key) {
+        this.throwIfDisposed();
+        return this.cacheForContext(contextKey).has(key);
+    }
+    set(contextKey, key, value) {
+        this.throwIfDisposed();
+        this.cacheForContext(contextKey).set(key, value);
+    }
+    get(contextKey, key, provider) {
+        this.throwIfDisposed();
+        const contextCache = this.cacheForContext(contextKey);
+        if (contextCache.has(key)) {
+            return contextCache.get(key);
+        }
+        else if (provider) {
+            const value = provider();
+            contextCache.set(key, value);
+            return value;
+        }
+        else {
+            return undefined;
+        }
+    }
+    delete(contextKey, key) {
+        this.throwIfDisposed();
+        return this.cacheForContext(contextKey).delete(key);
+    }
+    clear(contextKey) {
+        this.throwIfDisposed();
+        if (contextKey) {
+            const mapKey = this.converter(contextKey);
+            this.cache.delete(mapKey);
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    cacheForContext(contextKey) {
+        const mapKey = this.converter(contextKey);
+        let documentCache = this.cache.get(mapKey);
+        if (!documentCache) {
+            documentCache = new Map();
+            this.cache.set(mapKey, documentCache);
+        }
+        return documentCache;
+    }
+}
+/**
+ * Every key/value pair in this cache is scoped to the whole workspace.
+ * If any document in the workspace is added, changed or deleted, the whole cache is evicted.
+ */
+class WorkspaceCache extends SimpleCache {
+    /**
+     * Creates a new workspace cache.
+     *
+     * @param sharedServices Service container instance to hook into document lifecycle events.
+     * @param state Optional document state on which the cache should evict.
+     * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
+     * *Deleted* documents are considered in both cases.
+     */
+    constructor(sharedServices, state) {
+        super();
+        if (state) {
+            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onBuildPhase(state, () => {
+                this.clear();
+            }));
+            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {
+                if (deleted.length > 0) { // react only on deleted documents
+                    this.clear();
+                }
+            }));
+        }
+        else {
+            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate(() => {
+                this.clear();
+            }));
+        }
+    }
+}
+
+exports.ContextCache = ContextCache;
+exports.DisposableCache = DisposableCache;
+exports.SimpleCache = SimpleCache;
+exports.WorkspaceCache = WorkspaceCache;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/caching.mjs

@@ -0,0 +1,148 @@
+/******************************************************************************
+ * Copyright 2023 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 DisposableCache {
+    constructor() {
+        this.toDispose = [];
+        this.isDisposed = false;
+    }
+    onDispose(disposable) {
+        this.toDispose.push(disposable);
+    }
+    dispose() {
+        this.throwIfDisposed();
+        this.clear();
+        this.isDisposed = true;
+        this.toDispose.forEach(disposable => disposable.dispose());
+    }
+    throwIfDisposed() {
+        if (this.isDisposed) {
+            throw new Error('This cache has already been disposed');
+        }
+    }
+}
+class SimpleCache extends DisposableCache {
+    constructor() {
+        super(...arguments);
+        this.cache = new Map();
+    }
+    has(key) {
+        this.throwIfDisposed();
+        return this.cache.has(key);
+    }
+    set(key, value) {
+        this.throwIfDisposed();
+        this.cache.set(key, value);
+    }
+    get(key, provider) {
+        this.throwIfDisposed();
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        else if (provider) {
+            const value = provider();
+            this.cache.set(key, value);
+            return value;
+        }
+        else {
+            return undefined;
+        }
+    }
+    delete(key) {
+        this.throwIfDisposed();
+        return this.cache.delete(key);
+    }
+    clear() {
+        this.throwIfDisposed();
+        this.cache.clear();
+    }
+}
+class ContextCache extends DisposableCache {
+    constructor(converter) {
+        super();
+        this.cache = new Map();
+        this.converter = converter ?? (value => value);
+    }
+    has(contextKey, key) {
+        this.throwIfDisposed();
+        return this.cacheForContext(contextKey).has(key);
+    }
+    set(contextKey, key, value) {
+        this.throwIfDisposed();
+        this.cacheForContext(contextKey).set(key, value);
+    }
+    get(contextKey, key, provider) {
+        this.throwIfDisposed();
+        const contextCache = this.cacheForContext(contextKey);
+        if (contextCache.has(key)) {
+            return contextCache.get(key);
+        }
+        else if (provider) {
+            const value = provider();
+            contextCache.set(key, value);
+            return value;
+        }
+        else {
+            return undefined;
+        }
+    }
+    delete(contextKey, key) {
+        this.throwIfDisposed();
+        return this.cacheForContext(contextKey).delete(key);
+    }
+    clear(contextKey) {
+        this.throwIfDisposed();
+        if (contextKey) {
+            const mapKey = this.converter(contextKey);
+            this.cache.delete(mapKey);
+        }
+        else {
+            this.cache.clear();
+        }
+    }
+    cacheForContext(contextKey) {
+        const mapKey = this.converter(contextKey);
+        let documentCache = this.cache.get(mapKey);
+        if (!documentCache) {
+            documentCache = new Map();
+            this.cache.set(mapKey, documentCache);
+        }
+        return documentCache;
+    }
+}
+/**
+ * Every key/value pair in this cache is scoped to the whole workspace.
+ * If any document in the workspace is added, changed or deleted, the whole cache is evicted.
+ */
+class WorkspaceCache extends SimpleCache {
+    /**
+     * Creates a new workspace cache.
+     *
+     * @param sharedServices Service container instance to hook into document lifecycle events.
+     * @param state Optional document state on which the cache should evict.
+     * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
+     * *Deleted* documents are considered in both cases.
+     */
+    constructor(sharedServices, state) {
+        super();
+        if (state) {
+            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onBuildPhase(state, () => {
+                this.clear();
+            }));
+            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {
+                if (deleted.length > 0) { // react only on deleted documents
+                    this.clear();
+                }
+            }));
+        }
+        else {
+            this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate(() => {
+                this.clear();
+            }));
+        }
+    }
+}
+
+export { ContextCache, DisposableCache, SimpleCache, WorkspaceCache };