@eui/ecl 19.3.3-snapshot-1754912586607 → 21.0.0-alpha.2

package/components/ecl-inpage-navigation/index.d.ts

@@ -1,10 +1,207 @@
-import { EclInpageNavigationItemComponent } from './ecl-inpage-navigation-item.component';
-import { EclInpageNavigationListDirective } from './ecl-inpage-navigation-list.directive';
-import { EclInpageNavigationComponent } from './ecl-inpage-navigation.component';
-export * from './ecl-inpage-navigation.module';
-export * from './ecl-inpage-navigation.component';
-export * from './ecl-inpage-navigation-item.component';
-export * from './ecl-inpage-navigation-list.directive';
-export * from './services/ecl-inpage-navigation.service';
-export declare const EUI_ECL_INPAGE_NAVIGATION: readonly [typeof EclInpageNavigationComponent, typeof EclInpageNavigationItemComponent, typeof EclInpageNavigationListDirective];
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { EventEmitter, AfterContentInit, OnDestroy, ElementRef, OnInit, DoCheck, QueryList } from '@angular/core';
+import { ECLBaseDirective, EclBaseEvent, EclThemeService } from '@eui/ecl/core';
+import { EclLinkDirective } from '@eui/ecl/components/ecl-link';
+import { Observable } from 'rxjs';
+
+declare class EclInpageNavigationItemClickEvent extends EclBaseEvent {
+    sectionElementId: string;
+    constructor(sectionElementId: string);
+}
+/**
+ * Represent a single navigation item. contains the link, that activates/scrolls to the new current paragraph of the page.
+ */
+declare class EclInpageNavigationItemComponent extends ECLBaseDirective {
+    cmpClass: boolean;
+    /**
+     * The role of the component is 'listitem', should not be changed.
+     */
+    role: string;
+    /**
+     * The label that is displayed in the items list.
+     */
+    label: string;
+    sectionId: string;
+    isActive: boolean;
+    /**
+     * Emited when user clicks on the item.
+     */
+    itemClick: EventEmitter<EclInpageNavigationItemClickEvent>;
+    /**
+     * Emitted when on keyboard navigation, user clicks the arrow-up.
+     */
+    itemArrowUp: EventEmitter<any>;
+    /**
+     * Emitted when on keyboard navigation, user clicks the arrow-down.
+     */
+    itemArrowDown: EventEmitter<any>;
+    /**
+     * Emitted when on keyboard navigation, user clicks the TAB.
+     */
+    itemTab: EventEmitter<Event>;
+    /**
+     * Emitted when on keyboard navigation, user clicks the ENTER.
+     */
+    itemEnter: EventEmitter<any>;
+    link: EclLinkDirective;
+    constructor();
+    onItemClick(evt: MouseEvent): void;
+    /**
+     * Returns page element/paragraph, that is associated with this item from the navigation list.
+     */
+    get sectionElement(): HTMLElement;
+    onArrowUp(evt: Event): void;
+    onArrowDown(evt: Event): void;
+    onTab(evt: Event): void;
+    onFocus(): void;
+    onEnter(evt: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclInpageNavigationItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclInpageNavigationItemComponent, "ecl-inpage-navigation-item, li[eclInpageNavigationItem]", never, { "label": { "alias": "label"; "required": false; }; "sectionId": { "alias": "sectionId"; "required": false; }; "isActive": { "alias": "isActive"; "required": false; }; }, { "itemClick": "itemClick"; "itemArrowUp": "itemArrowUp"; "itemArrowDown": "itemArrowDown"; "itemTab": "itemTab"; "itemEnter": "itemEnter"; }, never, never, true, never>;
+}
+
+/**
+ * The parent list component, that contains navigation items links.
+ */
+declare class EclInpageNavigationListDirective extends ECLBaseDirective implements AfterContentInit, OnDestroy {
+    el: ElementRef<any>;
+    hasClass: boolean;
+    /**
+     * If the dropdown is visible in mobile view.
+     */
+    isVisible: boolean;
+    maxHeight: any;
+    private destroy$;
+    private eclInpageNavigationService;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclInpageNavigationListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclInpageNavigationListDirective, "ul[eclInpageNavigationList]", never, {}, {}, never, never, true, never>;
+}
+
+declare class EclInpageNavigationSectionEnterEvent extends EclBaseEvent {
+    sectionId: string;
+    constructor(sectionId: string);
+}
+/**
+ * The in-page navigation is a vertical menu containing (anchored) links to H2-headings on long content pages.
+ * It gives the user an overview of the page contents and has a fixed position (does not move while scrolling) at either the left
+ * side of a page on desktop or top-bar on mobile. This component helps users scan of the page quickly contents and may potentially
+ * reduce vertical scrolling, allowing users to easily jump straight to the segment of the page.
+ */
+declare class EclInpageNavigationComponent extends ECLBaseDirective implements OnInit, OnDestroy, DoCheck {
+    eclThemeService: EclThemeService;
+    eclTitle: string;
+    /**
+     * Used to calculate component's position.
+     */
+    marginTop: number;
+    marginBottom: number;
+    /**
+     * Sets the offset from the top of the page (for example if there is a toolbar or header). Used to calculate scrolling behaviour.
+     */
+    offsetTop: number;
+    togglerButton: ElementRef<HTMLButtonElement>;
+    toggleWrapper: ElementRef<HTMLDivElement>;
+    /**
+     * @deprecated To be removed in v20. Not needed, replaced by 'eclNavigationList'
+     */
+    listContainer: ElementRef<HTMLUListElement>;
+    navTittle: ElementRef<HTMLDivElement>;
+    /**
+     * This event will be emitted, when onscroll a new section becomes active.
+     */
+    sectionEnter: EventEmitter<EclInpageNavigationSectionEnterEvent>;
+    eclNavigationLinkItems: QueryList<EclInpageNavigationItemComponent>;
+    eclNavigationList: EclInpageNavigationListDirective;
+    /**
+     * Used for the mobile view, where user can select a section from the dropdown.
+     */
+    isButtonExpanded: boolean;
+    currentSectionElement: HTMLElement;
+    isRtl: boolean;
+    listMaxHeight: number;
+    private destroy$;
+    private differ;
+    private isMobileBreakpoint;
+    private MIN_DISTANCE_TOP;
+    private readonly ICON_SIZE_EC_THEME;
+    private readonly ICON_SIZE_EU_THEME;
+    private readonly TABLET_BREAKPOINT;
+    private intersectionObserver;
+    private eclRtlService;
+    private differs;
+    private scrollDispatcher;
+    private zone;
+    private cdkBreakpointObserver;
+    private viewportRuler;
+    private eclInpageNavigationService;
+    constructor();
+    ngOnInit(): void;
+    get hasNavigationList(): boolean;
+    get currentNavigationLinkItem(): EclInpageNavigationItemComponent;
+    /**
+     * the size of the arrow-down icon, used in mobile view. There are different sizes for EC and EU themes.
+     */
+    get sizeIcon(): string;
+    get hasActiveSection(): boolean;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    /**
+     * On mobile view - handle the dropdown toggle.
+     */
+    onExpandButtonClick(): void;
+    /**
+     * Dropdown keyboard navigation on mobile view.
+     * @param evt
+     */
+    onExpandButtonKeydown(evt: Event): void;
+    private handleRtlChangeState;
+    /**
+     * Set the height of the list with the navigation items in px. So in case the full list cannot be displayed, a scroll will appear.
+     */
+    private setListHeight;
+    private onExpandButtonArrowDown;
+    private onExpandButtonTab;
+    private connectItemEvents;
+    private onItemEnter;
+    private onItemArrowDown;
+    private onItemArrowUp;
+    private onItemTab;
+    private subscribeToCDKScrollEvent;
+    private selectNavigationItem;
+    private handleNavigationLinksHighlight;
+    private findActiveSectionElement;
+    private observeBreakpointChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclInpageNavigationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclInpageNavigationComponent, "ecl-inpage-navigation", never, { "eclTitle": { "alias": "eclTitle"; "required": false; }; "marginTop": { "alias": "marginTop"; "required": false; }; "marginBottom": { "alias": "marginBottom"; "required": false; }; "offsetTop": { "alias": "offsetTop"; "required": false; }; }, { "sectionEnter": "sectionEnter"; }, ["eclNavigationList", "eclNavigationLinkItems"], ["*"], true, never>;
+    static ngAcceptInputType_offsetTop: unknown;
+}
+
+/**
+ * Module that provides the EclInpageNavigationComponent and its dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_INPAGE_NAVIGATION} instead.
+ */
+declare class EclInpageNavigationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclInpageNavigationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclInpageNavigationModule, never, [typeof EclInpageNavigationComponent, typeof EclInpageNavigationItemComponent, typeof EclInpageNavigationListDirective], [typeof EclInpageNavigationComponent, typeof EclInpageNavigationItemComponent, typeof EclInpageNavigationListDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclInpageNavigationModule>;
+}
+
+declare class EclInpageNavigationService {
+    eclInpageNavigationExpanded$: Observable<boolean>;
+    private eclInpageNavigationExpanded;
+    constructor();
+    /**
+     * When user clicks on arrow down button in mobile view.
+     * @param isExpanded
+     */
+    eclInpageNavigationToggle(isExpanded: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclInpageNavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EclInpageNavigationService>;
+}
+
+declare const EUI_ECL_INPAGE_NAVIGATION: readonly [typeof EclInpageNavigationComponent, typeof EclInpageNavigationItemComponent, typeof EclInpageNavigationListDirective];
+
+export { EUI_ECL_INPAGE_NAVIGATION, EclInpageNavigationComponent, EclInpageNavigationItemClickEvent, EclInpageNavigationItemComponent, EclInpageNavigationListDirective, EclInpageNavigationModule, EclInpageNavigationSectionEnterEvent, EclInpageNavigationService };
+//# sourceMappingURL=index.d.ts.map

package/components/ecl-inpage-navigation/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-inpage-navigation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,wCAAwC,CAAC;AAC1F,OAAO,EAAE,gCAAgC,EAAE,MAAM,wCAAwC,CAAC;AAC1F,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AAEjF,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC;AAEzD,eAAO,MAAM,yBAAyB,kIAE5B,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-inpage-navigation/ecl-inpage-navigation-item.component.ts","../../../components/ecl-inpage-navigation/ecl-inpage-navigation-list.directive.ts","../../../components/ecl-inpage-navigation/ecl-inpage-navigation.component.ts","../../../components/ecl-inpage-navigation/ecl-inpage-navigation.module.ts","../../../components/ecl-inpage-navigation/services/ecl-inpage-navigation.service.ts","../../../components/ecl-inpage-navigation/index.ts"],"sourcesContent":[null,null,null,null,null,null],"names":[],"mappings":";;;;;;AAKA,cAAA,iCAAA,SAAA,YAAA;AACuB;AAAA;AAGtB;AACD;;AAEG;AAEH,cAAA,gCAAA,SAAA,gBAAA;AAasD;AAClD;;AAEG;AACuB;AAE1B;;AAEG;;;;AAKH;;AAEG;AACO,eAAA,YAAA,CAAA,iCAAA;AACV;;AAEG;AACO,iBAAA,YAAA;AACV;;AAEG;AACO,mBAAA,YAAA;AACV;;AAEG;AACO,aAAA,YAAA,CAAA,KAAA;AACV;;AAEG;AACO,eAAA,YAAA;;;AAaV,qBAAA,UAAA;AAOA;;AAEG;;AAKH,mBAAA,KAAA;AAKA,qBAAA,KAAA;AAKA,eAAA,KAAA;AAIA;AAIA,iBAAA,KAAA;;;AAKH;;ACxGD;;AAEG;AACH,cAAA,gCAAA,SAAA,gBAAA,YAAA,gBAAA,EAAA,SAAA;AAKI,QAAA,UAAA;AAEkD;AAClD;;AAEG;AACwD;AACvB;;;AAKpC;AAMA;;;AAIH;;ACnBD,cAAA,oCAAA,SAAA,YAAA;AACuB;AAAA;AAGtB;AAED;;;;;AAKG;AACH,cAAA,4BAAA,SAAA,gBAAA,YAAA,MAAA,EAAA,SAAA,EAAA,OAAA;AAeI,qBAAA,eAAA;;AAGA;;AAEG;;;AAGH;;AAEG;;AAEyB,mBAAA,UAAA,CAAA,iBAAA;AACA,mBAAA,UAAA,CAAA,cAAA;AAC5B;;AAEG;AACyB,mBAAA,UAAA,CAAA,gBAAA;AACJ,eAAA,UAAA,CAAA,cAAA;AACxB;;AAEG;AACO,kBAAA,YAAA,CAAA,oCAAA;AAEgE,4BAAA,SAAA,CAAA,gCAAA;;AAG1E;;AAEG;AACH;;AAEO;;;;;;AAMP;AACA;AACA;;;;;;;;;;AA8BA;;;AAYA;;AAEG;;;AAaH;AASA;AAMA;;AAEG;AACH;AAKA;;;AAGG;AACH,+BAAA,KAAA;AAaA;AAMA;;AAEG;AACH;AAgCA;AAMA;AAOA;AA0BA;AAaA;AAOA;AAYA;AAYA;AAWA;AAMA;AAUA;AAWA;;;;AAQH;;ACxVD;;;;AAIG;AACH,cAAA,yBAAA;;;;AAIyC;;ACZzC,cAAA,0BAAA;AAGQ,kCAAA,UAAA;;;AAOP;;;AAGG;AACA;;;AAGH;;ACVD,cAAA,yBAAA,mBAAA,4BAAA,SAAA,gCAAA,SAAA,gCAAA;;;;"}

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

@@ -1,5 +1,45 @@
-import { EclLabelDirective } from './ecl-label.directive';
-export * from './ecl-label.module';
-export * from './ecl-label.directive';
-export declare const EUI_ECL_LABEL: readonly [typeof EclLabelDirective];
-//# sourceMappingURL=index.d.ts.map
+import { ECLBaseDirective } from '@eui/ecl/core';
+import * as i0 from '@angular/core';
+
+/**
+ * Directive for applying ECL label styles.
+ *
+ * Supports multiple visual variants based on importance or context.
+ * Adds appropriate ECL classes dynamically.
+ */
+declare class EclLabelDirective extends ECLBaseDirective {
+    /**
+     * Defines the visual variant of the label.
+     *
+     * - `'low'` – default styling
+     * - `'medium'` – medium emphasis
+     * - `'high'` – high emphasis
+     * - `'highlight'` – special highlight
+     *
+     * @default 'low'
+     */
+    variant: 'low' | 'medium' | 'high' | 'highlight';
+    /**
+     * CSS classes applied to the host element.
+     * Combines base ECL label class with the variant modifier.
+     */
+    get cssClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclLabelDirective, "[eclLabel]", never, { "variant": { "alias": "variant"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Module that provides the EclLabel directive.
+ *
+ * @deprecated Use {@link EUI_ECL_LABEL} instead.
+ */
+declare class EclLabelModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclLabelModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclLabelModule, never, [typeof EclLabelDirective], [typeof EclLabelDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclLabelModule>;
+}
+
+declare const EUI_ECL_LABEL: readonly [typeof EclLabelDirective];
+
+export { EUI_ECL_LABEL, EclLabelDirective, EclLabelModule };
+//# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-label/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AAEtC,eAAO,MAAM,aAAa,qCAEhB,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-label/ecl-label.directive.ts","../../../components/ecl-label/ecl-label.module.ts","../../../components/ecl-label/index.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":";;;AAGA;;;;;AAKG;AACH,cAAA,iBAAA,SAAA,gBAAA;AAII;;;;;;;;;AASG;;AAGH;;;AAGG;;;;AAKN;;AC9BD;;;;AAIG;AACH,cAAA,cAAA;;;;AAI8B;;ACP9B,cAAA,aAAA,mBAAA,iBAAA;;;;"}

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

@@ -1,7 +1,87 @@
-import { EclIndicatorDirective, EclLinkIconContainerDirective, EclLinkLabelDirective } from './ecl-link-label.directive';
-import { EclLinkDirective } from './ecl-link.directive';
-export * from './ecl-link.module';
-export * from './ecl-link.directive';
-export * from './ecl-link-label.directive';
-export declare const EUI_ECL_LINK: readonly [typeof EclLinkDirective, typeof EclLinkLabelDirective, typeof EclIndicatorDirective, typeof EclLinkIconContainerDirective];
-//# sourceMappingURL=index.d.ts.map
+import { ECLBaseDirective } from '@eui/ecl/core';
+import * as i0 from '@angular/core';
+import { AfterContentInit, ElementRef, QueryList } from '@angular/core';
+import { EclIconComponent } from '@eui/ecl/components/ecl-icon';
+
+declare class EclLinkLabelDirective extends ECLBaseDirective {
+    get cssClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclLinkLabelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclLinkLabelDirective, "[eclLinkLabel]", never, {}, {}, never, never, true, never>;
+}
+declare class EclIndicatorDirective {
+    hasClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclIndicatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclIndicatorDirective, "[eclIndicator]", never, {}, {}, never, never, true, never>;
+}
+declare class EclLinkIconContainerDirective {
+    hasClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclLinkIconContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclLinkIconContainerDirective, "[eclLinkIconContainer]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * 'eclLink' directive is used to add some styling to the defalt HTML anchor component. In order to comply with ECL standards.
+ */
+declare class EclLinkDirective extends ECLBaseDirective implements AfterContentInit {
+    el: ElementRef<any>;
+    /**
+     * Adds speific ECL classes to the <a> component.
+     */
+    get cssClasses(): string;
+    /**
+     * Adds class for styling if the link has icon.
+     */
+    get hasIcon(): boolean;
+    get isLinkNoVisited(): boolean;
+    /**
+     * Property to style the component as 'inverted' (with dark background).
+     */
+    isInverted: boolean;
+    /**
+     * Property to style the component if it consist only of an icon.
+     */
+    isIconOnly: boolean;
+    /**
+     * @deprecated - will be removed in v20. Deprecated on ECL side.
+     */
+    isNoVisited: boolean;
+    /**
+     * With 'varian' property user can add some more specific styling to the <a> component.
+     */
+    variant: 'standalone' | 'cta' | 'primary' | 'secondary';
+    eclIconComponents: QueryList<EclIconComponent>;
+    ngAfterContentInit(): void;
+    /**
+     * Calls the native focus() method of the default HTML element.
+     */
+    onFocus(): void;
+    /**
+     * Calls the native click() method of the default HTML element.
+     */
+    onClick(): void;
+    /**
+     * Calls the native blur() method of the default HTML element.
+     */
+    onBlur(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclLinkDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclLinkDirective, "[eclLink]", never, { "isInverted": { "alias": "isInverted"; "required": false; }; "isIconOnly": { "alias": "isIconOnly"; "required": false; }; "isNoVisited": { "alias": "isNoVisited"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, ["eclIconComponents"], never, true, never>;
+    static ngAcceptInputType_isInverted: unknown;
+    static ngAcceptInputType_isIconOnly: unknown;
+    static ngAcceptInputType_isNoVisited: unknown;
+}
+
+/**
+ * Module that provides the EclLink directive and its dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_LINK} instead.
+ */
+declare class EclLinkModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclLinkModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclLinkModule, never, [typeof EclLinkDirective, typeof EclLinkLabelDirective, typeof EclIndicatorDirective, typeof EclLinkIconContainerDirective], [typeof EclLinkDirective, typeof EclLinkLabelDirective, typeof EclIndicatorDirective, typeof EclLinkIconContainerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclLinkModule>;
+}
+
+declare const EUI_ECL_LINK: readonly [typeof EclLinkDirective, typeof EclLinkLabelDirective, typeof EclIndicatorDirective, typeof EclLinkIconContainerDirective];
+
+export { EUI_ECL_LINK, EclIndicatorDirective, EclLinkDirective, EclLinkIconContainerDirective, EclLinkLabelDirective, EclLinkModule };
+//# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-link/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACzH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAE3C,eAAO,MAAM,YAAY,sIAEf,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-link/ecl-link-label.directive.ts","../../../components/ecl-link/ecl-link.directive.ts","../../../components/ecl-link/ecl-link.module.ts","../../../components/ecl-link/index.ts"],"sourcesContent":[null,null,null,null],"names":[],"mappings":";;;;;AAIA,cAAA,qBAAA,SAAA,gBAAA;;;;AAQC;AAED,cAAA,qBAAA;AAIwC;;;AACvC;AAED,cAAA,6BAAA;AAImD;;;AAClD;;ACtBD;;AAEG;AACH,cAAA,gBAAA,SAAA,gBAAA,YAAA,gBAAA;AAII,QAAA,UAAA;AAEA;;AAEG;;AAKH;;AAEG;;;AAWH;;AAEG;AAC8E;AACjF;;AAEG;AAC+E;AAClF;;AAEG;;AAEH;;AAEG;;AAGyE,uBAAA,SAAA,CAAA,gBAAA;AAE5E;AAWA;;AAEG;AACH;AAIA;;AAEG;AACH;AAIA;;AAEG;AACH;;;;;;AAGH;;AC/ED;;;;AAIG;AACH,cAAA,aAAA;;;;AAI6B;;ACN7B,cAAA,YAAA,mBAAA,gBAAA,SAAA,qBAAA,SAAA,qBAAA,SAAA,6BAAA;;;;"}

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

@@ -1,9 +1,207 @@
-import { EclDescriptionListDefinitionItemDirective, EclDescriptionListDefinitionListDirective } from './ecl-description-list-definition-item.directive';
-import { EclDescriptionListDefinitionComponent } from './ecl-description-list-definition/ecl-description-list-definition.component';
-import { EclDescriptionListDirective, EclDescriptionListTermDirective, EclOrderedListDirective, EclOrderedListItemDirective, EclUnorderedListDirective, EclUnorderedListItemDirective } from './ecl-list.directive';
-export * from './ecl-list.module';
-export * from './ecl-list.directive';
-export * from './ecl-description-list-definition-item.directive';
-export * from './ecl-description-list-definition/ecl-description-list-definition.component';
-export declare const EUI_ECL_LIST: readonly [typeof EclOrderedListDirective, typeof EclOrderedListItemDirective, typeof EclUnorderedListDirective, typeof EclUnorderedListItemDirective, typeof EclDescriptionListDirective, typeof EclDescriptionListTermDirective, typeof EclDescriptionListDefinitionComponent, typeof EclDescriptionListDefinitionItemDirective, typeof EclDescriptionListDefinitionListDirective];
-//# sourceMappingURL=index.d.ts.map
+import { ECLBaseDirective } from '@eui/ecl/core';
+import * as i0 from '@angular/core';
+import { AfterViewInit, QueryList, AfterContentInit } from '@angular/core';
+
+/**
+ * Directive representing a single item in an ECL description list definition.
+ *
+ * Applies the appropriate styling classes and allows visibility control for "see all" behavior.
+ */
+declare class EclDescriptionListDefinitionItemDirective extends ECLBaseDirective {
+    /**
+     * Applies appropriate ECL classes based on visibility state.
+     */
+    get cssClasses(): string;
+    /**
+     * Internal state used to hide the item when exceeding the visible limit.
+     */
+    isHidden: boolean;
+    /**
+     * Indicates whether this is the last item visible before the "see all" action is triggered.
+     */
+    isLastVisible: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclDescriptionListDefinitionItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclDescriptionListDefinitionItemDirective, "[eclDescriptionListDefinitionItem]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive representing a container for definition list items within an ECL description list.
+ *
+ * Applies the ECL-specific class for the list wrapper.
+ */
+declare class EclDescriptionListDefinitionListDirective extends ECLBaseDirective {
+    /**
+     * Applies the ECL list container class.
+     */
+    cmpClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclDescriptionListDefinitionListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclDescriptionListDefinitionListDirective, "[eclDescriptionListDefinitionList]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Component representing a group of definition items in an ECL description list.
+ *
+ * Allows display of items in different visual variants and optionally limits how many items are visible by default.
+ * Additional items can be revealed via a "see all" toggle.
+ */
+declare class EclDescriptionListDefinitionComponent extends ECLBaseDirective implements AfterViewInit {
+    /**
+     * Visual variant of the definition list group.
+     *
+     * Available values:
+     * - `'link'` – link-style list
+     * - `'inline'` – inline list
+     * - `'taxonomy'` – taxonomy-style list
+     * - `'tag'` – tag-style list
+     */
+    variant: 'link' | 'inline' | 'taxonomy' | 'tag';
+    /**
+     * Internal list of child definition items.
+     */
+    eclListItems: QueryList<EclDescriptionListDefinitionItemDirective>;
+    /**
+     * Applies appropriate ECL CSS classes to the host element.
+     */
+    get cssClasses(): string;
+    private _maxVisibleItems;
+    private currentItemsNumber;
+    /**
+     * Number of items visible before the "see all" button is displayed.
+     */
+    set maxVisibleItems(value: number);
+    /**
+     * Returns `true` if there are hidden items and the "see all" button should be shown.
+     */
+    get hasSeeAll(): boolean;
+    /**
+     * Lifecycle hook triggered after content projection is initialized.
+     * Handles hiding excess items based on the configured limit.
+     */
+    ngAfterViewInit(): void;
+    /**
+     * Handles the "see all" link/button click.
+     * Reveals all hidden list items.
+     */
+    onShowAllItems(evt: Event): void;
+    private hideListItem;
+    private showListItem;
+    private hasHiddenListitems;
+    private getHiddenItems;
+    private getLastVisibleItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclDescriptionListDefinitionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclDescriptionListDefinitionComponent, "[eclDescriptionListDefinition]", never, { "variant": { "alias": "variant"; "required": false; }; }, {}, ["eclListItems"], ["*"], true, never>;
+}
+
+/**
+ * Directive representing an ordered list using ECL styles.
+ */
+declare class EclOrderedListDirective extends ECLBaseDirective {
+    /**
+     * Applies the ECL class for ordered lists.
+     */
+    cmpClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclOrderedListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclOrderedListDirective, "[eclOrderedList]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive for a single item within an ECL ordered list.
+ */
+declare class EclOrderedListItemDirective extends ECLBaseDirective {
+    /**
+     * Applies the ECL class for ordered list items.
+     */
+    cmpClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclOrderedListItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclOrderedListItemDirective, "[eclOrderedListItem]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive representing an unordered list using ECL styles.
+ *
+ * Supports optional variants like divider and no-marker.
+ */
+declare class EclUnorderedListDirective extends ECLBaseDirective {
+    /**
+     * Applies the ECL class for unordered lists.
+     */
+    cmpClass: boolean;
+    /**
+     * Adds a divider between list items.
+     */
+    isDivider: boolean;
+    /**
+     * Adds a divider between list items.
+     */
+    isNoMarker: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclUnorderedListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclUnorderedListDirective, "[eclUnorderedList]", never, { "isDivider": { "alias": "isDivider"; "required": false; }; "isNoMarker": { "alias": "isNoMarker"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_isDivider: unknown;
+    static ngAcceptInputType_isNoMarker: unknown;
+}
+/**
+ * Directive for a single item within an ECL unordered list.
+ */
+declare class EclUnorderedListItemDirective extends ECLBaseDirective {
+    /**
+     * Applies the ECL class for unordered list items.
+     */
+    cmpClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclUnorderedListItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclUnorderedListItemDirective, "[eclUnorderedListItem]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Directive for a description list using ECL styles.
+ *
+ * Supports horizontal layout and maxVisibleItems functionality
+ * passed down to nested definition components.
+ */
+declare class EclDescriptionListDirective extends ECLBaseDirective implements AfterContentInit {
+    /**
+     * Enables horizontal layout.
+     */
+    isHorizontal: boolean;
+    /**
+     * Maximum number of visible items before collapsing.
+     * Applied to nested `eclDescriptionListDefinition` components.
+     */
+    maxVisibleItems: number;
+    eclListItems: QueryList<EclDescriptionListDefinitionComponent>;
+    /**
+     * Applies the base ECL class for description lists.
+     */
+    get cssClasses(): string;
+    private cd;
+    /**
+     * Assigns `maxVisibleItems` to child definition components if needed.
+     */
+    ngAfterContentInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclDescriptionListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclDescriptionListDirective, "[eclDescriptionList]", never, { "isHorizontal": { "alias": "isHorizontal"; "required": false; }; "maxVisibleItems": { "alias": "maxVisibleItems"; "required": false; }; }, {}, ["eclListItems"], never, true, never>;
+    static ngAcceptInputType_isHorizontal: unknown;
+    static ngAcceptInputType_maxVisibleItems: unknown;
+}
+/**
+ * Directive representing a term within an ECL description list.
+ */
+declare class EclDescriptionListTermDirective extends ECLBaseDirective {
+    /**
+     * Applies the ECL class for description list terms.
+     */
+    cmpClass: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclDescriptionListTermDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclDescriptionListTermDirective, "[eclDescriptionListTerm]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Module that provides the EclList component and its dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_LIST} instead.
+ */
+declare class EclListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclListModule, never, [typeof EclOrderedListDirective, typeof EclOrderedListItemDirective, typeof EclUnorderedListDirective, typeof EclUnorderedListItemDirective, typeof EclDescriptionListDirective, typeof EclDescriptionListTermDirective, typeof EclDescriptionListDefinitionComponent, typeof EclDescriptionListDefinitionItemDirective, typeof EclDescriptionListDefinitionListDirective], [typeof EclOrderedListDirective, typeof EclOrderedListItemDirective, typeof EclUnorderedListDirective, typeof EclUnorderedListItemDirective, typeof EclDescriptionListDirective, typeof EclDescriptionListTermDirective, typeof EclDescriptionListDefinitionComponent, typeof EclDescriptionListDefinitionItemDirective, typeof EclDescriptionListDefinitionListDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclListModule>;
+}
+
+declare const EUI_ECL_LIST: readonly [typeof EclOrderedListDirective, typeof EclOrderedListItemDirective, typeof EclUnorderedListDirective, typeof EclUnorderedListItemDirective, typeof EclDescriptionListDirective, typeof EclDescriptionListTermDirective, typeof EclDescriptionListDefinitionComponent, typeof EclDescriptionListDefinitionItemDirective, typeof EclDescriptionListDefinitionListDirective];
+
+export { EUI_ECL_LIST, EclDescriptionListDefinitionComponent, EclDescriptionListDefinitionItemDirective, EclDescriptionListDefinitionListDirective, EclDescriptionListDirective, EclDescriptionListTermDirective, EclListModule, EclOrderedListDirective, EclOrderedListItemDirective, EclUnorderedListDirective, EclUnorderedListItemDirective };
+//# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-list/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yCAAyC,EAAE,yCAAyC,EAAE,MAAM,kDAAkD,CAAC;AACxJ,OAAO,EAAE,qCAAqC,EAAE,MAAM,6EAA6E,CAAC;AACpI,OAAO,EACH,2BAA2B,EAC3B,+BAA+B,EAC/B,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,EACzB,6BAA6B,EAChC,MAAM,sBAAsB,CAAC;AAE9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kDAAkD,CAAC;AACjE,cAAc,6EAA6E,CAAC;AAE5F,eAAO,MAAM,YAAY,qXAUf,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-list/ecl-description-list-definition-item.directive.ts","../../../components/ecl-list/ecl-description-list-definition/ecl-description-list-definition.component.ts","../../../components/ecl-list/ecl-list.directive.ts","../../../components/ecl-list/ecl-list.module.ts","../../../components/ecl-list/index.ts"],"sourcesContent":[null,null,null,null,null],"names":[],"mappings":";;;;AAGA;;;;AAIG;AACH,cAAA,yCAAA,SAAA,gBAAA;AAII;;AAEG;;AAUH;;AAEG;AACH;AAEA;;AAEG;AACH;;;AACH;AAED;;;;AAIG;AACH,cAAA,yCAAA,SAAA,gBAAA;AAII;;AAEG;AACyD;;;AAC/D;;AC1CD;;;;;AAKG;AACH,cAAA,qCAAA,SAAA,gBAAA,YAAA,aAAA;AAOI;;;;;;;;AAQG;;AAGH;;AAEG;AAEH,kBAAA,SAAA,CAAA,yCAAA;AAEA;;AAEG;;;;AAYH;;AAEG;AACH;AAIA;;AAEG;;AAKH;;;AAGG;AACH;AAUA;;;AAGG;AACH,wBAAA,KAAA;AAOA;AAIA;AAIA;AAQA;AAIA;;;AAGH;;AC5GD;;AAEG;AACH,cAAA,uBAAA,SAAA,gBAAA;AAII;;AAEG;AACoC;;;AAC1C;AAED;;AAEG;AACH,cAAA,2BAAA,SAAA,gBAAA;AAII;;AAEG;AAC0C;;;AAChD;AAED;;;;AAIG;AACH,cAAA,yBAAA,SAAA,gBAAA;AAII;;AAEG;AACsC;AAEzC;;AAEG;AACuF;AAE1F;;AAEG;AACyF;;;;;AAC/F;AAED;;AAEG;AACH,cAAA,6BAAA,SAAA,gBAAA;AAII;;AAEG;AAC4C;;;AAClD;AAED;;;;;AAKG;AACH,cAAA,2BAAA,SAAA,gBAAA,YAAA,gBAAA;AAII;;AAEG;AAC4F;AAE/F;;;AAGG;AACoC;AAGvC,kBAAA,SAAA,CAAA,qCAAA;AAEA;;AAEG;;;AAOH;;AAEG;AACH;;;;;AAMH;AAED;;AAEG;AACH,cAAA,+BAAA,SAAA,gBAAA;AAII;;AAEG;AAC8C;;;AACpD;;ACpGD;;;;AAIG;AACH,cAAA,aAAA;;;;AAI6B;;AChB7B,cAAA,YAAA,mBAAA,uBAAA,SAAA,2BAAA,SAAA,yBAAA,SAAA,6BAAA,SAAA,2BAAA,SAAA,+BAAA,SAAA,qCAAA,SAAA,yCAAA,SAAA,yCAAA;;;;"}