@windrun-huaiin/third-ui 13.1.4 → 14.0.0

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

@@ -1,218 +0,0 @@
-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

@@ -1,153 +0,0 @@
-'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

@@ -1,148 +0,0 @@
-/******************************************************************************
- * 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 };