@acorex/cdk 19.15.0-next.8 → 20.0.0

package/list-navigation/index.d.ts

@@ -1,3 +1,44 @@
-export * from './lib/list-navigation-item.directive';
-export * from './lib/list-navigation.directive';
-export * from './lib/list-navigation.module';
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as i1 from '@angular/common';
+
+declare class AXListNavigationItemDirective {
+    #private;
+    itemElem: ElementRef<any>;
+    isActive: i0.WritableSignal<boolean>;
+    navigationItemKey: number;
+    navigationParentItemKey: i0.WritableSignal<any>;
+    index: i0.WritableSignal<number>;
+    private parent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXListNavigationItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXListNavigationItemDirective, "[axListNavigationItem]", ["axListNavigationItem"], {}, {}, never, never, true, never>;
+}
+
+declare class AXListNavigationDirective {
+    #private;
+    private parentElem;
+    private childElem;
+    private activeIndex;
+    private holdShift;
+    onNavigationChanged: i0.OutputEmitterRef<{
+        sender: AXListNavigationDirective;
+    }>;
+    onPressEnterOrSpace: i0.OutputEmitterRef<{
+        active: number;
+    }>;
+    orientation: i0.InputSignal<"horizontal" | "vertical">;
+    private navigationHandler;
+    private parentNavigationHandler;
+    navigateTo(e: AXListNavigationItemDirective): void;
+    private activeByKeyboardHandler;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXListNavigationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXListNavigationDirective, "[axListNavigation]", ["axListNavigation"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "onNavigationChanged": "onNavigationChanged"; "onPressEnterOrSpace": "onPressEnterOrSpace"; }, ["childElem"], never, true, never>;
+}
+
+declare class AXListNavigationModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXListNavigationModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXListNavigationModule, never, [typeof i1.CommonModule, typeof AXListNavigationDirective, typeof AXListNavigationItemDirective], [typeof AXListNavigationDirective, typeof AXListNavigationItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXListNavigationModule>;
+}
+
+export { AXListNavigationDirective, AXListNavigationItemDirective, AXListNavigationModule };

package/outline/index.d.ts

