@acorex/cdk 19.14.1 → 19.14.2

package/common/lib/components/value-component.class.d.ts

@@ -0,0 +1,70 @@
+import { AXValidationSummary } from '@acorex/core/validation';
+import { EventEmitter } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { AXFormValidationRule } from '../classes/components.class';
+import { AXValueChangedEvent } from '../classes/events.class';
+import { AXComponentState } from './base-component.class';
+import { MXInteractiveComponent } from './interactive-component.class';
+import * as i0 from "@angular/core";
+export declare class MXValueComponent<T = any> extends MXInteractiveComponent implements ControlValueAccessor {
+    /**
+     *  Fires each time the user press a key.
+     *  @event
+     */
+    onValueChanged: EventEmitter<AXValueChangedEvent<any>>;
+    /**
+     * @deprecated The event should not be used, use ngModelChange instead
+     */
+    valueChange: EventEmitter<any>;
+    readonlyChange: EventEmitter<boolean>;
+    private _readonly;
+    /**
+     *  If set to true, user cannot change the value of component.
+     */
+    get readonly(): boolean;
+    set readonly(value: boolean);
+    private _name;
+    get name(): string;
+    set name(value: string);
+    private _dirty;
+    get dirty(): boolean;
+    markAsDirty(): void;
+    private _isUserInteraction;
+    initValue: T;
+    defaultValue: T;
+    private _value;
+    /**
+     * @deprecated The property should not be used, use ngModel instead
+     */
+    get value(): T;
+    set value(v: T);
+    stateChange: EventEmitter<AXComponentState>;
+    private _state;
+    get state(): AXComponentState;
+    set state(value: AXComponentState);
+    protected emitOnValueChangedEvent(oldValue?: any, newValue?: any): void;
+    protected internalSetValue(value: any): T;
+    protected internalGetValue(value: any): T;
+    protected internalValueChanged(value: any): void;
+    protected ngOnInit(): void;
+    protected ngOnDestroy(): void;
+    protected registerValidation(): void;
+    protected document: Document;
+    protected platformID: Object;
+    private validationService;
+    validationRulesChange: EventEmitter<AXFormValidationRule[]>;
+    private validationRules;
+    get isRequired(): boolean;
+    addValidationRule(rule: AXFormValidationRule): void;
+    removeValidationRule(ruleToRemove: AXFormValidationRule): void;
+    validate(): Promise<AXValidationSummary>;
+    protected setState(state: AXComponentState, ...args: any[]): void;
+    protected onChangeCallback: (value: T) => void;
+    registerOnChange(fn: (value: T) => void): void;
+    writeValue(value: T): void;
+    commitValue(value: T, u?: boolean): void;
+    reset(e?: boolean): void;
+    resetErrors(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MXValueComponent<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MXValueComponent<any>>;
+}

package/common/lib/directives/auto-focus.directive.d.ts

@@ -0,0 +1,17 @@
+import { AfterViewInit, ElementRef, Renderer2 } from '@angular/core';
+import { AXFocusableComponent } from '../classes/components.class';
+import * as i0 from "@angular/core";
+export declare class AXAutoFocusDirective implements AfterViewInit {
+    private renderer;
+    private el;
+    _host: AXFocusableComponent;
+    autoFocus?: boolean;
+    time: number;
+    private document;
+    private platformID;
+    constructor(renderer: Renderer2, el: ElementRef<HTMLElement>, _host: AXFocusableComponent);
+    ngAfterViewInit(): void;
+    protected doFocus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXAutoFocusDirective, [null, null, { optional: true; host: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXAutoFocusDirective, "[axAutoFocus]", never, { "autoFocus": { "alias": "axAutoFocus"; "required": false; }; "time": { "alias": "axAutoFocusTime"; "required": false; }; }, {}, never, never, true, never>;
+}

package/common/lib/directives/copy-clipboard.directive.d.ts

@@ -0,0 +1,40 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive to copy provided context to the clipboard on click,
+ * using Angular's input signal injection for the context.
+ * Emits copy status via a writable signal property.
+ *
+ * Usage:
+ * <button
+ *   axCopyClipboard
+ *   [copiedSignal]="copiedSignal"
+ * >Copy</button>
+ */
+export declare class AXCopyClipboardDirective {
+    elementRef: ElementRef<any>;
+    /**
+     * Required string input signal for the context to copy.
+     * Bound via: axCopyClipboard="textSignal"
+     */
+    context: import("@angular/core").InputSignal<string>;
+    /**
+     * WritableSignal to capture copy success (true) or failure (false).
+     * Can be bound: [copiedSignal]="myWritableSignal"
+     */
+    copied: import("@angular/core").OutputEmitterRef<boolean>;
+    /**
+     * Trigger copy when the host element is clicked.
+     */
+    onHostHover(): Promise<void>;
+    /**
+     * Trigger copy when the host element is clicked.
+     */
+    onHostClick(): Promise<void>;
+    /**
+     * Copy the string to the clipboard.
+     */
+    private copyToClipboard;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXCopyClipboardDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXCopyClipboardDirective, "[axCopyClipboard]", never, { "context": { "alias": "axCopyClipboard"; "required": true; "isSignal": true; }; }, { "copied": "copied"; }, never, never, true, never>;
+}

package/common/lib/directives/delayed-value-changed.directive.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { NgModel } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class AXNgModelDelayedValueChangedDirective implements OnDestroy {
+    private ngModel;
+    axDelayedValueChanged: EventEmitter<any>;
+    axDelayTimeChange: EventEmitter<number>;
+    private _delayTime;
+    get delayTime(): number;
+    set delayTime(v: number);
+    private subscription;
+    ngOnDestroy(): void;
+    constructor(ngModel: NgModel);
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXNgModelDelayedValueChangedDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXNgModelDelayedValueChangedDirective, "[axDelayedValueChanged]", never, { "delayTime": { "alias": "delayTime"; "required": false; }; }, { "axDelayedValueChanged": "axDelayedValueChanged"; "axDelayTimeChange": "axDelayTimeChange"; }, never, never, true, never>;
+}

package/common/lib/directives/hotkey.directive.d.ts

@@ -0,0 +1,22 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import { AXComponent } from '../classes/components.class';
+import { AXHotkeysService } from '../services/hotkey.service';
+import * as i0 from "@angular/core";
+export type AXHotKeyAction = {
+    [key: string]: string | Function;
+    parmas?: any;
+};
+export declare class AXHotkeyDirective implements AfterViewInit {
+    private el;
+    _host: AXComponent;
+    private hs;
+    axHotkey: string | AXHotKeyAction | AXHotKeyAction[];
+    private _subs;
+    constructor(el: ElementRef<HTMLElement>, _host: AXComponent, hs: AXHotkeysService);
+    ngAfterViewInit(): void;
+    private _addDefaultAction;
+    private _addHotKeyAction;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXHotkeyDirective, [null, { optional: true; host: true; self: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXHotkeyDirective, "[axHotkey]", never, { "axHotkey": { "alias": "axHotkey"; "required": false; }; }, {}, never, never, true, never>;
+}

package/common/lib/directives/infinite-scroll.directive.d.ts

@@ -0,0 +1,25 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface AXScrollPosition {
+    scrollHeight: number;
+    scrollTop: number;
+    clientHeight: number;
+}
+export declare class AXInfiniteScrollerDirective implements AfterViewInit {
+    private elm;
+    private scrollEvent$;
+    private userScrolledDown$;
+    private requestOnScroll$;
+    scrollCallback: Function;
+    immediateCallback: any;
+    scrollPercent: number;
+    constructor(elm: ElementRef);
+    ngAfterViewInit(): void;
+    private registerScrollEvent;
+    private streamScrollEvents;
+    private requestCallbackOnScroll;
+    private isUserScrollingDown;
+    private isScrollExpectedPercent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXInfiniteScrollerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXInfiniteScrollerDirective, "[axInfiniteScroller]", never, { "scrollCallback": { "alias": "scrollCallback"; "required": false; }; "immediateCallback": { "alias": "immediateCallback"; "required": false; }; "scrollPercent": { "alias": "scrollPercent"; "required": false; }; }, {}, never, never, true, never>;
+}

package/common/lib/directives/inverted-color.directive.d.ts

@@ -0,0 +1,12 @@
+import { ViewContainerRef } from '@angular/core';
+import { AXStyleColorType } from '../classes/styles.class';
+import * as i0 from "@angular/core";
+export declare class AXInvertedColorDirective {
+    color: import("@angular/core").InputSignal<AXStyleColorType>;
+    ref: ViewContainerRef;
+    private platformID;
+    constructor();
+    protected invertColor(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXInvertedColorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXInvertedColorDirective, "[axInvertedColor]", never, { "color": { "alias": "color"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/common/lib/directives/responsive.directive.d.ts

@@ -0,0 +1,10 @@
+import { ElementRef, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AXResponsiveDirective implements OnDestroy {
+    private _elementRef;
+    private _observer;
+    constructor(_elementRef: ElementRef<HTMLDivElement>);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXResponsiveDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXResponsiveDirective, "[axResponsive]", never, {}, {}, never, never, true, never>;
+}

package/common/lib/directives/ripple.directive.d.ts

@@ -0,0 +1,18 @@
+import { ChangeDetectorRef, ElementRef, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AXRippleDirective implements OnDestroy {
+    private el;
+    private cdr;
+    enabled?: boolean;
+    axRippleColor: string;
+    ripple: HTMLSpanElement | null;
+    private document;
+    private platformID;
+    constructor(el: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private onElementClick;
+    private createRipple;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXRippleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXRippleDirective, "[axRipple]", never, { "enabled": { "alias": "axRipple"; "required": false; }; "axRippleColor": { "alias": "axRippleColor"; "required": false; }; }, {}, never, never, true, never>;
+}

package/common/lib/interfaces/component.interface.d.ts

@@ -0,0 +1,4 @@
+export interface AXExpandToggleIcons {
+    expanded: string;
+    collapsed: string;
+}

package/common/lib/services/dom.service.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class AXDomService {
+    generateElementId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXDomService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXDomService>;
+}

package/common/lib/services/hotkey.service.d.ts

@@ -0,0 +1,31 @@
+import { EventManager } from '@angular/platform-browser';
+import { Observable } from 'rxjs/internal/Observable';
+import * as i0 from "@angular/core";
+type Options = {
+    /**
+     * element - An html element
+     */
+    element: any;
+    /**
+     * keys - string of keys like (Control.f)
+     */
+    keys: string;
+};
+export declare class AXHotkeysService {
+    private eventManager;
+    private document;
+    defaults: Partial<Options>;
+    constructor(eventManager: EventManager);
+    /**
+     * Add shortcut
+     *
+     *
+     * @param options
+     * @returns Observable
+     *
+     */
+    addShortcut(options: Partial<Options>): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXHotkeysService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXHotkeysService>;
+}
+export {};

package/common/lib/types/animation.d.ts

@@ -0,0 +1 @@
+export type AXAnimationEasing = 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'cubic' | 'cubic-in' | 'cubic-out' | 'cubic-in-out';

package/common/lib/types/base/button.type.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare abstract class NXButtonComponent {
+    text: import("@angular/core").ModelSignal<string>;
+    toggleableChange: import("@angular/core").OutputEmitterRef<boolean>;
+    selectedChange: import("@angular/core").OutputEmitterRef<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NXButtonComponent, "ng-component", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "text": "textChange"; "toggleableChange": "toggleableChange"; "selectedChange": "selectedChange"; }, never, never, true, never>;
+}

package/common/lib/types/base/color.type.d.ts

@@ -0,0 +1,7 @@
+import { AXStyleColorType } from '../../classes/styles.class';
+import * as i0 from "@angular/core";
+export declare abstract class NXColorComponent {
+    color: import("@angular/core").ModelSignal<AXStyleColorType>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXColorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NXColorComponent, "ng-component", never, { "color": { "alias": "color"; "required": false; "isSignal": true; }; }, { "color": "colorChange"; }, never, never, true, never>;
+}

package/common/lib/types/base/component.types.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare abstract class NXComponent {
+    #private;
+    protected isRendered: import("@angular/core").Signal<boolean>;
+    get nativeElement(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXComponent, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NXComponent>;
+}

package/common/lib/types/base/events.types.d.ts

@@ -0,0 +1,21 @@
+import { NXComponent } from './component.types';
+/**
+ *  Base event class
+ * @category Events
+ */
+export declare class NXEvent<T extends NXComponent = NXComponent> {
+    sender: T;
+}
+/**
+ *  Contains native event
+ * @category Events
+ */
+export declare class NXNativeEvent<T extends NXComponent = NXComponent, E extends Event = Event> extends NXEvent<T> {
+    nativeEvent: E;
+}
+/**
+ *  Fires each time the user click the element.
+ * @category Events
+ */
+export declare class NXClickEvent<T extends NXComponent = NXComponent> extends NXNativeEvent<T, MouseEvent> {
+}

package/common/lib/types/base/index.d.ts

@@ -0,0 +1,7 @@
+export * from './button.type';
+export * from './color.type';
+export * from './component.types';
+export * from './events.types';
+export * from './interactive.type';
+export * from './look.type';
+export * from './value.type';

package/common/lib/types/base/interactive.type.d.ts

@@ -0,0 +1,13 @@
+import { NXComponent } from './component.types';
+import * as i0 from "@angular/core";
+export declare abstract class NXInteractiveComponent extends NXComponent {
+    disabled: import("@angular/core").ModelSignal<boolean>;
+    tabIndex: import("@angular/core").ModelSignal<number>;
+    onFocus: import("@angular/core").OutputEmitterRef<void>;
+    onBlur: import("@angular/core").OutputEmitterRef<void>;
+    focus(): void;
+    blur(): void;
+    hasFocus(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXInteractiveComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NXInteractiveComponent, "ng-component", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "tabIndex": { "alias": "tabIndex"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "tabIndex": "tabIndexChange"; "onFocus": "onFocus"; "onBlur": "onBlur"; }, never, never, true, never>;
+}

package/common/lib/types/base/look.type.d.ts

@@ -0,0 +1,7 @@
+import { AXStyleLookType } from '../../classes/styles.class';
+import * as i0 from "@angular/core";
+export declare abstract class NXLookComponent {
+    look: import("@angular/core").ModelSignal<AXStyleLookType>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXLookComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NXLookComponent, "ng-component", never, { "look": { "alias": "look"; "required": false; "isSignal": true; }; }, { "look": "lookChange"; }, never, never, true, never>;
+}

package/common/lib/types/base/value.type.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare abstract class NXValueComponent {
+    readonly: import("@angular/core").ModelSignal<boolean>;
+    name: import("@angular/core").ModelSignal<string>;
+    value: import("@angular/core").ModelSignal<unknown>;
+    onValueChanged: import("@angular/core").OutputEmitterRef<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NXValueComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NXValueComponent, "ng-component", never, { "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "readonly": "readonlyChange"; "name": "nameChange"; "value": "valueChange"; "onValueChanged": "onValueChanged"; }, never, never, true, never>;
+}

package/common/lib/types/direction.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A token that specifies the direction of component.
+ */
+export type AXDirection = 'vertical' | 'horizontal';

package/common/lib/types/orientation.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A token that specifies the orientation of component.
+ */
+export type AXOrientation = 'vertical' | 'horizontal';

package/common/lib/types/placement.d.ts

@@ -0,0 +1,30 @@
+export type AXPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'end' | 'end-top' | 'end-bottom' | 'start' | 'start-top' | 'start-bottom';
+export type AXPlacementType = AXConnectedPosition | AXConnectedPosition[] | AXPlacement | AXPlacement[];
+export declare function convertToPlacement(value: AXPlacementType): AXConnectedPosition[];
+export interface AXConnectedPosition {
+    originX: 'start' | 'center' | 'end';
+    originY: 'top' | 'center' | 'bottom';
+    overlayX: 'start' | 'center' | 'end';
+    overlayY: 'top' | 'center' | 'bottom';
+    weight?: number;
+    offsetX?: number;
+    offsetY?: number;
+}
+export declare const AX_PLACEMENT_TOP: AXConnectedPosition;
+export declare const AX_PLACEMENT_TOP_START: AXConnectedPosition;
+export declare const AX_PLACEMENT_TOP_END: AXConnectedPosition;
+export declare const AX_PLACEMENT_BOTTOM: AXConnectedPosition;
+export declare const AX_PLACEMENT_BOTTOM_START: AXConnectedPosition;
+export declare const AX_PLACEMENT_BOTTOM_END: AXConnectedPosition;
+export declare const AX_PLACEMENT_START: AXConnectedPosition;
+export declare const AX_PLACEMENT_START_TOP: AXConnectedPosition;
+export declare const AX_PLACEMENT_START_BOTTOM: AXConnectedPosition;
+export declare const AX_PLACEMENT_END: AXConnectedPosition;
+export declare const AX_PLACEMENT_END_TOP: AXConnectedPosition;
+export declare const AX_PLACEMENT_END_BOTTOM: AXConnectedPosition;
+export declare const AX_PLACEMENT_MAP: {
+    [key: string]: {
+        origin: AXConnectedPosition;
+        alts?: AXConnectedPosition[];
+    };
+};

package/common/lib/types/range.d.ts

@@ -0,0 +1,4 @@
+export interface AXRange<T> {
+    from: T;
+    end: T;
+}

package/common/lib/types/selection-mode.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A token that specifies the  selection mode of component.
+ */
+export type AXSelectionMode = 'single' | 'multiple' | 'none';

package/drag-drop/lib/drag.directive.d.ts

@@ -9,6 +9,7 @@ export declare class AXDragDirective implements OnInit, OnDestroy {
     private zone;
     private document;
     private renderer;
+    private cdr;
     private platformId;
     private el;
     private handleDirective;

package/drag-drop/lib/drop-zone.directive.d.ts

@@ -1,16 +1,14 @@
+import { NXComponent, NXNativeEvent } from '@acorex/cdk/common';
 import { OnInit } from '@angular/core';
 import { AXDragDirective } from './drag.directive';
 import * as i0 from "@angular/core";
-export type AXDropZoneDropEvent = {
-    sender: AXDropZoneDirective;
-    nativeEvent: PointerEvent;
+export interface AXDropZoneDropEvent extends NXNativeEvent<AXDropZoneDirective, PointerEvent> {
     dropped: AXDragDirective;
-};
+}
 export type AXDropZoneHoverEvent = AXDropZoneDropEvent & {
     state: 'enter' | 'leave';
 };
-export declare class AXDropZoneDirective implements OnInit {
-    private el;
+export declare class AXDropZoneDirective extends NXComponent implements OnInit {
     dropZoneGroup: import("@angular/core").InputSignal<string>;
     isHovered: import("@angular/core").WritableSignal<boolean>;
     readonly element: import("@angular/core").WritableSignal<HTMLElement>;

package/drawer/lib/drawer-item.directive.d.ts

@@ -1,4 +1,4 @@
-import { AXClickEvent } from '@acorex/core/types';
+import { AXClickEvent } from '@acorex/cdk/common';
 import * as i0 from "@angular/core";
 export declare class AXDrawerItemDirective {
     #private;

package/fesm2022/acorex-cdk-carousel.mjs

@@ -55,10 +55,10 @@ class AXCarouselDirective {
         });
         this.carousel.set(res);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCarouselDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.10", type: AXCarouselDirective, isStandalone: true, selector: "[axCarousel]", inputs: { carouselOptions: { classPropertyName: "carouselOptions", publicName: "carouselOptions", isSignal: true, isRequired: false, transformFunction: null } }, exportAs: ["axCarousel"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCarouselDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.2.11", type: AXCarouselDirective, isStandalone: true, selector: "[axCarousel]", inputs: { carouselOptions: { classPropertyName: "carouselOptions", publicName: "carouselOptions", isSignal: true, isRequired: false, transformFunction: null } }, exportAs: ["axCarousel"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCarouselDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCarouselDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[axCarousel]',

package/fesm2022/acorex-cdk-collapse.mjs

@@ -15,10 +15,10 @@ class AXCollapseCloseButtonDirective {
         });
     }
     #init;
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseCloseButtonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.10", type: AXCollapseCloseButtonDirective, isStandalone: true, selector: "[axCollapseCloseButton]", outputs: { onclick: "onclick" }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseCloseButtonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.11", type: AXCollapseCloseButtonDirective, isStandalone: true, selector: "[axCollapseCloseButton]", outputs: { onclick: "onclick" }, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseCloseButtonDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseCloseButtonDirective, decorators: [{
             type: Directive,
             args: [{ selector: '[axCollapseCloseButton]' }]
         }] });
@@ -40,10 +40,10 @@ class AXCollapseItemContentlDirective {
         });
     }
     #eff;
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseItemContentlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.10", type: AXCollapseItemContentlDirective, isStandalone: true, selector: "[axCollapseItemContent]", exportAs: ["axCollapseItemContent"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseItemContentlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.11", type: AXCollapseItemContentlDirective, isStandalone: true, selector: "[axCollapseItemContent]", exportAs: ["axCollapseItemContent"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseItemContentlDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseItemContentlDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[axCollapseItemContent]',
@@ -70,10 +70,10 @@ class AXCollapseItemlDirective {
     }
     #init;
     #init2;
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseItemlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "19.2.10", type: AXCollapseItemlDirective, isStandalone: true, selector: "[axCollapseItem]", outputs: { onclick: "onclick" }, queries: [{ propertyName: "content", first: true, predicate: AXCollapseItemContentlDirective, descendants: true, isSignal: true }, { propertyName: "close", first: true, predicate: AXCollapseCloseButtonDirective, descendants: true, isSignal: true }], exportAs: ["axCollapseItem"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseItemlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "19.2.11", type: AXCollapseItemlDirective, isStandalone: true, selector: "[axCollapseItem]", outputs: { onclick: "onclick" }, queries: [{ propertyName: "content", first: true, predicate: AXCollapseItemContentlDirective, descendants: true, isSignal: true }, { propertyName: "close", first: true, predicate: AXCollapseCloseButtonDirective, descendants: true, isSignal: true }], exportAs: ["axCollapseItem"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseItemlDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseItemlDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[axCollapseItem]',
@@ -110,10 +110,10 @@ class AXCollapseGrouplDirective {
     }
     #eff;
     #eff2;
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseGrouplDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "19.2.10", type: AXCollapseGrouplDirective, isStandalone: true, selector: "[axCollapseGroup]", inputs: { accordion: { classPropertyName: "accordion", publicName: "accordion", isSignal: true, isRequired: false, transformFunction: null } }, queries: [{ propertyName: "content", predicate: AXCollapseItemlDirective, isSignal: true }], exportAs: ["axCollapseGroup"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseGrouplDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.2.0", version: "19.2.11", type: AXCollapseGrouplDirective, isStandalone: true, selector: "[axCollapseGroup]", inputs: { accordion: { classPropertyName: "accordion", publicName: "accordion", isSignal: true, isRequired: false, transformFunction: null } }, queries: [{ propertyName: "content", predicate: AXCollapseItemlDirective, isSignal: true }], exportAs: ["axCollapseGroup"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseGrouplDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseGrouplDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[axCollapseGroup]',
@@ -122,10 +122,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImpo
         }] });
 
 class AXCollapseItemHeaderlDirective {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseItemHeaderlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.10", type: AXCollapseItemHeaderlDirective, isStandalone: true, selector: "[axCollapseItemHeader]", exportAs: ["axCollapseItemHeader"], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseItemHeaderlDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.2.11", type: AXCollapseItemHeaderlDirective, isStandalone: true, selector: "[axCollapseItemHeader]", exportAs: ["axCollapseItemHeader"], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseItemHeaderlDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseItemHeaderlDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[axCollapseItemHeader]',
@@ -142,8 +142,8 @@ const COMPONENT = [
 ];
 const MODULES = [CommonModule];
 class AXCollapseModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseModule, imports: [CommonModule, AXCollapseGrouplDirective,
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseModule, imports: [CommonModule, AXCollapseGrouplDirective,
             AXCollapseItemContentlDirective,
             AXCollapseItemHeaderlDirective,
             AXCollapseItemlDirective,
@@ -152,9 +152,9 @@ class AXCollapseModule {
             AXCollapseItemHeaderlDirective,
             AXCollapseItemlDirective,
             AXCollapseCloseButtonDirective] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseModule, imports: [MODULES] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseModule, imports: [MODULES] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.10", ngImport: i0, type: AXCollapseModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.11", ngImport: i0, type: AXCollapseModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [...MODULES, ...COMPONENT],