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

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

@@ -1,11 +1,135 @@
-import { EclRadioHelpComponent } from './ecl-radio-help.component';
-import { EclRadioInputDirective } from './ecl-radio-input.directive';
-import { EclRadioLabelComponent } from './ecl-radio-label.component';
-import { EclRadioDirective } from './ecl-radio.directive';
-export * from './ecl-radio.module';
-export * from './ecl-radio-input.directive';
-export * from './ecl-radio.directive';
-export * from './ecl-radio-label.component';
-export * from './ecl-radio-help.component';
-export declare const EUI_ECL_RADIO: readonly [typeof EclRadioDirective, typeof EclRadioInputDirective, typeof EclRadioLabelComponent, typeof EclRadioHelpComponent];
-//# sourceMappingURL=index.d.ts.map
+import { ECLBaseDirective } from '@eui/ecl/core';
+import * as i0 from '@angular/core';
+import { DoCheck, ChangeDetectorRef } from '@angular/core';
+import { NgControl } from '@angular/forms';
+
+/**
+ * Component that displays help text for the ECL radio input.
+ *
+ * Supports styling for the disabled state and applies the proper ECL CSS classes.
+ * Should be placed inside a component using eclRadio.
+ */
+declare class EclRadioHelpComponent extends ECLBaseDirective {
+    /**
+     * Adds styling for a disabled help text.
+     */
+    isDisabled: boolean;
+    /**
+     * Returns the CSS classes applied to the host element.
+     * Includes the base ecl-radio__help class.
+     */
+    get cssClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRadioHelpComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclRadioHelpComponent, "[eclRadioHelp]", never, { "isDisabled": { "alias": "isDisabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_isDisabled: unknown;
+}
+
+/**
+ * Component representing a label for an ECL radio button.
+ *
+ * Used inside an element with the [eclRadio] directive to provide
+ * a styled label that can reflect the radio's state.
+ */
+declare class EclRadioLabelComponent extends ECLBaseDirective {
+    /**
+     * Adds styling for an invalid state.
+     */
+    isInvalid: boolean;
+    /**
+     * Adds styling for a disabled state.
+     */
+    isDisabled: boolean;
+    /**
+     * Returns the CSS classes applied to the host element.
+     * Includes the base `ecl-radio__label` class.
+     */
+    get cssClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRadioLabelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclRadioLabelComponent, "[eclRadioLabel]", never, { "isInvalid": { "alias": "isInvalid"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; }, {}, never, ["*"], true, never>;
+    static ngAcceptInputType_isInvalid: unknown;
+    static ngAcceptInputType_isDisabled: unknown;
+}
+
+/**
+ * Directive that applies the ECL radio button styling and behavior.
+ *
+ * Should be applied to native radio input elements to enhance them
+ * with ECL styles and support for invalid, disabled and binary states.
+ */
+declare class EclRadioDirective extends ECLBaseDirective implements DoCheck {
+    /**
+     * Adds the `ecl-radio--binary` class when true.
+     */
+    isBinary: boolean;
+    /**
+     * Adds the `ecl-radio--disabled` class to the host element when true.
+     */
+    isDisabled: boolean;
+    /**
+     * Adds the `ecl-radio--invalid` class to the host element when true.
+     */
+    isInvalid: boolean;
+    /**
+     * Reference to the projected EclRadioLabelComponent, if present.
+     * Used to synchronize disabled and invalid states with the label.
+     */
+    eclRadioLabelComponent: EclRadioLabelComponent;
+    /**
+     * Reference to the projected EclRadioHelpComponent, if present.
+     * Used to synchronize the disabled state with the help text.
+     */
+    eclRadioHelpComponent: EclRadioHelpComponent;
+    /**
+     * Returns the CSS classes to apply on the host element.
+     * Includes the base `ecl-radio` class and the binary modifier if applicable.
+     */
+    get cssClasses(): string;
+    /**
+     * Angular lifecycle hook called during every change detection run.
+     * Used to update child components with the current disabled and invalid states.
+     */
+    ngDoCheck(): void;
+    private updateChildElements;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRadioDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclRadioDirective, "[eclRadio]", never, { "isBinary": { "alias": "isBinary"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "isInvalid": { "alias": "isInvalid"; "required": false; }; }, {}, ["eclRadioLabelComponent", "eclRadioHelpComponent"], never, true, never>;
+    static ngAcceptInputType_isBinary: unknown;
+    static ngAcceptInputType_isDisabled: unknown;
+    static ngAcceptInputType_isInvalid: unknown;
+}
+
+/**
+ * Directive that decorates native <input> elements to be styled as ECL radio inputs.
+ *
+ * Applies the proper ECL CSS classes and integrates with Angular forms
+ * to reflect validation states (invalid, disabled) in the parent ECL radio directive.
+ * Should be used together with the eclRadio directive.
+ */
+declare class EclRadioInputDirective extends ECLBaseDirective implements DoCheck {
+    eclRadio: EclRadioDirective;
+    protected ngControl: NgControl;
+    protected cd: ChangeDetectorRef;
+    /**
+     * Returns the CSS classes applied to the host input element.
+     * Includes the base ecl-radio__input class.
+     */
+    get cssClasses(): string;
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRadioInputDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclRadioInputDirective, "input[eclRadioInput]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Module that provides the EclRadio directive and its dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_RADIO} instead.
+ */
+declare class EclRadioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRadioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclRadioModule, never, [typeof EclRadioDirective, typeof EclRadioInputDirective, typeof EclRadioLabelComponent, typeof EclRadioHelpComponent], [typeof EclRadioDirective, typeof EclRadioInputDirective, typeof EclRadioLabelComponent, typeof EclRadioHelpComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclRadioModule>;
+}
+
+declare const EUI_ECL_RADIO: readonly [typeof EclRadioDirective, typeof EclRadioInputDirective, typeof EclRadioLabelComponent, typeof EclRadioHelpComponent];
+
+export { EUI_ECL_RADIO, EclRadioDirective, EclRadioHelpComponent, EclRadioInputDirective, EclRadioLabelComponent, EclRadioModule };
+//# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-radio/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAE3C,eAAO,MAAM,aAAa,iIAEhB,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-radio/ecl-radio-help.component.ts","../../../components/ecl-radio/ecl-radio-label.component.ts","../../../components/ecl-radio/ecl-radio.directive.ts","../../../components/ecl-radio/ecl-radio-input.directive.ts","../../../components/ecl-radio/ecl-radio.module.ts","../../../components/ecl-radio/index.ts"],"sourcesContent":[null,null,null,null,null,null],"names":[],"mappings":";;;;;AAGA;;;;;AAKG;AACH,cAAA,qBAAA,SAAA,gBAAA;AAMI;;AAEG;AAGH;AAEA;;;AAGG;;;;;AAKN;;AC3BD;;;;;AAKG;AACH,cAAA,sBAAA,SAAA,gBAAA;AAOI;;AAEG;AACqC;AAExC;;AAEG;AACqC;AAExC;;;AAGG;;;;;;AAKN;;AC7BD;;;;;AAKG;AACH,cAAA,iBAAA,SAAA,gBAAA,YAAA,OAAA;AAII;;AAEG;;AAGH;;AAEG;AAGH;AAEA;;AAEG;AAGH;AAEA;;;AAGG;;AAIH;;;AAGG;;AAIH;;;AAGG;;AAMH;;;AAGG;AACH;AAIA;;;;;;AAUH;;ACtED;;;;;;AAMG;AACH,cAAA,sBAAA,SAAA,gBAAA,YAAA,OAAA;AAII,cAAA,iBAAA;;;AAIA;;;AAGG;;AAMH;;;AAQH;;AC/BD;;;;AAIG;AACH,cAAA,cAAA;;;;AAI8B;;ACJ9B,cAAA,aAAA,mBAAA,iBAAA,SAAA,sBAAA,SAAA,sBAAA,SAAA,qBAAA;;;;"}

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

@@ -1,10 +1,159 @@
-import { EclRangeBubbleComponent } from './ecl-range-bubble.component';
-import { EclRangeValueComponent } from './ecl-range-value.component';
-import { EclRangeDirective } from './ecl-range.directive';
-export * from './ecl-range.module';
-export * from './ecl-range.directive';
-export * from './ecl-range-value.component';
-export * from './ecl-range-bubble.component';
-export * from './events/ecl-range.event';
-export declare const EUI_ECL_RANGE: readonly [typeof EclRangeDirective, typeof EclRangeValueComponent, typeof EclRangeBubbleComponent];
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { ElementRef, OnInit, OnDestroy, EventEmitter } from '@angular/core';
+import { ECLBaseDirective, EclBaseEvent } from '@eui/ecl/core';
+import { NgControl } from '@angular/forms';
+
+/**
+ * Component representing a bubble tooltip shown above a range input,
+ * used to display the current value with ECL styling.
+ */
+declare class EclRangeBubbleComponent extends ECLBaseDirective {
+    el: ElementRef<any>;
+    /**
+     * Value displayed inside the bubble.
+     */
+    value: number;
+    /**
+     * Returns the CSS classes applied to the host element.
+     * Always includes `ecl-range__bubble` and optionally adds the visible modifier.
+     */
+    get cssClasses(): string;
+    /**
+     * Horizontal offset in pixels for positioning the bubble.
+     * Applied as the left style property of the host element.
+     */
+    left: number;
+    /**
+     * Controls the visibility of the bubble.
+     * Adds the `ecl-range__bubble--visible` class when true.
+     */
+    isVisible: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRangeBubbleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclRangeBubbleComponent, "ecl-range-bubble", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Component representing the value label displayed next to a range input.
+ * Applies ECL styling for the value element.
+ */
+declare class EclRangeValueComponent extends ECLBaseDirective {
+    /**
+     * Value to display next to the range input.
+     */
+    value: number;
+    /**
+     * ID attribute applied to the component's host element.
+     */
+    id: string;
+    /**
+     * Returns the CSS classes applied to the host element.
+     * Adds the base `ecl-range__value` class for styling.
+     */
+    get cssClasses(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRangeValueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclRangeValueComponent, "ecl-range-value", never, { "value": { "alias": "value"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Event emitted by the ECL range directive
+ * whenever the range value changes.
+ */
+declare class EclRangeEvent extends EclBaseEvent {
+    value: number;
+    /**
+     * The current numeric value of the range input.
+     */
+    constructor(value: number);
+}
+
+/**
+ * Directive enhancing native input[type=range] with ECL styles and behavior.
+ * Adds value display, bubble indicator, RTL support and integration with reactive forms.
+ */
+declare class EclRangeDirective extends ECLBaseDirective implements OnInit, OnDestroy {
+    protected ngControl: NgControl;
+    /**
+     * Defines the size of the range component.
+     * Adds a corresponding size class like `ecl-range--m`.
+     */
+    eclSize: string;
+    /**
+     * Initial value for the range input when used standalone.
+     */
+    value: string;
+    /**
+     * ID assigned to the projected ECL range value component.
+     */
+    rangeValueId: string;
+    /**
+     * Adds the `ecl-range--invalid` class when true.
+     */
+    isInvalid: boolean;
+    /**
+     * Enables or disables the display of a value label.
+     */
+    hasValueLabel: boolean;
+    /**
+     * Emits when the range value changes.
+     */
+    rangeChange: EventEmitter<EclRangeEvent>;
+    private rangeValueComponent;
+    private rangeBubbleComponent;
+    private isRtl;
+    private destroy$;
+    private viewContainerRef;
+    private el;
+    private eclRtlService;
+    private cd;
+    /**
+     * Returns the CSS classes applied to the host element.
+     */
+    get cssClasses(): string;
+    /**
+     * Returns whether the component is in an invalid state.
+     * Checks reactive form control if available, or uses `isInvalid` input.
+     */
+    get invalidState(): boolean;
+    /**
+     * Handles native input events on the range element
+     * when not used with reactive forms.
+     */
+    onInput(evt: InputEvent): void;
+    /**
+     * Angular lifecycle hook.
+     * Initializes dynamic components and event listeners.
+     */
+    ngOnInit(): void;
+    /**
+     * Angular lifecycle hook.
+     * Cleans up subscriptions on destroy.
+     */
+    ngOnDestroy(): void;
+    private handleRtlChangeState;
+    private createRangeValueComponent;
+    private initializeRangeValueComponent;
+    private observeReactiveFormValueChanges;
+    private updateRangeValue;
+    private initializeEventListeners;
+    private recalculateBubblePosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRangeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclRangeDirective, "input[eclRange]", never, { "eclSize": { "alias": "eclSize"; "required": false; }; "value": { "alias": "value"; "required": false; }; "rangeValueId": { "alias": "rangeValueId"; "required": false; }; "isInvalid": { "alias": "isInvalid"; "required": false; }; "hasValueLabel": { "alias": "hasValueLabel"; "required": false; }; }, { "rangeChange": "rangeChange"; }, never, never, true, never>;
+    static ngAcceptInputType_isInvalid: unknown;
+    static ngAcceptInputType_hasValueLabel: unknown;
+}
+
+/**
+ * Module that provides the EclRange directive and its dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_RANGE} instead.
+ */
+declare class EclRangeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRangeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclRangeModule, never, [typeof EclRangeDirective, typeof EclRangeValueComponent, typeof EclRangeBubbleComponent], [typeof EclRangeDirective, typeof EclRangeValueComponent, typeof EclRangeBubbleComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclRangeModule>;
+}
+
+declare const EUI_ECL_RANGE: readonly [typeof EclRangeDirective, typeof EclRangeValueComponent, typeof EclRangeBubbleComponent];
+
+export { EUI_ECL_RANGE, EclRangeBubbleComponent, EclRangeDirective, EclRangeEvent, EclRangeModule, EclRangeValueComponent };
+//# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-range/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AAEzC,eAAO,MAAM,aAAa,oGAEhB,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-range/ecl-range-bubble.component.ts","../../../components/ecl-range/ecl-range-value.component.ts","../../../components/ecl-range/events/ecl-range.event.ts","../../../components/ecl-range/ecl-range.directive.ts","../../../components/ecl-range/ecl-range.module.ts","../../../components/ecl-range/index.ts"],"sourcesContent":[null,null,null,null,null,null],"names":[],"mappings":";;;;;AAGA;;;AAGG;AACH,cAAA,uBAAA,SAAA,gBAAA;AAKC,QAAA,UAAA;AAEA;;AAEG;;AAGH;;;AAGG;;AASH;;;AAGG;;AAGH;;;AAGG;AACH;;;AACA;;ACtCD;;;AAGG;AACH,cAAA,sBAAA,SAAA,gBAAA;AAaI;;AAEG;;AAGH;;AAEG;;AAGH;;;AAGG;;;;AAKN;;ACrCD;;;AAGG;AACH,cAAA,aAAA,SAAA,YAAA;AAIuB;AAHnB;;AAEG;AACgB;AAGtB;;ACJD;;;AAGG;AACH,cAAA,iBAAA,SAAA,gBAAA,YAAA,MAAA,EAAA,SAAA;;AAMI;;;AAGG;AACM;AAET;;AAEG;;AAGH;;AAEG;;AAGH;;AAEG;AACqC;AAExC;;AAEG;AACqC;AAExC;;AAEG;AACO,iBAAA,YAAA,CAAA,aAAA;;;;;;;;;AAWV;;AAEG;;AAMH;;;AAGG;;AAUH;;;AAGG;AAEH,iBAAA,UAAA;AAOA;;;AAGG;AACH;AAQA;;;AAGG;AACH;AAKA;AAMA;AAUA;AAKA;AAMA;AASA;AAsBA;;;;;AAyBH;;AC7LD;;;;AAIG;AACH,cAAA,cAAA;;;;AAI8B;;ACN9B,cAAA,aAAA,mBAAA,iBAAA,SAAA,sBAAA,SAAA,uBAAA;;;;"}

package/components/ecl-rating-field/index.d.ts

@@ -1,6 +1,85 @@
-import { EclRatingFieldComponent } from './ecl-rating-field.component';
-export * from './ecl-rating-field.module';
-export * from './ecl-rating-field.component';
-export * from './events/ecl-rating-change.event';
-export declare const EUI_ECL_RATING_FIELD: readonly [typeof EclRatingFieldComponent];
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { EventEmitter, Provider } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ECLBaseDirective, EclBaseEvent } from '@eui/ecl/core';
+
+declare const ECL_RATINGFIELD_VALUE_ACCESSOR: Provider;
+/**
+ * Component representing rating field, displayed with stars.
+ * Typically used when the user needs to evaluate something.
+ */
+declare class EclRatingFieldComponent extends ECLBaseDirective implements ControlValueAccessor {
+    /**
+     * Name of the radio group. Also used for creating id for each radio button.
+     */
+    name: string;
+    /**
+     * How many stars should the rating have.
+     */
+    numberOfStars: number;
+    /**
+     * The initial value, if any.
+     */
+    rating: number;
+    /**
+     * Can be used to set disabled status.
+     */
+    disabled: boolean;
+    /**
+     * The event to be emitted when rating is changed.
+     */
+    ratingChange: EventEmitter<any>;
+    private onChange;
+    private onTouched;
+    /**
+     * Array of numbers, from 1 to 'numberOfStars'
+     */
+    get numbers(): Array<number>;
+    /**
+    * Applies the base class `ecl-rating-field` to the host element. Applies 'ecl-rating-field--disabled' class on condition.
+    */
+    get cssClasses(): string;
+    /**
+     * Method that sets the new rating and emit 'ratingChange' event, that includes the new rating number.
+     * @param rating - the new rating
+     */
+    onRadioClick(rating: number): void;
+    /**
+     * Informs the component of any changes in the parent (ControlValueAccessor). Sets the new value for the 'rating' property.
+     * @param value
+     */
+    writeValue(value: number): void;
+    /**
+     * Disable/enable component.
+     * @param isDisabled
+     */
+    setDisabledState(isDisabled: boolean): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRatingFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclRatingFieldComponent, "ecl-rating-field", never, { "name": { "alias": "name"; "required": false; }; "numberOfStars": { "alias": "numberOfStars"; "required": false; }; "rating": { "alias": "rating"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "ratingChange": "ratingChange"; }, never, never, true, never>;
+    static ngAcceptInputType_numberOfStars: unknown;
+    static ngAcceptInputType_rating: unknown;
+    static ngAcceptInputType_disabled: unknown;
+}
+
+/**
+ * Module that provides the EclRatingField component.
+ *
+ * @deprecated Use {@link EUI_ECL_RATING_FIELD} instead.
+ */
+declare class EclRatingFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclRatingFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclRatingFieldModule, never, [typeof EclRatingFieldComponent], [typeof EclRatingFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclRatingFieldModule>;
+}
+
+declare class EclRatingChangeEvent extends EclBaseEvent {
+    readonly value: number;
+    constructor(value: number);
+}
+
+declare const EUI_ECL_RATING_FIELD: readonly [typeof EclRatingFieldComponent];
+
+export { ECL_RATINGFIELD_VALUE_ACCESSOR, EUI_ECL_RATING_FIELD, EclRatingChangeEvent, EclRatingFieldComponent, EclRatingFieldModule };
+//# sourceMappingURL=index.d.ts.map

package/components/ecl-rating-field/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-rating-field/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kCAAkC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,2CAEvB,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-rating-field/ecl-rating-field.component.ts","../../../components/ecl-rating-field/ecl-rating-field.module.ts","../../../components/ecl-rating-field/events/ecl-rating-change.event.ts","../../../components/ecl-rating-field/index.ts"],"sourcesContent":[null,null,null,null],"names":[],"mappings":";;;;;AAMA,cAAA,8BAAA,EAAA,QAAA;AAUA;;;AAGG;AACH,cAAA,uBAAA,SAAA,gBAAA,YAAA,oBAAA;AAOI;;AAEG;AACM;AACT;;AAEG;AACoC;AACvC;;AAEG;;AAEH;;AAEG;;AAKH;;AAEG;AAEO,kBAAA,YAAA;;;AAMV;;AAEG;AACH,mBAAA,KAAA;AAMA;;AAEE;;AAMF;;;AAGG;AACH;AASA;;;AAGG;AACH;AAIA;;;AAGG;AACH;AAKA;AAKA;;;;;;AAGH;;AC5GD;;;;AAIG;AACH,cAAA,oBAAA;;;;AAIoC;;ACVpC,cAAA,oBAAA,SAAA,YAAA;AACgC;AAAA;AAG/B;;ACAD,cAAA,oBAAA,mBAAA,uBAAA;;;;"}

package/components/ecl-search-form/index.d.ts

@@ -1,6 +1,71 @@
-import { EclSearchFormComponent } from './ecl-search-form.component';
-export * from './ecl-search-form.module';
-export * from './ecl-search-form.component';
-export * from './events/ecl-search-form.event';
-export declare const EUI_ECL_SEARCH_FORM: readonly [typeof EclSearchFormComponent];
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { EventEmitter, Provider } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { EclBaseEvent, ECLBaseDirective, EclThemeService } from '@eui/ecl/core';
+
+declare class EclSearchFormEvent extends EclBaseEvent {
+    keyword: string;
+    constructor(keyword: string);
+}
+
+declare const ECL_SEARCH_FORM_VALUE_ACCESSOR: Provider;
+/**
+ * Component representing search field - input and button, in a responsive, styled layout.
+ */
+declare class EclSearchFormComponent extends ECLBaseDirective implements ControlValueAccessor {
+    protected eclThemeService: EclThemeService;
+    /**
+    * The current/default search text.
+    */
+    searchInputText: string;
+    placeholder: string;
+    searchButtonLabel: string;
+    searchButtonIcon: string;
+    buttonExtraClassses: string;
+    inputExtraClassses: string;
+    /**
+    * Applies the base class `ecl-search-form` to the host element.
+    */
+    get cssClasses(): string;
+    role: string;
+    /**
+    * This event is emited, when user performs the search action. Includes the search text from the input field.
+    */
+    search: EventEmitter<EclSearchFormEvent>;
+    private onChange;
+    private onTouched;
+    /**
+    * Perform search when user clicks the search button. Emits the search event with the search text.
+    */
+    onSearchClick(evt: Event): void;
+    /**
+    * Perform search when user clicks Enter when on the input field. Emits the search event with the search text.
+    */
+    onEnterKeyDown(evt: Event): void;
+    /**
+     * Assigns the new input text value to the 'searchInputText' property, each time the input is changed.
+     * @param newValue
+     */
+    onModelChange(newValue: string): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: (_: any) => void): void;
+    registerOnTouched(fn: (_: any) => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclSearchFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclSearchFormComponent, "ecl-search-form", never, { "searchInputText": { "alias": "searchInputText"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "searchButtonLabel": { "alias": "searchButtonLabel"; "required": false; }; "searchButtonIcon": { "alias": "searchButtonIcon"; "required": false; }; "buttonExtraClassses": { "alias": "buttonExtraClassses"; "required": false; }; "inputExtraClassses": { "alias": "inputExtraClassses"; "required": false; }; }, { "search": "search"; }, never, never, true, never>;
+}
+
+/**
+ * Module that provides the EclSearchForm component.
+ *
+ * @deprecated Use {@link EUI_ECL_SEARCH_FORM} instead.
+ */
+declare class EclSearchFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclSearchFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclSearchFormModule, never, [typeof EclSearchFormComponent], [typeof EclSearchFormComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclSearchFormModule>;
+}
+
+declare const EUI_ECL_SEARCH_FORM: readonly [typeof EclSearchFormComponent];
+
+export { ECL_SEARCH_FORM_VALUE_ACCESSOR, EUI_ECL_SEARCH_FORM, EclSearchFormComponent, EclSearchFormEvent, EclSearchFormModule };
+//# sourceMappingURL=index.d.ts.map

package/components/ecl-search-form/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-search-form/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAErE,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAe,gCAAgC,CAAC;AAEhD,eAAO,MAAM,mBAAmB,0CAEtB,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-search-form/events/ecl-search-form.event.ts","../../../components/ecl-search-form/ecl-search-form.component.ts","../../../components/ecl-search-form/ecl-search-form.module.ts","../../../components/ecl-search-form/index.ts"],"sourcesContent":[null,null,null,null],"names":[],"mappings":";;;;;AAEA,cAAA,kBAAA,SAAA,YAAA;AACoB;AAAA;AAGnB;;ACKD,cAAA,8BAAA,EAAA,QAAA;AAUA;;AAEG;AACH,cAAA,sBAAA,SAAA,gBAAA,YAAA,oBAAA;;AASI;;AAEE;;;;AAIO;AACA;AACA;AAET;;AAEE;;AAMwB;AAE1B;;AAEE;AAGQ,YAAA,YAAA,CAAA,kBAAA;;;AAOV;;AAEE;AACF,uBAAA,KAAA;AAKA;;AAEE;AAEF,wBAAA,KAAA;AAKA;;;AAGG;AACH;AAMA;;;;;AAaH;;ACtGD;;;;AAIG;AACH,cAAA,mBAAA;;;;AAImC;;ACNnC,cAAA,mBAAA,mBAAA,sBAAA;;;;"}

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

@@ -1,7 +1,100 @@
-import { EclSelectDirective } from './ecl-select.directive';
-import { EclSelectContainerComponent } from './ecl-select-container.component';
-export * from './ecl-select.module';
-export * from './ecl-select.directive';
-export * from './ecl-select-container.component';
-export declare const EUI_ECL_SELECT: readonly [typeof EclSelectDirective, typeof EclSelectContainerComponent];
-//# sourceMappingURL=index.d.ts.map
+import * as i0 from '@angular/core';
+import { OnInit, DoCheck, AfterContentInit } from '@angular/core';
+import { ECLBaseDirective } from '@eui/ecl/core';
+
+/**
+ * The default HTML <select> component, with some added styling and formatting according to ECL standards.
+ */
+declare class EclSelectDirective extends ECLBaseDirective implements OnInit, DoCheck, AfterContentInit {
+    disabled: boolean;
+    isInvalid: boolean;
+    /**
+     * Custom label for the arrow-down button.
+     */
+    toggleLabel: string | undefined;
+    /**
+     * Size/length of the field and the dropdown, can be 's', 'm' or 'l'. Default is 'm'.
+     */
+    eclSize: 's' | 'm' | 'l';
+    private containerComponent;
+    private readonly OPTGROUP_TAG_NAME;
+    /**
+     * Applies the 'ecl-select' class to the main <select> component
+     */
+    get cssClasses(): string;
+    get isDisabled(): boolean;
+    /**
+     * Adds 'ecl-select--invalid' class to the host element, in case the component has invalid status.
+     */
+    get isInvalidState(): boolean;
+    private ngControl;
+    private el;
+    private viewContainerRef;
+    private renderer;
+    /**
+     * Creates container component for the <select> and assigns default values to it's parameters.
+     */
+    ngOnInit(): void;
+    /**
+     * Handles the group options.
+     */
+    ngAfterContentInit(): void;
+    ngDoCheck(): void;
+    /**
+     * Sets custom 'aria-label' attribute for parent of the option group and for the children.
+     */
+    private handleOptgroup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclSelectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EclSelectDirective, "select[eclSelect]", never, { "disabled": { "alias": "disabled"; "required": false; }; "isInvalid": { "alias": "isInvalid"; "required": false; }; "toggleLabel": { "alias": "toggleLabel"; "required": false; }; "eclSize": { "alias": "eclSize"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_isInvalid: unknown;
+}
+
+/**
+ * Container component, which wraps the <select> component. Ataches custom select button with dropdown arrow.
+ */
+declare class EclSelectContainerComponent extends ECLBaseDirective {
+    /**
+     * Size/length of the field and the dropdown, can be 's', 'm' or 'l'. Default is 'm'.
+     * Same as the size of the main host element.
+     */
+    eclSize: string;
+    disabled: boolean;
+    isInvalid: boolean;
+    /**
+     * Custom label for the arrow-down button. Set from the main host element.
+     */
+    toggleLabel: string | undefined;
+    /**
+     * Adds specific classes for the container.
+     */
+    get cssClasses(): string;
+    private ICON_SIZE_EC;
+    private ICON_SIZE_EU;
+    private eclThemeService;
+    /**
+     * Returns different icon sizes, depending if it's EU (s) or EC (xs) theme.
+     */
+    get iconSize(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclSelectContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EclSelectContainerComponent, "ecl-select-container", never, { "eclSize": { "alias": "eclSize"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isInvalid": { "alias": "isInvalid"; "required": false; }; "toggleLabel": { "alias": "toggleLabel"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_isInvalid: unknown;
+}
+
+/**
+ * @description
+ * Module that provides the EclSelect component and its dependencies.
+ *
+ * @deprecated Use {@link EUI_ECL_SELECT} instead.
+ */
+declare class EclSelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EclSelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EclSelectModule, never, [typeof EclSelectDirective, typeof EclSelectContainerComponent], [typeof EclSelectDirective, typeof EclSelectContainerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EclSelectModule>;
+}
+
+declare const EUI_ECL_SELECT: readonly [typeof EclSelectDirective, typeof EclSelectContainerComponent];
+
+export { EUI_ECL_SELECT, EclSelectContainerComponent, EclSelectDirective, EclSelectModule };
+//# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../components/ecl-select/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,kCAAkC,CAAC;AAE/E,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kCAAkC,CAAC;AAEjD,eAAO,MAAM,cAAc,0EAGjB,CAAC"}
+{"version":3,"file":"index.d.ts","sources":["../../../components/ecl-select/ecl-select.directive.ts","../../../components/ecl-select/ecl-select-container.component.ts","../../../components/ecl-select/ecl-select.module.ts","../../../components/ecl-select/index.ts"],"sourcesContent":[null,null,null,null],"names":[],"mappings":";;;;AAKA;;AAEG;AACH,cAAA,kBAAA,SAAA,gBAAA,YAAA,MAAA,EAAA,OAAA,EAAA,gBAAA;AAI0E;AAC9B;AACxC;;AAEG;AACM;AACT;;AAEG;AACM;;AAGT;AAEA;;AAEG;;;AAeH;;AAEG;;;;;;AAcH;;AAEG;AACH;AAYA;;AAEG;AACH;AAKA;AAMA;;AAEG;AACH;;;;;AAcH;;AClGD;;AAEG;AACH,cAAA,2BAAA,SAAA,gBAAA;AAUI;;;AAGG;AACM;;;AAGT;;AAEG;AACM;AAET;;AAEG;;;;;AAiBH;;AAEG;;;;;;AAQN;;ACpDD;;;;;AAKG;AACH,cAAA,eAAA;;;;AAI+B;;ACZ/B,cAAA,cAAA,mBAAA,kBAAA,SAAA,2BAAA;;;;"}