@cute-widgets/base 20.0.1

package/fesm2022/cute-widgets-base-tree.mjs

@@ -0,0 +1,598 @@
+import { CdkTreeNode, CdkTreeNodeDef, CdkNestedTreeNode, CDK_TREE_NODE_OUTLET_NODE, CdkTreeNodePadding, CdkTreeNodeOutlet, CdkTree, CdkTreeNodeToggle, CdkTreeModule } from '@angular/cdk/tree';
+import * as i0 from '@angular/core';
+import { inject, HostAttributeToken, booleanAttribute, numberAttribute, Input, Directive, ViewContainerRef, EventEmitter, ViewChild, Output, ChangeDetectionStrategy, ViewEncapsulation, Component, NgModule } from '@angular/core';
+import { Subject, BehaviorSubject, merge } from 'rxjs';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { DataSource } from '@angular/cdk/collections';
+import { take, map } from 'rxjs/operators';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Determine if argument TreeKeyManager is the NoopTreeKeyManager. This function is safe to use with SSR.
+ */
+function isNoopTreeKeyManager(keyManager) {
+    return !!keyManager._isNoopTreeKeyManager;
+}
+/**
+ * Wrapper for the CdkTree node with CuteWidget's design styles.
+ */
+class CuteTreeNode extends CdkTreeNode {
+    /**
+     * The tabindex of the tree node.
+     *
+     * @deprecated By default CuteTreeNode manages focus using TreeKeyManager instead of tabIndex.
+     *   Recommend to avoid setting tabIndex directly to prevent TreeKeyManager from getting into
+     *   an unexpected state. Tabindex to be removed in a future version.
+     * @breaking-change 21.0.0 Remove this attribute.
+     */
+    get tabIndexInputBinding() { return this._tabIndexInputBinding; }
+    set tabIndexInputBinding(value) {
+        // If the specified tabIndex value is null or undefined, fall back to the default value.
+        this._tabIndexInputBinding = value;
+    }
+    _getTabindexAttribute() {
+        if (isNoopTreeKeyManager(this._tree._keyManager)) {
+            return this.tabIndexInputBinding;
+        }
+        return this._tabindex;
+    }
+    /**
+     * Whether the component is disabled.
+     *
+     * @deprecated This is an alias for `isDisabled`.
+     * @breaking-change 21.0.0 Remove this input
+     */
+    get disabled() { return this.isDisabled; }
+    set disabled(value) { this.isDisabled = value; }
+    constructor() {
+        super();
+        this._tabIndexInputBinding = 0;
+        /**
+         * The default tabindex of the tree node.
+         *
+         * @deprecated By default CuteTreeNode manages focus using TreeKeyManager instead of tabIndex.
+         *   Recommend to avoid setting tabIndex directly to prevent TreeKeyManager form getting into
+         *   an unexpected state. Tabindex to be removed in a future version.
+         * @breaking-change 21.0.0 Remove this attribute.
+         */
+        this.defaultTabIndex = 0;
+        const tabIndex = inject(new HostAttributeToken('tabindex'), { optional: true });
+        this.tabIndexInputBinding = Number(tabIndex) || this.defaultTabIndex;
+    }
+    // This is a workaround for https://github.com/angular/angular/issues/23091
+    // In aot mode, the lifecycle hooks from parent class are not called.
+    ngOnInit() {
+        super.ngOnInit();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeNode, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "20.3.15", type: CuteTreeNode, isStandalone: true, selector: "cute-tree-node", inputs: { cdkTreeNodeTypeaheadLabel: ["cuteTreeNodeTypeaheadLabel", "cdkTreeNodeTypeaheadLabel"], tabIndexInputBinding: ["tabIndex", "tabIndexInputBinding", (value) => (value == null ? 0 : numberAttribute(value))], disabled: ["disabled", "disabled", booleanAttribute] }, outputs: { activation: "activation", expandedChange: "expandedChange" }, host: { listeners: { "click": "_focusItem()" }, properties: { "attr.aria-expanded": "_getAriaExpanded()", "attr.aria-level": "level + 1", "attr.aria-posinset": "_getPositionInSet()", "attr.aria-setsize": "_getSetSize()", "tabindex": "_getTabindexAttribute()" }, classAttribute: "cute-tree-node" }, providers: [{ provide: CdkTreeNode, useExisting: CuteTreeNode }], exportAs: ["cuteTreeNode"], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeNode, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'cute-tree-node',
+                    exportAs: 'cuteTreeNode',
+                    inputs: ['cdkTreeNodeTypeaheadLabel: cuteTreeNodeTypeaheadLabel'],
+                    outputs: ['activation', 'expandedChange'],
+                    providers: [{ provide: CdkTreeNode, useExisting: CuteTreeNode }],
+                    host: {
+                        'class': 'cute-tree-node',
+                        '[attr.aria-expanded]': '_getAriaExpanded()',
+                        '[attr.aria-level]': 'level + 1',
+                        '[attr.aria-posinset]': '_getPositionInSet()',
+                        '[attr.aria-setsize]': '_getSetSize()',
+                        '(click)': '_focusItem()',
+                        '[tabindex]': '_getTabindexAttribute()',
+                    },
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { tabIndexInputBinding: [{
+                type: Input,
+                args: [{
+                        transform: (value) => (value == null ? 0 : numberAttribute(value)),
+                        alias: 'tabIndex',
+                    }]
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+/**
+ * Wrapper for the CdkTree node definition with CuteWidgets' design styles.
+ * Captures the node's template and a `when` predicate that describes when this node should be used.
+ */
+class CuteTreeNodeDef extends CdkTreeNodeDef {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeNodeDef, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteTreeNodeDef, isStandalone: true, selector: "[cuteTreeNodeDef]", inputs: { when: ["cuteTreeNodeDefWhen", "when"], data: ["cuteTreeNode", "data"] }, providers: [{ provide: CdkTreeNodeDef, useExisting: CuteTreeNodeDef }], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeNodeDef, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cuteTreeNodeDef]',
+                    inputs: ['when: cuteTreeNodeDefWhen'],
+                    providers: [{ provide: CdkTreeNodeDef, useExisting: CuteTreeNodeDef }],
+                    standalone: true,
+                }]
+        }], propDecorators: { data: [{
+                type: Input,
+                args: ['cuteTreeNode']
+            }] } });
+/**
+ * Wrapper for the CdkTree nested node with CuteWidgets' design styles.
+ */
+class CuteNestedTreeNode extends CdkNestedTreeNode {
+    constructor() {
+        super(...arguments);
+        this._tabIndex = 0;
+    }
+    /**
+     * Whether the node is disabled.
+     *
+     * @deprecated This is an alias for `isDisabled`.
+     * @breaking-change 21.0.0 Remove this input
+     */
+    get disabled() { return this.isDisabled; }
+    set disabled(value) { this.isDisabled = value; }
+    /** Tabindex of the node. */
+    get tabIndex() { return this.isDisabled ? -1 : this._tabIndex; }
+    set tabIndex(value) {
+        // If the specified tabIndex value is null or undefined, fall back to the default value.
+        this._tabIndex = value;
+    }
+    // This is a workaround for https://github.com/angular/angular/issues/19145
+    // In aot mode, the lifecycle hooks from parent class are not called.
+    // TODO(tinayuangao): Remove when the angular issue #19145 is fixed
+    ngOnInit() {
+        super.ngOnInit();
+    }
+    ngAfterContentInit() {
+        super.ngAfterContentInit();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteNestedTreeNode, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "20.3.15", type: CuteNestedTreeNode, isStandalone: true, selector: "cute-nested-tree-node", inputs: { node: ["cuteNestedTreeNode", "node"], disabled: ["disabled", "disabled", booleanAttribute], tabIndex: ["tabIndex", "tabIndex", (value) => (value == null ? 0 : numberAttribute(value))] }, outputs: { activation: "activation", expandedChange: "expandedChange" }, host: { classAttribute: "cute-nested-tree-node" }, providers: [
+            { provide: CdkNestedTreeNode, useExisting: CuteNestedTreeNode },
+            { provide: CdkTreeNode, useExisting: CuteNestedTreeNode },
+            { provide: CDK_TREE_NODE_OUTLET_NODE, useExisting: CuteNestedTreeNode },
+        ], exportAs: ["cuteNestedTreeNode"], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteNestedTreeNode, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'cute-nested-tree-node',
+                    exportAs: 'cuteNestedTreeNode',
+                    outputs: ['activation', 'expandedChange'],
+                    providers: [
+                        { provide: CdkNestedTreeNode, useExisting: CuteNestedTreeNode },
+                        { provide: CdkTreeNode, useExisting: CuteNestedTreeNode },
+                        { provide: CDK_TREE_NODE_OUTLET_NODE, useExisting: CuteNestedTreeNode },
+                    ],
+                    host: {
+                        'class': 'cute-nested-tree-node',
+                    },
+                    standalone: true,
+                }]
+        }], propDecorators: { node: [{
+                type: Input,
+                args: ['cuteNestedTreeNode']
+            }], disabled: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], tabIndex: [{
+                type: Input,
+                args: [{
+                        transform: (value) => (value == null ? 0 : numberAttribute(value)),
+                    }]
+            }] } });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Wrapper for the CdkTree padding with **CuteWidgets** design styles.
+ */
+class CuteTreeNodePadding extends CdkTreeNodePadding {
+    /** The level of depth of the tree node. The padding will be `level * indent` pixels. */
+    get level() { return this._level; }
+    set level(value) { this._setLevelInput(value); }
+    /** The indent for each level. Default number 40px from material design menu submenu spec. */
+    get indent() { return this._indent; }
+    set indent(indent) { this._setIndentInput(indent); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeNodePadding, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "16.1.0", version: "20.3.15", type: CuteTreeNodePadding, isStandalone: true, selector: "[cuteTreeNodePadding]", inputs: { level: ["cuteTreeNodePadding", "level", numberAttribute], indent: ["cuteTreeNodePaddingIndent", "indent"] }, providers: [{ provide: CdkTreeNodePadding, useExisting: CuteTreeNodePadding }], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeNodePadding, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cuteTreeNodePadding]',
+                    providers: [{ provide: CdkTreeNodePadding, useExisting: CuteTreeNodePadding }],
+                    standalone: true,
+                }]
+        }], propDecorators: { level: [{
+                type: Input,
+                args: [{ alias: 'cuteTreeNodePadding', transform: numberAttribute }]
+            }], indent: [{
+                type: Input,
+                args: ['cuteTreeNodePaddingIndent']
+            }] } });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Outlet for nested CdkNode. Put `[cuteTreeNodeOutlet]` on a tag to place children dataNodes
+ * inside the outlet.
+ */
+class CuteTreeNodeOutlet {
+    constructor() {
+        this.viewContainer = inject(ViewContainerRef);
+        this._node = inject(CDK_TREE_NODE_OUTLET_NODE, { optional: true });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeNodeOutlet, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteTreeNodeOutlet, isStandalone: true, selector: "[cuteTreeNodeOutlet]", providers: [
+            {
+                provide: CdkTreeNodeOutlet,
+                useExisting: CuteTreeNodeOutlet,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeNodeOutlet, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cuteTreeNodeOutlet]',
+                    providers: [
+                        {
+                            provide: CdkTreeNodeOutlet,
+                            useExisting: CuteTreeNodeOutlet,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Wrapper for the CdkTable with **CuteWidgets** design styles.
+ */
+class CuteTree extends CdkTree {
+    constructor() {
+        super();
+        this._renderChanges = new Subject();
+        /** Event emitted on each change in the rendered data. */
+        this.renderNodesChange = new EventEmitter();
+        // Outlets within the tree's template where the dataNodes will be inserted.
+        // We need an initializer here to avoid a TS error. The value will be set in `ngAfterViewInit`.
+        this._nodeOutlet = undefined;
+        this._renderChanges
+            .pipe(takeUntilDestroyed())
+            .subscribe(nodes => this.renderNodesChange.emit(nodes));
+    }
+    renderNodeChanges(data) {
+        // We generate an event before calling the ancestor, otherwise
+        // the content of `data` array will not be correct !!!???
+        this._renderChanges.next(data);
+        super.renderNodeChanges(data);
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._renderChanges.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTree, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.15", type: CuteTree, isStandalone: true, selector: "cute-tree", outputs: { renderNodesChange: "renderNodesChange" }, host: { attributes: { "role": "tree" }, classAttribute: "cute-tree" }, providers: [{ provide: CdkTree, useExisting: CuteTree }], viewQueries: [{ propertyName: "_nodeOutlet", first: true, predicate: CuteTreeNodeOutlet, descendants: true, static: true }], exportAs: ["cuteTree"], usesInheritance: true, ngImport: i0, template: `<ng-container cuteTreeNodeOutlet></ng-container>`, isInline: true, styles: [".cute-tree{display:block}.cute-tree-node:is([cuteTreeNodeToggle]),.cute-nested-tree-node:is([cuteTreeNodeToggle]){cursor:pointer}.cute-tree-node{display:flex;align-items:center;flex:1;word-wrap:break-word}.cute-nested-tree-node{display:flex;align-items:center;flex:1;word-wrap:break-word;border-bottom-width:0}\n"], dependencies: [{ kind: "directive", type: CuteTreeNodeOutlet, selector: "[cuteTreeNodeOutlet]" }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTree, decorators: [{
+            type: Component,
+            args: [{ selector: 'cute-tree', exportAs: 'cuteTree', template: `<ng-container cuteTreeNodeOutlet></ng-container>`, host: {
+                        'class': 'cute-tree',
+                        'role': 'tree',
+                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.Default, providers: [{ provide: CdkTree, useExisting: CuteTree }], imports: [CuteTreeNodeOutlet], styles: [".cute-tree{display:block}.cute-tree-node:is([cuteTreeNodeToggle]),.cute-nested-tree-node:is([cuteTreeNodeToggle]){cursor:pointer}.cute-tree-node{display:flex;align-items:center;flex:1;word-wrap:break-word}.cute-nested-tree-node{display:flex;align-items:center;flex:1;word-wrap:break-word;border-bottom-width:0}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { renderNodesChange: [{
+                type: Output
+            }], _nodeOutlet: [{
+                type: ViewChild,
+                args: [CuteTreeNodeOutlet, { static: true }]
+            }] } });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Wrapper for the CdkTree's toggle with **CuteWidgets** design styles.
+ */
+class CuteTreeNodeToggle extends CdkTreeNodeToggle {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeNodeToggle, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteTreeNodeToggle, isStandalone: true, selector: "[cuteTreeNodeToggle]", inputs: { recursive: ["cuteTreeNodeToggleRecursive", "recursive"] }, providers: [{ provide: CdkTreeNodeToggle, useExisting: CuteTreeNodeToggle }], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeNodeToggle, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cuteTreeNodeToggle]',
+                    providers: [{ provide: CdkTreeNodeToggle, useExisting: CuteTreeNodeToggle }],
+                    inputs: ['recursive: cuteTreeNodeToggleRecursive'],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Tree flattener to convert a normal type of node to node with children & level information.
+ * Transform nested nodes of type `T` to flattened nodes of type `F`.
+ *
+ * For example, the input data of type `T` is nested, and contains its children data:
+ *   SomeNode: {
+ *     key: 'Fruits',
+ *     children: [
+ *       NodeOne: {
+ *         key: 'Apple',
+ *       },
+ *       NodeTwo: {
+ *        key: 'Pear',
+ *      }
+ *    ]
+ *  }
+ *  After flattener flatten the tree, the structure will become
+ *  SomeNode: {
+ *    key: 'Fruits',
+ *    expandable: true,
+ *    level: 1
+ *  },
+ *  NodeOne: {
+ *    key: 'Apple',
+ *    expandable: false,
+ *    level: 2
+ *  },
+ *  NodeTwo: {
+ *   key: 'Pear',
+ *   expandable: false,
+ *   level: 2
+ * }
+ * and the output flattened type is `F` with additional information.
+ */
+class CuteTreeFlattener {
+    constructor(transformFunction, getLevel, isExpandable, getChildren) {
+        this.transformFunction = transformFunction;
+        this.getLevel = getLevel;
+        this.isExpandable = isExpandable;
+        this.getChildren = getChildren;
+    }
+    _flattenNode(node, level, resultNodes, parentMap) {
+        const flatNode = this.transformFunction(node, level);
+        resultNodes.push(flatNode);
+        if (this.isExpandable(flatNode)) {
+            const childrenNodes = this.getChildren(node);
+            if (childrenNodes) {
+                if (Array.isArray(childrenNodes)) {
+                    this._flattenChildren(childrenNodes, level, resultNodes, parentMap);
+                }
+                else {
+                    childrenNodes.pipe(take(1)).subscribe(children => {
+                        this._flattenChildren(children, level, resultNodes, parentMap);
+                    });
+                }
+            }
+        }
+        return resultNodes;
+    }
+    _flattenChildren(children, level, resultNodes, parentMap) {
+        children.forEach((child, index) => {
+            let childParentMap = parentMap.slice();
+            childParentMap.push(index != children.length - 1);
+            this._flattenNode(child, level + 1, resultNodes, childParentMap);
+        });
+    }
+    /**
+     * Flatten a list of node type T to a flattened version of node F.
+     * Please note that type T may be nested, and the length of `structuredData` may be different
+     * from that of a returned list `F[]`.
+     */
+    flattenNodes(structuredData) {
+        let resultNodes = [];
+        structuredData.forEach(node => this._flattenNode(node, 0, resultNodes, []));
+        return resultNodes;
+    }
+    /**
+     * Expand flattened node with current expansion status.
+     * The returned list may have different length.
+     */
+    expandFlattenedNodes(nodes, treeControl) {
+        let results = [];
+        let currentExpand = [];
+        currentExpand[0] = true;
+        nodes.forEach(node => {
+            let expand = true;
+            for (let i = 0; i <= this.getLevel(node); i++) {
+                expand = expand && currentExpand[i];
+            }
+            if (expand) {
+                results.push(node);
+            }
+            if (this.isExpandable(node)) {
+                currentExpand[this.getLevel(node) + 1] = treeControl.isExpanded(node);
+            }
+        });
+        return results;
+    }
+}
+/**
+ * Data source for a flat tree.
+ * The data source needs to handle expansion/collapsion of the tree node and change the data feed
+ * to `CuteTree`.
+ * The nested tree nodes of type `T` are flattened through `CuteTreeFlattener`, and converted
+ * to type `F` for `CuteTree` to consume.
+ */
+class CuteTreeFlatDataSource extends DataSource {
+    get data() {
+        return this._data.value;
+    }
+    set data(value) {
+        this._data.next(value);
+        this._flattenedData.next(this._treeFlattener.flattenNodes(this.data));
+        this._treeControl.dataNodes = this._flattenedData.value;
+    }
+    constructor(_treeControl, _treeFlattener, initialData) {
+        super();
+        this._treeControl = _treeControl;
+        this._treeFlattener = _treeFlattener;
+        this._flattenedData = new BehaviorSubject([]);
+        this._expandedData = new BehaviorSubject([]);
+        this._data = new BehaviorSubject([]);
+        if (initialData) {
+            // Assign the data through the constructor to ensure that all of the logic is executed.
+            this.data = initialData;
+        }
+    }
+    connect(collectionViewer) {
+        return merge(collectionViewer.viewChange, this._treeControl.expansionModel.changed, this._flattenedData).pipe(map(() => {
+            this._expandedData.next(this._treeFlattener.expandFlattenedNodes(this._flattenedData.value, this._treeControl));
+            return this._expandedData.value;
+        }));
+    }
+    disconnect() {
+        // no op
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Data source for a nested tree.
+ *
+ * The data source for a nested tree doesn't have to consider node flattener, or the way to expand
+ * or collapse. The expansion/collapsion will be handled by TreeControl and each non-leaf node.
+ */
+class CuteTreeNestedDataSource extends DataSource {
+    constructor() {
+        super(...arguments);
+        this._data = new BehaviorSubject([]);
+    }
+    /**
+     * Data for the nested tree
+     */
+    get data() { return this._data.value; }
+    set data(value) {
+        this._data.next(value);
+    }
+    connect(collectionViewer) {
+        return merge(...[collectionViewer.viewChange, this._data]).pipe(map(() => this.data));
+    }
+    disconnect() {
+        // no op
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+const TYPES = [
+    CuteNestedTreeNode,
+    CuteTreeNodeDef,
+    CuteTreeNodePadding,
+    CuteTreeNodeToggle,
+    CuteTree,
+    CuteTreeNode,
+    CuteTreeNodeOutlet,
+];
+class CuteTreeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeModule, imports: [CdkTreeModule, CuteNestedTreeNode,
+            CuteTreeNodeDef,
+            CuteTreeNodePadding,
+            CuteTreeNodeToggle,
+            CuteTree,
+            CuteTreeNode,
+            CuteTreeNodeOutlet], exports: [CuteNestedTreeNode,
+            CuteTreeNodeDef,
+            CuteTreeNodePadding,
+            CuteTreeNodeToggle,
+            CuteTree,
+            CuteTreeNode,
+            CuteTreeNodeOutlet] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeModule, imports: [CdkTreeModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteTreeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CdkTreeModule, ...TYPES],
+                    exports: TYPES,
+                    declarations: [],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CuteNestedTreeNode, CuteTree, CuteTreeFlatDataSource, CuteTreeFlattener, CuteTreeModule, CuteTreeNestedDataSource, CuteTreeNode, CuteTreeNodeDef, CuteTreeNodeOutlet, CuteTreeNodePadding, CuteTreeNodeToggle };
+//# sourceMappingURL=cute-widgets-base-tree.mjs.map