@@ -1,3 +1,57 @@
-export * from './lib/outline-container.directive';
-export * from './lib/outline-item.directive';
-export * from './lib/outline.module';
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i1 from '@angular/common';
+
+type outlineItemType = {
+    el: HTMLElement;
+    active: boolean;
+    scrollY: number;
+    hasAnchor: boolean;
+};
+declare class AXOutlineContainerDirective implements OnDestroy {
+    #private;
+    private zone;
+    private platformId;
+    private el;
+    private unsubscriber;
+    private clipboardService;
+    target: _angular_core.InputSignal<string>;
+    smoothScroll: _angular_core.InputSignal<boolean>;
+    showHashItem: _angular_core.InputSignal<boolean>;
+    activationOffset: _angular_core.InputSignal<number>;
+    copyUrlOnClick: _angular_core.InputSignal<boolean>;
+    activateLastAtBottom: _angular_core.InputSignal<boolean>;
+    scrollableElementId: _angular_core.InputSignal<string>;
+    private scrollTop;
+    private outlineItems;
+    private scrollableElement;
+    private mutationSubject;
+    private readonly MUTATION_DEBOUNCE_TIME;
+    private mutationObserver;
+    outlineItems$: BehaviorSubject<outlineItemType[]>;
+    ngOnDestroy(): void;
+    private scrollChanged;
+    private setOutlineItems;
+    refreshOutlineItems(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXOutlineContainerDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXOutlineContainerDirective, "[axOutlineContainer]", ["axOutlineContainer"], { "target": { "alias": "target"; "required": false; "isSignal": true; }; "smoothScroll": { "alias": "smoothScroll"; "required": false; "isSignal": true; }; "showHashItem": { "alias": "showHashItem"; "required": false; "isSignal": true; }; "activationOffset": { "alias": "activationOffset"; "required": false; "isSignal": true; }; "copyUrlOnClick": { "alias": "copyUrlOnClick"; "required": false; "isSignal": true; }; "activateLastAtBottom": { "alias": "activateLastAtBottom"; "required": false; "isSignal": true; }; "scrollableElementId": { "alias": "scrollableElementId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXOutlineItemDirective {
+    #private;
+    private el;
+    id: _angular_core.InputSignal<string>;
+    disabled: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXOutlineItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXOutlineItemDirective, "[axOutlineItem]", ["axOutlineItem"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class AXOutlineModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXOutlineModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXOutlineModule, never, [typeof i1.CommonModule, typeof AXOutlineContainerDirective, typeof AXOutlineItemDirective], [typeof AXOutlineContainerDirective, typeof AXOutlineItemDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXOutlineModule>;
+}
+
+export { AXOutlineContainerDirective, AXOutlineItemDirective, AXOutlineModule };
+export type { outlineItemType };

package/overlay/index.d.ts

@@ -1,2 +1,27 @@
-export * from './lib/overlay.service';
-export * from './lib/overlay.types';
+import { AXComponentOptions, AXComponentContent } from '@acorex/core/components';
+import { AXPlacement } from '@acorex/cdk/common';
+import * as i0 from '@angular/core';
+import { EmbeddedViewRef, ComponentRef } from '@angular/core';
+
+interface AXOverlayRef<T> {
+    instance: EmbeddedViewRef<T> | ComponentRef<T>;
+}
+interface AXOverlayOptions extends AXComponentOptions {
+    backdrop?: {
+        enabled?: boolean;
+        background?: boolean;
+        cssClass?: string;
+        closeOnClick?: boolean;
+    };
+    position?: AXPlacement;
+}
+
+declare class AXOverlayService {
+    private componentService;
+    create<T = any>(content: AXComponentContent<T>, options?: AXOverlayOptions): Promise<AXOverlayRef<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXOverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXOverlayService>;
+}
+
+export { AXOverlayService };
+export type { AXOverlayOptions, AXOverlayRef };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@acorex/cdk",
-  "version": "19.15.0-next.8",
+  "version": "20.0.0",
   "peerDependencies": {
-    "@angular/common": ">=19.0.0",
-    "@angular/core": ">=19.0.0",
+    "@angular/common": "^20.0.0",
+    "@angular/core": "^20.0.0",
     "quill": ">=2.0.2",
     "quill-delta-to-html": ">=0.12.1",
     "qrcode": ">=1.5.4",
@@ -23,13 +23,17 @@
       "types": "./index.d.ts",
       "default": "./fesm2022/acorex-cdk.mjs"
     },
+    "./accordion": {
+      "types": "./accordion/index.d.ts",
+      "default": "./fesm2022/acorex-cdk-accordion.mjs"
+    },
     "./carousel": {
       "types": "./carousel/index.d.ts",
       "default": "./fesm2022/acorex-cdk-carousel.mjs"
     },
-    "./collapse": {
-      "types": "./collapse/index.d.ts",
-      "default": "./fesm2022/acorex-cdk-collapse.mjs"
+    "./clipboard": {
+      "types": "./clipboard/index.d.ts",
+      "default": "./fesm2022/acorex-cdk-clipboard.mjs"
     },
     "./common": {
       "types": "./common/index.d.ts",
@@ -51,10 +55,18 @@
       "types": "./focus-trap/index.d.ts",
       "default": "./fesm2022/acorex-cdk-focus-trap.mjs"
     },
+    "./input-mask": {
+      "types": "./input-mask/index.d.ts",
+      "default": "./fesm2022/acorex-cdk-input-mask.mjs"
+    },
     "./list-navigation": {
       "types": "./list-navigation/index.d.ts",
       "default": "./fesm2022/acorex-cdk-list-navigation.mjs"
     },
+    "./outline": {
+      "types": "./outline/index.d.ts",
+      "default": "./fesm2022/acorex-cdk-outline.mjs"
+    },
     "./overlay": {
       "types": "./overlay/index.d.ts",
       "default": "./fesm2022/acorex-cdk-overlay.mjs"
@@ -75,10 +87,6 @@
       "types": "./selection/index.d.ts",
       "default": "./fesm2022/acorex-cdk-selection.mjs"
     },
-    "./outline": {
-      "types": "./outline/index.d.ts",
-      "default": "./fesm2022/acorex-cdk-outline.mjs"
-    },
     "./sliding-item": {
       "types": "./sliding-item/index.d.ts",
       "default": "./fesm2022/acorex-cdk-sliding-item.mjs"
@@ -87,13 +95,13 @@
       "types": "./sticky/index.d.ts",
       "default": "./fesm2022/acorex-cdk-sticky.mjs"
     },
-    "./wysiwyg": {
-      "types": "./wysiwyg/index.d.ts",
-      "default": "./fesm2022/acorex-cdk-wysiwyg.mjs"
-    },
     "./virtual-scroll": {
       "types": "./virtual-scroll/index.d.ts",
       "default": "./fesm2022/acorex-cdk-virtual-scroll.mjs"
+    },
+    "./wysiwyg": {
+      "types": "./wysiwyg/index.d.ts",
+      "default": "./fesm2022/acorex-cdk-wysiwyg.mjs"
     }
   },
   "dependencies": {

package/pan-view/index.d.ts

@@ -1 +1,51 @@
-export * from './lib/pan-view.directive';
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+
+declare class AXPanViewDirective implements OnDestroy {
+    #private;
+    private resizeObserver;
+    private platformId;
+    private zone;
+    private render;
+    private document;
+    private el;
+    private startX;
+    private startY;
+    private pointerDown;
+    private wrapper;
+    zoomStep: _angular_core.InputSignal<number>;
+    minZoom: _angular_core.InputSignal<number>;
+    maxZoom: _angular_core.InputSignal<number>;
+    freeMode: _angular_core.InputSignal<boolean>;
+    fitContent: _angular_core.InputSignal<boolean>;
+    disablePan: _angular_core.InputSignal<boolean>;
+    disableZoom: _angular_core.InputSignal<boolean>;
+    wrapperClasses: _angular_core.InputSignal<string>;
+    panX: _angular_core.ModelSignal<number>;
+    panY: _angular_core.ModelSignal<number>;
+    zoom: _angular_core.ModelSignal<number>;
+    zoomChange: _angular_core.OutputEmitterRef<number>;
+    positionChange: _angular_core.OutputEmitterRef<{
+        x: number;
+        y: number;
+    }>;
+    private nativeEl;
+    private initialWidth;
+    private initialHeight;
+    ngOnDestroy(): void;
+    private createWrapper;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handleZoomChange;
+    private sizeChanged;
+    private setFitContentScale;
+    setElementPosition(): void;
+    resetPosition(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXPanViewDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXPanViewDirective, "[axPanView]", ["axPanView"], { "zoomStep": { "alias": "zoomStep"; "required": false; "isSignal": true; }; "minZoom": { "alias": "minZoom"; "required": false; "isSignal": true; }; "maxZoom": { "alias": "maxZoom"; "required": false; "isSignal": true; }; "freeMode": { "alias": "freeMode"; "required": false; "isSignal": true; }; "fitContent": { "alias": "fitContent"; "required": false; "isSignal": true; }; "disablePan": { "alias": "disablePan"; "required": false; "isSignal": true; }; "disableZoom": { "alias": "disableZoom"; "required": false; "isSignal": true; }; "wrapperClasses": { "alias": "wrapperClasses"; "required": false; "isSignal": true; }; "panX": { "alias": "panX"; "required": false; "isSignal": true; }; "panY": { "alias": "panY"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; }, { "panX": "panXChange"; "panY": "panYChange"; "zoom": "zoomChange"; "zoomChange": "zoomChange"; "positionChange": "positionChange"; }, never, never, true, never>;
+}
+
+export { AXPanViewDirective };

package/qrcode/index.d.ts

@@ -1,2 +1,22 @@
-import { generateQRCode } from './qrcode.class';
+/**
+ * Generates a QR code with the given content and options.
+ * @param content - The text/content to encode in the QR code.
+ * @param width - The width/size of the QR code.
+ * @param level - The error correction level ('L', 'M', 'Q', 'H') (default: 'M').
+ * @param color - The color of the QR code (default: '#000000').
+ * @param backgroundColor - The background color of the QR code (default: '#FFFFFF').
+ * @param outputType - The output type: 'canvas', 'svg', or 'url' (default: 'canvas').
+ * @param canvas - Optional canvas element reference if output type is 'canvas'.
+ * @param svg - Optional SVG element reference if output type is 'svg'.
+ * @returns A Promise that resolves with a URL if the output type is 'url', or void for other types.
+ */
+declare function generateQRCode(content: string, // Mandatory content parameter
+width: number, // Mandatory size parameter
+level: 'L' | 'M' | 'Q' | 'H', // Default level is 'M'
+color: string, // Default color is black
+backgroundColor: string, // Default background color is white
+outputType?: 'canvas' | 'svg' | 'url', // Default output type is 'canvas'
+canvas?: HTMLCanvasElement, // Optional canvas element for canvas output
+svg?: HTMLElement): Promise<string | void>;
+
 export { generateQRCode };

package/resizable/index.d.ts

@@ -1 +1,61 @@
-export * from './lib/resize.directive';
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy } from '@angular/core';
+
+declare class AXResizableDirective implements AfterViewInit, OnDestroy {
+    private el;
+    private platformService;
+    private zone;
+    private document;
+    private platformID;
+    private resizeHandle;
+    private isResizing;
+    private initialElementWidth;
+    private startMoveWidth;
+    private resizeObserver;
+    /** Define if directive is active or not */
+    axResizable: _angular_core.ModelSignal<boolean>;
+    /** Minimum width for the resizable element. */
+    minWidth: _angular_core.ModelSignal<number>;
+    /** Maximum width for the resizable element. Defaults to parent width if not provided. */
+    maxWidth: _angular_core.ModelSignal<number>;
+    /** Behavior on double-click: 'reset' or 'maximize'. */
+    dblClickAction: _angular_core.ModelSignal<"reset" | "maximize" | "fit">;
+    /** Define initial width for the element. */
+    width: _angular_core.ModelSignal<number>;
+    /** Define reset width for the element. */
+    defaultWidth: _angular_core.ModelSignal<number>;
+    /** Event emitted when resizing starts. */
+    onResizingStarted: _angular_core.OutputEmitterRef<AXValueChangedEvent<number>>;
+    /** Event emitted when resizing ends. */
+    onResizingEnded: _angular_core.OutputEmitterRef<AXValueChangedEvent<number>>;
+    /** Event emitted on double-click. */
+    onResizingDblClick: _angular_core.OutputEmitterRef<AXValueChangedEvent<number>>;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private setupResizableState;
+    private createResizeHandle;
+    private cleanupEventListeners;
+    private isRTL;
+    private onMouseDown;
+    private onMouseMove;
+    private onMouseUp;
+    private onMouseEnter;
+    private onMouseLeave;
+    private onDoubleClick;
+    private resetToInitialWidth;
+    private maximizeToMaxWidth;
+    private fitToContent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXResizableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXResizableDirective, "[axResizable]", never, { "axResizable": { "alias": "axResizable"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "dblClickAction": { "alias": "dblClickAction"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "defaultWidth": { "alias": "defaultWidth"; "required": false; "isSignal": true; }; }, { "axResizable": "axResizableChange"; "minWidth": "minWidthChange"; "maxWidth": "maxWidthChange"; "dblClickAction": "dblClickActionChange"; "width": "widthChange"; "defaultWidth": "defaultWidthChange"; "onResizingStarted": "onResizingStarted"; "onResizingEnded": "onResizingEnded"; "onResizingDblClick": "onResizingDblClick"; }, never, never, true, never>;
+}
+interface AXValueChangedEvent<T> {
+    component: unknown;
+    htmlElement?: HTMLElement;
+    isUserInteraction?: boolean;
+    name?: string;
+    value?: T;
+    oldValue?: T;
+}
+
+export { AXResizableDirective };

package/selection/index.d.ts

@@ -1,3 +1,43 @@
-export * from './lib/selection-group.directive';
-export * from './lib/selection-item.directive';
-export * from './lib/selection.module';
+import * as _angular_core from '@angular/core';
+import { AXSelectionValueChangedEvent } from '@acorex/cdk/common';
+import * as i1 from '@angular/common';
+
+declare class AXSelectionItemDirective {
+    #private;
+    private elm;
+    isActive: _angular_core.WritableSignal<boolean>;
+    onClick: _angular_core.OutputEmitterRef<{
+        sender: AXSelectionItemDirective;
+    }>;
+    key: _angular_core.InputSignal<string | number>;
+    disable: _angular_core.InputSignal<boolean>;
+    toggle(): void;
+    select(): void;
+    unselect(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSelectionItemDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXSelectionItemDirective, "[axSelectionItem]", ["axSelectionItem"], { "key": { "alias": "key"; "required": true; "isSignal": true; }; "disable": { "alias": "disable"; "required": false; "isSignal": true; }; }, { "onClick": "onClick"; }, never, never, true, never>;
+}
+
+type AXSelectionGroupSelectedKeys = string | string[] | number | number[];
+declare class AXSelectionGroupDirective {
+    #private;
+    private content;
+    private activeIndex;
+    multiple: _angular_core.InputSignal<boolean>;
+    disable: _angular_core.InputSignal<boolean>;
+    selectedKeys: _angular_core.InputSignal<AXSelectionGroupSelectedKeys>;
+    onSelectionChanged: _angular_core.OutputEmitterRef<AXSelectionValueChangedEvent>;
+    selectionItemsClass: _angular_core.Signal<readonly AXSelectionItemDirective[]>;
+    activeItemByIndex(...restParams: number[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSelectionGroupDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXSelectionGroupDirective, "[axSelectionGroup]", ["axSelectionGroup"], { "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disable": { "alias": "disable"; "required": false; "isSignal": true; }; "selectedKeys": { "alias": "selectedKeys"; "required": false; "isSignal": true; }; }, { "onSelectionChanged": "onSelectionChanged"; }, ["content", "selectionItemsClass"], never, true, never>;
+}
+
+declare class AXSelectionCdkModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXSelectionCdkModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<AXSelectionCdkModule, never, [typeof i1.CommonModule, typeof AXSelectionGroupDirective, typeof AXSelectionItemDirective], [typeof AXSelectionGroupDirective, typeof AXSelectionItemDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<AXSelectionCdkModule>;
+}
+
+export { AXSelectionCdkModule, AXSelectionGroupDirective, AXSelectionItemDirective };
+export type { AXSelectionGroupSelectedKeys };

package/sliding-item/index.d.ts

@@ -1,2 +1,25 @@
-export * from './lib/sliding-item.directive';
-export * from './lib/sliding-item.module';
+import * as i0 from '@angular/core';
+import * as i1 from '@angular/common';
+
+declare class AXSlidingItemDirective {
+    #private;
+    private hostElement;
+    private isMouseDown;
+    private prevX;
+    currentX: i0.WritableSignal<number>;
+    stopPoint: i0.WritableSignal<number>;
+    disableSlidingRight: i0.WritableSignal<boolean>;
+    disableSlidingLeft: i0.WritableSignal<boolean>;
+    private dismiss;
+    setPosition(pos: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXSlidingItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXSlidingItemDirective, "[axSlidingItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXSlidingItemDirectiveModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXSlidingItemDirectiveModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXSlidingItemDirectiveModule, never, [typeof i1.CommonModule, typeof AXSlidingItemDirective], [typeof AXSlidingItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXSlidingItemDirectiveModule>;
+}
+
+export { AXSlidingItemDirective, AXSlidingItemDirectiveModule };

package/sticky/index.d.ts

@@ -1 +1,31 @@
-export * from './lib/sticky.directive';
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, EventEmitter } from '@angular/core';
+
+declare class AXStickyDirective implements AfterViewInit, OnDestroy {
+    private element;
+    private renderer;
+    private zone;
+    private cdr;
+    stickyClass: string;
+    stickyOffset: number;
+    isStickyChange: EventEmitter<boolean>;
+    private _isSticky;
+    get isSticky(): boolean;
+    set isSticky(value: boolean);
+    private topOffset;
+    private parentElement;
+    private targetElement;
+    private mutationObserver;
+    stickyParent: string | HTMLElement;
+    stickyTarget: string;
+    ngAfterViewInit(): void;
+    private initSticky;
+    private updateTopOffset;
+    private onParentScroll;
+    private toggleStickyClasses;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXStickyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXStickyDirective, "[axSticky]", ["axpSticky"], { "stickyClass": { "alias": "axSticky"; "required": false; }; "stickyOffset": { "alias": "stickyOffset"; "required": false; }; "stickyParent": { "alias": "stickyParent"; "required": false; }; "stickyTarget": { "alias": "stickyTarget"; "required": false; }; }, { "isStickyChange": "isStickyChange"; }, never, never, true, never>;
+}
+
+export { AXStickyDirective };

package/virtual-scroll/index.d.ts

@@ -1,3 +1,41 @@
-export * from './lib/virtual-scroll.module';
-export * from './lib/virtual-scrolling-contianer/virtual-scrolling-contianer.directive';
-export * from './lib/virtual-scrolling-item/virtual-scrolling-item.directive';
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+
+declare class AXVirtualScrollingItemDirective {
+    private elementRef;
+    get nativeElement(): HTMLElement;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXVirtualScrollingItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXVirtualScrollingItemDirective, "[axVirtualScrollingItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class AXVirtualScrollingContainerDirective {
+    #private;
+    height: i0.InputSignal<unknown>;
+    /** @ignore */
+    protected observer: IntersectionObserver;
+    ScrollEnd: i0.OutputEmitterRef<void>;
+    /** @ignore */
+    loading: boolean;
+    container: ElementRef<any>;
+    /** @ignore */
+    protected children: i0.Signal<readonly AXVirtualScrollingItemDirective[]>;
+    /** @ignore */
+    protected firstCall: i0.WritableSignal<boolean>;
+    /** @ignore */
+    protected lastChildElem: i0.Signal<Element>;
+    /** @ignore */
+    protected firstChildElem: i0.Signal<Element>;
+    /** @ignore */
+    protected callBack(entries: IntersectionObserverEntry[]): void;
+    get __hostClass(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXVirtualScrollingContainerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXVirtualScrollingContainerDirective, "[axVirtualScrollingContainer]", never, { "height": { "alias": "height"; "required": true; "isSignal": true; }; }, { "ScrollEnd": "ScrollEnd"; }, ["children"], never, true, never>;
+}
+
+declare class AXVirtualScrollModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXVirtualScrollModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXVirtualScrollModule, never, [typeof AXVirtualScrollingContainerDirective, typeof AXVirtualScrollingItemDirective], [typeof AXVirtualScrollingContainerDirective, typeof AXVirtualScrollingItemDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXVirtualScrollModule>;
+}
+
+export { AXVirtualScrollModule, AXVirtualScrollingContainerDirective, AXVirtualScrollingItemDirective };

package/wysiwyg/index.d.ts

@@ -1 +1,29 @@
-export * from './wysiwyg.class';
+import * as _angular_core from '@angular/core';
+import Quill, { QuillOptions } from 'quill/quill.d.ts';
+
+type Wysiwyg = Quill;
+type WysiwygOptions = QuillOptions;
+declare class AXWysiwyg {
+    quillObj: _angular_core.WritableSignal<Quill>;
+    init(container: HTMLElement | string, option?: WysiwygOptions): Promise<void>;
+    bold(value: boolean): void;
+    italic(value: boolean): void;
+    underLine(value: boolean): void;
+    strike(value: boolean): void;
+    color(value: string): void;
+    header(value: number): void;
+    list(value: 'ordered' | 'bullet' | ''): void;
+    align(value: 'center' | 'right' | 'left' | 'justify'): void;
+    direction(value: 'rtl' | 'ltr'): void;
+    fontSize(value: 'small' | false | 'large' | 'huge', range: any): void;
+    get HTMLoutput(): string;
+    undo(): void;
+    redo(): void;
+    background(value: string): void;
+    addImage(value: string): void;
+    focus(): void;
+    blur(): void;
+}
+
+export { AXWysiwyg };
+export type { Wysiwyg, WysiwygOptions };

package/carousel/carousel.directive.d.ts

@@ -1,13 +0,0 @@
-import type { Swiper, SwiperOptions } from 'swiper/types';
-import * as i0 from "@angular/core";
-export type AXCarousel = Swiper;
-export type AXCarouselOptions = SwiperOptions;
-export declare class AXCarouselDirective {
-    #private;
-    carousel: import("@angular/core").WritableSignal<Swiper>;
-    carouselOptions: import("@angular/core").InputSignal<SwiperOptions>;
-    private el;
-    private init;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXCarouselDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXCarouselDirective, "[axCarousel]", ["axCarousel"], { "carouselOptions": { "alias": "carouselOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/collapse/index.d.ts

@@ -1,6 +0,0 @@
-export * from './lib/collapse-directive/collapse-close-button.directive';
-export * from './lib/collapse-directive/collapse-group.directive';
-export * from './lib/collapse-directive/collapse-item-content.directive';
-export * from './lib/collapse-directive/collapse-item-header.directive';
-export * from './lib/collapse-directive/collapse-item.directive';
-export * from './lib/collapse.module';

package/collapse/lib/collapse-directive/collapse-close-button.directive.d.ts

@@ -1,8 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class AXCollapseCloseButtonDirective {
-    #private;
-    private elm;
-    onclick: import("@angular/core").OutputEmitterRef<MouseEvent>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXCollapseCloseButtonDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXCollapseCloseButtonDirective, "[axCollapseCloseButton]", never, {}, { "onclick": "onclick"; }, never, never, true, never>;
-}

package/collapse/lib/collapse-directive/collapse-group.directive.d.ts

@@ -1,9 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class AXCollapseGrouplDirective {
-    #private;
-    accordion: import("@angular/core").InputSignal<boolean>;
-    private content;
-    private activeIndex;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXCollapseGrouplDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXCollapseGrouplDirective, "[axCollapseGroup]", ["axCollapseGroup"], { "accordion": { "alias": "accordion"; "required": false; "isSignal": true; }; }, {}, ["content"], never, true, never>;
-}

package/collapse/lib/collapse-directive/collapse-item-content.directive.d.ts

@@ -1,8 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class AXCollapseItemContentlDirective {
-    #private;
-    private elm;
-    collapseContent: import("@angular/core").WritableSignal<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXCollapseItemContentlDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXCollapseItemContentlDirective, "[axCollapseItemContent]", ["axCollapseItemContent"], {}, {}, never, never, true, never>;
-}

package/collapse/lib/collapse-directive/collapse-item-header.directive.d.ts

@@ -1,5 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class AXCollapseItemHeaderlDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXCollapseItemHeaderlDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXCollapseItemHeaderlDirective, "[axCollapseItemHeader]", ["axCollapseItemHeader"], {}, {}, never, never, true, never>;
-}

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

@@ -1,13 +0,0 @@
-import * as i0 from "@angular/core";
-export declare class AXCollapseItemlDirective {
-    #private;
-    private content;
-    private close;
-    collapse: import("@angular/core").WritableSignal<boolean>;
-    onclick: import("@angular/core").OutputEmitterRef<{
-        component: AXCollapseItemlDirective;
-    }>;
-    id: import("@angular/core").WritableSignal<number>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXCollapseItemlDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXCollapseItemlDirective, "[axCollapseItem]", ["axCollapseItem"], {}, { "onclick": "onclick"; }, ["content", "close"], never, true, never>;
-}

package/collapse/lib/collapse.module.d.ts

@@ -1,12 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common";
-import * as i2 from "./collapse-directive/collapse-group.directive";
-import * as i3 from "./collapse-directive/collapse-item-content.directive";
-import * as i4 from "./collapse-directive/collapse-item-header.directive";
-import * as i5 from "./collapse-directive/collapse-item.directive";
-import * as i6 from "./collapse-directive/collapse-close-button.directive";
-export declare class AXCollapseModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXCollapseModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AXCollapseModule, never, [typeof i1.CommonModule, typeof i2.AXCollapseGrouplDirective, typeof i3.AXCollapseItemContentlDirective, typeof i4.AXCollapseItemHeaderlDirective, typeof i5.AXCollapseItemlDirective, typeof i6.AXCollapseCloseButtonDirective], [typeof i2.AXCollapseGrouplDirective, typeof i3.AXCollapseItemContentlDirective, typeof i4.AXCollapseItemHeaderlDirective, typeof i5.AXCollapseItemlDirective, typeof i6.AXCollapseCloseButtonDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AXCollapseModule>;
-}