@taiga-ui/core 3.58.0 → 3.59.0-canary.1c24449

package/esm2020/directives/dropdown/dropdown-selection.directive.mjs

@@ -0,0 +1,161 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, ElementRef, Inject, Input, ViewContainerRef, } from '@angular/core';
+import { ALWAYS_TRUE_HANDLER, CHAR_NO_BREAK_SPACE, CHAR_ZERO_WIDTH_SPACE, EMPTY_CLIENT_RECT, TUI_RANGE, tuiGetNativeFocused, tuiIsElement, tuiIsString, tuiIsTextfield, tuiIsTextNode, tuiPx, } from '@taiga-ui/cdk';
+import { tuiAsDriver, tuiAsRectAccessor, TuiDriver, } from '@taiga-ui/core/abstract';
+import { TUI_SELECTION_STREAM } from '@taiga-ui/core/tokens';
+import { tuiGetWordRange } from '@taiga-ui/core/utils';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { TuiDropdownDirective } from './dropdown.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "rxjs";
+import * as i2 from "./dropdown.directive";
+export class TuiDropdownSelectionDirective extends TuiDriver {
+    set tuiDropdownSelection(visible) {
+        if (!tuiIsString(visible)) {
+            this.handler$.next(visible);
+        }
+    }
+    constructor(range, doc, selection$, el, vcr, dropdown) {
+        super(subscriber => this.stream$.subscribe(subscriber));
+        this.range = range;
+        this.doc = doc;
+        this.selection$ = selection$;
+        this.el = el;
+        this.vcr = vcr;
+        this.dropdown = dropdown;
+        this.handler$ = new BehaviorSubject(ALWAYS_TRUE_HANDLER);
+        this.stream$ = combineLatest([
+            this.handler$,
+            this.selection$.pipe(map(() => this.getRange()), distinctUntilChanged((x, y) => x.startOffset === y.startOffset && x.endOffset === y.endOffset)),
+        ]).pipe(map(([handler, range]) => {
+            const contained = this.el.nativeElement.contains(range.commonAncestorContainer);
+            this.range =
+                contained && tuiIsTextNode(range.commonAncestorContainer)
+                    ? range
+                    : this.range;
+            return (contained && handler(this.range)) || this.inDropdown(range);
+        }));
+        this.position = 'selection';
+        this.type = 'dropdown';
+    }
+    getClientRect() {
+        switch (this.position) {
+            case 'tag': {
+                const { commonAncestorContainer } = this.range;
+                const element = tuiIsElement(commonAncestorContainer)
+                    ? commonAncestorContainer
+                    : commonAncestorContainer.parentNode;
+                return element && tuiIsElement(element)
+                    ? element.getBoundingClientRect()
+                    : EMPTY_CLIENT_RECT;
+            }
+            case 'word':
+                return tuiGetWordRange(this.range).getBoundingClientRect();
+            default:
+                return this.range.getBoundingClientRect();
+        }
+    }
+    ngOnDestroy() {
+        if (this.ghost) {
+            this.vcr.element.nativeElement.removeChild(this.ghost);
+        }
+    }
+    getRange() {
+        const active = tuiGetNativeFocused(this.doc);
+        const selection = this.doc.getSelection();
+        const range = active && tuiIsTextfield(active) && this.el.nativeElement.contains(active)
+            ? this.veryVerySadInputFix(active)
+            : (selection?.rangeCount && selection.getRangeAt(0)) || this.range;
+        return range.cloneRange();
+    }
+    /**
+     * Check if Node is inside dropdown
+     */
+    boxContains(node) {
+        return !!this.dropdown.dropdownBoxRef?.location.nativeElement.contains(node);
+    }
+    /**
+     * Check if given range is at least partially inside dropdown
+     */
+    inDropdown(range) {
+        const { startContainer, endContainer } = range;
+        const { nativeElement } = this.el;
+        const inDropdown = this.boxContains(range.commonAncestorContainer);
+        const hostToDropdown = this.boxContains(endContainer) && nativeElement.contains(startContainer);
+        const dropdownToHost = this.boxContains(startContainer) && nativeElement.contains(endContainer);
+        return inDropdown || hostToDropdown || dropdownToHost;
+    }
+    veryVerySadInputFix(element) {
+        const { ghost = this.initGhost(element) } = this;
+        const { top, left, width, height } = element.getBoundingClientRect();
+        const { selectionStart, selectionEnd, value } = element;
+        const range = this.doc.createRange();
+        const hostRect = this.el.nativeElement.getBoundingClientRect();
+        ghost.style.top = tuiPx(top - hostRect.top);
+        ghost.style.left = tuiPx(left - hostRect.left);
+        ghost.style.width = tuiPx(width);
+        ghost.style.height = tuiPx(height);
+        ghost.textContent = CHAR_ZERO_WIDTH_SPACE + value + CHAR_NO_BREAK_SPACE;
+        range.setStart(ghost.firstChild, selectionStart || 0);
+        range.setEnd(ghost.firstChild, selectionEnd || 0);
+        return range;
+    }
+    /**
+     * Create an invisible DIV styled exactly like input/textarea element inside directive
+     */
+    initGhost(element) {
+        const ghost = this.doc.createElement('div');
+        const { font, letterSpacing, textTransform, padding } = getComputedStyle(element);
+        ghost.style.position = 'absolute';
+        ghost.style.pointerEvents = 'none';
+        ghost.style.opacity = '0';
+        ghost.style.whiteSpace = 'pre-wrap';
+        ghost.style.font = font;
+        ghost.style.letterSpacing = letterSpacing;
+        ghost.style.textTransform = textTransform;
+        ghost.style.padding = padding;
+        this.vcr.element.nativeElement.appendChild(ghost);
+        this.ghost = ghost;
+        return ghost;
+    }
+}
+TuiDropdownSelectionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TuiDropdownSelectionDirective, deps: [{ token: TUI_RANGE }, { token: DOCUMENT }, { token: TUI_SELECTION_STREAM }, { token: ElementRef }, { token: ViewContainerRef }, { token: TuiDropdownDirective }], target: i0.ɵɵFactoryTarget.Directive });
+TuiDropdownSelectionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: TuiDropdownSelectionDirective, selector: "[tuiDropdown][tuiDropdownSelection]", inputs: { position: ["tuiDropdownSelectionPosition", "position"], tuiDropdownSelection: "tuiDropdownSelection" }, providers: [
+        tuiAsDriver(TuiDropdownSelectionDirective),
+        tuiAsRectAccessor(TuiDropdownSelectionDirective),
+    ], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TuiDropdownSelectionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tuiDropdown][tuiDropdownSelection]',
+                    providers: [
+                        tuiAsDriver(TuiDropdownSelectionDirective),
+                        tuiAsRectAccessor(TuiDropdownSelectionDirective),
+                    ],
+                }]
+        }], ctorParameters: function () { return [{ type: Range, decorators: [{
+                    type: Inject,
+                    args: [TUI_RANGE]
+                }] }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [TUI_SELECTION_STREAM]
+                }] }, { type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.ViewContainerRef, decorators: [{
+                    type: Inject,
+                    args: [ViewContainerRef]
+                }] }, { type: i2.TuiDropdownDirective, decorators: [{
+                    type: Inject,
+                    args: [TuiDropdownDirective]
+                }] }]; }, propDecorators: { position: [{
+                type: Input,
+                args: ['tuiDropdownSelectionPosition']
+            }], tuiDropdownSelection: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown-selection.directive.js","sourceRoot":"","sources":["../../../../../projects/core/directives/dropdown/dropdown-selection.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {DOCUMENT} from '@angular/common';\nimport {\n    Directive,\n    ElementRef,\n    Inject,\n    Input,\n    OnDestroy,\n    ViewContainerRef,\n} from '@angular/core';\nimport {\n    ALWAYS_TRUE_HANDLER,\n    CHAR_NO_BREAK_SPACE,\n    CHAR_ZERO_WIDTH_SPACE,\n    EMPTY_CLIENT_RECT,\n    TUI_RANGE,\n    TuiBooleanHandler,\n    tuiGetNativeFocused,\n    tuiIsElement,\n    tuiIsString,\n    tuiIsTextfield,\n    tuiIsTextNode,\n    tuiPx,\n} from '@taiga-ui/cdk';\nimport {\n    tuiAsDriver,\n    tuiAsRectAccessor,\n    TuiDriver,\n    TuiRectAccessor,\n} from '@taiga-ui/core/abstract';\nimport {TUI_SELECTION_STREAM} from '@taiga-ui/core/tokens';\nimport {tuiGetWordRange} from '@taiga-ui/core/utils';\nimport {BehaviorSubject, combineLatest, Observable} from 'rxjs';\nimport {distinctUntilChanged, map} from 'rxjs/operators';\n\nimport {TuiDropdownDirective} from './dropdown.directive';\n\n@Directive({\n    selector: '[tuiDropdown][tuiDropdownSelection]',\n    providers: [\n        tuiAsDriver(TuiDropdownSelectionDirective),\n        tuiAsRectAccessor(TuiDropdownSelectionDirective),\n    ],\n})\nexport class TuiDropdownSelectionDirective\n    extends TuiDriver\n    implements TuiRectAccessor, OnDestroy\n{\n    private readonly handler$ = new BehaviorSubject<TuiBooleanHandler<Range>>(\n        ALWAYS_TRUE_HANDLER,\n    );\n\n    private readonly stream$ = combineLatest([\n        this.handler$,\n        this.selection$.pipe(\n            map(() => this.getRange()),\n            distinctUntilChanged(\n                (x, y) => x.startOffset === y.startOffset && x.endOffset === y.endOffset,\n            ),\n        ),\n    ]).pipe(\n        map(([handler, range]) => {\n            const contained = this.el.nativeElement.contains(\n                range.commonAncestorContainer,\n            );\n\n            this.range =\n                contained && tuiIsTextNode(range.commonAncestorContainer)\n                    ? range\n                    : this.range;\n\n            return (contained && handler(this.range)) || this.inDropdown(range);\n        }),\n    );\n\n    private ghost?: HTMLElement;\n\n    @Input('tuiDropdownSelectionPosition')\n    position: 'selection' | 'tag' | 'word' = 'selection';\n\n    @Input()\n    set tuiDropdownSelection(visible: TuiBooleanHandler<Range> | string) {\n        if (!tuiIsString(visible)) {\n            this.handler$.next(visible);\n        }\n    }\n\n    readonly type = 'dropdown';\n\n    constructor(\n        @Inject(TUI_RANGE) private range: Range,\n        @Inject(DOCUMENT) private readonly doc: Document,\n        @Inject(TUI_SELECTION_STREAM) private readonly selection$: Observable<unknown>,\n        @Inject(ElementRef) private readonly el: ElementRef<HTMLElement>,\n        @Inject(ViewContainerRef) private readonly vcr: ViewContainerRef,\n        @Inject(TuiDropdownDirective) private readonly dropdown: TuiDropdownDirective,\n    ) {\n        super(subscriber => this.stream$.subscribe(subscriber));\n    }\n\n    getClientRect(): ClientRect {\n        switch (this.position) {\n            case 'tag': {\n                const {commonAncestorContainer} = this.range;\n                const element = tuiIsElement(commonAncestorContainer)\n                    ? commonAncestorContainer\n                    : commonAncestorContainer.parentNode;\n\n                return element && tuiIsElement(element)\n                    ? element.getBoundingClientRect()\n                    : EMPTY_CLIENT_RECT;\n            }\n            case 'word':\n                return tuiGetWordRange(this.range).getBoundingClientRect();\n            default:\n                return this.range.getBoundingClientRect();\n        }\n    }\n\n    ngOnDestroy(): void {\n        if (this.ghost) {\n            this.vcr.element.nativeElement.removeChild(this.ghost);\n        }\n    }\n\n    private getRange(): Range {\n        const active = tuiGetNativeFocused(this.doc);\n        const selection = this.doc.getSelection();\n        const range =\n            active && tuiIsTextfield(active) && this.el.nativeElement.contains(active)\n                ? this.veryVerySadInputFix(active)\n                : (selection?.rangeCount && selection.getRangeAt(0)) || this.range;\n\n        return range.cloneRange();\n    }\n\n    /**\n     * Check if Node is inside dropdown\n     */\n    private boxContains(node: Node): boolean {\n        return !!this.dropdown.dropdownBoxRef?.location.nativeElement.contains(node);\n    }\n\n    /**\n     * Check if given range is at least partially inside dropdown\n     */\n    private inDropdown(range: Range): boolean {\n        const {startContainer, endContainer} = range;\n        const {nativeElement} = this.el;\n        const inDropdown = this.boxContains(range.commonAncestorContainer);\n        const hostToDropdown =\n            this.boxContains(endContainer) && nativeElement.contains(startContainer);\n        const dropdownToHost =\n            this.boxContains(startContainer) && nativeElement.contains(endContainer);\n\n        return inDropdown || hostToDropdown || dropdownToHost;\n    }\n\n    private veryVerySadInputFix(element: HTMLInputElement | HTMLTextAreaElement): Range {\n        const {ghost = this.initGhost(element)} = this;\n        const {top, left, width, height} = element.getBoundingClientRect();\n        const {selectionStart, selectionEnd, value} = element;\n        const range = this.doc.createRange();\n        const hostRect = this.el.nativeElement.getBoundingClientRect();\n\n        ghost.style.top = tuiPx(top - hostRect.top);\n        ghost.style.left = tuiPx(left - hostRect.left);\n        ghost.style.width = tuiPx(width);\n        ghost.style.height = tuiPx(height);\n        ghost.textContent = CHAR_ZERO_WIDTH_SPACE + value + CHAR_NO_BREAK_SPACE;\n\n        range.setStart(ghost.firstChild as Node, selectionStart || 0);\n        range.setEnd(ghost.firstChild as Node, selectionEnd || 0);\n\n        return range;\n    }\n\n    /**\n     * Create an invisible DIV styled exactly like input/textarea element inside directive\n     */\n    private initGhost(element: HTMLInputElement | HTMLTextAreaElement): HTMLElement {\n        const ghost = this.doc.createElement('div');\n        const {font, letterSpacing, textTransform, padding} = getComputedStyle(element);\n\n        ghost.style.position = 'absolute';\n        ghost.style.pointerEvents = 'none';\n        ghost.style.opacity = '0';\n        ghost.style.whiteSpace = 'pre-wrap';\n        ghost.style.font = font;\n        ghost.style.letterSpacing = letterSpacing;\n        ghost.style.textTransform = textTransform;\n        ghost.style.padding = padding;\n\n        this.vcr.element.nativeElement.appendChild(ghost);\n        this.ghost = ghost;\n\n        return ghost;\n    }\n}\n"]}

package/esm2020/directives/dropdown/dropdown.component.mjs

@@ -0,0 +1,162 @@
+import { ChangeDetectionStrategy, Component, ElementRef, Inject, Optional, Self, } from '@angular/core';
+import { WINDOW } from '@ng-web-apis/common';
+import { TuiDestroyService, tuiGetClosestFocusable, tuiPx } from '@taiga-ui/cdk';
+import { tuiPositionAccessorFor, TuiRectAccessor, tuiRectAccessorFor, } from '@taiga-ui/core/abstract';
+import { tuiDropdownAnimation } from '@taiga-ui/core/animations';
+import { MODE_PROVIDER } from '@taiga-ui/core/providers';
+import { TuiPositionService, TuiVisualViewportService } from '@taiga-ui/core/services';
+import { TUI_ANIMATION_OPTIONS, TUI_MODE } from '@taiga-ui/core/tokens';
+import { map, takeUntil } from 'rxjs/operators';
+import { TuiDropdownDirective } from './dropdown.directive';
+import { TuiDropdownHoverDirective } from './dropdown-hover.directive';
+import { TUI_DROPDOWN_OPTIONS } from './dropdown-options.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@tinkoff/ng-polymorpheus";
+import * as i2 from "@taiga-ui/cdk";
+import * as i3 from "@taiga-ui/core/components/scrollbar";
+import * as i4 from "@taiga-ui/core/services";
+import * as i5 from "rxjs";
+import * as i6 from "./dropdown.directive";
+import * as i7 from "@taiga-ui/core/abstract";
+import * as i8 from "./dropdown-hover.directive";
+/**
+ * @description:
+ * This component is used to show template in a portal
+ * using default style of white rounded box with a shadow
+ */
+export class TuiDropdownComponent {
+    constructor(visualViewportService, position$, destroy$, directive, animation, el, accessor, win, mode$, options, hoverDirective) {
+        this.directive = directive;
+        this.animation = animation;
+        this.el = el;
+        this.accessor = accessor;
+        this.win = win;
+        this.mode$ = mode$;
+        this.options = options;
+        this.hoverDirective = hoverDirective;
+        position$
+            .pipe(map(point => this.directive.position === 'fixed'
+            ? visualViewportService.correct(point)
+            : point), takeUntil(destroy$))
+            .subscribe(([top, left]) => {
+            this.update(top, left);
+        });
+        this.updateWidth(this.accessor.getClientRect().width);
+    }
+    onHoveredChange(hovered) {
+        this.hoverDirective?.toggle(hovered);
+    }
+    onTopFocus() {
+        this.moveFocusOutside(true);
+    }
+    onBottomFocus() {
+        this.moveFocusOutside(false);
+    }
+    update(top, left) {
+        const { style } = this.el.nativeElement;
+        const { right } = this.el.nativeElement.getBoundingClientRect();
+        const { maxHeight, offset } = this.options;
+        const { innerHeight } = this.win;
+        const clientRect = this.el.nativeElement.offsetParent?.getBoundingClientRect();
+        const { position } = this.directive;
+        const rect = this.accessor.getClientRect();
+        const offsetX = position === 'fixed' ? 0 : -(clientRect?.left || 0);
+        const offsetY = position === 'fixed' ? 0 : -(clientRect?.top || 0);
+        top += offsetY;
+        left += offsetX;
+        const isIntersecting = left < rect.right && right > rect.left && top < offsetY + 2 * offset;
+        const available = isIntersecting
+            ? rect.top - 2 * offset
+            : offsetY + innerHeight - top - offset;
+        style.position = position;
+        style.top = tuiPx(Math.max(top, offsetY + offset));
+        style.left = tuiPx(left);
+        style.maxHeight = tuiPx(Math.min(maxHeight, available));
+        style.width = '';
+        style.minWidth = '';
+        this.updateWidth(rect.width);
+    }
+    updateWidth(width) {
+        const { style } = this.el.nativeElement;
+        switch (this.options.limitWidth) {
+            case 'min':
+                style.minWidth = tuiPx(width);
+                break;
+            case 'fixed':
+                style.width = tuiPx(width);
+                break;
+            case 'auto':
+                break;
+        }
+    }
+    moveFocusOutside(previous) {
+        const { nativeElement } = this.directive.el;
+        const { ownerDocument } = nativeElement;
+        const root = ownerDocument ? ownerDocument.body : nativeElement;
+        let focusable = tuiGetClosestFocusable({ initial: nativeElement, root, previous });
+        while (focusable !== null && nativeElement.contains(focusable)) {
+            focusable = tuiGetClosestFocusable({ initial: focusable, root, previous });
+        }
+        focusable?.focus();
+    }
+}
+TuiDropdownComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TuiDropdownComponent, deps: [{ token: TuiVisualViewportService }, { token: TuiPositionService }, { token: TuiDestroyService, self: true }, { token: TuiDropdownDirective }, { token: TUI_ANIMATION_OPTIONS }, { token: ElementRef }, { token: TuiRectAccessor }, { token: WINDOW }, { token: TUI_MODE }, { token: TUI_DROPDOWN_OPTIONS }, { token: TuiDropdownHoverDirective, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+TuiDropdownComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: TuiDropdownComponent, selector: "tui-dropdown", host: { listeners: { "$.data-mode.attr": "mode$" }, properties: { "@tuiDropdownAnimation": "animation", "attr.data-appearance": "options.appearance" } }, providers: [
+        TuiDestroyService,
+        TuiPositionService,
+        tuiPositionAccessorFor('dropdown'),
+        tuiRectAccessorFor('dropdown', TuiDropdownDirective),
+        MODE_PROVIDER,
+    ], ngImport: i0, template: "<tui-scrollbar\n    #activeZone=\"tuiActiveZone\"\n    tuiActiveZone\n    tuiOverscroll=\"all\"\n    class=\"t-scroll\"\n    (tuiHoveredChange)=\"onHoveredChange($event)\"\n>\n    <div\n        tabindex=\"0\"\n        (focus)=\"onTopFocus()\"\n    ></div>\n    <div\n        *polymorpheusOutlet=\"directive.content as text; context: {$implicit: activeZone}\"\n        class=\"t-primitive\"\n    >\n        {{ text }}\n    </div>\n    <div\n        tabindex=\"0\"\n        (focus)=\"onBottomFocus()\"\n    ></div>\n</tui-scrollbar>\n", styles: [":host{position:absolute;display:flex;box-shadow:var(--tui-shadow-dropdown);background:var(--tui-elevation-02);border-radius:var(--tui-radius-m);overflow:hidden;border:1px solid var(--tui-base-04);box-sizing:border-box;max-width:calc(100% - 8px);isolation:isolate;pointer-events:auto}:host.ng-animating{pointer-events:none}:host:not([style*=\"top\"]){visibility:hidden}:host[data-mode=onDark]{--tui-text-01: var(--tui-text-01-night);--tui-clear: var(--tui-clear-inverse);background:#222;border:1px solid #808080}.t-scroll{flex-grow:1;max-width:100%}.t-primitive{padding:1rem}\n"], dependencies: [{ kind: "directive", type: i1.PolymorpheusOutletDirective, selector: "[polymorpheusOutlet]", inputs: ["polymorpheusOutlet", "polymorpheusOutletContext"] }, { kind: "directive", type: i2.TuiActiveZoneDirective, selector: "[tuiActiveZone]:not(ng-container), [tuiActiveZoneChange]:not(ng-container), [tuiActiveZoneParent]:not(ng-container)", inputs: ["tuiActiveZoneParent"], outputs: ["tuiActiveZoneChange"], exportAs: ["tuiActiveZone"] }, { kind: "directive", type: i2.TuiOverscrollDirective, selector: "[tuiOverscroll]", inputs: ["tuiOverscroll"] }, { kind: "component", type: i3.TuiScrollbarComponent, selector: "tui-scrollbar", inputs: ["hidden"] }, { kind: "directive", type: i2.TuiHoveredDirective, selector: "[tuiHoveredChange]", outputs: ["tuiHoveredChange"] }], animations: [tuiDropdownAnimation], changeDetection: i0.ChangeDetectionStrategy.Default });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TuiDropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tui-dropdown', changeDetection: ChangeDetectionStrategy.Default, providers: [
+                        TuiDestroyService,
+                        TuiPositionService,
+                        tuiPositionAccessorFor('dropdown'),
+                        tuiRectAccessorFor('dropdown', TuiDropdownDirective),
+                        MODE_PROVIDER,
+                    ], host: {
+                        '[@tuiDropdownAnimation]': 'animation',
+                        '[attr.data-appearance]': 'options.appearance',
+                        '($.data-mode.attr)': 'mode$',
+                    }, animations: [tuiDropdownAnimation], template: "<tui-scrollbar\n    #activeZone=\"tuiActiveZone\"\n    tuiActiveZone\n    tuiOverscroll=\"all\"\n    class=\"t-scroll\"\n    (tuiHoveredChange)=\"onHoveredChange($event)\"\n>\n    <div\n        tabindex=\"0\"\n        (focus)=\"onTopFocus()\"\n    ></div>\n    <div\n        *polymorpheusOutlet=\"directive.content as text; context: {$implicit: activeZone}\"\n        class=\"t-primitive\"\n    >\n        {{ text }}\n    </div>\n    <div\n        tabindex=\"0\"\n        (focus)=\"onBottomFocus()\"\n    ></div>\n</tui-scrollbar>\n", styles: [":host{position:absolute;display:flex;box-shadow:var(--tui-shadow-dropdown);background:var(--tui-elevation-02);border-radius:var(--tui-radius-m);overflow:hidden;border:1px solid var(--tui-base-04);box-sizing:border-box;max-width:calc(100% - 8px);isolation:isolate;pointer-events:auto}:host.ng-animating{pointer-events:none}:host:not([style*=\"top\"]){visibility:hidden}:host[data-mode=onDark]{--tui-text-01: var(--tui-text-01-night);--tui-clear: var(--tui-clear-inverse);background:#222;border:1px solid #808080}.t-scroll{flex-grow:1;max-width:100%}.t-primitive{padding:1rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: i4.TuiVisualViewportService, decorators: [{
+                    type: Inject,
+                    args: [TuiVisualViewportService]
+                }] }, { type: i5.Observable, decorators: [{
+                    type: Inject,
+                    args: [TuiPositionService]
+                }] }, { type: i5.Observable, decorators: [{
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [TuiDestroyService]
+                }] }, { type: i6.TuiDropdownDirective, decorators: [{
+                    type: Inject,
+                    args: [TuiDropdownDirective]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TUI_ANIMATION_OPTIONS]
+                }] }, { type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i7.TuiRectAccessor, decorators: [{
+                    type: Inject,
+                    args: [TuiRectAccessor]
+                }] }, { type: Window, decorators: [{
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: i5.Observable, decorators: [{
+                    type: Inject,
+                    args: [TUI_MODE]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TUI_DROPDOWN_OPTIONS]
+                }] }, { type: i8.TuiDropdownHoverDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TuiDropdownHoverDirective]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown.component.js","sourceRoot":"","sources":["../../../../../projects/core/directives/dropdown/dropdown.component.ts","../../../../../projects/core/directives/dropdown/dropdown.template.html"],"names":[],"mappings":"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","sourcesContent":["import {AnimationOptions} from '@angular/animations';\nimport {\n    ChangeDetectionStrategy,\n    Component,\n    ElementRef,\n    Inject,\n    Optional,\n    Self,\n} from '@angular/core';\nimport {WINDOW} from '@ng-web-apis/common';\nimport {TuiDestroyService, tuiGetClosestFocusable, tuiPx} from '@taiga-ui/cdk';\nimport {\n    tuiPositionAccessorFor,\n    TuiRectAccessor,\n    tuiRectAccessorFor,\n} from '@taiga-ui/core/abstract';\nimport {tuiDropdownAnimation} from '@taiga-ui/core/animations';\nimport {MODE_PROVIDER} from '@taiga-ui/core/providers';\nimport {TuiPositionService, TuiVisualViewportService} from '@taiga-ui/core/services';\nimport {TUI_ANIMATION_OPTIONS, TUI_MODE} from '@taiga-ui/core/tokens';\nimport {TuiBrightness, TuiPoint} from '@taiga-ui/core/types';\nimport {Observable} from 'rxjs';\nimport {map, takeUntil} from 'rxjs/operators';\n\nimport {TuiDropdownDirective} from './dropdown.directive';\nimport {TuiDropdownHoverDirective} from './dropdown-hover.directive';\nimport {TUI_DROPDOWN_OPTIONS, TuiDropdownOptions} from './dropdown-options.directive';\n\n/**\n * @description:\n * This component is used to show template in a portal\n * using default style of white rounded box with a shadow\n */\n@Component({\n    selector: 'tui-dropdown',\n    templateUrl: './dropdown.template.html',\n    styleUrls: ['./dropdown.style.less'],\n    // @bad TODO: OnPush\n    // eslint-disable-next-line @angular-eslint/prefer-on-push-component-change-detection\n    changeDetection: ChangeDetectionStrategy.Default,\n    providers: [\n        TuiDestroyService,\n        TuiPositionService,\n        tuiPositionAccessorFor('dropdown'),\n        tuiRectAccessorFor('dropdown', TuiDropdownDirective),\n        MODE_PROVIDER,\n    ],\n    host: {\n        '[@tuiDropdownAnimation]': 'animation',\n        '[attr.data-appearance]': 'options.appearance',\n        '($.data-mode.attr)': 'mode$',\n    },\n    animations: [tuiDropdownAnimation],\n})\nexport class TuiDropdownComponent {\n    constructor(\n        @Inject(TuiVisualViewportService) visualViewportService: TuiVisualViewportService,\n        @Inject(TuiPositionService) position$: Observable<TuiPoint>,\n        @Self() @Inject(TuiDestroyService) destroy$: Observable<void>,\n        @Inject(TuiDropdownDirective) readonly directive: TuiDropdownDirective,\n        @Inject(TUI_ANIMATION_OPTIONS) readonly animation: AnimationOptions,\n        @Inject(ElementRef) private readonly el: ElementRef<HTMLElement>,\n        @Inject(TuiRectAccessor) private readonly accessor: TuiRectAccessor,\n        @Inject(WINDOW) private readonly win: Window,\n        @Inject(TUI_MODE) readonly mode$: Observable<TuiBrightness | null>,\n        @Inject(TUI_DROPDOWN_OPTIONS) readonly options: TuiDropdownOptions,\n        @Optional()\n        @Inject(TuiDropdownHoverDirective)\n        private readonly hoverDirective: TuiDropdownHoverDirective | null,\n    ) {\n        position$\n            .pipe(\n                map(point =>\n                    this.directive.position === 'fixed'\n                        ? visualViewportService.correct(point)\n                        : point,\n                ),\n                takeUntil(destroy$),\n            )\n            .subscribe(([top, left]) => {\n                this.update(top, left);\n            });\n\n        this.updateWidth(this.accessor.getClientRect().width);\n    }\n\n    onHoveredChange(hovered: boolean): void {\n        this.hoverDirective?.toggle(hovered);\n    }\n\n    onTopFocus(): void {\n        this.moveFocusOutside(true);\n    }\n\n    onBottomFocus(): void {\n        this.moveFocusOutside(false);\n    }\n\n    private update(top: number, left: number): void {\n        const {style} = this.el.nativeElement;\n        const {right} = this.el.nativeElement.getBoundingClientRect();\n        const {maxHeight, offset} = this.options;\n        const {innerHeight} = this.win;\n        const clientRect = this.el.nativeElement.offsetParent?.getBoundingClientRect();\n        const {position} = this.directive;\n        const rect = this.accessor.getClientRect();\n        const offsetX = position === 'fixed' ? 0 : -(clientRect?.left || 0);\n        const offsetY = position === 'fixed' ? 0 : -(clientRect?.top || 0);\n\n        top += offsetY;\n        left += offsetX;\n\n        const isIntersecting =\n            left < rect.right && right > rect.left && top < offsetY + 2 * offset;\n        const available = isIntersecting\n            ? rect.top - 2 * offset\n            : offsetY + innerHeight - top - offset;\n\n        style.position = position;\n        style.top = tuiPx(Math.max(top, offsetY + offset));\n        style.left = tuiPx(left);\n        style.maxHeight = tuiPx(Math.min(maxHeight, available));\n        style.width = '';\n        style.minWidth = '';\n\n        this.updateWidth(rect.width);\n    }\n\n    private updateWidth(width: number): void {\n        const {style} = this.el.nativeElement;\n\n        switch (this.options.limitWidth) {\n            case 'min':\n                style.minWidth = tuiPx(width);\n                break;\n            case 'fixed':\n                style.width = tuiPx(width);\n                break;\n            case 'auto':\n                break;\n        }\n    }\n\n    private moveFocusOutside(previous: boolean): void {\n        const {nativeElement} = this.directive.el;\n        const {ownerDocument} = nativeElement;\n        const root = ownerDocument ? ownerDocument.body : nativeElement;\n        let focusable = tuiGetClosestFocusable({initial: nativeElement, root, previous});\n\n        while (focusable !== null && nativeElement.contains(focusable)) {\n            focusable = tuiGetClosestFocusable({initial: focusable, root, previous});\n        }\n\n        focusable?.focus();\n    }\n}\n","<tui-scrollbar\n    #activeZone=\"tuiActiveZone\"\n    tuiActiveZone\n    tuiOverscroll=\"all\"\n    class=\"t-scroll\"\n    (tuiHoveredChange)=\"onHoveredChange($event)\"\n>\n    <div\n        tabindex=\"0\"\n        (focus)=\"onTopFocus()\"\n    ></div>\n    <div\n        *polymorpheusOutlet=\"directive.content as text; context: {$implicit: activeZone}\"\n        class=\"t-primitive\"\n    >\n        {{ text }}\n    </div>\n    <div\n        tabindex=\"0\"\n        (focus)=\"onBottomFocus()\"\n    ></div>\n</tui-scrollbar>\n"]}

package/esm2020/directives/dropdown/dropdown.directive.mjs

@@ -0,0 +1,121 @@
+import { __decorate } from "tslib";
+import { Directive, ElementRef, Inject, INJECTOR, Input, Optional, Self, } from '@angular/core';
+import { TuiDestroyService, TuiDropdownPortalService, tuiPure, } from '@taiga-ui/cdk';
+import { tuiAsRectAccessor, tuiAsVehicle, } from '@taiga-ui/core/abstract';
+import { tuiCheckFixedPosition } from '@taiga-ui/core/utils';
+import { PolymorpheusComponent } from '@tinkoff/ng-polymorpheus';
+import { Subject } from 'rxjs';
+import { takeUntil, throttleTime } from 'rxjs/operators';
+import { TUI_DROPDOWN_COMPONENT } from './dropdown.providers';
+import { TuiDropdownOpenDirective } from './dropdown-open.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "rxjs";
+import * as i2 from "@taiga-ui/cdk";
+import * as i3 from "./dropdown-open.directive";
+export class TuiDropdownDirective {
+    constructor(destroy$, el, dropdown, injector, dropdownService, open) {
+        this.el = el;
+        this.dropdown = dropdown;
+        this.injector = injector;
+        this.dropdownService = dropdownService;
+        this.open = open;
+        this.refresh$ = new Subject();
+        this.dropdownBoxRef = null;
+        this.type = 'dropdown';
+        this.component = new PolymorpheusComponent(this.dropdown, this.injector);
+        if (this.open && !this.open.dropdown) {
+            this.open.dropdown = this;
+        }
+        else {
+            this.open = null;
+        }
+        // Ignore multiple change detection triggers at the same frame
+        this.refresh$.pipe(throttleTime(0), takeUntil(destroy$)).subscribe(() => {
+            this.dropdownBoxRef?.changeDetectorRef.detectChanges();
+            this.dropdownBoxRef?.changeDetectorRef.markForCheck();
+        });
+    }
+    get position() {
+        return tuiCheckFixedPosition(this.el.nativeElement) ? 'fixed' : 'absolute';
+    }
+    ngAfterViewChecked() {
+        this.refresh$.next();
+    }
+    ngAfterViewInit() {
+        if (this.open) {
+            this.toggle(this.open.tuiDropdownOpen);
+        }
+    }
+    ngOnChanges() {
+        if (!this.content) {
+            this.toggle(false);
+        }
+    }
+    ngOnDestroy() {
+        this.toggle(false);
+        if (this.open) {
+            this.open.dropdown = undefined;
+        }
+    }
+    getClientRect() {
+        return this.el.nativeElement.getBoundingClientRect();
+    }
+    toggle(show) {
+        if (show && this.content && !this.dropdownBoxRef) {
+            this.dropdownBoxRef = this.dropdownService.add(this.component);
+            this.open?.update(true);
+        }
+        else if (!show && this.dropdownBoxRef) {
+            this.dropdownService.remove(this.dropdownBoxRef);
+            this.dropdownBoxRef = null;
+            this.open?.update(false);
+        }
+    }
+}
+TuiDropdownDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TuiDropdownDirective, deps: [{ token: TuiDestroyService, self: true }, { token: ElementRef }, { token: TUI_DROPDOWN_COMPONENT }, { token: INJECTOR }, { token: TuiDropdownPortalService }, { token: TuiDropdownOpenDirective, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+TuiDropdownDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: TuiDropdownDirective, selector: "[tuiDropdown]:not(ng-container)", inputs: { content: ["tuiDropdown", "content"] }, providers: [
+        TuiDestroyService,
+        tuiAsRectAccessor(TuiDropdownDirective),
+        tuiAsVehicle(TuiDropdownDirective),
+    ], exportAs: ["tuiDropdown"], usesOnChanges: true, ngImport: i0 });
+__decorate([
+    tuiPure
+], TuiDropdownDirective.prototype, "position", null);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TuiDropdownDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tuiDropdown]:not(ng-container)',
+                    providers: [
+                        TuiDestroyService,
+                        tuiAsRectAccessor(TuiDropdownDirective),
+                        tuiAsVehicle(TuiDropdownDirective),
+                    ],
+                    exportAs: 'tuiDropdown',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Observable, decorators: [{
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [TuiDestroyService]
+                }] }, { type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.Type, decorators: [{
+                    type: Inject,
+                    args: [TUI_DROPDOWN_COMPONENT]
+                }] }, { type: i0.Injector, decorators: [{
+                    type: Inject,
+                    args: [INJECTOR]
+                }] }, { type: i2.TuiDropdownPortalService, decorators: [{
+                    type: Inject,
+                    args: [TuiDropdownPortalService]
+                }] }, { type: i3.TuiDropdownOpenDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TuiDropdownOpenDirective]
+                }] }]; }, propDecorators: { content: [{
+                type: Input,
+                args: ['tuiDropdown']
+            }], position: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown.directive.js","sourceRoot":"","sources":["../../../../../projects/core/directives/dropdown/dropdown.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewChecked,\n    AfterViewInit,\n    ComponentRef,\n    Directive,\n    ElementRef,\n    Inject,\n    INJECTOR,\n    Injector,\n    Input,\n    OnChanges,\n    OnDestroy,\n    Optional,\n    Self,\n    Type,\n} from '@angular/core';\nimport {\n    TuiActiveZoneDirective,\n    TuiContextWithImplicit,\n    TuiDestroyService,\n    TuiDropdownPortalService,\n    tuiPure,\n} from '@taiga-ui/cdk';\nimport {\n    tuiAsRectAccessor,\n    tuiAsVehicle,\n    TuiRectAccessor,\n    TuiVehicle,\n} from '@taiga-ui/core/abstract';\nimport {TuiPortalItem} from '@taiga-ui/core/interfaces';\nimport {tuiCheckFixedPosition} from '@taiga-ui/core/utils';\nimport {PolymorpheusComponent, PolymorpheusContent} from '@tinkoff/ng-polymorpheus';\nimport {Observable, Subject} from 'rxjs';\nimport {takeUntil, throttleTime} from 'rxjs/operators';\n\nimport {TUI_DROPDOWN_COMPONENT} from './dropdown.providers';\nimport {TuiDropdownOpenDirective} from './dropdown-open.directive';\n\n@Directive({\n    selector: '[tuiDropdown]:not(ng-container)',\n    providers: [\n        TuiDestroyService,\n        tuiAsRectAccessor(TuiDropdownDirective),\n        tuiAsVehicle(TuiDropdownDirective),\n    ],\n    exportAs: 'tuiDropdown',\n})\nexport class TuiDropdownDirective\n    implements\n        AfterViewChecked,\n        AfterViewInit,\n        OnDestroy,\n        OnChanges,\n        TuiPortalItem,\n        TuiRectAccessor,\n        TuiVehicle\n{\n    private readonly refresh$ = new Subject<void>();\n\n    @Input('tuiDropdown')\n    content: PolymorpheusContent<TuiContextWithImplicit<TuiActiveZoneDirective>>;\n\n    dropdownBoxRef: ComponentRef<unknown> | null = null;\n\n    readonly type = 'dropdown';\n\n    readonly component = new PolymorpheusComponent(this.dropdown, this.injector);\n\n    constructor(\n        @Self() @Inject(TuiDestroyService) destroy$: Observable<unknown>,\n        @Inject(ElementRef) readonly el: ElementRef<HTMLElement>,\n        @Inject(TUI_DROPDOWN_COMPONENT) private readonly dropdown: Type<unknown>,\n        @Inject(INJECTOR) private readonly injector: Injector,\n        @Inject(TuiDropdownPortalService)\n        private readonly dropdownService: TuiDropdownPortalService,\n        @Optional()\n        @Inject(TuiDropdownOpenDirective)\n        private readonly open: TuiDropdownOpenDirective | null,\n    ) {\n        if (this.open && !this.open.dropdown) {\n            this.open.dropdown = this;\n        } else {\n            this.open = null;\n        }\n\n        // Ignore multiple change detection triggers at the same frame\n        this.refresh$.pipe(throttleTime(0), takeUntil(destroy$)).subscribe(() => {\n            this.dropdownBoxRef?.changeDetectorRef.detectChanges();\n            this.dropdownBoxRef?.changeDetectorRef.markForCheck();\n        });\n    }\n\n    @tuiPure\n    get position(): 'absolute' | 'fixed' {\n        return tuiCheckFixedPosition(this.el.nativeElement) ? 'fixed' : 'absolute';\n    }\n\n    ngAfterViewChecked(): void {\n        this.refresh$.next();\n    }\n\n    ngAfterViewInit(): void {\n        if (this.open) {\n            this.toggle(this.open.tuiDropdownOpen);\n        }\n    }\n\n    ngOnChanges(): void {\n        if (!this.content) {\n            this.toggle(false);\n        }\n    }\n\n    ngOnDestroy(): void {\n        this.toggle(false);\n\n        if (this.open) {\n            this.open.dropdown = undefined;\n        }\n    }\n\n    getClientRect(): ClientRect {\n        return this.el.nativeElement.getBoundingClientRect();\n    }\n\n    toggle(show: boolean): void {\n        if (show && this.content && !this.dropdownBoxRef) {\n            this.dropdownBoxRef = this.dropdownService.add(this.component);\n            this.open?.update(true);\n        } else if (!show && this.dropdownBoxRef) {\n            this.dropdownService.remove(this.dropdownBoxRef);\n            this.dropdownBoxRef = null;\n            this.open?.update(false);\n        }\n    }\n}\n"]}

package/esm2020/directives/dropdown/dropdown.module.mjs

@@ -0,0 +1,93 @@
+import { NgModule } from '@angular/core';
+import { TuiActiveZoneModule, TuiHoveredModule, TuiOverscrollModule } from '@taiga-ui/cdk';
+import { TuiScrollbarModule } from '@taiga-ui/core/components/scrollbar';
+import { PolymorpheusModule } from '@tinkoff/ng-polymorpheus';
+import { TuiDropdownComponent } from './dropdown.component';
+import { TuiDropdownDirective } from './dropdown.directive';
+import { TuiDropdownContextDirective } from './dropdown-context.directive';
+import { TuiDropdownDriverDirective } from './dropdown-driver.directive';
+import { TuiDropdownHostDirective } from './dropdown-host.directive';
+import { TuiDropdownHoverDirective } from './dropdown-hover.directive';
+import { TuiDropdownManualDirective } from './dropdown-manual.directive';
+import { TuiDropdownOpenDirective } from './dropdown-open.directive';
+import { TuiDropdownOptionsDirective } from './dropdown-options.directive';
+import { TuiDropdownPositionDirective } from './dropdown-position.directive';
+import { TuiDropdownPositionSidedDirective } from './dropdown-position-sided.directive';
+import { TuiDropdownSelectionDirective } from './dropdown-selection.directive';
+import * as i0 from "@angular/core";
+export class TuiDropdownModule {
+}
+TuiDropdownModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TuiDropdownModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TuiDropdownModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: TuiDropdownModule, declarations: [TuiDropdownDirective,
+        TuiDropdownComponent,
+        TuiDropdownOpenDirective,
+        TuiDropdownOptionsDirective,
+        TuiDropdownHostDirective,
+        TuiDropdownDriverDirective,
+        TuiDropdownManualDirective,
+        TuiDropdownHoverDirective,
+        TuiDropdownContextDirective,
+        TuiDropdownPositionDirective,
+        TuiDropdownPositionSidedDirective,
+        TuiDropdownSelectionDirective], imports: [PolymorpheusModule,
+        TuiActiveZoneModule,
+        TuiOverscrollModule,
+        TuiScrollbarModule,
+        TuiHoveredModule], exports: [TuiDropdownDirective,
+        TuiDropdownComponent,
+        TuiDropdownOpenDirective,
+        TuiDropdownOptionsDirective,
+        TuiDropdownHostDirective,
+        TuiDropdownDriverDirective,
+        TuiDropdownManualDirective,
+        TuiDropdownHoverDirective,
+        TuiDropdownContextDirective,
+        TuiDropdownPositionDirective,
+        TuiDropdownPositionSidedDirective,
+        TuiDropdownSelectionDirective] });
+TuiDropdownModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TuiDropdownModule, imports: [PolymorpheusModule,
+        TuiActiveZoneModule,
+        TuiOverscrollModule,
+        TuiScrollbarModule,
+        TuiHoveredModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: TuiDropdownModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        PolymorpheusModule,
+                        TuiActiveZoneModule,
+                        TuiOverscrollModule,
+                        TuiScrollbarModule,
+                        TuiHoveredModule,
+                    ],
+                    declarations: [
+                        TuiDropdownDirective,
+                        TuiDropdownComponent,
+                        TuiDropdownOpenDirective,
+                        TuiDropdownOptionsDirective,
+                        TuiDropdownHostDirective,
+                        TuiDropdownDriverDirective,
+                        TuiDropdownManualDirective,
+                        TuiDropdownHoverDirective,
+                        TuiDropdownContextDirective,
+                        TuiDropdownPositionDirective,
+                        TuiDropdownPositionSidedDirective,
+                        TuiDropdownSelectionDirective,
+                    ],
+                    exports: [
+                        TuiDropdownDirective,
+                        TuiDropdownComponent,
+                        TuiDropdownOpenDirective,
+                        TuiDropdownOptionsDirective,
+                        TuiDropdownHostDirective,
+                        TuiDropdownDriverDirective,
+                        TuiDropdownManualDirective,
+                        TuiDropdownHoverDirective,
+                        TuiDropdownContextDirective,
+                        TuiDropdownPositionDirective,
+                        TuiDropdownPositionSidedDirective,
+                        TuiDropdownSelectionDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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