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

package/esm2022/components/stepper/stepper.component.mjs

@@ -0,0 +1,129 @@
+import { __decorate } from "tslib";
+import { AsyncPipe, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, DestroyRef, ElementRef, EventEmitter, forwardRef, HostBinding, HostListener, inject, Input, Output, } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { ResizeObserverService } from '@ng-web-apis/resize-observer';
+import { EMPTY_QUERY } from '@taiga-ui/cdk/constants';
+import { tuiQueryListChanges } from '@taiga-ui/cdk/observables';
+import { TuiScrollService } from '@taiga-ui/cdk/services';
+import { tuiInjectElement, tuiIsElement } from '@taiga-ui/cdk/utils/dom';
+import { tuiMoveFocus } from '@taiga-ui/cdk/utils/focus';
+import { tuiGetOriginalArrayFromQueryList, tuiPure, } from '@taiga-ui/cdk/utils/miscellaneous';
+import { TUI_ANIMATIONS_SPEED } from '@taiga-ui/core/tokens';
+import { tuiGetDuration } from '@taiga-ui/core/utils/miscellaneous';
+import { delay } from 'rxjs';
+import { TuiStep } from './step.component';
+import * as i0 from "@angular/core";
+class TuiStepperComponent {
+    constructor() {
+        this.steps = EMPTY_QUERY;
+        this.cdr = inject(ChangeDetectorRef);
+        this.el = tuiInjectElement();
+        this.scrollService = inject(TuiScrollService);
+        this.resize$ = inject(ResizeObserverService);
+        this.speed = inject(TUI_ANIMATIONS_SPEED);
+        this.destroyRef = inject(DestroyRef);
+        this.activeItemIndex = 0;
+        this.orientation = 'horizontal';
+        this.activeItemIndexChange = new EventEmitter();
+        this.resize$
+            .pipe(takeUntilDestroyed())
+            .subscribe(() => this.scrollIntoView(this.activeItemIndex));
+    }
+    set activeIndex(index) {
+        this.activeItemIndex = index;
+        this.scrollIntoView(index);
+    }
+    indexOf(step) {
+        return tuiGetOriginalArrayFromQueryList(this.steps).findIndex(({ nativeElement }) => nativeElement === step);
+    }
+    isActive(index) {
+        return index === this.activeItemIndex;
+    }
+    activate(index) {
+        if (this.activeItemIndex === index) {
+            return;
+        }
+        this.activeItemIndex = index;
+        this.activeItemIndexChange.emit(index);
+        this.cdr.markForCheck();
+        this.scrollIntoView(index);
+    }
+    get changes$() {
+        // Delay is required to trigger change detection after steps are rendered,
+        // so they can update their "active" status
+        return tuiQueryListChanges(this.steps).pipe(delay(0));
+    }
+    onHorizontal(event, step) {
+        if (this.orientation !== 'horizontal' || !event.target) {
+            return;
+        }
+        event.preventDefault();
+        this.moveFocus(event.target, step);
+    }
+    onVertical(event, step) {
+        if (this.orientation !== 'vertical' || !event.target) {
+            return;
+        }
+        event.preventDefault();
+        this.moveFocus(event.target, step);
+    }
+    moveFocus(current, step) {
+        if (!tuiIsElement(current)) {
+            return;
+        }
+        const stepElements = this.steps.toArray().map(({ nativeElement }) => nativeElement);
+        const index = stepElements.findIndex((element) => element === current);
+        tuiMoveFocus(index, stepElements, step);
+    }
+    scrollIntoView(index) {
+        const step = this.steps.get(index)?.nativeElement;
+        if (!step) {
+            return;
+        }
+        const { clientHeight, clientWidth, offsetTop, offsetLeft } = this.el;
+        const { offsetHeight, offsetWidth, offsetTop: stepOffsetTop, offsetLeft: stepOffsetLeft, } = step;
+        const top = stepOffsetTop - offsetTop - clientHeight / 2 + offsetHeight / 2;
+        const left = stepOffsetLeft - offsetLeft - clientWidth / 2 + offsetWidth / 2;
+        this.scrollService
+            .scroll$(this.el, Math.max(0, top), Math.max(0, left), tuiGetDuration(this.speed) / 3)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiStepperComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiStepperComponent, isStandalone: true, selector: "tui-stepper, nav[tuiStepper]", inputs: { orientation: "orientation", activeIndex: ["activeItemIndex", "activeIndex"] }, outputs: { activeItemIndexChange: "activeItemIndexChange" }, host: { listeners: { "keydown.arrowRight": "onHorizontal($event,1)", "keydown.arrowLeft": "onHorizontal($event,-1)", "keydown.arrowDown": "onVertical($event,1)", "keydown.arrowUp": "onVertical($event,-1)" }, properties: { "attr.data-orientation": "this.orientation" } }, providers: [ResizeObserverService], queries: [{ propertyName: "steps", predicate: i0.forwardRef(function () { return TuiStep; }), read: ElementRef }], ngImport: i0, template: "<ng-container *ngIf=\"changes$ | async\" />\n<ng-content />\n", styles: [":host{scrollbar-width:none;-ms-overflow-style:none;scroll-behavior:smooth;display:flex;overflow:auto;counter-reset:steps}:host::-webkit-scrollbar,:host::-webkit-scrollbar-thumb{display:none}:host-context(tui-root._reduced-motion) :host{scroll-behavior:auto}:host[data-orientation=vertical]{flex-direction:column}\n"], dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+__decorate([
+    tuiPure
+], TuiStepperComponent.prototype, "changes$", null);
+export { TuiStepperComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiStepperComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'tui-stepper, nav[tuiStepper]', imports: [AsyncPipe, NgIf], changeDetection: ChangeDetectionStrategy.OnPush, providers: [ResizeObserverService], template: "<ng-container *ngIf=\"changes$ | async\" />\n<ng-content />\n", styles: [":host{scrollbar-width:none;-ms-overflow-style:none;scroll-behavior:smooth;display:flex;overflow:auto;counter-reset:steps}:host::-webkit-scrollbar,:host::-webkit-scrollbar-thumb{display:none}:host-context(tui-root._reduced-motion) :host{scroll-behavior:auto}:host[data-orientation=vertical]{flex-direction:column}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { steps: [{
+                type: ContentChildren,
+                args: [forwardRef(() => TuiStep), { read: ElementRef }]
+            }], orientation: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.data-orientation']
+            }], activeItemIndexChange: [{
+                type: Output
+            }], activeIndex: [{
+                type: Input,
+                args: ['activeItemIndex']
+            }], changes$: [], onHorizontal: [{
+                type: HostListener,
+                args: ['keydown.arrowRight', ['$event', '1']]
+            }, {
+                type: HostListener,
+                args: ['keydown.arrowLeft', ['$event', '-1']]
+            }], onVertical: [{
+                type: HostListener,
+                args: ['keydown.arrowDown', ['$event', '1']]
+            }, {
+                type: HostListener,
+                args: ['keydown.arrowUp', ['$event', '-1']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stepper.component.js","sourceRoot":"","sources":["../../../../../projects/kit/components/stepper/stepper.component.ts","../../../../../projects/kit/components/stepper/stepper.template.html"],"names":[],"mappings":"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","sourcesContent":["import {AsyncPipe, NgIf} from '@angular/common';\nimport type {QueryList} from '@angular/core';\nimport {\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ContentChildren,\n    DestroyRef,\n    ElementRef,\n    EventEmitter,\n    forwardRef,\n    HostBinding,\n    HostListener,\n    inject,\n    Input,\n    Output,\n} from '@angular/core';\nimport {takeUntilDestroyed} from '@angular/core/rxjs-interop';\nimport {ResizeObserverService} from '@ng-web-apis/resize-observer';\nimport {EMPTY_QUERY} from '@taiga-ui/cdk/constants';\nimport {tuiQueryListChanges} from '@taiga-ui/cdk/observables';\nimport {TuiScrollService} from '@taiga-ui/cdk/services';\nimport {tuiInjectElement, tuiIsElement} from '@taiga-ui/cdk/utils/dom';\nimport {tuiMoveFocus} from '@taiga-ui/cdk/utils/focus';\nimport {\n    tuiGetOriginalArrayFromQueryList,\n    tuiPure,\n} from '@taiga-ui/cdk/utils/miscellaneous';\nimport {TUI_ANIMATIONS_SPEED} from '@taiga-ui/core/tokens';\nimport type {TuiOrientation} from '@taiga-ui/core/types';\nimport {tuiGetDuration} from '@taiga-ui/core/utils/miscellaneous';\nimport type {Observable} from 'rxjs';\nimport {delay} from 'rxjs';\n\nimport {TuiStep} from './step.component';\n\n@Component({\n    standalone: true,\n    selector: 'tui-stepper, nav[tuiStepper]',\n    imports: [AsyncPipe, NgIf],\n    templateUrl: './stepper.template.html',\n    styleUrls: ['./stepper.style.less'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [ResizeObserverService],\n})\nexport class TuiStepperComponent {\n    @ContentChildren(forwardRef(() => TuiStep), {read: ElementRef})\n    private readonly steps: QueryList<ElementRef<HTMLElement>> = EMPTY_QUERY;\n\n    private readonly cdr = inject(ChangeDetectorRef);\n    private readonly el = tuiInjectElement();\n    private readonly scrollService = inject(TuiScrollService);\n    private readonly resize$ = inject(ResizeObserverService);\n    private readonly speed = inject(TUI_ANIMATIONS_SPEED);\n    private readonly destroyRef = inject(DestroyRef);\n\n    protected activeItemIndex = 0;\n\n    @Input()\n    @HostBinding('attr.data-orientation')\n    public orientation: TuiOrientation = 'horizontal';\n\n    @Output()\n    public readonly activeItemIndexChange = new EventEmitter<number>();\n\n    constructor() {\n        this.resize$\n            .pipe(takeUntilDestroyed())\n            .subscribe(() => this.scrollIntoView(this.activeItemIndex));\n    }\n\n    @Input('activeItemIndex')\n    public set activeIndex(index: number) {\n        this.activeItemIndex = index;\n        this.scrollIntoView(index);\n    }\n\n    public indexOf(step: HTMLElement): number {\n        return tuiGetOriginalArrayFromQueryList(this.steps).findIndex(\n            ({nativeElement}) => nativeElement === step,\n        );\n    }\n\n    public isActive(index: number): boolean {\n        return index === this.activeItemIndex;\n    }\n\n    public activate(index: number): void {\n        if (this.activeItemIndex === index) {\n            return;\n        }\n\n        this.activeItemIndex = index;\n        this.activeItemIndexChange.emit(index);\n        this.cdr.markForCheck();\n        this.scrollIntoView(index);\n    }\n\n    @tuiPure\n    protected get changes$(): Observable<unknown> {\n        // Delay is required to trigger change detection after steps are rendered,\n        // so they can update their \"active\" status\n        return tuiQueryListChanges(this.steps).pipe(delay(0));\n    }\n\n    @HostListener('keydown.arrowRight', ['$event', '1'])\n    @HostListener('keydown.arrowLeft', ['$event', '-1'])\n    protected onHorizontal(event: Event, step: number): void {\n        if (this.orientation !== 'horizontal' || !event.target) {\n            return;\n        }\n\n        event.preventDefault();\n        this.moveFocus(event.target, step);\n    }\n\n    @HostListener('keydown.arrowDown', ['$event', '1'])\n    @HostListener('keydown.arrowUp', ['$event', '-1'])\n    protected onVertical(event: Event, step: number): void {\n        if (this.orientation !== 'vertical' || !event.target) {\n            return;\n        }\n\n        event.preventDefault();\n        this.moveFocus(event.target, step);\n    }\n\n    private moveFocus(current: EventTarget, step: number): void {\n        if (!tuiIsElement(current)) {\n            return;\n        }\n\n        const stepElements = this.steps.toArray().map(({nativeElement}) => nativeElement);\n        const index = stepElements.findIndex((element) => element === current);\n\n        tuiMoveFocus(index, stepElements, step);\n    }\n\n    private scrollIntoView(index: number): void {\n        const step = this.steps.get(index)?.nativeElement;\n\n        if (!step) {\n            return;\n        }\n\n        const {clientHeight, clientWidth, offsetTop, offsetLeft} = this.el;\n        const {\n            offsetHeight,\n            offsetWidth,\n            offsetTop: stepOffsetTop,\n            offsetLeft: stepOffsetLeft,\n        } = step;\n        const top = stepOffsetTop - offsetTop - clientHeight / 2 + offsetHeight / 2;\n        const left = stepOffsetLeft - offsetLeft - clientWidth / 2 + offsetWidth / 2;\n\n        this.scrollService\n            .scroll$(\n                this.el,\n                Math.max(0, top),\n                Math.max(0, left),\n                tuiGetDuration(this.speed) / 3,\n            )\n            .pipe(takeUntilDestroyed(this.destroyRef))\n            .subscribe();\n    }\n}\n","<ng-container *ngIf=\"changes$ | async\" />\n<ng-content />\n"]}

package/esm2022/components/stepper/stepper.mjs

@@ -0,0 +1,4 @@
+import { TuiStep } from './step.component';
+import { TuiStepperComponent } from './stepper.component';
+export const TuiStepper = [TuiStepperComponent, TuiStep];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RlcHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2tpdC9jb21wb25lbnRzL3N0ZXBwZXIvc3RlcHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsT0FBTyxFQUFDLE1BQU0sa0JBQWtCLENBQUM7QUFDekMsT0FBTyxFQUFDLG1CQUFtQixFQUFDLE1BQU0scUJBQXFCLENBQUM7QUFFeEQsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLENBQUMsbUJBQW1CLEVBQUUsT0FBTyxDQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1R1aVN0ZXB9IGZyb20gJy4vc3RlcC5jb21wb25lbnQnO1xuaW1wb3J0IHtUdWlTdGVwcGVyQ29tcG9uZW50fSBmcm9tICcuL3N0ZXBwZXIuY29tcG9uZW50JztcblxuZXhwb3J0IGNvbnN0IFR1aVN0ZXBwZXIgPSBbVHVpU3RlcHBlckNvbXBvbmVudCwgVHVpU3RlcF0gYXMgY29uc3Q7XG4iXX0=

package/esm2022/components/switch/index.mjs

@@ -0,0 +1,3 @@
+export * from './switch.component';
+export * from './switch.options';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9raXQvY29tcG9uZW50cy9zd2l0Y2gvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zd2l0Y2guY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc3dpdGNoLm9wdGlvbnMnO1xuIl19

package/esm2022/components/switch/switch.component.mjs

@@ -0,0 +1,51 @@
+import { ChangeDetectionStrategy, Component, HostBinding, inject, Input, } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { TuiNativeValidator } from '@taiga-ui/cdk/directives/native-validator';
+import { tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
+import { tuiIsString } from '@taiga-ui/cdk/utils/miscellaneous';
+import { TuiAppearance, TuiWithAppearance } from '@taiga-ui/core/directives/appearance';
+import { tuiInjectIconResolver } from '@taiga-ui/core/tokens';
+import { TUI_SWITCH_OPTIONS } from './switch.options';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/directives/appearance";
+import * as i2 from "@taiga-ui/cdk/directives/native-validator";
+class TuiSwitch {
+    constructor() {
+        this.appearance = inject(TuiAppearance);
+        this.resolver = tuiInjectIconResolver();
+        this.options = inject(TUI_SWITCH_OPTIONS);
+        this.el = tuiInjectElement();
+        this.control = inject(NgControl, { optional: true, self: true });
+        this.size = this.options.size;
+        this.showIcons = this.options.showIcons;
+    }
+    ngDoCheck() {
+        this.appearance.tuiAppearance = this.options.appearance(this.el);
+    }
+    get icon() {
+        const { options, resolver, size } = this;
+        const icon = tuiIsString(options.icon) ? options.icon : options.icon(size);
+        return `url(${resolver(icon)})`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiSwitch, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiSwitch, isStandalone: true, selector: "input[type=\"checkbox\"][tuiSwitch]", inputs: { size: "size", showIcons: "showIcons" }, host: { attributes: { "role": "switch" }, properties: { "disabled": "!control || control.disabled", "attr.data-size": "size", "class._readonly": "!control", "class._icons": "showIcons", "style.--t-mask": "this.icon" } }, hostDirectives: [{ directive: i1.TuiWithAppearance }, { directive: i2.TuiNativeValidator }], ngImport: i0, template: '', isInline: true, styles: [":host{transition-property:background,box-shadow;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;width:3rem;height:1.5rem;border-radius:2rem;overflow:hidden;cursor:pointer;margin:0;color:#fff!important}:host[data-size=s]{height:1rem;width:2rem}:host[data-size=s]:before{width:1rem;transform:translate(-1rem);-webkit-mask-size:.75rem;mask-size:.75rem}:host[data-size=s]:after{width:1rem;box-shadow:-2rem 0 0 .25rem currentColor}:host[data-size=s]:checked:after{transform:scale(.5) translate(2rem)}:host:checked:before{transform:none}:host:checked:after{transform:scale(.5) translate(3rem)}:host:disabled._readonly{opacity:1}:host:before,:host:after{transition-property:transform;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;content:\"\";position:absolute;height:100%;width:1.5rem}:host:before{display:none;background:currentColor;-webkit-mask:var(--t-mask) no-repeat center;mask:var(--t-mask) no-repeat center;-webkit-mask-size:1rem;mask-size:1rem;transform:translate(-1.5rem)}:host:after{right:0;border-radius:100%;transform:scale(.5);box-shadow:-3rem 0 0 .25rem currentColor}:host._icons:before{display:block}:host._icons:after{box-shadow:inset 0 0 0 .25rem var(--tui-background-neutral-2-pressed),-3rem 0 0 .25rem currentColor}:host._icons[data-size=s]:after{box-shadow:inset 0 0 0 .125rem var(--tui-background-neutral-2-pressed),-2rem 0 0 .25rem currentColor}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { TuiSwitch };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiSwitch, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'input[type="checkbox"][tuiSwitch]', template: '', changeDetection: ChangeDetectionStrategy.OnPush, hostDirectives: [TuiWithAppearance, TuiNativeValidator], host: {
+                        role: 'switch',
+                        '[disabled]': '!control || control.disabled',
+                        '[attr.data-size]': 'size',
+                        '[class._readonly]': '!control',
+                        '[class._icons]': 'showIcons',
+                    }, styles: [":host{transition-property:background,box-shadow;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;width:3rem;height:1.5rem;border-radius:2rem;overflow:hidden;cursor:pointer;margin:0;color:#fff!important}:host[data-size=s]{height:1rem;width:2rem}:host[data-size=s]:before{width:1rem;transform:translate(-1rem);-webkit-mask-size:.75rem;mask-size:.75rem}:host[data-size=s]:after{width:1rem;box-shadow:-2rem 0 0 .25rem currentColor}:host[data-size=s]:checked:after{transform:scale(.5) translate(2rem)}:host:checked:before{transform:none}:host:checked:after{transform:scale(.5) translate(3rem)}:host:disabled._readonly{opacity:1}:host:before,:host:after{transition-property:transform;transition-duration:var(--tui-duration, .3s);transition-timing-function:ease-in-out;content:\"\";position:absolute;height:100%;width:1.5rem}:host:before{display:none;background:currentColor;-webkit-mask:var(--t-mask) no-repeat center;mask:var(--t-mask) no-repeat center;-webkit-mask-size:1rem;mask-size:1rem;transform:translate(-1.5rem)}:host:after{right:0;border-radius:100%;transform:scale(.5);box-shadow:-3rem 0 0 .25rem currentColor}:host._icons:before{display:block}:host._icons:after{box-shadow:inset 0 0 0 .25rem var(--tui-background-neutral-2-pressed),-3rem 0 0 .25rem currentColor}:host._icons[data-size=s]:after{box-shadow:inset 0 0 0 .125rem var(--tui-background-neutral-2-pressed),-2rem 0 0 .25rem currentColor}\n"] }]
+        }], propDecorators: { size: [{
+                type: Input
+            }], showIcons: [{
+                type: Input
+            }], icon: [{
+                type: HostBinding,
+                args: ['style.--t-mask']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/switch/switch.options.mjs

@@ -0,0 +1,12 @@
+import { tuiCreateToken, tuiProvideOptions } from '@taiga-ui/cdk/utils/miscellaneous';
+export const TUI_SWITCH_DEFAULT_OPTIONS = {
+    showIcons: true,
+    size: 'm',
+    icon: '@tui.check',
+    appearance: (el) => (el.checked ? 'primary' : 'secondary'),
+};
+export const TUI_SWITCH_OPTIONS = tuiCreateToken(TUI_SWITCH_DEFAULT_OPTIONS);
+export function tuiSwitchOptionsProvider(options) {
+    return tuiProvideOptions(TUI_SWITCH_OPTIONS, options, TUI_SWITCH_DEFAULT_OPTIONS);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/switch/taiga-ui-kit-components-switch.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFpZ2EtdWkta2l0LWNvbXBvbmVudHMtc3dpdGNoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2l0L2NvbXBvbmVudHMvc3dpdGNoL3RhaWdhLXVpLWtpdC1jb21wb25lbnRzLXN3aXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/components/tabs/index.mjs

@@ -0,0 +1,9 @@
+export * from './tab.directive';
+export * from './tabs';
+export * from './tabs.directive';
+export * from './tabs.options';
+export * from './tabs.providers';
+export * from './tabs-horizontal.directive';
+export * from './tabs-vertical.directive';
+export * from './tabs-with-more.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9raXQvY29tcG9uZW50cy90YWJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RhYi5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJzJztcbmV4cG9ydCAqIGZyb20gJy4vdGFicy5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJzLm9wdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJzLnByb3ZpZGVycyc7XG5leHBvcnQgKiBmcm9tICcuL3RhYnMtaG9yaXpvbnRhbC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJzLXZlcnRpY2FsLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3RhYnMtd2l0aC1tb3JlLmNvbXBvbmVudCc7XG4iXX0=

package/esm2022/components/tabs/tab.directive.mjs

@@ -0,0 +1,43 @@
+import { Directive, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { RouterLinkActive } from '@angular/router';
+import { MutationObserverService } from '@ng-web-apis/mutation-observer';
+import { tuiTypedFromEvent } from '@taiga-ui/cdk/observables';
+import { tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
+import { tuiIsNativeFocused } from '@taiga-ui/cdk/utils/focus';
+import { TuiWithIcons } from '@taiga-ui/core/directives/icons';
+import { EMPTY, filter, merge } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@taiga-ui/core/directives/icons";
+export const TUI_TAB_ACTIVATE = 'tui-tab-activate';
+class TuiTab {
+    constructor() {
+        this.el = tuiInjectElement();
+        this.rla = inject(RouterLinkActive, { optional: true });
+        this.observer = this.rla &&
+            inject(MutationObserverService, { optional: true })?.pipe(filter(() => !!this.rla?.isActive));
+        this.sub = merge(this.observer || EMPTY, this.rla?.isActiveChange.pipe(filter(Boolean)) || EMPTY, this.el.matches('button') ? tuiTypedFromEvent(this.el, 'click') : EMPTY)
+            .pipe(takeUntilDestroyed())
+            .subscribe(() => this.el.dispatchEvent(new CustomEvent(TUI_TAB_ACTIVATE, { bubbles: true })));
+    }
+    ngOnDestroy() {
+        if (tuiIsNativeFocused(this.el)) {
+            this.el.blur();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTab, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TuiTab, isStandalone: true, selector: "a[tuiTab]:not([routerLink]), a[tuiTab][routerLink][routerLinkActive], button[tuiTab]", host: { attributes: { "type": "button" } }, hostDirectives: [{ directive: i1.TuiWithIcons }], ngImport: i0 }); }
+}
+export { TuiTab };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTab, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: 'a[tuiTab]:not([routerLink]), a[tuiTab][routerLink][routerLinkActive], button[tuiTab]',
+                    hostDirectives: [TuiWithIcons],
+                    host: {
+                        type: 'button',
+                    },
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/tabs/tabs-horizontal.directive.mjs

@@ -0,0 +1,114 @@
+import { __decorate } from "tslib";
+import { ContentChildren, Directive, forwardRef, HostListener, inject, Input, NgZone, } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { MUTATION_OBSERVER_INIT, MutationObserverService, } from '@ng-web-apis/mutation-observer';
+import { EMPTY_QUERY } from '@taiga-ui/cdk/constants';
+import { tuiZonefree } from '@taiga-ui/cdk/observables';
+import { tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
+import { tuiPure, tuiPx } from '@taiga-ui/cdk/utils/miscellaneous';
+import { TuiTab } from './tab.directive';
+import { TuiTabsDirective } from './tabs.directive';
+import { TUI_TABS_OPTIONS } from './tabs.options';
+import * as i0 from "@angular/core";
+import * as i1 from "./tabs.directive";
+class TuiTabsHorizontal {
+    constructor() {
+        this.el = tuiInjectElement();
+        this.options = inject(TUI_TABS_OPTIONS);
+        this.tabs = inject(TuiTabsDirective);
+        this.children = EMPTY_QUERY;
+        this.sub = inject(MutationObserverService)
+            .pipe(tuiZonefree(inject(NgZone)), takeUntilDestroyed())
+            .subscribe(() => this.refresh());
+        this.underline = this.options.underline;
+    }
+    ngAfterViewChecked() {
+        this.scrollTo(this.tabs.activeItemIndex);
+        this.refresh();
+    }
+    onKeyDownArrow(current, step) {
+        this.tabs.moveFocus(current, step);
+    }
+    refresh() {
+        const { activeElement } = this.tabs;
+        if (activeElement && !activeElement.isConnected) {
+            return;
+        }
+        const { offsetLeft = 0, offsetWidth = 0 } = activeElement || {};
+        this.el.style.setProperty('--t-left', tuiPx(offsetLeft));
+        this.el.style.setProperty('--t-width', tuiPx(offsetWidth));
+    }
+    scrollTo(index) {
+        const element = this.tabs.tabs[index];
+        if (!element) {
+            return;
+        }
+        const { offsetLeft, offsetWidth } = element;
+        if (offsetLeft < this.el.scrollLeft) {
+            this.el.scrollLeft = offsetLeft;
+        }
+        if (offsetLeft + offsetWidth > this.el.scrollLeft + this.el.offsetWidth) {
+            this.el.scrollLeft = offsetLeft + offsetWidth - this.el.offsetWidth;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTabsHorizontal, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TuiTabsHorizontal, isStandalone: true, selector: "tui-tabs:not([vertical]), nav[tuiTabs]:not([vertical])", inputs: { underline: "underline" }, host: { listeners: { "keydown.arrowRight.prevent": "onKeyDownArrow($event.target,1)", "keydown.arrowLeft.prevent": "onKeyDownArrow($event.target,-1)", "animationend": "refresh()" }, properties: { "class._underline": "underline", "style.--t-color": "underline === true ? 'var(--tui-background-accent-1)' : underline" } }, providers: [
+            MutationObserverService,
+            {
+                provide: MUTATION_OBSERVER_INIT,
+                useValue: {
+                    childList: true,
+                    characterData: true,
+                    subtree: true,
+                },
+            },
+        ], queries: [{ propertyName: "children", predicate: i0.forwardRef(function () { return TuiTab; }) }], hostDirectives: [{ directive: i1.TuiTabsDirective, inputs: ["activeItemIndex", "activeItemIndex", "size", "size"], outputs: ["activeItemIndexChange", "activeItemIndexChange"] }], ngImport: i0 }); }
+}
+__decorate([
+    tuiPure
+], TuiTabsHorizontal.prototype, "scrollTo", null);
+export { TuiTabsHorizontal };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTabsHorizontal, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: 'tui-tabs:not([vertical]), nav[tuiTabs]:not([vertical])',
+                    providers: [
+                        MutationObserverService,
+                        {
+                            provide: MUTATION_OBSERVER_INIT,
+                            useValue: {
+                                childList: true,
+                                characterData: true,
+                                subtree: true,
+                            },
+                        },
+                    ],
+                    hostDirectives: [
+                        {
+                            directive: TuiTabsDirective,
+                            inputs: ['activeItemIndex', 'size'],
+                            outputs: ['activeItemIndexChange'],
+                        },
+                    ],
+                    host: {
+                        '[class._underline]': 'underline',
+                        '[style.--t-color]': "underline === true ? 'var(--tui-background-accent-1)' : underline",
+                    },
+                }]
+        }], propDecorators: { children: [{
+                type: ContentChildren,
+                args: [forwardRef(() => TuiTab)]
+            }], underline: [{
+                type: Input
+            }], onKeyDownArrow: [{
+                type: HostListener,
+                args: ['keydown.arrowRight.prevent', ['$event.target', '1']]
+            }, {
+                type: HostListener,
+                args: ['keydown.arrowLeft.prevent', ['$event.target', '-1']]
+            }], refresh: [{
+                type: HostListener,
+                args: ['animationend']
+            }], scrollTo: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tabs-horizontal.directive.js","sourceRoot":"","sources":["../../../../../projects/kit/components/tabs/tabs-horizontal.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import type {AfterViewChecked, QueryList} from '@angular/core';\nimport {\n    ContentChildren,\n    Directive,\n    forwardRef,\n    HostListener,\n    inject,\n    Input,\n    NgZone,\n} from '@angular/core';\nimport {takeUntilDestroyed} from '@angular/core/rxjs-interop';\nimport {\n    MUTATION_OBSERVER_INIT,\n    MutationObserverService,\n} from '@ng-web-apis/mutation-observer';\nimport {EMPTY_QUERY} from '@taiga-ui/cdk/constants';\nimport {tuiZonefree} from '@taiga-ui/cdk/observables';\nimport {tuiInjectElement} from '@taiga-ui/cdk/utils/dom';\nimport {tuiPure, tuiPx} from '@taiga-ui/cdk/utils/miscellaneous';\n\nimport {TuiTab} from './tab.directive';\nimport {TuiTabsDirective} from './tabs.directive';\nimport {TUI_TABS_OPTIONS} from './tabs.options';\n\n@Directive({\n    standalone: true,\n    selector: 'tui-tabs:not([vertical]), nav[tuiTabs]:not([vertical])',\n    providers: [\n        MutationObserverService,\n        {\n            provide: MUTATION_OBSERVER_INIT,\n            useValue: {\n                childList: true,\n                characterData: true,\n                subtree: true,\n            },\n        },\n    ],\n    hostDirectives: [\n        {\n            directive: TuiTabsDirective,\n            inputs: ['activeItemIndex', 'size'],\n            outputs: ['activeItemIndexChange'],\n        },\n    ],\n    host: {\n        '[class._underline]': 'underline',\n        '[style.--t-color]':\n            \"underline === true ? 'var(--tui-background-accent-1)' : underline\",\n    },\n})\nexport class TuiTabsHorizontal implements AfterViewChecked {\n    private readonly el = tuiInjectElement();\n    private readonly options = inject(TUI_TABS_OPTIONS);\n    private readonly tabs = inject(TuiTabsDirective);\n\n    @ContentChildren(forwardRef(() => TuiTab))\n    protected readonly children: QueryList<unknown> = EMPTY_QUERY;\n\n    protected readonly sub = inject(MutationObserverService)\n        .pipe(tuiZonefree(inject(NgZone)), takeUntilDestroyed())\n        .subscribe(() => this.refresh());\n\n    @Input()\n    public underline = this.options.underline;\n\n    public ngAfterViewChecked(): void {\n        this.scrollTo(this.tabs.activeItemIndex);\n        this.refresh();\n    }\n\n    @HostListener('keydown.arrowRight.prevent', ['$event.target', '1'])\n    @HostListener('keydown.arrowLeft.prevent', ['$event.target', '-1'])\n    protected onKeyDownArrow(current: HTMLElement, step: number): void {\n        this.tabs.moveFocus(current, step);\n    }\n\n    @HostListener('animationend')\n    protected refresh(): void {\n        const {activeElement} = this.tabs;\n\n        if (activeElement && !activeElement.isConnected) {\n            return;\n        }\n\n        const {offsetLeft = 0, offsetWidth = 0} = activeElement || {};\n\n        this.el.style.setProperty('--t-left', tuiPx(offsetLeft));\n        this.el.style.setProperty('--t-width', tuiPx(offsetWidth));\n    }\n\n    @tuiPure\n    private scrollTo(index: number): void {\n        const element = this.tabs.tabs[index];\n\n        if (!element) {\n            return;\n        }\n\n        const {offsetLeft, offsetWidth} = element;\n\n        if (offsetLeft < this.el.scrollLeft) {\n            this.el.scrollLeft = offsetLeft;\n        }\n\n        if (offsetLeft + offsetWidth > this.el.scrollLeft + this.el.offsetWidth) {\n            this.el.scrollLeft = offsetLeft + offsetWidth - this.el.offsetWidth;\n        }\n    }\n}\n"]}

package/esm2022/components/tabs/tabs-vertical.directive.mjs

@@ -0,0 +1,42 @@
+import { Directive, HostBinding, HostListener, inject, Input } from '@angular/core';
+import { TuiTabsDirective } from './tabs.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "./tabs.directive";
+class TuiTabsVertical {
+    constructor() {
+        this.tabs = inject(TuiTabsDirective);
+        this.vertical = 'left';
+    }
+    onKeyDownArrow(current, step) {
+        this.tabs.moveFocus(current, step);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTabsVertical, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TuiTabsVertical, isStandalone: true, selector: "tui-tabs[vertical], nav[tuiTabs][vertical]", inputs: { vertical: "vertical" }, host: { listeners: { "keydown.arrowDown.prevent": "onKeyDownArrow($event.target,1)", "keydown.arrowUp.prevent": "onKeyDownArrow($event.target,-1)" }, properties: { "attr.data-vertical": "this.vertical" } }, hostDirectives: [{ directive: i1.TuiTabsDirective, inputs: ["activeItemIndex", "activeItemIndex", "size", "size"], outputs: ["activeItemIndexChange", "activeItemIndexChange"] }], ngImport: i0 }); }
+}
+export { TuiTabsVertical };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTabsVertical, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: 'tui-tabs[vertical], nav[tuiTabs][vertical]',
+                    hostDirectives: [
+                        {
+                            directive: TuiTabsDirective,
+                            inputs: ['activeItemIndex', 'size'],
+                            outputs: ['activeItemIndexChange'],
+                        },
+                    ],
+                }]
+        }], propDecorators: { vertical: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.data-vertical']
+            }], onKeyDownArrow: [{
+                type: HostListener,
+                args: ['keydown.arrowDown.prevent', ['$event.target', '1']]
+            }, {
+                type: HostListener,
+                args: ['keydown.arrowUp.prevent', ['$event.target', '-1']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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