@taiga-ui/legacy 4.0.0-rc.1

package/esm2022/components/svg/content-processor.mjs

@@ -0,0 +1,38 @@
+import { tuiIsString } from '@taiga-ui/cdk/utils/miscellaneous';
+function makeRandomSalt() {
+    return Math.floor(Math.random() * Date.now());
+}
+function extractLinearGradientIdsFromSvg(svg) {
+    const ids = (svg.match(/url\(("?)('*)#(.*?)('*)\)/g) ?? []).map(url => url.slice(4, url.length - 1).replaceAll(/['"#]+/g, ''));
+    return Array.from(new Set(ids));
+}
+/**
+ * @description:
+ * Any ‘linearGradient’ attributes which are defined on the referenced
+ * element which are not defined on this element are inherited by this element.
+ * If this element has no defined gradient stops, and the referenced element does
+ * (possibly due to its own ‘xlink:href’ attribute), then this element inherits
+ * the gradient stop from the referenced element. Inheritance can be indirect
+ * to an arbitrary level; thus, if the referenced element inherits attribute
+ * or gradient stops due to its own ‘xlink:href’ attribute, then the current
+ * element can inherit those attributes or gradient stops.
+ *
+ * Documentation: https://www.w3.org/TR/SVG11/pservers.html
+ *
+ */
+export function tuiSvgLinearGradientProcessor(svg, salt = makeRandomSalt()) {
+    if (tuiIsString(svg)) {
+        const uniqueIds = extractLinearGradientIdsFromSvg(svg);
+        return uniqueIds.reduce((newSvg, previousId) => {
+            const newId = `id_${salt}_${previousId}`;
+            return newSvg
+                .replaceAll(`"${previousId}"`, `"${newId}"`)
+                .replaceAll(`'${previousId}'`, `'${newId}'`)
+                .replaceAll(`url('#${previousId}')`, `url('#${newId}')`)
+                .replaceAll(`url("#${previousId}")`, `url("#${newId}")`)
+                .replaceAll(`url(#${previousId})`, `url(#${newId})`);
+        }, svg);
+    }
+    return svg;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/svg/deprecated-icons.mjs

@@ -0,0 +1,59 @@
+export const TUI_DEPRECATED_ICONS = {
+    tuiIconAttach: 'tuiIconPaperclip',
+    tuiIconAttention: 'tuiIconAlertCircle',
+    tuiIconBackCircle: 'tuiIconArrowLeftCircle',
+    tuiIconCall: 'tuiIconPhone',
+    tuiIconCallIn: 'tuiIconPhoneIncoming',
+    tuiIconCallOut: 'tuiIconPhoneOutgoing',
+    tuiIconCallTransfer: 'tuiIconPhoneForwarded',
+    tuiIconCancel: 'tuiIconXCircle',
+    tuiIconCancelCircle: 'tuiIconSlash',
+    tuiIconCard: 'tuiIconCreditCard',
+    tuiIconCards: 'tuiIconCreditCard',
+    tuiIconChartBar: 'tuiIconBarChart',
+    tuiIconChart: 'tuiIconBarChart',
+    tuiIconCheckList: 'tuiIconClipboard',
+    tuiIconCloseCircle: 'tuiIconXCircle',
+    tuiIconCollapse: 'tuiIconMinimize',
+    tuiIconComment: 'tuiIconMessageSquare',
+    tuiIconCommentFw: 'tuiIconMessageForward',
+    tuiIconCompany: 'tuiIconBriefcase',
+    tuiIconDefaultDoc: 'tuiIconFile',
+    tuiIconDesktop: 'tuiIconMonitor',
+    tuiIconDesktopOff: 'tuiIconMonitorOff',
+    tuiIconDislike: 'tuiIconThumbsDown',
+    tuiIconDone: 'tuiIconCheckCircle',
+    tuiIconDraft: 'tuiIconEdit2',
+    tuiIconEyeOpen: 'tuiIconEye',
+    tuiIconEyeClosed: 'tuiIconEyeOff',
+    tuiIconExpand: 'tuiIconMaximize',
+    tuiIconExternal: 'tuiIconExternalLink',
+    tuiIconFrame: 'tuiIconLayout',
+    tuiIconGeo: 'tuiIconMapPin',
+    tuiIconHeartFilled: 'tuiIconHeart',
+    tuiIconHide: 'tuiIconEyeOff',
+    tuiIconImg: 'tuiIconImage',
+    tuiIconInfoCircle: 'tuiIconInfo',
+    tuiIconLike: 'tuiIconThumbsUp',
+    tuiIconLockOpen: 'tuiIconUnlock',
+    tuiIconMobile: 'tuiIconSmartphone',
+    tuiIconMoreHor: 'tuiIconMoreHorizontal',
+    tuiIconMoreVer: 'tuiIconMoreVertical',
+    tuiIconMoreVert: 'tuiIconMoreVertical',
+    tuiIconPicture: 'tuiIconImage',
+    tuiIconPin: 'tuiIconMapPin',
+    tuiIconPrint: 'tuiIconPrinter',
+    tuiIconRefresh: 'tuiIconRefreshCw',
+    tuiIconRemove: 'tuiIconX',
+    tuiIconShow: 'tuiIconEye',
+    tuiIconSound: 'tuiIconVolume',
+    tuiIconSoundOff: 'tuiIconVolumeX',
+    tuiIconStarFilled: 'tuiIconStar',
+    tuiIconStop: 'tuiIconSquare',
+    tuiIconStructure: 'tuiIconLayoutGrid',
+    tuiIconTime: 'tuiIconClock',
+    tuiIconTooltip: 'tuiIconHelpCircle',
+    tuiIconViewList: 'tuiIconList',
+    tuiIconWifiOn: 'tuiIconWifi',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/svg/index.mjs

@@ -0,0 +1,6 @@
+export * from './content-processor';
+export * from './deprecated-icons';
+export * from './svg.component';
+export * from './svg.service';
+export * from './svg-options';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9sZWdhY3kvY29tcG9uZW50cy9zdmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnRlbnQtcHJvY2Vzc29yJztcbmV4cG9ydCAqIGZyb20gJy4vZGVwcmVjYXRlZC1pY29ucyc7XG5leHBvcnQgKiBmcm9tICcuL3N2Zy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zdmcuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3N2Zy1vcHRpb25zJztcbiJdfQ==

package/esm2022/components/svg/svg-options.mjs

@@ -0,0 +1,60 @@
+import { InjectionToken, Optional, SkipSelf } from '@angular/core';
+import { tuiCreateTokenFromFactory, tuiIsString } from '@taiga-ui/cdk/utils/miscellaneous';
+import { tuiIconsPathFactory } from '@taiga-ui/legacy/utils';
+import { identity } from 'rxjs';
+import { tuiSvgLinearGradientProcessor } from './content-processor';
+import { TUI_DEPRECATED_ICONS } from './deprecated-icons';
+export const TUI_DEFAULT_ICONS_PLACE = 'assets/taiga-ui/icons';
+export const TUI_SVG_DEFAULT_OPTIONS = {
+    iconsPlace: TUI_DEFAULT_ICONS_PLACE,
+    path: tuiIconsPathFactory(TUI_DEFAULT_ICONS_PLACE),
+    srcProcessor: identity,
+    contentProcessor: tuiSvgLinearGradientProcessor,
+    deprecated: src => {
+        const oldIcon = src.replace('Large', '').replace('Outline', '');
+        const newIcon = TUI_DEPRECATED_ICONS[oldIcon];
+        return newIcon
+            ? `${oldIcon}/(Large|Outline) is deprecated, use ${newIcon}/(Large|Outline) instead`
+            : '';
+    },
+};
+/**
+ * SVG component options
+ */
+export const TUI_SVG_OPTIONS = tuiCreateTokenFromFactory(() => ({
+    iconsPlace: TUI_DEFAULT_ICONS_PLACE,
+    path: tuiIconsPathFactory(TUI_DEFAULT_ICONS_PLACE),
+    deprecated: TUI_SVG_DEFAULT_OPTIONS.deprecated,
+    srcProcessor: identity,
+    contentProcessor: tuiSvgLinearGradientProcessor,
+}));
+export const TUI_SVG_SRC_INTERCEPTORS = new InjectionToken('[TUI_SVG_SRC_INTERCEPTORS]');
+export function tuiSvgSrcInterceptors(interceptor) {
+    return {
+        provide: TUI_SVG_SRC_INTERCEPTORS,
+        useValue: interceptor,
+        multi: true,
+    };
+}
+export const tuiSvgOptionsProvider = options => ({
+    provide: TUI_SVG_OPTIONS,
+    deps: [[new SkipSelf(), new Optional(), TUI_SVG_OPTIONS]],
+    useFactory: (fallback) => ({
+        iconsPlace: options.iconsPlace ??
+            fallback?.iconsPlace ??
+            TUI_SVG_DEFAULT_OPTIONS.iconsPlace,
+        path: tuiIsString(options.path)
+            ? tuiIconsPathFactory(options.path)
+            : options.path ?? fallback?.path ?? TUI_SVG_DEFAULT_OPTIONS.path,
+        deprecated: options.deprecated ??
+            fallback?.deprecated ??
+            TUI_SVG_DEFAULT_OPTIONS.deprecated,
+        srcProcessor: options.srcProcessor ??
+            fallback?.srcProcessor ??
+            TUI_SVG_DEFAULT_OPTIONS.srcProcessor,
+        contentProcessor: options.contentProcessor ??
+            fallback?.contentProcessor ??
+            TUI_SVG_DEFAULT_OPTIONS.contentProcessor,
+    }),
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/svg/svg.component.mjs

@@ -0,0 +1,147 @@
+import { __decorate } from "tslib";
+/// <reference types="@taiga-ui/tsconfig/ng-dev-mode" />
+/// <reference types="@taiga-ui/tsconfig/ng-dev-mode" />
+import { AsyncPipe, DOCUMENT, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject, Input, SecurityContext, } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { WINDOW } from '@ng-web-apis/common';
+import { TuiLet } from '@taiga-ui/cdk/directives/let';
+import { TuiStaticRequestService } from '@taiga-ui/cdk/services';
+import { TUI_BASE_HREF } from '@taiga-ui/cdk/tokens';
+import { tuiGetDocumentOrShadowRoot, tuiInjectElement } from '@taiga-ui/cdk/utils/dom';
+import { tuiIsString, tuiPure } from '@taiga-ui/cdk/utils/miscellaneous';
+import { TUI_SANITIZER } from '@taiga-ui/legacy/tokens';
+import { TUI_CACHE_BUSTING_PAYLOAD, tuiIsPresumedHTMLString } from '@taiga-ui/legacy/utils';
+import { catchError, map, of, ReplaySubject, startWith, switchMap } from 'rxjs';
+import { TuiSvgService } from './svg.service';
+import { TUI_SVG_OPTIONS, TUI_SVG_SRC_INTERCEPTORS } from './svg-options';
+import * as i0 from "@angular/core";
+const UNDEFINED_NAMED_ICON = 'Attempted to use undefined named icon';
+const MISSING_EXTERNAL_ICON = 'External icon is missing on the given URL';
+const FAILED_EXTERNAL_ICON = 'Failed to load external SVG';
+// TODO: Move to legacy along with all related infrastructure SvgService and SvgDefsHostComponent
+class TuiSvgComponent {
+    constructor() {
+        this.icon = '';
+        this.doc = inject(DOCUMENT);
+        this.win = inject(WINDOW);
+        this.options = inject(TUI_SVG_OPTIONS);
+        this.tuiSanitizer = inject(TUI_SANITIZER, { optional: true });
+        this.svgService = inject(TuiSvgService);
+        this.staticRequestService = inject(TuiStaticRequestService);
+        this.sanitizer = inject(DomSanitizer);
+        this.el = tuiInjectElement();
+        this.baseHref = inject(TUI_BASE_HREF);
+        this.src$ = new ReplaySubject(1);
+        this.srcInterceptors = inject(TUI_SVG_SRC_INTERCEPTORS, {
+            optional: true,
+        });
+        this.innerHTML$ = this.src$.pipe(switchMap(() => {
+            if (tuiIsString(this.icon)) {
+                return this.isExternal
+                    ? this.getExternalIcon(this.icon)
+                    : of(this.getSafeHtml(this.icon));
+            }
+            return of(this.icon);
+        }), startWith(''));
+    }
+    set src(src) {
+        const deprecated = this.options.deprecated(String(src));
+        ngDevMode && console.assert(!deprecated, deprecated);
+        this.icon = (this.srcInterceptors ?? []).reduce((newSrc, interceptor) => interceptor(newSrc, this.options), this.options.srcProcessor(src || ''));
+        this.src$.next();
+    }
+    get src() {
+        return this.icon;
+    }
+    get use() {
+        if (tuiIsString(this.icon)) {
+            return this.icon.includes('.svg#')
+                ? this.icon
+                : this.resolveName(this.icon, this.options.path);
+        }
+        return '';
+    }
+    get isInnerHTML() {
+        return (!tuiIsString(this.icon) ||
+            this.isSrc ||
+            this.isExternal ||
+            (this.isName && this.isShadowDOM));
+    }
+    onError(message = MISSING_EXTERNAL_ICON) {
+        const { icon } = this;
+        const event = new CustomEvent('tui-icon-error', {
+            bubbles: true,
+            detail: {
+                message,
+                icon: icon,
+            },
+        });
+        ngDevMode && console.assert(false, message, icon);
+        this.el.dispatchEvent(event);
+    }
+    get isShadowDOM() {
+        return tuiGetDocumentOrShadowRoot(this.el) !== this.doc;
+    }
+    get isUse() {
+        return this.use.replace(TUI_CACHE_BUSTING_PAYLOAD, '').includes('.svg#');
+    }
+    get isExternal() {
+        return (this.isUrl ||
+            this.isCrossDomain ||
+            (!this.isSrc && !this.svgService.getOriginal(String(this.icon))));
+    }
+    get isUrl() {
+        return (tuiIsString(this.icon) &&
+            this.icon.replace(TUI_CACHE_BUSTING_PAYLOAD, '').endsWith('.svg'));
+    }
+    get isSrc() {
+        return tuiIsString(this.icon) && tuiIsPresumedHTMLString(this.icon);
+    }
+    get isName() {
+        return !this.isUrl && !this.isUse && !this.isSrc;
+    }
+    get isCrossDomain() {
+        const { use, isUse, win } = this;
+        return (isUse && use.startsWith('http') && !!win.origin && !use.startsWith(win.origin));
+    }
+    resolveName(name, iconsPath) {
+        return iconsPath(name, this.baseHref);
+    }
+    getSafeHtml(src) {
+        return this.isSrc ? this.sanitize(src) : this.process(src);
+    }
+    process(src) {
+        const icon = this.svgService.getOriginal(src);
+        if (this.isName && !icon && !!src) {
+            this.onError(UNDEFINED_NAMED_ICON);
+        }
+        return this.sanitize(icon || '');
+    }
+    sanitize(src) {
+        src = this.options.contentProcessor(src);
+        return this.tuiSanitizer && tuiIsString(src)
+            ? this.sanitizer.bypassSecurityTrustHtml(this.tuiSanitizer.sanitize(SecurityContext.HTML, src) || '')
+            : src;
+    }
+    getExternalIcon(src) {
+        const url = src.includes('.svg') ? src : this.use;
+        return this.staticRequestService.request(url).pipe(catchError(() => {
+            this.onError(FAILED_EXTERNAL_ICON);
+            return of('');
+        }), map(response => this.sanitize(response.replace('<svg', '<svg focusable="false"'))));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiSvgComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiSvgComponent, isStandalone: true, selector: "tui-svg", inputs: { src: "src" }, ngImport: i0, template: "<div\n    class=\"t-src\"\n    [innerHTML]=\"innerHTML$ | async\"\n></div>\n", styles: [":host{display:inline-flex;vertical-align:middle;flex-shrink:0;align-items:center;justify-content:center;line-height:0;height:1.5rem;width:1.5rem;fill:transparent;stroke:transparent;font-size:1rem}.t-src{display:flex;width:100%;height:100%;align-items:center;justify-content:center}.t-svg{overflow:visible}\n"], dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+__decorate([
+    tuiPure
+], TuiSvgComponent.prototype, "resolveName", null);
+export { TuiSvgComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiSvgComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'tui-svg', imports: [TuiLet, AsyncPipe, NgIf], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div\n    class=\"t-src\"\n    [innerHTML]=\"innerHTML$ | async\"\n></div>\n", styles: [":host{display:inline-flex;vertical-align:middle;flex-shrink:0;align-items:center;justify-content:center;line-height:0;height:1.5rem;width:1.5rem;fill:transparent;stroke:transparent;font-size:1rem}.t-src{display:flex;width:100%;height:100%;align-items:center;justify-content:center}.t-svg{overflow:visible}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { src: [{
+                type: Input
+            }], resolveName: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"svg.component.js","sourceRoot":"","sources":["../../../../../projects/legacy/components/svg/svg.component.ts","../../../../../projects/legacy/components/svg/svg.template.html"],"names":[],"mappings":";AAAA,wDAAwD;AAAxD,wDAAwD;AACxD,OAAO,EAAC,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAC,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EACH,uBAAuB,EACvB,SAAS,EACT,MAAM,EACN,KAAK,EACL,eAAe,GAClB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAC,MAAM,EAAC,MAAM,qBAAqB,CAAC;AAC3C,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAC,uBAAuB,EAAC,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAC,aAAa,EAAC,MAAM,sBAAsB,CAAC;AAEnD,OAAO,EAAC,0BAA0B,EAAE,gBAAgB,EAAC,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAAC,WAAW,EAAE,OAAO,EAAC,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAC,aAAa,EAAC,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAC,yBAAyB,EAAE,uBAAuB,EAAC,MAAM,wBAAwB,CAAC;AAE1F,OAAO,EAAC,UAAU,EAAE,GAAG,EAAE,EAAE,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAC,MAAM,MAAM,CAAC;AAE9E,OAAO,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAC,eAAe,EAAE,wBAAwB,EAAC,MAAM,eAAe,CAAC;;AAExE,MAAM,oBAAoB,GAAG,uCAAuC,CAAC;AACrE,MAAM,qBAAqB,GAAG,2CAA2C,CAAC;AAC1E,MAAM,oBAAoB,GAAG,6BAA6B,CAAC;AAO3D,iGAAiG;AACjG,MAQa,eAAe;IAkBxB;QAjBQ,SAAI,GAAgB,EAAE,CAAC;QACd,QAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QACvB,QAAG,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QACrB,YAAO,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC;QAClC,iBAAY,GAAG,MAAM,CAAC,aAAa,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QACvD,eAAU,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QACnC,yBAAoB,GAAG,MAAM,CAAC,uBAAuB,CAAC,CAAC;QACvD,cAAS,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QACjC,OAAE,GAAG,gBAAgB,EAAE,CAAC;QACxB,aAAQ,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;QACjC,SAAI,GAAG,IAAI,aAAa,CAAO,CAAC,CAAC,CAAC;QAClC,oBAAe,GAAG,MAAM,CAAC,wBAAwB,EAAE;YAChE,QAAQ,EAAE,IAAI;SACjB,CAA+C,CAAC;QAK7C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAC5B,SAAS,CAAC,GAAG,EAAE;YACX,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBACxB,OAAO,IAAI,CAAC,UAAU;oBAClB,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;oBACjC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;aACzC;YAED,OAAO,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC,CAAC,EACF,SAAS,CAAC,EAAE,CAAC,CAChB,CAAC;IACN,CAAC;IAED,IACW,GAAG,CAAC,GAAmC;QAC9C,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;QAExD,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;QAErD,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,MAAM,CAC3C,CAAC,MAAM,EAAE,WAAqC,EAAE,EAAE,CAC9C,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,EACrC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,EAAE,CAAC,CACvC,CAAC;QAEF,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IAED,IAAW,GAAG;QACV,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IAED,IAAW,GAAG;QACV,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YACxB,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;gBAC9B,CAAC,CAAC,IAAI,CAAC,IAAI;gBACX,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;SACxD;QAED,OAAO,EAAE,CAAC;IACd,CAAC;IAED,IAAW,WAAW;QAClB,OAAO,CACH,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;YACvB,IAAI,CAAC,KAAK;YACV,IAAI,CAAC,UAAU;YACf,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,WAAW,CAAC,CACpC,CAAC;IACN,CAAC;IAES,OAAO,CAAC,UAAkB,qBAAqB;QACrD,MAAM,EAAC,IAAI,EAAC,GAAG,IAAI,CAAC;QACpB,MAAM,KAAK,GAAG,IAAI,WAAW,CAAe,gBAAgB,EAAE;YAC1D,OAAO,EAAE,IAAI;YACb,MAAM,EAAE;gBACJ,OAAO;gBACP,IAAI,EAAE,IAAc;aACvB;SACJ,CAAC,CAAC;QAEH,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QAClD,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,IAAY,WAAW;QACnB,OAAO,0BAA0B,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,CAAC;IAC5D,CAAC;IAED,IAAY,KAAK;QACb,OAAO,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,yBAAyB,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC7E,CAAC;IAED,IAAY,UAAU;QAClB,OAAO,CACH,IAAI,CAAC,KAAK;YACV,IAAI,CAAC,aAAa;YAClB,CAAC,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CACnE,CAAC;IACN,CAAC;IAED,IAAY,KAAK;QACb,OAAO,CACH,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;YACtB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,yBAAyB,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CACpE,CAAC;IACN,CAAC;IAED,IAAY,KAAK;QACb,OAAO,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxE,CAAC;IAED,IAAY,MAAM;QACd,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;IACrD,CAAC;IAED,IAAY,aAAa;QACrB,MAAM,EAAC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAC,GAAG,IAAI,CAAC;QAE/B,OAAO,CACH,KAAK,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CACjF,CAAC;IACN,CAAC;IAGO,WAAW,CAAC,IAAY,EAAE,SAAgC;QAC9D,OAAO,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAEO,WAAW,CAAC,GAAW;QAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/D,CAAC;IAEO,OAAO,CAAC,GAAW;QACvB,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QAE9C,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,EAAE;YAC/B,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;SACtC;QAED,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;IACrC,CAAC;IAEO,QAAQ,CAAC,GAAgB;QAC7B,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;QAEzC,OAAO,IAAI,CAAC,YAAY,IAAI,WAAW,CAAC,GAAG,CAAC;YACxC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAClC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,CAC9D;YACH,CAAC,CAAC,GAAG,CAAC;IACd,CAAC;IAEO,eAAe,CAAC,GAAW;QAC/B,MAAM,GAAG,GAAG,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QAElD,OAAO,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAC9C,UAAU,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;YAEnC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;QAClB,CAAC,CAAC,EACF,GAAG,CAAC,QAAQ,CAAC,EAAE,CACX,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC,CACpE,CACJ,CAAC;IACN,CAAC;+GAtKQ,eAAe;mGAAf,eAAe,2FC7C5B,8EAIA,wWDoCsB,SAAS;;AAkInB;IADP,OAAO;kDAGP;SA/HQ,eAAe;4FAAf,eAAe;kBAR3B,SAAS;iCACM,IAAI,YACN,SAAS,WACV,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,mBAGjB,uBAAuB,CAAC,MAAM;0EAoCpC,GAAG;sBADb,KAAK;gBA4FE,WAAW","sourcesContent":["/// <reference types=\"@taiga-ui/tsconfig/ng-dev-mode\" />\nimport {AsyncPipe, DOCUMENT, NgIf} from '@angular/common';\nimport {\n    ChangeDetectionStrategy,\n    Component,\n    inject,\n    Input,\n    SecurityContext,\n} from '@angular/core';\nimport type {SafeHtml} from '@angular/platform-browser';\nimport {DomSanitizer} from '@angular/platform-browser';\nimport {WINDOW} from '@ng-web-apis/common';\nimport {TuiLet} from '@taiga-ui/cdk/directives/let';\nimport {TuiStaticRequestService} from '@taiga-ui/cdk/services';\nimport {TUI_BASE_HREF} from '@taiga-ui/cdk/tokens';\nimport type {TuiSafeHtml} from '@taiga-ui/cdk/types';\nimport {tuiGetDocumentOrShadowRoot, tuiInjectElement} from '@taiga-ui/cdk/utils/dom';\nimport {tuiIsString, tuiPure} from '@taiga-ui/cdk/utils/miscellaneous';\nimport {TUI_SANITIZER} from '@taiga-ui/legacy/tokens';\nimport {TUI_CACHE_BUSTING_PAYLOAD, tuiIsPresumedHTMLString} from '@taiga-ui/legacy/utils';\nimport type {Observable} from 'rxjs';\nimport {catchError, map, of, ReplaySubject, startWith, switchMap} from 'rxjs';\n\nimport {TuiSvgService} from './svg.service';\nimport type {TuiSvgInterceptorHandler, TuiSvgOptions} from './svg-options';\nimport {TUI_SVG_OPTIONS, TUI_SVG_SRC_INTERCEPTORS} from './svg-options';\n\nconst UNDEFINED_NAMED_ICON = 'Attempted to use undefined named icon';\nconst MISSING_EXTERNAL_ICON = 'External icon is missing on the given URL';\nconst FAILED_EXTERNAL_ICON = 'Failed to load external SVG';\n\nexport interface TuiIconError {\n    readonly icon: string;\n    readonly message: string;\n}\n\n// TODO: Move to legacy along with all related infrastructure SvgService and SvgDefsHostComponent\n@Component({\n    standalone: true,\n    selector: 'tui-svg',\n    imports: [TuiLet, AsyncPipe, NgIf],\n    templateUrl: './svg.template.html',\n    styleUrls: ['./svg.style.less'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class TuiSvgComponent {\n    private icon: TuiSafeHtml = '';\n    private readonly doc = inject(DOCUMENT);\n    private readonly win = inject(WINDOW);\n    private readonly options = inject(TUI_SVG_OPTIONS);\n    private readonly tuiSanitizer = inject(TUI_SANITIZER, {optional: true});\n    private readonly svgService = inject(TuiSvgService);\n    private readonly staticRequestService = inject(TuiStaticRequestService);\n    private readonly sanitizer = inject(DomSanitizer);\n    private readonly el = tuiInjectElement();\n    private readonly baseHref = inject(TUI_BASE_HREF);\n    private readonly src$ = new ReplaySubject<void>(1);\n    private readonly srcInterceptors = inject(TUI_SVG_SRC_INTERCEPTORS, {\n        optional: true,\n    }) as readonly TuiSvgInterceptorHandler[] | null;\n\n    protected readonly innerHTML$: Observable<SafeHtml>;\n\n    constructor() {\n        this.innerHTML$ = this.src$.pipe(\n            switchMap(() => {\n                if (tuiIsString(this.icon)) {\n                    return this.isExternal\n                        ? this.getExternalIcon(this.icon)\n                        : of(this.getSafeHtml(this.icon));\n                }\n\n                return of(this.icon);\n            }),\n            startWith(''),\n        );\n    }\n\n    @Input()\n    public set src(src: TuiSafeHtml | null | undefined) {\n        const deprecated = this.options.deprecated(String(src));\n\n        ngDevMode && console.assert(!deprecated, deprecated);\n\n        this.icon = (this.srcInterceptors ?? []).reduce(\n            (newSrc, interceptor: TuiSvgInterceptorHandler) =>\n                interceptor(newSrc, this.options),\n            this.options.srcProcessor(src || ''),\n        );\n\n        this.src$.next();\n    }\n\n    public get src(): TuiSafeHtml {\n        return this.icon;\n    }\n\n    public get use(): string {\n        if (tuiIsString(this.icon)) {\n            return this.icon.includes('.svg#')\n                ? this.icon\n                : this.resolveName(this.icon, this.options.path);\n        }\n\n        return '';\n    }\n\n    public get isInnerHTML(): boolean {\n        return (\n            !tuiIsString(this.icon) ||\n            this.isSrc ||\n            this.isExternal ||\n            (this.isName && this.isShadowDOM)\n        );\n    }\n\n    protected onError(message: string = MISSING_EXTERNAL_ICON): void {\n        const {icon} = this;\n        const event = new CustomEvent<TuiIconError>('tui-icon-error', {\n            bubbles: true,\n            detail: {\n                message,\n                icon: icon as string,\n            },\n        });\n\n        ngDevMode && console.assert(false, message, icon);\n        this.el.dispatchEvent(event);\n    }\n\n    private get isShadowDOM(): boolean {\n        return tuiGetDocumentOrShadowRoot(this.el) !== this.doc;\n    }\n\n    private get isUse(): boolean {\n        return this.use.replace(TUI_CACHE_BUSTING_PAYLOAD, '').includes('.svg#');\n    }\n\n    private get isExternal(): boolean {\n        return (\n            this.isUrl ||\n            this.isCrossDomain ||\n            (!this.isSrc && !this.svgService.getOriginal(String(this.icon)))\n        );\n    }\n\n    private get isUrl(): boolean {\n        return (\n            tuiIsString(this.icon) &&\n            this.icon.replace(TUI_CACHE_BUSTING_PAYLOAD, '').endsWith('.svg')\n        );\n    }\n\n    private get isSrc(): boolean {\n        return tuiIsString(this.icon) && tuiIsPresumedHTMLString(this.icon);\n    }\n\n    private get isName(): boolean {\n        return !this.isUrl && !this.isUse && !this.isSrc;\n    }\n\n    private get isCrossDomain(): boolean {\n        const {use, isUse, win} = this;\n\n        return (\n            isUse && use.startsWith('http') && !!win.origin && !use.startsWith(win.origin)\n        );\n    }\n\n    @tuiPure\n    private resolveName(name: string, iconsPath: TuiSvgOptions['path']): string {\n        return iconsPath(name, this.baseHref);\n    }\n\n    private getSafeHtml(src: string): SafeHtml {\n        return this.isSrc ? this.sanitize(src) : this.process(src);\n    }\n\n    private process(src: string): SafeHtml {\n        const icon = this.svgService.getOriginal(src);\n\n        if (this.isName && !icon && !!src) {\n            this.onError(UNDEFINED_NAMED_ICON);\n        }\n\n        return this.sanitize(icon || '');\n    }\n\n    private sanitize(src: TuiSafeHtml): TuiSafeHtml {\n        src = this.options.contentProcessor(src);\n\n        return this.tuiSanitizer && tuiIsString(src)\n            ? this.sanitizer.bypassSecurityTrustHtml(\n                  this.tuiSanitizer.sanitize(SecurityContext.HTML, src) || '',\n              )\n            : src;\n    }\n\n    private getExternalIcon(src: string): Observable<SafeHtml> {\n        const url = src.includes('.svg') ? src : this.use;\n\n        return this.staticRequestService.request(url).pipe(\n            catchError(() => {\n                this.onError(FAILED_EXTERNAL_ICON);\n\n                return of('');\n            }),\n            map(response =>\n                this.sanitize(response.replace('<svg', '<svg focusable=\"false\"')),\n            ),\n        );\n    }\n}\n","<div\n    class=\"t-src\"\n    [innerHTML]=\"innerHTML$ | async\"\n></div>\n"]}

package/esm2022/components/svg/svg.service.mjs

@@ -0,0 +1,64 @@
+/// <reference types="@taiga-ui/tsconfig/ng-dev-mode" />
+/// <reference types="@taiga-ui/tsconfig/ng-dev-mode" />
+import { inject, Injectable, SecurityContext } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { TUI_ICONS, TUI_SANITIZER } from '@taiga-ui/legacy/tokens';
+import { tuiProcessIcon } from '@taiga-ui/legacy/utils';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service for reusing SVGs without inlining each instance
+ * @deprecated
+ */
+class TuiSvgService {
+    constructor() {
+        this.tuiSanitizer = inject(TUI_SANITIZER, { optional: true });
+        this.sanitizer = inject(DomSanitizer);
+        this.originals = {};
+        this.items$ = new BehaviorSubject(new Map());
+        this.define(inject(TUI_ICONS));
+    }
+    define(icons) {
+        const { value } = this.items$;
+        Object.keys(icons).forEach(key => {
+            this.defineIcon(key, icons[key], value);
+        });
+        this.items$.next(value);
+    }
+    getOriginal(name) {
+        return this.originals[name] || null;
+    }
+    defineIcon(name, src, map) {
+        if (map.has(name)) {
+            return;
+        }
+        const parsed = this.parseSrc(name, src);
+        if (!parsed) {
+            ngDevMode && console.assert(false, 'Unable to parse given SVG src');
+            return;
+        }
+        map.set(name, parsed);
+        this.originals = {
+            ...this.originals,
+            [name]: src,
+        };
+    }
+    parseSrc(name, src) {
+        return this.sanitize(tuiProcessIcon(src, name));
+    }
+    sanitize(src) {
+        return this.sanitizer.bypassSecurityTrustHtml((this.tuiSanitizer
+            ? this.tuiSanitizer.sanitize(SecurityContext.HTML, src)
+            : this.sanitizer.sanitize(SecurityContext.HTML, src)) || '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiSvgService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiSvgService, providedIn: 'root' }); }
+}
+export { TuiSvgService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiSvgService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/svg/taiga-ui-legacy-components-svg.mjs

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

package/esm2022/components/table-bar/index.mjs

@@ -0,0 +1,6 @@
+export * from './table-bar.directive';
+export * from './table-bar.options';
+export * from './table-bars.service';
+export * from './table-bars-host.component';
+export * from './table-bars-host.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9sZWdhY3kvY29tcG9uZW50cy90YWJsZS1iYXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDZCQUE2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90YWJsZS1iYXIuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vdGFibGUtYmFyLm9wdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJsZS1iYXJzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJsZS1iYXJzLWhvc3QuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vdGFibGUtYmFycy1ob3N0LmNvbXBvbmVudCc7XG4iXX0=

package/esm2022/components/table-bar/table-bar.component.mjs

@@ -0,0 +1,33 @@
+import { AsyncPipe, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+import { tuiParentAnimation, tuiSlideInTop } from '@taiga-ui/core/animations';
+import { TuiButton } from '@taiga-ui/core/components/button';
+import { TUI_ANIMATIONS_SPEED, TUI_CLOSE_WORD, TUI_COMMON_ICONS, } from '@taiga-ui/core/tokens';
+import { tuiToAnimationOptions } from '@taiga-ui/core/utils/miscellaneous';
+import { POLYMORPHEUS_CONTEXT, PolymorpheusOutlet, PolymorpheusTemplate, } from '@taiga-ui/polymorpheus';
+import * as i0 from "@angular/core";
+class TuiTableBarComponent {
+    constructor() {
+        this.icons = inject(TUI_COMMON_ICONS);
+        this.closeWord$ = inject(TUI_CLOSE_WORD);
+        this.context = inject(POLYMORPHEUS_CONTEXT);
+        this.animation = tuiToAnimationOptions(inject(TUI_ANIMATIONS_SPEED));
+    }
+    getTheme(appearance) {
+        return appearance === 'onDark' ? 'dark' : null;
+    }
+    close() {
+        this.context.$implicit.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTableBarComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiTableBarComponent, isStandalone: true, selector: "tui-table-bar", host: { properties: { "@tuiSlideInTop": "animation", "attr.data-appearance": "context.mode" } }, ngImport: i0, template: "<div\n    automation-id=\"tui-table-bar__bar\"\n    class=\"t-container\"\n    [attr.tuiTheme]=\"getTheme(context.mode || 'onDark')\"\n    [class.t-container_adaptive]=\"context.adaptive\"\n>\n    <div class=\"t-inner\">\n        <div class=\"t-content\">\n            <ng-container *polymorpheusOutlet=\"context.content as text; context: context\">\n                {{ text }}\n            </ng-container>\n        </div>\n\n        <button\n            *ngIf=\"context.hasCloseButton\"\n            appearance=\"icon\"\n            automation-id=\"tui-table-bar__close-button\"\n            size=\"xs\"\n            tuiIconButton\n            type=\"button\"\n            class=\"t-close-button\"\n            [iconLeft]=\"icons.close\"\n            (click)=\"close()\"\n        >\n            {{ closeWord$ | async }}\n        </button>\n    </div>\n</div>\n", styles: [":host{display:block;width:100%;box-shadow:var(--tui-shadow);flex:0 0 100%}:host[data-appearance=onLight]{background:var(--tui-background-base);color:var(--tui-text-primary)}:host[data-appearance=onDark]{background:var(--tui-background-accent-opposite-pressed);color:var(--tui-background-base)}.t-wrapper{display:flex;width:100%}.t-container{position:relative;margin:0 auto}@media screen and (min-width: 80em){.t-container.t-container_adaptive{width:69rem}}@media screen and (max-width: 79.9625em){.t-container.t-container_adaptive{width:51.5rem}}@media screen and (max-width: 47.9625em){.t-container.t-container_adaptive{width:100%;padding:0 1rem;box-sizing:border-box}}@media screen and (min-width: 80em){.t-container{width:69rem}}@media screen and (max-width: 79.9625em){.t-container{width:51.5rem;padding:0 3rem}}.t-inner{display:flex;align-items:center;height:4.5rem;width:100%;overflow:hidden}:host-context(tui-root._mobile) .t-inner{height:5.75rem}.t-close-button{margin-left:1.5rem}.t-content{width:100%;flex:1 1 0}\n"], dependencies: [{ kind: "directive", type: PolymorpheusOutlet, selector: "[polymorpheusOutlet]", inputs: ["polymorpheusOutlet", "polymorpheusOutletContext"] }, { kind: "directive", type: TuiButton, selector: "a[tuiButton],button[tuiButton],a[tuiIconButton],button[tuiIconButton]", inputs: ["size"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], animations: [tuiSlideInTop, tuiParentAnimation], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { TuiTableBarComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTableBarComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'tui-table-bar', imports: [PolymorpheusOutlet, PolymorpheusTemplate, TuiButton, AsyncPipe, NgIf], changeDetection: ChangeDetectionStrategy.OnPush, animations: [tuiSlideInTop, tuiParentAnimation], host: {
+                        '[@tuiSlideInTop]': 'animation',
+                        '[attr.data-appearance]': 'context.mode',
+                    }, template: "<div\n    automation-id=\"tui-table-bar__bar\"\n    class=\"t-container\"\n    [attr.tuiTheme]=\"getTheme(context.mode || 'onDark')\"\n    [class.t-container_adaptive]=\"context.adaptive\"\n>\n    <div class=\"t-inner\">\n        <div class=\"t-content\">\n            <ng-container *polymorpheusOutlet=\"context.content as text; context: context\">\n                {{ text }}\n            </ng-container>\n        </div>\n\n        <button\n            *ngIf=\"context.hasCloseButton\"\n            appearance=\"icon\"\n            automation-id=\"tui-table-bar__close-button\"\n            size=\"xs\"\n            tuiIconButton\n            type=\"button\"\n            class=\"t-close-button\"\n            [iconLeft]=\"icons.close\"\n            (click)=\"close()\"\n        >\n            {{ closeWord$ | async }}\n        </button>\n    </div>\n</div>\n", styles: [":host{display:block;width:100%;box-shadow:var(--tui-shadow);flex:0 0 100%}:host[data-appearance=onLight]{background:var(--tui-background-base);color:var(--tui-text-primary)}:host[data-appearance=onDark]{background:var(--tui-background-accent-opposite-pressed);color:var(--tui-background-base)}.t-wrapper{display:flex;width:100%}.t-container{position:relative;margin:0 auto}@media screen and (min-width: 80em){.t-container.t-container_adaptive{width:69rem}}@media screen and (max-width: 79.9625em){.t-container.t-container_adaptive{width:51.5rem}}@media screen and (max-width: 47.9625em){.t-container.t-container_adaptive{width:100%;padding:0 1rem;box-sizing:border-box}}@media screen and (min-width: 80em){.t-container{width:69rem}}@media screen and (max-width: 79.9625em){.t-container{width:51.5rem;padding:0 3rem}}.t-inner{display:flex;align-items:center;height:4.5rem;width:100%;overflow:hidden}:host-context(tui-root._mobile) .t-inner{height:5.75rem}.t-close-button{margin-left:1.5rem}.t-content{width:100%;flex:1 1 0}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/table-bar/table-bar.directive.mjs

@@ -0,0 +1,21 @@
+import { Directive } from '@angular/core';
+import { TuiPopoverDirective } from '@taiga-ui/cdk/directives/popover';
+import { tuiAsPopover } from '@taiga-ui/cdk/services';
+import { TuiTableBarsService } from './table-bars.service';
+import * as i0 from "@angular/core";
+class TuiTableBarDirective extends TuiPopoverDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTableBarDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TuiTableBarDirective, isStandalone: true, selector: "ng-template[tuiTableBar]", inputs: { open: ["tuiTableBar", "open"], options: ["tuiTableBarOptions", "options"] }, outputs: { openChange: "tuiTableBarChange" }, providers: [tuiAsPopover(TuiTableBarsService)], usesInheritance: true, ngImport: i0 }); }
+}
+export { TuiTableBarDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTableBarDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    selector: 'ng-template[tuiTableBar]',
+                    inputs: ['open: tuiTableBar', 'options: tuiTableBarOptions'],
+                    outputs: ['openChange: tuiTableBarChange'],
+                    providers: [tuiAsPopover(TuiTableBarsService)],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtYmFyLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2xlZ2FjeS9jb21wb25lbnRzL3RhYmxlLWJhci90YWJsZS1iYXIuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDeEMsT0FBTyxFQUFDLG1CQUFtQixFQUFDLE1BQU0sa0NBQWtDLENBQUM7QUFDckUsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLHdCQUF3QixDQUFDO0FBR3BELE9BQU8sRUFBQyxtQkFBbUIsRUFBQyxNQUFNLHNCQUFzQixDQUFDOztBQUV6RCxNQU9hLG9CQUFxQixTQUFRLG1CQUF1QzsrR0FBcEUsb0JBQW9CO21HQUFwQixvQkFBb0IsNE1BRmxCLENBQUMsWUFBWSxDQUFDLG1CQUFtQixDQUFDLENBQUM7O1NBRXJDLG9CQUFvQjs0RkFBcEIsb0JBQW9CO2tCQVBoQyxTQUFTO21CQUFDO29CQUNQLFVBQVUsRUFBRSxJQUFJO29CQUNoQixRQUFRLEVBQUUsMEJBQTBCO29CQUNwQyxNQUFNLEVBQUUsQ0FBQyxtQkFBbUIsRUFBRSw2QkFBNkIsQ0FBQztvQkFDNUQsT0FBTyxFQUFFLENBQUMsK0JBQStCLENBQUM7b0JBQzFDLFNBQVMsRUFBRSxDQUFDLFlBQVksQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO2lCQUNqRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGlyZWN0aXZlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7VHVpUG9wb3ZlckRpcmVjdGl2ZX0gZnJvbSAnQHRhaWdhLXVpL2Nkay9kaXJlY3RpdmVzL3BvcG92ZXInO1xuaW1wb3J0IHt0dWlBc1BvcG92ZXJ9IGZyb20gJ0B0YWlnYS11aS9jZGsvc2VydmljZXMnO1xuXG5pbXBvcnQgdHlwZSB7VHVpVGFibGVCYXJPcHRpb25zfSBmcm9tICcuL3RhYmxlLWJhci5vcHRpb25zJztcbmltcG9ydCB7VHVpVGFibGVCYXJzU2VydmljZX0gZnJvbSAnLi90YWJsZS1iYXJzLnNlcnZpY2UnO1xuXG5ARGlyZWN0aXZlKHtcbiAgICBzdGFuZGFsb25lOiB0cnVlLFxuICAgIHNlbGVjdG9yOiAnbmctdGVtcGxhdGVbdHVpVGFibGVCYXJdJyxcbiAgICBpbnB1dHM6IFsnb3BlbjogdHVpVGFibGVCYXInLCAnb3B0aW9uczogdHVpVGFibGVCYXJPcHRpb25zJ10sXG4gICAgb3V0cHV0czogWydvcGVuQ2hhbmdlOiB0dWlUYWJsZUJhckNoYW5nZSddLFxuICAgIHByb3ZpZGVyczogW3R1aUFzUG9wb3ZlcihUdWlUYWJsZUJhcnNTZXJ2aWNlKV0sXG59KVxuZXhwb3J0IGNsYXNzIFR1aVRhYmxlQmFyRGlyZWN0aXZlIGV4dGVuZHMgVHVpUG9wb3ZlckRpcmVjdGl2ZTxUdWlUYWJsZUJhck9wdGlvbnM+IHt9XG4iXX0=

package/esm2022/components/table-bar/table-bar.options.mjs

@@ -0,0 +1,16 @@
+import { tuiCreateToken, tuiProvideOptions } from '@taiga-ui/cdk/utils/miscellaneous';
+import { BehaviorSubject } from 'rxjs';
+export const TUI_TABLE_BARS = tuiCreateToken(new BehaviorSubject([]));
+export const TUI_TABLE_BAR_DEFAULT_OPTIONS = {
+    adaptive: true,
+    hasCloseButton: true,
+    mode: 'onDark',
+};
+/**
+ * Default parameters for table bars component
+ */
+export const TUI_TABLE_BAR_OPTIONS = tuiCreateToken(TUI_TABLE_BAR_DEFAULT_OPTIONS);
+export function tuiTableBarOptionsProvider(options) {
+    return tuiProvideOptions(TUI_TABLE_BAR_OPTIONS, options, TUI_TABLE_BAR_DEFAULT_OPTIONS);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/table-bar/table-bars-host.component.mjs

@@ -0,0 +1,35 @@
+import { AsyncPipe, NgForOf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject } from '@angular/core';
+import { tuiParentAnimation } from '@taiga-ui/core/animations';
+import { PolymorpheusOutlet, PolymorpheusTemplate } from '@taiga-ui/polymorpheus';
+import { TUI_TABLE_BARS } from './table-bar.options';
+import * as i0 from "@angular/core";
+class TuiTableBarsHostComponent {
+    constructor() {
+        this.bars$ = inject(TUI_TABLE_BARS);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTableBarsHostComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: TuiTableBarsHostComponent, isStandalone: true, selector: "tui-table-bars-host", ngImport: i0, template: `
+        <div
+            *ngFor="let item of bars$ | async"
+            class="t-wrapper"
+            @tuiParentAnimation
+        >
+            <ng-container *polymorpheusOutlet="item.component; context: item" />
+        </div>
+    `, isInline: true, styles: [".t-wrapper{position:fixed;top:0;left:0;bottom:0;right:0;top:unset}\n"], dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "directive", type: PolymorpheusOutlet, selector: "[polymorpheusOutlet]", inputs: ["polymorpheusOutlet", "polymorpheusOutletContext"] }, { kind: "directive", type: NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], animations: [tuiParentAnimation], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+export { TuiTableBarsHostComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TuiTableBarsHostComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'tui-table-bars-host', imports: [AsyncPipe, PolymorpheusOutlet, PolymorpheusTemplate, NgForOf], template: `
+        <div
+            *ngFor="let item of bars$ | async"
+            class="t-wrapper"
+            @tuiParentAnimation
+        >
+            <ng-container *polymorpheusOutlet="item.component; context: item" />
+        </div>
+    `, changeDetection: ChangeDetectionStrategy.OnPush, animations: [tuiParentAnimation], styles: [".t-wrapper{position:fixed;top:0;left:0;bottom:0;right:0;top:unset}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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