@eui/ecl 19.3.3-snapshot-1754655052849 → 21.0.0-alpha.1

package/components/ecl-tabs/index.d.ts

@@ -1,13 +1,381 @@
-import { EclTabLabelComponent } from './ecl-tab-label.component';
-import { EclTabMoreComponent } from './ecl-tab-more.component';
-import { EclTabComponent } from './ecl-tab.component';
-import { EclTabsComponent } from './ecl-tabs.component';
-export * from './ecl-tabs.module';
-export * from './ecl-tabs.component';
-export * from './ecl-tab.component';
-export * from './ecl-tab-more.component';
-export * from './ecl-tab-label.component';
-export * from './models/ecl-tab.model';
-export * from './events/ecl-tab-select.event';
-export declare const EUI_ECL_TABS: readonly [typeof EclTabsComponent, typeof EclTabComponent, typeof EclTabLabelComponent, typeof EclTabMoreComponent];
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { ElementRef, AfterViewInit, EventEmitter, TemplateRef, OnInit, OnDestroy, QueryList } from '@angular/core';
+import { ECLBaseDirective, EclBaseEvent } from '@eui/ecl/core';
+import { EclLinkDirective } from '@eui/ecl/components/ecl-link';
+import { EclButtonComponent } from '@eui/ecl/components/ecl-button';
+
+/**
+ * Component representing a tab label within ECL Tabs.
+ * Used as a container for the tab's visual label content.
+ */
+declare class EclTabLabelComponent extends ECLBaseDirective {
+    el: ElementRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTabLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclTabLabelComponent, "ecl-tab-label", never, {}, {}, never, ["*"], true, never>;
+}
+
+/**
+ * @deprecated
+ * This component is deprecated and will be removed in v20.
+ *
+ * Represents a "More" tab item used to group additional tabs when space is limited.
+ */
+declare class EclTabMoreComponent extends ECLBaseDirective {
+    /**
+     * Controls whether the tab is hidden.
+     * When true, the `ecl-tabs__item--hidden` class is applied.
+     */
+    isHidden: boolean;
+    /**
+     * Host CSS classes applied to the component.
+     */
+    get cssClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTabMoreComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclTabMoreComponent, "ecl-tab-more", never, { "isHidden": { "alias": "isHidden"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_isHidden: unknown;
+}
+
+interface EclTab {
+    id?: string;
+}
+
+/**
+ * Event emitted when a tab is selected.
+ *
+ * Contains a reference to the selected tab instance.
+ */
+declare class EclTabSelectEvent extends EclBaseEvent {
+    tab: EclTab;
+    /**
+     * The tab instance that has been selected.
+     */
+    constructor(tab: EclTab);
+}
+
+/**
+ * Represents a single tab inside the ECL Tabs component.
+ * Manages its label, state (active, hidden), and interaction events like click or keydown.
+ *
+ * Note: The old selector `ecl-tab` is deprecated and will be removed in v20.
+ * Use `div[eclTab]` instead.
+ */
+declare class EclTabComponent extends ECLBaseDirective implements EclTab, AfterViewInit {
+    /**
+     * Unique identifier for the tab.
+     */
+    id: string;
+    /**
+     * Hides the tab when true by applying the `ecl-tabs__item--hidden` CSS class.
+     */
+    isHidden: boolean;
+    /**
+     * Marks the tab as active.
+     */
+    isActive: boolean;
+    /**
+     * Emits when the tab is selected via click.
+     */
+    selectTab: EventEmitter<EclTabSelectEvent>;
+    /**
+     * Emits when a keydown event occurs on the tab.
+     */
+    keydownTab: EventEmitter<Event>;
+    /**
+     * Reference to the tab content template.
+     */
+    contentTemplate: TemplateRef<any>;
+    /**
+     * Reference to the internal link directive used in the tab.
+     */
+    link: EclLinkDirective;
+    /**
+     * Reference to the projected tab label component.
+     */
+    label: EclTabLabelComponent;
+    /**
+     * Contains the inner HTML of the tab label.
+     */
+    tabLabel: string;
+    /**
+     * The tab index value for the tab's link.
+     */
+    hrefTabindex: number;
+    private isFirstCall;
+    private width;
+    private elementRef;
+    constructor();
+    /**
+     * Returns the host HTML element of the tab component.
+     */
+    get hostElement(): HTMLElement;
+    /**
+     * Determines if the deprecated selector `<ecl-tab>` is used.
+     */
+    get isUsingOldSelector(): boolean;
+    ngAfterViewInit(): void;
+    /**
+     * Returns the CSS classes applied to the host element.
+     */
+    get cssClasses(): string;
+    /**
+     * Returns the inner HTML content of the tab label.
+     */
+    getTabLabel(): string;
+    /**
+     * Returns the width of the tab element in pixels.
+     * The measurement is cached after the first call.
+     */
+    getWidth(): number;
+    /**
+     * Handles a click event on the tab and emits the `selectTab` event.
+     */
+    onTabClick(): void;
+    /**
+     * Handles a keydown event on the tab and emits the `keydownTab` event.
+     */
+    onKeydown(event: Event): void;
+    /**
+     * Calls the focus method on the inner link directive.
+     */
+    onFocus(): void;
+    /**
+     * Calls the blur method on the inner link directive.
+     */
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTabComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclTabComponent, "ecl-tab, div[eclTab]", never, { "id": { "alias": "id"; "required": false; }; "isHidden": { "alias": "isHidden"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; }, { "selectTab": "selectTab"; "keydownTab": "keydownTab"; }, ["label"], ["ecl-tab-label", "*"], true, never>;
+    static ngAcceptInputType_isHidden: unknown;
+    static ngAcceptInputType_isActive: unknown;
+}
+
+declare enum ShiftDirection {
+    NEXT = "next",
+    PREVIOUS = "prev"
+}
+/**
+ * ECL Tabs component for displaying tabbed content and managing tab selection and navigation.
+ *
+ * Note: The old selector `ecl-tabs` is deprecated and will be removed in v20.
+ * Use `div[eclTabs]` instead.
+ */
+declare class EclTabsComponent extends ECLBaseDirective implements OnInit, OnDestroy {
+    /**
+     * Adds `ecl-tabs` class to the host if not using the deprecated selector.
+     */
+    hasClass: boolean;
+    /**
+     * Class applied to the tab body container.
+     */
+    bodyClass: string;
+    /**
+     * Emits an event when a tab is selected.
+     */
+    tabSelect: EventEmitter<EclTabSelectEvent>;
+    /**
+     * All projected tabs inside the component.
+     */
+    tabs: QueryList<EclTabComponent>;
+    /**
+     * Reference to the visible tab list container.
+     */
+    tabsList: ElementRef;
+    /**
+     * Reference to the "more" button.
+     */
+    moreButton: EclButtonComponent;
+    /**
+     * Reference to the scroll previous button.
+     */
+    btnPrev: EclButtonComponent;
+    /**
+     * Reference to the scroll next button.
+     */
+    btnNext: EclButtonComponent;
+    /**
+     * Reference to the dropdown list containing overflowed tabs.
+     */
+    dropdownList: ElementRef;
+    /**
+     * Tabs displayed in the dropdown.
+     */
+    dropdownTabs: Array<EclTabComponent>;
+    /**
+     * Tabs displayed in the visible list.
+     */
+    listTabs: Array<EclTabComponent>;
+    /**
+     * Index of the active tab.
+     */
+    index: number;
+    /**
+     * Indicates whether the dropdown is expanded.
+     */
+    isDropdownExpanded: boolean;
+    /**
+     * Indicates whether the mobile breakpoint is active.
+     */
+    isMobileBreakpoint: boolean;
+    /**
+     * Indicates whether the "more" button is shown.
+     */
+    isMoreButtonShow: boolean;
+    /**
+     * Indicates whether the scroll previous button is shown.
+     */
+    isScrollPrevBtnShow: boolean;
+    /**
+     * Indicates whether the scroll next button is shown.
+     */
+    isScrollNextBtnShow: boolean;
+    /**
+     * CSS transform applied to the scrollable tab list.
+     */
+    styleTransform: string;
+    private differs;
+    private cdkBreakpointObserver;
+    private cd;
+    private el;
+    private eclRtlService;
+    private platformId;
+    private differ;
+    private diff;
+    private destroy$;
+    private isFirstCall;
+    private isRtl;
+    private moreBtnWidth;
+    private TIMEOUT_INTERVAL;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onClick(target: any): void;
+    /**
+     * Whether the deprecated selector is being used.
+     */
+    get isUsingOldSelector(): boolean;
+    /**
+     * Whether any visible tab is active.
+     */
+    get isMoreButtonActive(): boolean;
+    /**
+     * Scrolls the tab list to the left.
+     */
+    onScrollPrev(): void;
+    /**
+     * Scrolls the tab list to the right.
+     */
+    onScrollNext(): void;
+    /**
+     * Toggles the dropdown visibility.
+     */
+    onDropdownToggle(): void;
+    /**
+     * Returns the style value for tab list width.
+     */
+    getTabsWidthStyle(): string;
+    /**
+     * Calculates total width of all tabs.
+     */
+    getTabsWidth(): number;
+    /**
+     * Returns the number of tabs hidden in dropdown.
+     */
+    getHiddenTabsCount(): number;
+    /**
+     * Returns the label of the tab at the specified index.
+     */
+    getTabLabel(index: number): string;
+    /**
+     * Returns the duration of the transition animation.
+     */
+    getTransitionDuration(): string;
+    /**
+     * Handles blur event when navigating tabs via keyboard.
+     */
+    onTabBlur(evt: KeyboardEvent): void;
+    /**
+     * Handles tab selection.
+     * @param tab Tab to activate.
+     */
+    onTabSelect(tab: EclTabComponent): void;
+    /**
+     * Handles right arrow key navigation.
+     * @param index Current tab index.
+     */
+    onTabKeydownArrowRight(index: number): void;
+    /**
+     * Handles left arrow key navigation.
+     * @param index Current tab index.
+     */
+    onTabKeydownArrowLeft(index: number): void;
+    /**
+     * Focuses the first tab in the list.
+     */
+    onTabKeydownHome(): void;
+    /**
+     * Focuses the last tab in the list.
+     */
+    onTabKeydownEnd(): void;
+    /**
+     * Handles all supported keyboard events for a tab.
+     * @param event KeyboardEvent triggered.
+     * @param tab Target tab.
+     */
+    onTabKeydown(event: Event, tab: EclTabComponent): void;
+    private getCurrentTabIndex;
+    private shiftTabs;
+    private getShifIndex;
+    private createSecondListForDropdown;
+    private getTabsAsArray;
+    private getTabsCount;
+    private closeDropdown;
+    private openDropdown;
+    private observeTabsChanges;
+    private createTabsChangesObservable;
+    private onTabsChanges;
+    private connectTabEvents;
+    private setTabindex;
+    private getLastVisibleTab;
+    private focusOnNextTab;
+    private focusOnFirstTab;
+    private focusOnLastTab;
+    private focusOnPrevTab;
+    private focusOnDropdownTab;
+    private getLastTabFromArray;
+    private getFirstTabFromArray;
+    private disconnectTabEvents;
+    private deactivateAllTabs;
+    private activateTab;
+    private sendTabSelectEvent;
+    private observeBreakpointChanges;
+    private handleResize;
+    private initMoreBtnWidth;
+    private hideAllDropdownTabs;
+    private setActiveItemForMainTabs;
+    private getTabsListWidth;
+    private setHiddenItemsForDropdownTabs;
+    private handleMobile;
+    private setAllTabsVisible;
+    private handleRtlChangeState;
+    private hasRtlChanged;
+    private handleRtlChange;
+    private observeElementSizeChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclTabsComponent, "div[eclTabs], ecl-tabs", never, { "bodyClass": { "alias": "bodyClass"; "required": false; }; }, { "tabSelect": "tabSelect"; }, ["tabs"], ["ecl-tab, [eclTab]"], true, never>;
+}
+
+/**
+ * Module that provides the EclTabsComponent and it's dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_TABS} instead.
+ */
+declare class EclTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclTabsModule, never, [typeof EclTabsComponent, typeof EclTabComponent, typeof EclTabLabelComponent, typeof EclTabMoreComponent], [typeof EclTabsComponent, typeof EclTabComponent, typeof EclTabLabelComponent, typeof EclTabMoreComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclTabsModule>;
+}
+
+declare const EUI_ECL_TABS: readonly [typeof EclTabsComponent, typeof EclTabComponent, typeof EclTabLabelComponent, typeof EclTabMoreComponent];
+
+export { EUI_ECL_TABS, EclTabComponent, EclTabLabelComponent, EclTabMoreComponent, EclTabSelectEvent, EclTabsComponent, EclTabsModule, ShiftDirection };
+export type { EclTab };
+//# sourceMappingURL=index.d.ts.map

package/components/ecl-tabs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-tabs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAE9C,eAAO,MAAM,YAAY,qHAEf,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-tabs/ecl-tab-label.component.ts","../../../components/ecl-tabs/ecl-tab-more.component.ts","../../../components/ecl-tabs/models/ecl-tab.model.ts","../../../components/ecl-tabs/events/ecl-tab-select.event.ts","../../../components/ecl-tabs/ecl-tab.component.ts","../../../components/ecl-tabs/ecl-tabs.component.ts","../../../components/ecl-tabs/ecl-tabs.module.ts","../../../components/ecl-tabs/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null],"names":[],"mappings":";;;;;;AAGA;;;AAGG;AACH;AAKI;;;AACH;;ACVD;;;;;AAKG;AACH;AAKI;;;AAGG;AACkF;AAErF;;AAEG;;;;;AAKN;;;;ACzBA;;ACCD;;;;AAIG;AACH;AAIuB;AAHnB;;AAEG;AACgB;AAGtB;;ACKD;;;;;;AAMG;AACH;AAMI;;AAEG;;AAGH;;AAEG;AACkF;AAErF;;AAEG;AACqC;AAExC;;AAEG;AACO;AAEV;;AAEG;AACO;AAEV;;AAEG;AAEmB;AAEtB;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;AACI;AAEP;;AAEG;AACH;;;;;AAaA;;AAEG;;AAKH;;AAEG;;AAQH;AAIA;;AAEG;;AAMH;;AAEG;AACH;AAIA;;;AAGG;AACI;AAQP;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;;AAEG;AACH;;;;;AAGH;;ACrID;AACI;AACA;AACH;AAED;;;;;AAKG;AACH;AAQI;;AAEG;AAC4B;AAE/B;;AAEG;AACM;AAET;;AAEG;AACO;AAEV;;AAEG;AACiD;AAEpD;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;AACH;AAEA;;AAEG;AACH;;;;;;;;;;;;;;;AA8BA;AAOA;AAMA;AAMA;;AAEG;;AAQH;;AAEG;;AAKH;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;;AAEG;AACH;AAOA;;AAEG;AACH;AAUA;;;AAGG;AACH;AAMA;;;AAGG;AACH;AAcA;;;AAGG;AACH;AAeA;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;;;;AAIG;;AA6CH;AAKA;AAkCA;AAgBA;AAUA;AAIA;AAIA;AAIA;AAIA;AAIA;AAIA;AAmBA;AASA;AAUA;AAYA;AAUA;AAKA;AASA;AASA;AAIA;AAIA;AAIA;AAMA;AAUA;AAIA;AAIA;AASA;AAsCA;AAOA;AAIA;AASA;AAIA;AAUA;AAOA;AAMA;AAYA;AAIA;AAMA;;;AAOH;;AC5sBD;;;;AAIG;AACH;;;;AAI6B;;ACH7B;;;"}

package/components/ecl-tag/index.d.ts

@@ -1,10 +1,108 @@
-import { EclTagComponent } from './ecl-tag.component';
-import { EclTagSetDirective, EclTagSetItemDirective } from './ecl-tag-set.directive';
-import { EclTagIconExternalDirective } from './ecl-tag-icon.directive';
-export * from './ecl-tag.module';
-export * from './ecl-tag.component';
-export * from './ecl-tag-set.directive';
-export * from './ecl-tag-icon.directive';
-export * from './events/ecl-tag-remove.event';
-export declare const EUI_ECL_TAG: readonly [typeof EclTagComponent, typeof EclTagSetDirective, typeof EclTagSetItemDirective, typeof EclTagIconExternalDirective];
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { OnDestroy, EventEmitter } from '@angular/core';
+import { EclBaseEvent, ECLBaseDirective } from '@eui/ecl/core';
+
+/**
+ * Event emitted when a tag is removed.
+ */
+declare class EclTagRemoveEvent extends EclBaseEvent {
+}
+
+declare class EclTagComponent extends ECLBaseDirective implements OnDestroy {
+    /**
+     * Defines the variant of the tag.
+     * Currently only 'removable' is supported.
+     */
+    variant: 'removable';
+    /**
+     * Whether the tag content should be allowed to wrap onto multiple lines.
+     * Set to false to force single-line display (adds `ecl-tag--nowrap` class).
+     * Defaults to true.
+     */
+    isWrapped: boolean;
+    /**
+     * Event emitted when the tag is removed.
+     * Can be prevented by calling `preventDefault()` on the emitted event.
+     */
+    remove: EventEmitter<EclTagRemoveEvent>;
+    get isHidden(): string | null;
+    get cssClasses(): string;
+    isVisible: boolean;
+    title: string;
+    private el;
+    private destroy$;
+    constructor();
+    /**
+     * Whether the tag is removable (based on the `variant` input).
+     */
+    get isRemovable(): boolean;
+    /**
+     * Lifecycle hook that cleans up subscriptions when the component is destroyed.
+     */
+    ngOnDestroy(): void;
+    /**
+     * Called when the tag’s remove button is clicked (or enter key pressed).
+     * Emits the `remove` event. If not prevented, the tag is hidden.
+     */
+    onRemoveClick(): void;
+    private connectEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTagComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclTagComponent, "ecl-tag, [eclTag]", never, { "variant": { "alias": "variant"; "required": false; }; "isWrapped": { "alias": "isWrapped"; "required": false; }; }, { "remove": "remove"; }, never, ["*"], true, never>;
+    static ngAcceptInputType_isWrapped: unknown;
+}
+
+/**
+ * Directive to style a container as a set of tags.
+ * Adds the `ecl-tag-set` class to the host element.
+ */
+declare class EclTagSetDirective extends ECLBaseDirective {
+    /**
+     * CSS classes applied to the host element.
+     * Adds `ecl-tag-set` to define the layout for a group of tags.
+     */
+    get cssClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTagSetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclTagSetDirective, "[eclTagSet]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive to mark an element as an individual item in a tag set.
+ * Adds the `ecl-tag-set__item` class to the host element.
+ */
+declare class EclTagSetItemDirective extends ECLBaseDirective {
+    /**
+     * Adds the `ecl-tag-set__item` CSS class to the host element.
+     */
+    hasClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTagSetItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclTagSetItemDirective, "[eclTagSetItem]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive to apply external icon styling inside an ECL tag.
+ * Adds specific CSS classes to render an "external" icon next to the tag content.
+ */
+declare class EclTagIconExternalDirective extends ECLBaseDirective {
+    /**
+     * CSS classes applied to the host element.
+     * Adds `ecl-tag__icon ecl-tag__icon--external` to display the icon correctly.
+     */
+    get cssClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTagIconExternalDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclTagIconExternalDirective, "[eclTagIconExternal]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Module that provides the EclTag component and its dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_TAG} instead.
+ */
+declare class EclTagModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTagModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclTagModule, never, [typeof EclTagComponent, typeof EclTagSetDirective, typeof EclTagSetItemDirective, typeof EclTagIconExternalDirective], [typeof EclTagComponent, typeof EclTagSetDirective, typeof EclTagSetItemDirective, typeof EclTagIconExternalDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclTagModule>;
+}
+
+declare const EUI_ECL_TAG: readonly [typeof EclTagComponent, typeof EclTagSetDirective, typeof EclTagSetItemDirective, typeof EclTagIconExternalDirective];
+
+export { EUI_ECL_TAG, EclTagComponent, EclTagIconExternalDirective, EclTagModule, EclTagRemoveEvent, EclTagSetDirective, EclTagSetItemDirective };
+//# sourceMappingURL=index.d.ts.map

package/components/ecl-tag/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-tag/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAEvE,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC;AAE9C,eAAO,MAAM,WAAW,iIAEd,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-tag/events/ecl-tag-remove.event.ts","../../../components/ecl-tag/ecl-tag.component.ts","../../../components/ecl-tag/ecl-tag-set.directive.ts","../../../components/ecl-tag/ecl-tag-icon.directive.ts","../../../components/ecl-tag/ecl-tag.module.ts","../../../components/ecl-tag/index.ts"],"sourcesContent":[null,null,null,null,null,null],"names":[],"mappings":";;;;AAEA;;AAEG;AACH,cAAA,iBAAA,SAAA,YAAA;AAAsD;;ACctD,cAAA,eAAA,SAAA,gBAAA,YAAA,SAAA;AAMI;;;AAGG;;AAGH;;;;AAIG;AACqC;AAExC;;;AAGG;AACO,YAAA,YAAA,CAAA,iBAAA;AAEV;;AAaA;AACA;;;;AAWA;;AAEG;;AAKH;;AAEG;AACH;AAKA;;;AAGG;AACH;AASA;;;;AASH;;ACvGD;;;AAGG;AACH,cAAA,kBAAA,SAAA,gBAAA;AAII;;;AAGG;;;;AAKN;AAED;;;AAGG;AACH,cAAA,sBAAA,SAAA,gBAAA;AAII;;AAEG;AACqC;;;AAC3C;;AC9BD;;;AAGG;AACH,cAAA,2BAAA,SAAA,gBAAA;AAII;;;AAGG;;;;AAKN;;ACbD;;;;AAIG;AACH,cAAA,YAAA;;;;AAI4B;;ACL5B,cAAA,WAAA,mBAAA,eAAA,SAAA,kBAAA,SAAA,sBAAA,SAAA,2BAAA;;;;"}

package/components/ecl-text-area/index.d.ts

@@ -1,5 +1,42 @@
-import { EclTextAreaDirective } from './ecl-text-area.directive';
-export * from './ecl-text-area.module';
-export * from './ecl-text-area.directive';
-export declare const EUI_ECL_TEXT_AREA: readonly [typeof EclTextAreaDirective];
-//# sourceMappingURL=index.d.ts.map
+import { ECLBaseDirective } from '@eui/ecl/core';
+import * as i0 from '@angular/core';
+
+/**
+ * Directive to be used with <textarea> HTML component. Applies custom styles and formatting, that comply with the ECL standards.
+ */
+declare class EclTextAreaDirective extends ECLBaseDirective {
+    /**
+     * Width of the component, can be 's', 'm' or 'l'. Default value is 'm'.
+     */
+    eclSize: string;
+    isInvalid: boolean;
+    /**
+     * Adds specific classes for the component.
+     */
+    get cssClasses(): string;
+    /**
+     * Adds 'ecl-text-area--invalid' class, depending on the invalid status of the component.
+     */
+    get invalidState(): boolean;
+    private ngControl;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTextAreaDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclTextAreaDirective, "textarea[eclTextArea]", never, { "eclSize": { "alias": "eclSize"; "required": false; }; "isInvalid": { "alias": "isInvalid"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_isInvalid: unknown;
+}
+
+/**
+ * @description
+ * Module that provides the EclTextArea directive and its dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_TEXT_AREA} instead.
+ */
+declare class EclTextAreaModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTextAreaModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclTextAreaModule, never, [typeof EclTextAreaDirective], [typeof EclTextAreaDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclTextAreaModule>;
+}
+
+declare const EUI_ECL_TEXT_AREA: readonly [typeof EclTextAreaDirective];
+
+export { EUI_ECL_TEXT_AREA, EclTextAreaDirective, EclTextAreaModule };
+//# sourceMappingURL=index.d.ts.map

package/components/ecl-text-area/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-text-area/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAE1C,eAAO,MAAM,iBAAiB,wCAEpB,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-text-area/ecl-text-area.directive.ts","../../../components/ecl-text-area/ecl-text-area.module.ts","../../../components/ecl-text-area/index.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":";;;AAIA;;AAEG;AACH,cAAA,oBAAA,SAAA,gBAAA;AAII;;AAEG;AACM;AAC+B;AAExC;;AAEG;;AAMH;;AAEG;;;;;;AAUN;;AClCD;;;;;AAKG;AACH,cAAA,iBAAA;;;;AAIiC;;ACRjC,cAAA,iBAAA,mBAAA,oBAAA;;;;"}

package/components/ecl-text-input/index.d.ts

@@ -1,5 +1,47 @@
-import { EclTextInputDirective } from './ecl-text-input.directive';
-export * from './ecl-text-input.module';
-export * from './ecl-text-input.directive';
-export declare const EUI_ECL_TEXT_INPUT: readonly [typeof EclTextInputDirective];
-//# sourceMappingURL=index.d.ts.map
+import { NgControl } from '@angular/forms';
+import { ECLBaseDirective } from '@eui/ecl/core';
+import * as i0 from '@angular/core';
+
+/**
+ * Directive, to be used with the HTMl element text <input>. Adds ECL compliant styling.
+ */
+declare class EclTextInputDirective extends ECLBaseDirective {
+    protected ngControl: NgControl;
+    /**
+     * This directive should be used with the input type 'text'.
+     */
+    type: string;
+    /**
+     * The size of the input width. Can be 's', 'm' or 'l'. Default value is 'm'.
+     */
+    eclSize: string;
+    isInvalid: boolean;
+    /**
+     * Adds ECL classes for the component.
+     */
+    get cssClasses(): string;
+    /**
+     * Adds 'ecl-text-input--invalid' class, depending on the invalid status of the component.
+     */
+    get invalidState(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTextInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclTextInputDirective, "input[eclTextInput]", never, { "type": { "alias": "type"; "required": false; }; "eclSize": { "alias": "eclSize"; "required": false; }; "isInvalid": { "alias": "isInvalid"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_isInvalid: unknown;
+}
+
+/**
+ * @description
+ * Module that provides the EclTextInput directive and its dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_TEXT_INPUT} instead.
+ */
+declare class EclTextInputModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclTextInputModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclTextInputModule, never, [typeof EclTextInputDirective], [typeof EclTextInputDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclTextInputModule>;
+}
+
+declare const EUI_ECL_TEXT_INPUT: readonly [typeof EclTextInputDirective];
+
+export { EUI_ECL_TEXT_INPUT, EclTextInputDirective, EclTextInputModule };
+//# sourceMappingURL=index.d.ts.map

package/components/ecl-text-input/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-text-input/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEnE,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAE3C,eAAO,MAAM,kBAAkB,yCAErB,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-text-input/ecl-text-input.directive.ts","../../../components/ecl-text-input/ecl-text-input.module.ts","../../../components/ecl-text-input/index.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":";;;;AAIA;;AAEG;AACH,cAAA,qBAAA,SAAA,gBAAA;;AAMI;;AAEG;AAEuB;AAE1B;;AAEG;AACM;AAC+B;AAExC;;AAEG;;AAMH;;AAEG;;;;;AASN;;ACzCD;;;;;AAKG;AACH,cAAA,kBAAA;;;;AAIkC;;ACRlC,cAAA,kBAAA,mBAAA,qBAAA;;;;"}