@taiga-ui/legacy 4.0.0-alpha.0

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

@@ -0,0 +1,40 @@
+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));
+}
+/**
+ * @deprecated: drop in v5.0
+ *
+ * @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,62 @@
+/**
+ * @deprecated: drop in v5.0
+ */
+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,76 @@
+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';
+/**
+ * @deprecated: drop in v5.0
+ */
+export const TUI_DEFAULT_ICONS_PLACE = 'assets/taiga-ui/icons';
+/**
+ * @deprecated: drop in v5.0
+ */
+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`
+            : '';
+    },
+};
+/**
+ * @deprecated: drop in v5.0
+ * 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,
+}));
+/**
+ * @deprecated: drop in v5.0
+ */
+export const TUI_SVG_SRC_INTERCEPTORS = new InjectionToken('[TUI_SVG_SRC_INTERCEPTORS]');
+/**
+ * @deprecated: drop in v5.0
+ */
+export function tuiSvgSrcInterceptors(interceptor) {
+    return {
+        provide: TUI_SVG_SRC_INTERCEPTORS,
+        useValue: interceptor,
+        multi: true,
+    };
+}
+/**
+ * @deprecated: drop in v5.0
+ */
+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,149 @@
+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';
+/**
+ * @deprecated: drop in v5.0
+ */
+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":"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","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\n/**\n * @deprecated: drop in v5.0\n */\nexport interface TuiIconError {\n    readonly icon: string;\n    readonly message: string;\n}\n\n/**\n * @deprecated: drop in v5.0\n */\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_ICON_STARTS, TUI_SANITIZER } from '@taiga-ui/legacy/tokens';
+import { tuiProcessIcon } from '@taiga-ui/legacy/utils';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated: drop in v5.0
+ * Service for reusing SVGs without inlining each instance
+ */
+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_ICON_STARTS));
+    }
+    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            [iconStart]=\"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-small);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            [iconStart]=\"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-small);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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