@taiga-ui/kit 3.491.1-canary.a08581f → 4.0.0-alpha.0

package/esm2022/components/tiles/tile.component.mjs

@@ -0,0 +1,70 @@
+import { ChangeDetectionStrategy, Component, HostBinding, HostListener, inject, Input, ViewChild, } from '@angular/core';
+import { tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
+import { TuiTileService } from './tile.service';
+import { TuiTilesComponent } from './tiles.component';
+import * as i0 from "@angular/core";
+class TuiTile {
+    constructor() {
+        this.service = inject(TuiTileService);
+        this.tiles = inject(TuiTilesComponent);
+        this.dragged = false;
+        this.width = 1;
+        this.height = 1;
+        this.element = tuiInjectElement();
+    }
+    onDrag(offset) {
+        const dragged = !Number.isNaN(offset[0]);
+        this.dragged = this.dragged || dragged;
+        this.tiles.element = dragged ? this.element : null;
+        this.service.setOffset(offset);
+    }
+    ngAfterViewInit() {
+        if (this.wrapper) {
+            this.service.init(this.wrapper.nativeElement);
+        }
+    }
+    ngOnDestroy() {
+        if (this.tiles.element === this.element) {
+            this.tiles.element = null;
+        }
+    }
+    get column() {
+        return `span var(--tui-width, ${this.width})`;
+    }
+    get row() {
+        return `span var(--tui-height, ${this.height})`;
+    }
+    onEnter() {
+        this.tiles.rearrange(this.element);
+    }
+    onTransitionEnd() {
+        this.dragged = false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTile, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiTile, isStandalone: true, selector: "tui-tile", inputs: { width: "width", height: "height" }, host: { listeners: { "pointerenter": "onEnter()" }, properties: { "class._dragged": "this.dragged", "style.gridColumn": "this.column", "style.gridRow": "this.row" } }, providers: [TuiTileService], viewQueries: [{ propertyName: "wrapper", first: true, predicate: ["wrapper"], descendants: true }], ngImport: i0, template: "<div\n    #wrapper\n    class=\"t-wrapper\"\n    (transitionend.self)=\"onTransitionEnd()\"\n>\n    <ng-content />\n</div>\n", changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { TuiTile };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTile, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'tui-tile', changeDetection: ChangeDetectionStrategy.OnPush, providers: [TuiTileService], template: "<div\n    #wrapper\n    class=\"t-wrapper\"\n    (transitionend.self)=\"onTransitionEnd()\"\n>\n    <ng-content />\n</div>\n" }]
+        }], propDecorators: { wrapper: [{
+                type: ViewChild,
+                args: ['wrapper']
+            }], dragged: [{
+                type: HostBinding,
+                args: ['class._dragged']
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], column: [{
+                type: HostBinding,
+                args: ['style.gridColumn']
+            }], row: [{
+                type: HostBinding,
+                args: ['style.gridRow']
+            }], onEnter: [{
+                type: HostListener,
+                args: ['pointerenter']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/tiles/tile.service.mjs

@@ -0,0 +1,85 @@
+import { isPlatformBrowser } from '@angular/common';
+import { inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { MutationObserverService } from '@ng-web-apis/mutation-observer';
+import { ResizeObserverService } from '@ng-web-apis/resize-observer';
+import { tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
+import { tuiArrayShallowEquals, tuiPx } from '@taiga-ui/cdk/utils/miscellaneous';
+import { BehaviorSubject, combineLatest, debounceTime, distinctUntilChanged, map, startWith, Subscription, } from 'rxjs';
+import { TuiTilesComponent } from './tiles.component';
+import * as i0 from "@angular/core";
+class TuiTileService {
+    constructor() {
+        this.isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+        this.el = tuiInjectElement();
+        this.tiles = inject(TuiTilesComponent);
+        this.sub = new Subscription();
+        this.offset$ = new BehaviorSubject([NaN, NaN]);
+        this.position$ = combineLatest([
+            this.offset$.pipe(distinctUntilChanged(tuiArrayShallowEquals)),
+            inject(ResizeObserverService).pipe(startWith(null)),
+            inject(MutationObserverService).pipe(startWith(null)),
+            this.tiles.order$.pipe(debounceTime(0)),
+        ]).pipe(map(([offset]) => offset));
+    }
+    init(element) {
+        if (this.isBrowser) {
+            this.sub.add(this.position$.subscribe((offset) => {
+                this.setPosition(element, offset);
+                this.setRect(element, offset);
+            }));
+        }
+        else {
+            this.el.style.setProperty('position', 'relative');
+        }
+    }
+    setOffset(offset) {
+        this.offset$.next(offset);
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    getRect([left, top]) {
+        const elTop = Number.isNaN(top) ? this.el.offsetTop : top;
+        const elLeft = Number.isNaN(left) ? this.el.offsetLeft : left;
+        const rect = {
+            top: elTop,
+            left: elLeft,
+            width: this.el.clientWidth,
+            height: this.el.clientHeight,
+            right: NaN,
+            bottom: NaN,
+            y: elTop,
+            x: elLeft,
+        };
+        return {
+            ...rect,
+            toJSON: () => JSON.stringify(rect),
+        };
+    }
+    setRect({ style }, offset) {
+        const { top, left, width, height } = this.getRect(offset);
+        style.top = tuiPx(top);
+        style.left = tuiPx(left);
+        style.width = tuiPx(width);
+        style.height = tuiPx(height);
+    }
+    setPosition(element, [left]) {
+        if (!Number.isNaN(left)) {
+            element.style.setProperty('position', 'fixed');
+            return;
+        }
+        const { style } = element;
+        const rect = element.getBoundingClientRect();
+        const host = this.el.getBoundingClientRect();
+        style.removeProperty('position');
+        style.top = tuiPx(rect.top - host.top + this.el.offsetTop);
+        style.left = tuiPx(rect.left - host.left + this.el.offsetLeft);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTileService }); }
+}
+export { TuiTileService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTileService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tile.service.js","sourceRoot":"","sources":["../../../../../projects/kit/components/tiles/tile.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {isPlatformBrowser} from '@angular/common';\nimport type {OnDestroy} from '@angular/core';\nimport {inject, Injectable, PLATFORM_ID} from '@angular/core';\nimport {MutationObserverService} from '@ng-web-apis/mutation-observer';\nimport {ResizeObserverService} from '@ng-web-apis/resize-observer';\nimport {tuiInjectElement} from '@taiga-ui/cdk/utils/dom';\nimport {tuiArrayShallowEquals, tuiPx} from '@taiga-ui/cdk/utils/miscellaneous';\nimport type {Observable} from 'rxjs';\nimport {\n    BehaviorSubject,\n    combineLatest,\n    debounceTime,\n    distinctUntilChanged,\n    map,\n    startWith,\n    Subscription,\n} from 'rxjs';\n\nimport {TuiTilesComponent} from './tiles.component';\n\n@Injectable()\nexport class TuiTileService implements OnDestroy {\n    private readonly isBrowser = isPlatformBrowser(inject(PLATFORM_ID));\n    private readonly el = tuiInjectElement();\n    private readonly tiles = inject(TuiTilesComponent);\n    private readonly sub = new Subscription();\n    private readonly offset$ = new BehaviorSubject<readonly [number, number]>([NaN, NaN]);\n    private readonly position$: Observable<readonly [number, number]> = combineLatest([\n        this.offset$.pipe(distinctUntilChanged(tuiArrayShallowEquals)),\n        inject(ResizeObserverService).pipe(startWith(null)),\n        inject(MutationObserverService).pipe(startWith(null)),\n        this.tiles.order$.pipe(debounceTime(0)),\n    ]).pipe(map(([offset]) => offset));\n\n    public init(element: HTMLElement): void {\n        if (this.isBrowser) {\n            this.sub.add(\n                this.position$.subscribe((offset) => {\n                    this.setPosition(element, offset);\n                    this.setRect(element, offset);\n                }),\n            );\n        } else {\n            this.el.style.setProperty('position', 'relative');\n        }\n    }\n\n    public setOffset(offset: readonly [number, number]): void {\n        this.offset$.next(offset);\n    }\n\n    public ngOnDestroy(): void {\n        this.sub.unsubscribe();\n    }\n\n    private getRect([left, top]: readonly [number, number]): DOMRect {\n        const elTop = Number.isNaN(top) ? this.el.offsetTop : top;\n        const elLeft = Number.isNaN(left) ? this.el.offsetLeft : left;\n\n        const rect = {\n            top: elTop,\n            left: elLeft,\n            width: this.el.clientWidth,\n            height: this.el.clientHeight,\n            right: NaN,\n            bottom: NaN,\n            y: elTop,\n            x: elLeft,\n        };\n\n        return {\n            ...rect,\n            toJSON: () => JSON.stringify(rect),\n        };\n    }\n\n    private setRect({style}: HTMLElement, offset: readonly [number, number]): void {\n        const {top, left, width, height} = this.getRect(offset);\n\n        style.top = tuiPx(top);\n        style.left = tuiPx(left);\n        style.width = tuiPx(width);\n        style.height = tuiPx(height);\n    }\n\n    private setPosition(element: HTMLElement, [left]: readonly [number, number]): void {\n        if (!Number.isNaN(left)) {\n            element.style.setProperty('position', 'fixed');\n\n            return;\n        }\n\n        const {style} = element;\n        const rect = element.getBoundingClientRect();\n        const host = this.el.getBoundingClientRect();\n\n        style.removeProperty('position');\n        style.top = tuiPx(rect.top - host.top + this.el.offsetTop);\n        style.left = tuiPx(rect.left - host.left + this.el.offsetLeft);\n    }\n}\n"]}

package/esm2022/components/tiles/tiles.component.mjs

@@ -0,0 +1,76 @@
+import { ChangeDetectionStrategy, Component, HostBinding, HostListener, Input, Output, ViewEncapsulation, } from '@angular/core';
+import { MUTATION_OBSERVER_INIT, MutationObserverService, } from '@ng-web-apis/mutation-observer';
+import { ResizeObserverService } from '@ng-web-apis/resize-observer';
+import { tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
+import { BehaviorSubject, debounce, filter, map, Subject, timer } from 'rxjs';
+import * as i0 from "@angular/core";
+class TuiTilesComponent {
+    constructor() {
+        this.el = tuiInjectElement();
+        this.el$ = new Subject();
+        this.debounce = 0;
+        this.orderChange = this.el$.pipe(debounce(() => timer(this.debounce)), filter(this.filter.bind(this)), map((element) => this.reorder(element)));
+        this.element = null;
+        this.order$ = new BehaviorSubject(new Map());
+    }
+    set order(map) {
+        this.order$.next(map);
+    }
+    get order() {
+        return this.order$.value;
+    }
+    rearrange(element) {
+        this.el$.next(element);
+    }
+    filter(element) {
+        return !!this.element && !!element && this.element !== element;
+    }
+    reorder(element) {
+        const elements = Array.from(this.el.children);
+        const currentIndex = elements.indexOf(this.element || element);
+        const newIndex = elements.indexOf(element);
+        const order = this.order.size
+            ? new Map(this.order)
+            : new Map(elements.map((_, index) => [index, index]));
+        const dragged = order.get(currentIndex) ?? currentIndex;
+        const placement = order.get(newIndex) ?? newIndex;
+        order.set(currentIndex, placement);
+        order.set(newIndex, dragged);
+        this.order$.next(order);
+        return order;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTilesComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiTilesComponent, isStandalone: true, selector: "tui-tiles", inputs: { debounce: "debounce", order: "order" }, outputs: { orderChange: "orderChange" }, host: { listeners: { "pointerleave.silent": "rearrange()" }, properties: { "class._dragged": "this.element" } }, providers: [
+            ResizeObserverService,
+            MutationObserverService,
+            {
+                provide: MUTATION_OBSERVER_INIT,
+                useValue: { childList: true },
+            },
+        ], ngImport: i0, template: '<ng-content></ng-content>', isInline: true, styles: ["tui-tiles{position:relative;z-index:0;display:grid;grid-auto-flow:dense;justify-items:stretch}tui-tiles._dragged tui-tile>.t-wrapper{pointer-events:none}tui-tiles._dragged tui-tile:not(._dragged)>.t-wrapper{transition-property:all;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;transition-delay:1ms}tui-tiles:not(._dragged) tui-tile._dragged>.t-wrapper{transition-property:all;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;transition-delay:1ms}tui-tile>.t-wrapper{position:absolute;top:0;left:0;width:100%;height:100%;z-index:0;border-radius:inherit}tui-tile._dragged>.t-wrapper{z-index:1;transition:none}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { TuiTilesComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTilesComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'tui-tiles', template: '<ng-content></ng-content>', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        ResizeObserverService,
+                        MutationObserverService,
+                        {
+                            provide: MUTATION_OBSERVER_INIT,
+                            useValue: { childList: true },
+                        },
+                    ], styles: ["tui-tiles{position:relative;z-index:0;display:grid;grid-auto-flow:dense;justify-items:stretch}tui-tiles._dragged tui-tile>.t-wrapper{pointer-events:none}tui-tiles._dragged tui-tile:not(._dragged)>.t-wrapper{transition-property:all;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;transition-delay:1ms}tui-tiles:not(._dragged) tui-tile._dragged>.t-wrapper{transition-property:all;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;transition-delay:1ms}tui-tile>.t-wrapper{position:absolute;top:0;left:0;width:100%;height:100%;z-index:0;border-radius:inherit}tui-tile._dragged>.t-wrapper{z-index:1;transition:none}\n"] }]
+        }], propDecorators: { debounce: [{
+                type: Input
+            }], orderChange: [{
+                type: Output
+            }], element: [{
+                type: HostBinding,
+                args: ['class._dragged']
+            }], order: [{
+                type: Input
+            }], rearrange: [{
+                type: HostListener,
+                args: ['pointerleave.silent']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/tiles/tiles.mjs

@@ -0,0 +1,5 @@
+import { TuiTile } from './tile.component';
+import { TuiTileHandle } from './tile-handle.directive';
+import { TuiTilesComponent } from './tiles.component';
+export const TuiTiles = [TuiTilesComponent, TuiTile, TuiTileHandle];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGlsZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9raXQvY29tcG9uZW50cy90aWxlcy90aWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sa0JBQWtCLENBQUM7QUFDekMsT0FBTyxFQUFDLGFBQWEsRUFBQyxNQUFNLHlCQUF5QixDQUFDO0FBQ3RELE9BQU8sRUFBQyxpQkFBaUIsRUFBQyxNQUFNLG1CQUFtQixDQUFDO0FBRXBELE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxDQUFDLGlCQUFpQixFQUFFLE9BQU8sRUFBRSxhQUFhLENBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7VHVpVGlsZX0gZnJvbSAnLi90aWxlLmNvbXBvbmVudCc7XG5pbXBvcnQge1R1aVRpbGVIYW5kbGV9IGZyb20gJy4vdGlsZS1oYW5kbGUuZGlyZWN0aXZlJztcbmltcG9ydCB7VHVpVGlsZXNDb21wb25lbnR9IGZyb20gJy4vdGlsZXMuY29tcG9uZW50JztcblxuZXhwb3J0IGNvbnN0IFR1aVRpbGVzID0gW1R1aVRpbGVzQ29tcG9uZW50LCBUdWlUaWxlLCBUdWlUaWxlSGFuZGxlXSBhcyBjb25zdDtcbiJdfQ==

package/esm2022/components/tree/components/tree/tree.component.mjs

@@ -0,0 +1,64 @@
+import { AsyncPipe, NgForOf, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, forwardRef, inject, Input, ViewChild, } from '@angular/core';
+import { TuiLet } from '@taiga-ui/cdk/directives/let';
+import { tuiProvide } from '@taiga-ui/cdk/utils/miscellaneous';
+import { PolymorpheusOutlet } from '@taiga-ui/polymorpheus';
+import { distinctUntilChanged, map, startWith, Subject } from 'rxjs';
+import { TuiTreeChildren } from '../../directives/tree-children.directive';
+import { TuiTreeNode } from '../../directives/tree-node.directive';
+import { TUI_TREE_NODE } from '../../misc/tree.tokens';
+import { TuiTreeItem } from '../tree-item/tree-item.component';
+import * as i0 from "@angular/core";
+class TuiTreeComponent {
+    constructor() {
+        this.check$ = new Subject();
+        this.children$ = this.check$.pipe(startWith(null), map(() => this.handler(this.value)), distinctUntilChanged());
+        this.directive = inject(TuiTreeChildren, {
+            optional: true,
+        });
+        this.trackBy = (_, item) => item;
+        this.content = ({ $implicit }) => String($implicit);
+    }
+    ngDoCheck() {
+        this.checkChanges();
+    }
+    checkChanges() {
+        this.check$.next();
+        this.item?.checkChanges();
+        this.child?.checkChanges();
+    }
+    get handler() {
+        return this.directive?.childrenHandler || TuiTreeChildren.defaultHandler;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTreeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiTreeComponent, isStandalone: true, selector: "tui-tree", inputs: { value: "value", trackBy: "trackBy", content: "content" }, host: { attributes: { "role": "tree" } }, providers: [tuiProvide(TUI_TREE_NODE, TuiTreeComponent)], viewQueries: [{ propertyName: "item", first: true, predicate: i0.forwardRef(function () { return TuiTreeItem; }), descendants: true }, { propertyName: "child", first: true, predicate: i0.forwardRef(function () { return TuiTreeComponent; }), descendants: true }], ngImport: i0, template: "<tui-tree-item\n    *tuiLet=\"children$ | async as children\"\n    #view\n    [tuiTreeNode]=\"value\"\n>\n    <ng-container *ngIf=\"value !== children\">\n        <ng-container *polymorpheusOutlet=\"content as text; context: {$implicit: value, node: view}\">\n            {{ text }}\n        </ng-container>\n    </ng-container>\n    <tui-tree\n        *ngFor=\"let child of children; trackBy: trackBy\"\n        [content]=\"content\"\n        [trackBy]=\"trackBy\"\n        [value]=\"child\"\n    />\n</tui-tree-item>\n", styles: [":host{position:relative;display:block}\n"], dependencies: [{ kind: "component", type: TuiTreeComponent, selector: "tui-tree", inputs: ["value", "trackBy", "content"] }, { kind: "component", type: TuiTreeItem, selector: "tui-tree-item" }, { kind: "directive", type: TuiLet, selector: "[tuiLet]", inputs: ["tuiLet"] }, { kind: "directive", type: PolymorpheusOutlet, selector: "[polymorpheusOutlet]", inputs: ["polymorpheusOutlet", "polymorpheusOutletContext"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: TuiTreeNode, selector: "tui-tree-item[tuiTreeNode]", inputs: ["tuiTreeNode"] }, { kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { TuiTreeComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTreeComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'tui-tree', imports: [
+                        TuiTreeItem,
+                        TuiLet,
+                        PolymorpheusOutlet,
+                        NgIf,
+                        NgForOf,
+                        TuiTreeNode,
+                        AsyncPipe,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, providers: [tuiProvide(TUI_TREE_NODE, TuiTreeComponent)], host: { role: 'tree' }, template: "<tui-tree-item\n    *tuiLet=\"children$ | async as children\"\n    #view\n    [tuiTreeNode]=\"value\"\n>\n    <ng-container *ngIf=\"value !== children\">\n        <ng-container *polymorpheusOutlet=\"content as text; context: {$implicit: value, node: view}\">\n            {{ text }}\n        </ng-container>\n    </ng-container>\n    <tui-tree\n        *ngFor=\"let child of children; trackBy: trackBy\"\n        [content]=\"content\"\n        [trackBy]=\"trackBy\"\n        [value]=\"child\"\n    />\n</tui-tree-item>\n", styles: [":host{position:relative;display:block}\n"] }]
+        }], propDecorators: { item: [{
+                type: ViewChild,
+                args: [forwardRef(() => TuiTreeItem)]
+            }], child: [{
+                type: ViewChild,
+                args: [forwardRef(() => TuiTreeComponent)]
+            }], value: [{
+                type: Input,
+                args: [{
+                        required: true,
+                    }]
+            }], trackBy: [{
+                type: Input
+            }], content: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/tree/components/tree-item/tree-item.component.mjs

@@ -0,0 +1,64 @@
+import { AsyncPipe, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChildren, forwardRef, HostBinding, inject, SkipSelf, } from '@angular/core';
+import { EMPTY_QUERY } from '@taiga-ui/cdk/constants';
+import { tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
+import { tuiProvide } from '@taiga-ui/cdk/utils/miscellaneous';
+import { TuiExpandComponent } from '@taiga-ui/core/components/expand';
+import { PolymorpheusOutlet } from '@taiga-ui/polymorpheus';
+import { distinctUntilChanged, map, startWith, Subject } from 'rxjs';
+import { TUI_TREE_CONTENT, TUI_TREE_CONTROLLER, TUI_TREE_LEVEL, TUI_TREE_NODE, } from '../../misc/tree.tokens';
+import * as i0 from "@angular/core";
+class TuiTreeItem {
+    constructor() {
+        this.nested = EMPTY_QUERY;
+        this.el = tuiInjectElement();
+        this.controller = inject(forwardRef(() => TUI_TREE_CONTROLLER));
+        this.change$ = new Subject();
+        this.level = inject(forwardRef(() => TUI_TREE_LEVEL));
+        this.content = inject(forwardRef(() => TUI_TREE_CONTENT));
+        this.expanded$ = this.change$.pipe(startWith(null), map(() => this.isExpanded));
+        this.attached$ = this.change$.pipe(map(() => this.el.isConnected), distinctUntilChanged());
+    }
+    get isExpandable() {
+        return !!this.nested.length;
+    }
+    get isExpanded() {
+        return this.controller.isExpanded(this);
+    }
+    ngDoCheck() {
+        this.checkChanges();
+    }
+    checkChanges() {
+        this.change$.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTreeItem, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiTreeItem, isStandalone: true, selector: "tui-tree-item", host: { attributes: { "role": "treeitem" }, properties: { "class._expandable": "this.isExpandable" } }, providers: [
+            tuiProvide(TUI_TREE_NODE, TuiTreeItem),
+            {
+                provide: TUI_TREE_LEVEL,
+                deps: [[new SkipSelf(), TUI_TREE_LEVEL]],
+                useFactory: (level) => ++level,
+            },
+        ], queries: [{ propertyName: "nested", predicate: TUI_TREE_NODE }], ngImport: i0, template: "<ng-template #template>\n    <ng-content />\n</ng-template>\n<ng-container *polymorpheusOutlet=\"content as text; context: {$implicit: this, template: template}\">\n    {{ text }}\n</ng-container>\n<tui-expand\n    *ngIf=\"isExpandable\"\n    role=\"group\"\n    class=\"t-children\"\n    [expanded]=\"expanded$ | async\"\n>\n    <div>\n        <ng-content select=\"tui-tree-item\" />\n        <ng-content select=\"tui-tree\" />\n    </div>\n</tui-expand>\n<ng-container *ngIf=\"attached$ | async\" />\n", styles: [":host{display:block}.t-children{position:relative;margin-left:var(--tui-tree-item-indent, 1.5rem)}\n"], dependencies: [{ kind: "directive", type: PolymorpheusOutlet, selector: "[polymorpheusOutlet]", inputs: ["polymorpheusOutlet", "polymorpheusOutletContext"] }, { kind: "component", type: TuiExpandComponent, selector: "tui-expand", inputs: ["async", "expanded"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { TuiTreeItem };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTreeItem, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'tui-tree-item', imports: [PolymorpheusOutlet, TuiExpandComponent, NgIf, AsyncPipe], changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        tuiProvide(TUI_TREE_NODE, TuiTreeItem),
+                        {
+                            provide: TUI_TREE_LEVEL,
+                            deps: [[new SkipSelf(), TUI_TREE_LEVEL]],
+                            useFactory: (level) => ++level,
+                        },
+                    ], host: {
+                        role: 'treeitem',
+                    }, template: "<ng-template #template>\n    <ng-content />\n</ng-template>\n<ng-container *polymorpheusOutlet=\"content as text; context: {$implicit: this, template: template}\">\n    {{ text }}\n</ng-container>\n<tui-expand\n    *ngIf=\"isExpandable\"\n    role=\"group\"\n    class=\"t-children\"\n    [expanded]=\"expanded$ | async\"\n>\n    <div>\n        <ng-content select=\"tui-tree-item\" />\n        <ng-content select=\"tui-tree\" />\n    </div>\n</tui-expand>\n<ng-container *ngIf=\"attached$ | async\" />\n", styles: [":host{display:block}.t-children{position:relative;margin-left:var(--tui-tree-item-indent, 1.5rem)}\n"] }]
+        }], propDecorators: { nested: [{
+                type: ContentChildren,
+                args: [TUI_TREE_NODE]
+            }], isExpandable: [{
+                type: HostBinding,
+                args: ['class._expandable']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/tree/components/tree-item-content/tree-item-content.component.mjs

@@ -0,0 +1,42 @@
+import { AsyncPipe, NgIf, NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, forwardRef, HostBinding, inject, } from '@angular/core';
+import { TuiButton } from '@taiga-ui/core/components/button';
+import { TUI_COMMON_ICONS } from '@taiga-ui/core/tokens';
+import { POLYMORPHEUS_CONTEXT } from '@taiga-ui/polymorpheus';
+import { distinctUntilChanged, map, startWith, Subject } from 'rxjs';
+import { TUI_DEFAULT_TREE_CONTROLLER } from '../../misc/tree.constants';
+import { TUI_TREE_CONTROLLER } from '../../misc/tree.tokens';
+import * as i0 from "@angular/core";
+class TuiTreeItemContent {
+    constructor() {
+        this.controller = inject(forwardRef(() => TUI_TREE_CONTROLLER));
+        this.change$ = new Subject();
+        this.icons = inject(TUI_COMMON_ICONS);
+        this.context = inject(POLYMORPHEUS_CONTEXT);
+        this.expanded$ = this.change$.pipe(startWith(null), map(() => this.isExpanded), distinctUntilChanged());
+    }
+    ngDoCheck() {
+        this.change$.next();
+    }
+    get isExpandable() {
+        return (this.context.$implicit.isExpandable &&
+            this.controller !== TUI_DEFAULT_TREE_CONTROLLER);
+    }
+    get isExpanded() {
+        return this.context.$implicit.isExpanded;
+    }
+    onClick() {
+        this.controller.toggle(this.context.$implicit);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTreeItemContent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiTreeItemContent, isStandalone: true, selector: "ng-component", host: { properties: { "class._expandable": "this.isExpandable" } }, ngImport: i0, template: "<button\n    *ngIf=\"isExpandable\"\n    appearance=\"flat\"\n    size=\"xs\"\n    tuiIconButton\n    type=\"button\"\n    class=\"t-button\"\n    [class.t-button_expanded]=\"expanded$ | async\"\n    [iconStart]=\"icons.more\"\n    [style.border-radius.%]=\"100\"\n    (click)=\"onClick()\"\n></button>\n<ng-container [ngTemplateOutlet]=\"context.template\" />\n", styles: [":host{display:flex;align-items:center}:host :host-context(tui-tree-item._expandable):not(._expandable){padding-left:2rem}.t-button{transition-property:transform;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;margin-right:.5rem}.t-button_expanded{transform:rotate(90deg)}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: TuiButton, selector: "a[tuiButton],button[tuiButton],a[tuiIconButton],button[tuiIconButton]", inputs: ["size"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { TuiTreeItemContent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTreeItemContent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, imports: [NgIf, TuiButton, NgTemplateOutlet, AsyncPipe], changeDetection: ChangeDetectionStrategy.OnPush, template: "<button\n    *ngIf=\"isExpandable\"\n    appearance=\"flat\"\n    size=\"xs\"\n    tuiIconButton\n    type=\"button\"\n    class=\"t-button\"\n    [class.t-button_expanded]=\"expanded$ | async\"\n    [iconStart]=\"icons.more\"\n    [style.border-radius.%]=\"100\"\n    (click)=\"onClick()\"\n></button>\n<ng-container [ngTemplateOutlet]=\"context.template\" />\n", styles: [":host{display:flex;align-items:center}:host :host-context(tui-tree-item._expandable):not(._expandable){padding-left:2rem}.t-button{transition-property:transform;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;margin-right:.5rem}.t-button_expanded{transform:rotate(90deg)}\n"] }]
+        }], propDecorators: { isExpandable: [{
+                type: HostBinding,
+                args: ['class._expandable']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1pdGVtLWNvbnRlbnQuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2l0L2NvbXBvbmVudHMvdHJlZS9jb21wb25lbnRzL3RyZWUtaXRlbS1jb250ZW50L3RyZWUtaXRlbS1jb250ZW50LmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2tpdC9jb21wb25lbnRzL3RyZWUvY29tcG9uZW50cy90cmVlLWl0ZW0tY29udGVudC90cmVlLWl0ZW0tY29udGVudC50ZW1wbGF0ZS5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFDLE1BQU0saUJBQWlCLENBQUM7QUFFbEUsT0FBTyxFQUNILHVCQUF1QixFQUN2QixTQUFTLEVBQ1QsVUFBVSxFQUNWLFdBQVcsRUFDWCxNQUFNLEdBQ1QsTUFBTSxlQUFlLENBQUM7QUFDdkIsT0FBTyxFQUFDLFNBQVMsRUFBQyxNQUFNLGtDQUFrQyxDQUFDO0FBQzNELE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLHVCQUF1QixDQUFDO0FBQ3ZELE9BQU8sRUFBQyxvQkFBb0IsRUFBQyxNQUFNLHdCQUF3QixDQUFDO0FBQzVELE9BQU8sRUFBQyxvQkFBb0IsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE9BQU8sRUFBQyxNQUFNLE1BQU0sQ0FBQztBQUVuRSxPQUFPLEVBQUMsMkJBQTJCLEVBQUMsTUFBTSwyQkFBMkIsQ0FBQztBQUV0RSxPQUFPLEVBQUMsbUJBQW1CLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQzs7QUFFM0QsTUFPYSxrQkFBa0I7SUFQL0I7UUFRcUIsZUFBVSxHQUFHLE1BQU0sQ0FDaEMsVUFBVSxDQUFDLEdBQUcsRUFBRSxDQUFDLG1CQUFtQixDQUFDLENBQ3hDLENBQUM7UUFFZSxZQUFPLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQztRQUU1QixVQUFLLEdBQUcsTUFBTSxDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFDakMsWUFBTyxHQUFHLE1BQU0sQ0FBcUIsb0JBQW9CLENBQUMsQ0FBQztRQUUzRCxjQUFTLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQzVDLFNBQVMsQ0FBQyxJQUFJLENBQUMsRUFDZixHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUMxQixvQkFBb0IsRUFBRSxDQUN6QixDQUFDO0tBcUJMO0lBbkJVLFNBQVM7UUFDWixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3hCLENBQUM7SUFFRCxJQUNjLFlBQVk7UUFDdEIsT0FBTyxDQUNILElBQUksQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLFlBQVk7WUFDbkMsSUFBSSxDQUFDLFVBQVUsS0FBSywyQkFBMkIsQ0FDbEQsQ0FBQztJQUNOLENBQUM7SUFFRCxJQUFjLFVBQVU7UUFDcEIsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUM7SUFDN0MsQ0FBQztJQUVTLE9BQU87UUFDYixJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ25ELENBQUM7K0dBbENRLGtCQUFrQjttR0FBbEIsa0JBQWtCLDRJQ3pCL0IsNFdBYUEsK1dET2MsSUFBSSw2RkFBRSxTQUFTLG9JQUFFLGdCQUFnQiwrSUFBRSxTQUFTOztTQUs3QyxrQkFBa0I7NEZBQWxCLGtCQUFrQjtrQkFQOUIsU0FBUztpQ0FDTSxJQUFJLFdBQ1AsQ0FBQyxJQUFJLEVBQUUsU0FBUyxFQUFFLGdCQUFnQixFQUFFLFNBQVMsQ0FBQyxtQkFHdEMsdUJBQXVCLENBQUMsTUFBTTs4QkF1QmpDLFlBQVk7c0JBRHpCLFdBQVc7dUJBQUMsbUJBQW1CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtBc3luY1BpcGUsIE5nSWYsIE5nVGVtcGxhdGVPdXRsZXR9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgdHlwZSB7RG9DaGVja30gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1xuICAgIENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxuICAgIENvbXBvbmVudCxcbiAgICBmb3J3YXJkUmVmLFxuICAgIEhvc3RCaW5kaW5nLFxuICAgIGluamVjdCxcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1R1aUJ1dHRvbn0gZnJvbSAnQHRhaWdhLXVpL2NvcmUvY29tcG9uZW50cy9idXR0b24nO1xuaW1wb3J0IHtUVUlfQ09NTU9OX0lDT05TfSBmcm9tICdAdGFpZ2EtdWkvY29yZS90b2tlbnMnO1xuaW1wb3J0IHtQT0xZTU9SUEhFVVNfQ09OVEVYVH0gZnJvbSAnQHRhaWdhLXVpL3BvbHltb3JwaGV1cyc7XG5pbXBvcnQge2Rpc3RpbmN0VW50aWxDaGFuZ2VkLCBtYXAsIHN0YXJ0V2l0aCwgU3ViamVjdH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7VFVJX0RFRkFVTFRfVFJFRV9DT05UUk9MTEVSfSBmcm9tICcuLi8uLi9taXNjL3RyZWUuY29uc3RhbnRzJztcbmltcG9ydCB0eXBlIHtUdWlUcmVlQ29udHJvbGxlciwgVHVpVHJlZUl0ZW1Db250ZXh0fSBmcm9tICcuLi8uLi9taXNjL3RyZWUuaW50ZXJmYWNlcyc7XG5pbXBvcnQge1RVSV9UUkVFX0NPTlRST0xMRVJ9IGZyb20gJy4uLy4uL21pc2MvdHJlZS50b2tlbnMnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIGltcG9ydHM6IFtOZ0lmLCBUdWlCdXR0b24sIE5nVGVtcGxhdGVPdXRsZXQsIEFzeW5jUGlwZV0sXG4gICAgdGVtcGxhdGVVcmw6ICcuL3RyZWUtaXRlbS1jb250ZW50LnRlbXBsYXRlLmh0bWwnLFxuICAgIHN0eWxlVXJsczogWycuL3RyZWUtaXRlbS1jb250ZW50LnN0eWxlLmxlc3MnXSxcbiAgICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbn0pXG5leHBvcnQgY2xhc3MgVHVpVHJlZUl0ZW1Db250ZW50IGltcGxlbWVudHMgRG9DaGVjayB7XG4gICAgcHJpdmF0ZSByZWFkb25seSBjb250cm9sbGVyID0gaW5qZWN0PFR1aVRyZWVDb250cm9sbGVyPihcbiAgICAgICAgZm9yd2FyZFJlZigoKSA9PiBUVUlfVFJFRV9DT05UUk9MTEVSKSxcbiAgICApO1xuXG4gICAgcHJpdmF0ZSByZWFkb25seSBjaGFuZ2UkID0gbmV3IFN1YmplY3Q8dm9pZD4oKTtcblxuICAgIHByb3RlY3RlZCByZWFkb25seSBpY29ucyA9IGluamVjdChUVUlfQ09NTU9OX0lDT05TKTtcbiAgICBwcm90ZWN0ZWQgcmVhZG9ubHkgY29udGV4dCA9IGluamVjdDxUdWlUcmVlSXRlbUNvbnRleHQ+KFBPTFlNT1JQSEVVU19DT05URVhUKTtcblxuICAgIHByb3RlY3RlZCByZWFkb25seSBleHBhbmRlZCQgPSB0aGlzLmNoYW5nZSQucGlwZShcbiAgICAgICAgc3RhcnRXaXRoKG51bGwpLFxuICAgICAgICBtYXAoKCkgPT4gdGhpcy5pc0V4cGFuZGVkKSxcbiAgICAgICAgZGlzdGluY3RVbnRpbENoYW5nZWQoKSxcbiAgICApO1xuXG4gICAgcHVibGljIG5nRG9DaGVjaygpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5jaGFuZ2UkLm5leHQoKTtcbiAgICB9XG5cbiAgICBASG9zdEJpbmRpbmcoJ2NsYXNzLl9leHBhbmRhYmxlJylcbiAgICBwcm90ZWN0ZWQgZ2V0IGlzRXhwYW5kYWJsZSgpOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuIChcbiAgICAgICAgICAgIHRoaXMuY29udGV4dC4kaW1wbGljaXQuaXNFeHBhbmRhYmxlICYmXG4gICAgICAgICAgICB0aGlzLmNvbnRyb2xsZXIgIT09IFRVSV9ERUZBVUxUX1RSRUVfQ09OVFJPTExFUlxuICAgICAgICApO1xuICAgIH1cblxuICAgIHByb3RlY3RlZCBnZXQgaXNFeHBhbmRlZCgpOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuIHRoaXMuY29udGV4dC4kaW1wbGljaXQuaXNFeHBhbmRlZDtcbiAgICB9XG5cbiAgICBwcm90ZWN0ZWQgb25DbGljaygpOiB2b2lkIHtcbiAgICAgICAgdGhpcy5jb250cm9sbGVyLnRvZ2dsZSh0aGlzLmNvbnRleHQuJGltcGxpY2l0KTtcbiAgICB9XG59XG4iLCI8YnV0dG9uXG4gICAgKm5nSWY9XCJpc0V4cGFuZGFibGVcIlxuICAgIGFwcGVhcmFuY2U9XCJmbGF0XCJcbiAgICBzaXplPVwieHNcIlxuICAgIHR1aUljb25CdXR0b25cbiAgICB0eXBlPVwiYnV0dG9uXCJcbiAgICBjbGFzcz1cInQtYnV0dG9uXCJcbiAgICBbY2xhc3MudC1idXR0b25fZXhwYW5kZWRdPVwiZXhwYW5kZWQkIHwgYXN5bmNcIlxuICAgIFtpY29uU3RhcnRdPVwiaWNvbnMubW9yZVwiXG4gICAgW3N0eWxlLmJvcmRlci1yYWRpdXMuJV09XCIxMDBcIlxuICAgIChjbGljayk9XCJvbkNsaWNrKClcIlxuPjwvYnV0dG9uPlxuPG5nLWNvbnRhaW5lciBbbmdUZW1wbGF0ZU91dGxldF09XCJjb250ZXh0LnRlbXBsYXRlXCIgLz5cbiJdfQ==

package/esm2022/components/tree/directives/tree-children.directive.mjs

@@ -0,0 +1,24 @@
+import { Directive, Input } from '@angular/core';
+import { EMPTY_ARRAY } from '@taiga-ui/cdk/constants';
+import * as i0 from "@angular/core";
+class TuiTreeChildren {
+    constructor() {
+        this.childrenHandler = TuiTreeChildren.defaultHandler;
+    }
+    static defaultHandler(item) {
+        return Array.isArray(item) ? item : EMPTY_ARRAY;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTreeChildren, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TuiTreeChildren, isStandalone: true, selector: "tui-tree[childrenHandler]", inputs: { childrenHandler: "childrenHandler" }, ngImport: i0 }); }
+}
+export { TuiTreeChildren };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTreeChildren, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: 'tui-tree[childrenHandler]',
+                }]
+        }], propDecorators: { childrenHandler: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1jaGlsZHJlbi5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9raXQvY29tcG9uZW50cy90cmVlL2RpcmVjdGl2ZXMvdHJlZS1jaGlsZHJlbi5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxLQUFLLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDL0MsT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLHlCQUF5QixDQUFDOztBQUdwRCxNQUlhLGVBQWU7SUFKNUI7UUFNVyxvQkFBZSxHQUFnQyxlQUFlLENBQUMsY0FBYyxDQUFDO0tBS3hGO0lBSFUsTUFBTSxDQUFDLGNBQWMsQ0FBSSxJQUFPO1FBQ25DLE9BQU8sS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUM7SUFDcEQsQ0FBQzsrR0FOUSxlQUFlO21HQUFmLGVBQWU7O1NBQWYsZUFBZTs0RkFBZixlQUFlO2tCQUozQixTQUFTO21CQUFDO29CQUNQLFVBQVUsRUFBRSxJQUFJO29CQUNoQixRQUFRLEVBQUUsMkJBQTJCO2lCQUN4Qzs4QkFHVSxlQUFlO3NCQURyQixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtEaXJlY3RpdmUsIElucHV0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7RU1QVFlfQVJSQVl9IGZyb20gJ0B0YWlnYS11aS9jZGsvY29uc3RhbnRzJztcbmltcG9ydCB0eXBlIHtUdWlIYW5kbGVyfSBmcm9tICdAdGFpZ2EtdWkvY2RrL3R5cGVzJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc3RhbmRhbG9uZTogdHJ1ZSxcbiAgICBzZWxlY3RvcjogJ3R1aS10cmVlW2NoaWxkcmVuSGFuZGxlcl0nLFxufSlcbmV4cG9ydCBjbGFzcyBUdWlUcmVlQ2hpbGRyZW48VD4ge1xuICAgIEBJbnB1dCgpXG4gICAgcHVibGljIGNoaWxkcmVuSGFuZGxlcjogVHVpSGFuZGxlcjxULCByZWFkb25seSBUW10+ID0gVHVpVHJlZUNoaWxkcmVuLmRlZmF1bHRIYW5kbGVyO1xuXG4gICAgcHVibGljIHN0YXRpYyBkZWZhdWx0SGFuZGxlcjxHPihpdGVtOiBHKTogcmVhZG9ubHkgR1tdIHtcbiAgICAgICAgcmV0dXJuIEFycmF5LmlzQXJyYXkoaXRlbSkgPyBpdGVtIDogRU1QVFlfQVJSQVk7XG4gICAgfVxufVxuIl19

package/esm2022/components/tree/directives/tree-controller.directive.mjs

@@ -0,0 +1,57 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { tuiIsPresent, tuiProvide } from '@taiga-ui/cdk/utils/miscellaneous';
+import { TUI_TREE_ACCESSOR, TUI_TREE_CONTROLLER } from '../misc/tree.tokens';
+import * as i0 from "@angular/core";
+class TuiTreeControllerDirective {
+    constructor() {
+        this.items = new Map();
+        this.fallback = true;
+        this.map = new Map();
+        this.toggled = new EventEmitter();
+    }
+    register(item, value) {
+        this.items.set(item, value);
+    }
+    unregister(item) {
+        this.items.delete(item);
+    }
+    isExpanded(item) {
+        const value = this.items.get(item);
+        return (value && this.map.get(value)) ?? this.fallback;
+    }
+    toggle(item) {
+        const value = this.items.get(item);
+        const expanded = this.isExpanded(item);
+        if (!tuiIsPresent(value)) {
+            return;
+        }
+        this.toggled.emit(value);
+        this.map.set(value, !expanded);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTreeControllerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TuiTreeControllerDirective, isStandalone: true, selector: "[tuiTreeController][map]", inputs: { fallback: ["tuiTreeController", "fallback"], map: "map" }, outputs: { toggled: "toggled" }, providers: [
+            tuiProvide(TUI_TREE_ACCESSOR, TuiTreeControllerDirective),
+            tuiProvide(TUI_TREE_CONTROLLER, TuiTreeControllerDirective),
+        ], exportAs: ["tuiTreeController"], ngImport: i0 }); }
+}
+export { TuiTreeControllerDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTreeControllerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: '[tuiTreeController][map]',
+                    providers: [
+                        tuiProvide(TUI_TREE_ACCESSOR, TuiTreeControllerDirective),
+                        tuiProvide(TUI_TREE_CONTROLLER, TuiTreeControllerDirective),
+                    ],
+                    exportAs: 'tuiTreeController',
+                }]
+        }], propDecorators: { fallback: [{
+                type: Input,
+                args: ['tuiTreeController']
+            }], map: [{
+                type: Input
+            }], toggled: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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