@acorex/cdk 22.1.8 → 22.2.0-next.1

package/types/acorex-cdk-drag-drop.d.ts

@@ -1,12 +1,31 @@
 import * as _angular_core from '@angular/core';
-import { OnInit, OnDestroy, TemplateRef, ElementRef, AfterContentInit } from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy, TemplateRef, ElementRef, AfterContentInit } from '@angular/core';
 import { NXComponent, NXNativeEvent } from '@acorex/cdk/common';
 
+declare class AXDragHandleDirective {
+    private el;
+    private parent;
+    readonly element: _angular_core.WritableSignal<any>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXDragHandleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXDragHandleDirective, "[axDragHandle]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Parent drag instance that nested `axDragHandle` directives register with.
+ * Provided by `AXDragDirective` so handles work inside dynamically created content.
+ */
+declare const AX_DRAG_PARENT: InjectionToken<AXDragParent>;
+interface AXDragParent {
+    registerHandle(handle: AXDragHandleDirective | HTMLElement): void;
+    unregisterHandle(handle: AXDragHandleDirective | HTMLElement): void;
+}
+
 type AXPositionType = {
     x: number;
     y: number;
 };
-declare class AXDragDirective implements OnInit, OnDestroy {
+declare class AXDragDirective implements OnInit, OnDestroy, AXDragParent {
     #private;
     private zone;
     private document;
@@ -15,7 +34,7 @@ declare class AXDragDirective implements OnInit, OnDestroy {
     private platformId;
     private viewContainerRef;
     private el;
-    private handleDirective;
+    private registeredHandleElements;
     axDrag: _angular_core.InputSignalWithTransform<boolean, string | boolean>;
     dragData: _angular_core.InputSignal<unknown>;
     dragDisabled: _angular_core.InputSignal<boolean>;
@@ -26,7 +45,7 @@ declare class AXDragDirective implements OnInit, OnDestroy {
     dragResetOnDblClick: _angular_core.InputSignal<boolean>;
     dragLockAxis: _angular_core.InputSignal<"x" | "y">;
     dragClonedTemplate: _angular_core.InputSignal<TemplateRef<unknown>>;
-    dragCursor: _angular_core.InputSignal<"move" | "grab" | "none">;
+    dragCursor: _angular_core.InputSignal<"move" | "grab" | "grab-on-drag" | "none">;
     dragBoundary: _angular_core.InputSignal<string | HTMLElement | ElementRef<HTMLElement>>;
     dragTransitionDuration: _angular_core.InputSignal<number>;
     readonly isDragDisabled: _angular_core.WritableSignal<boolean>;
@@ -34,7 +53,7 @@ declare class AXDragDirective implements OnInit, OnDestroy {
     readonly dragBoundaryOverride: _angular_core.WritableSignal<string | HTMLElement | ElementRef<HTMLElement>>;
     readonly startDelay: _angular_core.WritableSignal<number>;
     readonly dragTouchAction: _angular_core.WritableSignal<"none" | "pan-x" | "pan-y">;
-    readonly dragCursorOverride: _angular_core.WritableSignal<"move" | "grab" | "none">;
+    readonly dragCursorOverride: _angular_core.WritableSignal<"move" | "grab" | "grab-on-drag" | "none">;
     dragPositionChanged: _angular_core.OutputEmitterRef<AXPositionType>;
     isMoving: _angular_core.WritableSignal<boolean>;
     clonedElement: _angular_core.WritableSignal<HTMLElement>;
@@ -63,14 +82,21 @@ declare class AXDragDirective implements OnInit, OnDestroy {
     private boundaryElement;
     readonly elementRect: _angular_core.Signal<DOMRect>;
     private boundaryRect;
+    private handleElements;
     private handle;
     private boundHandleDblClick;
     private boundHandlePointerUp;
     private boundHandlePointerDown;
     private boundHandlePointerMove;
-    private listenersAttached;
+    private attachedHandleElements;
+    private styledHandleElements;
+    private activeHandleElement;
+    registerHandle(handle: AXDragHandleDirective | HTMLElement): void;
+    unregisterHandle(handle: AXDragHandleDirective | HTMLElement): void;
+    private resolveHandleElement;
     ngOnInit(): void;
     ngOnDestroy(): void;
+    private usesGrabDragCursor;
     private resolveDropCursor;
     private setActiveDragCursor;
     private clearActiveDragCursor;
@@ -83,6 +109,7 @@ declare class AXDragDirective implements OnInit, OnDestroy {
     private handleDblClick;
     private handlePointerMove;
     private abortDragSequence;
+    private resetHandleCursorAfterDrag;
     private startDrag;
     private handlePointerUp;
     private preventClicking;
@@ -104,14 +131,7 @@ declare class AXDragDirective implements OnInit, OnDestroy {
     private addDocumentListeners;
     private removeDocumentListeners;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXDragDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXDragDirective, "[axDrag]", never, { "axDrag": { "alias": "axDrag"; "required": false; "isSignal": true; }; "dragData": { "alias": "dragData"; "required": false; "isSignal": true; }; "dragDisabled": { "alias": "dragDisabled"; "required": false; "isSignal": true; }; "dragTransition": { "alias": "dragTransition"; "required": false; "isSignal": true; }; "dragElementClone": { "alias": "dragElementClone"; "required": false; "isSignal": true; }; "dropZoneGroup": { "alias": "dropZoneGroup"; "required": false; "isSignal": true; }; "dragStartDelay": { "alias": "dragStartDelay"; "required": false; "isSignal": true; }; "dragResetOnDblClick": { "alias": "dragResetOnDblClick"; "required": false; "isSignal": true; }; "dragLockAxis": { "alias": "dragLockAxis"; "required": false; "isSignal": true; }; "dragClonedTemplate": { "alias": "dragClonedTemplate"; "required": false; "isSignal": true; }; "dragCursor": { "alias": "dragCursor"; "required": false; "isSignal": true; }; "dragBoundary": { "alias": "dragBoundary"; "required": false; "isSignal": true; }; "dragTransitionDuration": { "alias": "dragTransitionDuration"; "required": false; "isSignal": true; }; }, { "dragPositionChanged": "dragPositionChanged"; }, ["handleDirective"], never, true, never>;
-}
-
-declare class AXDragHandleDirective {
-    private el;
-    readonly element: _angular_core.WritableSignal<HTMLElement>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXDragHandleDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXDragHandleDirective, "[axDragHandle]", never, {}, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXDragDirective, "[axDrag]", never, { "axDrag": { "alias": "axDrag"; "required": false; "isSignal": true; }; "dragData": { "alias": "dragData"; "required": false; "isSignal": true; }; "dragDisabled": { "alias": "dragDisabled"; "required": false; "isSignal": true; }; "dragTransition": { "alias": "dragTransition"; "required": false; "isSignal": true; }; "dragElementClone": { "alias": "dragElementClone"; "required": false; "isSignal": true; }; "dropZoneGroup": { "alias": "dropZoneGroup"; "required": false; "isSignal": true; }; "dragStartDelay": { "alias": "dragStartDelay"; "required": false; "isSignal": true; }; "dragResetOnDblClick": { "alias": "dragResetOnDblClick"; "required": false; "isSignal": true; }; "dragLockAxis": { "alias": "dragLockAxis"; "required": false; "isSignal": true; }; "dragClonedTemplate": { "alias": "dragClonedTemplate"; "required": false; "isSignal": true; }; "dragCursor": { "alias": "dragCursor"; "required": false; "isSignal": true; }; "dragBoundary": { "alias": "dragBoundary"; "required": false; "isSignal": true; }; "dragTransitionDuration": { "alias": "dragTransitionDuration"; "required": false; "isSignal": true; }; }, { "dragPositionChanged": "dragPositionChanged"; }, never, never, true, never>;
 }
 
 /** Event object emitted when an item is dropped into a drop list. */
@@ -148,6 +168,8 @@ declare class AXDropListDirective extends NXComponent implements OnInit, AfterCo
     dropListOrientation: _angular_core.InputSignal<"horizontal" | "vertical">;
     /** Emits when an item is dropped into the list. */
     dropListDropped: _angular_core.OutputEmitterRef<AXDropListDroppedEvent>;
+    /** Emits when the sort preview transforms change during an active drag. */
+    sortPreviewChanged: _angular_core.OutputEmitterRef<void>;
     /** The `axDrag` directives that are direct children of this list. */
     readonly _draggableItems: _angular_core.Signal<readonly AXDragDirective[]>;
     /** The native element of the drop list. */
@@ -162,6 +184,8 @@ declare class AXDropListDirective extends NXComponent implements OnInit, AfterCo
     private readonly _listInitialRect;
     /** The detected `gap` of the list for the current orientation. */
     private readonly _listGap;
+    /** Whether the list is in RTL direction (cached at drag start). */
+    private readonly _isRtl;
     /** Internal orientation state; can be overridden programmatically by host components. */
     readonly orientation: _angular_core.WritableSignal<"horizontal" | "vertical">;
     /** Internal sorting-disabled state; can be overridden programmatically by host components. */
@@ -173,6 +197,8 @@ declare class AXDropListDirective extends NXComponent implements OnInit, AfterCo
     ngOnDestroy(): void;
     /** Checks if the given drag item is the one currently active in this list. */
     isDragActiveForThisList(dragItem: AXDragDirective): boolean;
+    /** Whether the list is horizontal and in RTL direction. */
+    private isHorizontalRtl;
     /**
      * Prepares the list for sorting when a drag operation starts from within this list.
      * @param dragItem The item that is being dragged.
@@ -233,7 +259,7 @@ declare class AXDropListDirective extends NXComponent implements OnInit, AfterCo
     /** Resets the internal state of the directive to its initial values. */
     resetSortState(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXDropListDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXDropListDirective, "[axDropList]", ["axDropList"], { "axDropList": { "alias": "axDropList"; "required": false; "isSignal": true; }; "sortingDisabled": { "alias": "sortingDisabled"; "required": false; "isSignal": true; }; "dropListGroup": { "alias": "dropListGroup"; "required": false; "isSignal": true; }; "dropListOrientation": { "alias": "dropListOrientation"; "required": false; "isSignal": true; }; }, { "dropListDropped": "dropListDropped"; }, ["_draggableItems"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXDropListDirective, "[axDropList]", ["axDropList"], { "axDropList": { "alias": "axDropList"; "required": false; "isSignal": true; }; "sortingDisabled": { "alias": "sortingDisabled"; "required": false; "isSignal": true; }; "dropListGroup": { "alias": "dropListGroup"; "required": false; "isSignal": true; }; "dropListOrientation": { "alias": "dropListOrientation"; "required": false; "isSignal": true; }; }, { "dropListDropped": "dropListDropped"; "sortPreviewChanged": "sortPreviewChanged"; }, ["_draggableItems"], never, true, never>;
 }
 
 interface AXDropZoneDropEvent extends NXNativeEvent<AXDropZoneDirective, MouseEvent> {
@@ -275,5 +301,5 @@ declare function moveItemInArray<T = any>(array: T[], fromIndex: number, toIndex
  */
 declare function transferArrayItem<T = any>(currentArray: T[], targetArray: T[], currentIndex: number, targetIndex: number): void;
 
-export { AXDragDirective, AXDragDropModule, AXDragHandleDirective, AXDropListDirective, AXDropZoneDirective, moveItemInArray, transferArrayItem };
-export type { AXDropListDroppedEvent, AXDropZoneDropEvent, AXDropZoneHoverEvent };
+export { AXDragDirective, AXDragDropModule, AXDragHandleDirective, AXDropListDirective, AXDropZoneDirective, AX_DRAG_PARENT, moveItemInArray, transferArrayItem };
+export type { AXDragParent, AXDropListDroppedEvent, AXDropZoneDropEvent, AXDropZoneHoverEvent };

package/types/acorex-cdk-full-screen.d.ts

@@ -1,69 +1,44 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { AXFullScreenMode } from '@acorex/core/full-screen';
 
 /**
- * Fullscreen directive that provides CSS-based fullscreen functionality
+ * Fullscreen directive with overlay and browser modes.
  * Usage: <element axFullscreen #fullscreen="axFullscreen"></element>
  * Then: fullscreen.toggle() or fullscreen.enter() or fullscreen.exit()
  */
-declare class AXFullScreenDirective {
+declare class AXFullScreenDirective implements OnDestroy {
     /**
-     * Current fullscreen state
+     * Fullscreen implementation mode.
+     * @defaultValue 'overlay'
      */
-    private readonly isFullscreenState;
+    readonly mode: _angular_core.InputSignal<AXFullScreenMode>;
     /**
-     * Original element styles to restore
+     * Fullscreen change event for this host element.
      */
-    private originalStyles;
-    /**
-     * Original parent element reference
-     */
-    private originalParent;
-    /**
-     * Fullscreen container element
-     */
-    private fullscreenContainer;
-    /**
-     * Fullscreen change event
-     */
-    readonly fullscreenChange: i0.OutputEmitterRef<boolean>;
-    /**
-     * Z-index token for this fullscreen instance
-     */
-    private zToken;
-    private readonly renderer;
+    readonly fullscreenChange: _angular_core.OutputEmitterRef<boolean>;
     private readonly elementRef;
-    private readonly zIndexService;
+    private readonly fullScreenService;
     constructor();
     /**
-     * Toggle fullscreen state
+     * Toggle fullscreen state.
      */
     toggle(): void;
     /**
-     * Enter fullscreen mode using CSS
+     * Enter fullscreen mode.
      */
     enter(): void;
     /**
-     * Exit fullscreen mode
+     * Exit fullscreen mode.
      */
     exit(): void;
     /**
-     * Check if currently in fullscreen mode
+     * Check if this host is currently in fullscreen mode.
      */
     isFullscreen(): boolean;
-    /**
-     * Store original element styles
-     */
-    private storeOriginalStyles;
-    /**
-     * Restore original element styles
-     */
-    private restoreOriginalStyles;
-    /**
-     * Convert camelCase to kebab-case for CSS properties
-     */
-    private camelToKebabCase;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AXFullScreenDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AXFullScreenDirective, "[axFullscreen]", ["axFullscreen"], {}, { "fullscreenChange": "fullscreenChange"; }, never, never, true, never>;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXFullScreenDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXFullScreenDirective, "[axFullscreen]", ["axFullscreen"], { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, { "fullscreenChange": "fullscreenChange"; }, never, never, true, never>;
 }
 
 export { AXFullScreenDirective };

package/types/acorex-cdk-gesture.d.ts

@@ -89,6 +89,11 @@ declare class AXGestureDirective implements OnDestroy {
      * Stops gesture recognition when true.
      */
     disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Maximum interval in milliseconds between taps for double-tap recognition.
+     * Maps to Hammer.js tap recognizer `interval`. Defaults to Hammer's built-in value (300ms).
+     */
+    tapInterval: _angular_core.InputSignal<number>;
     tap: OutputEmitterRef<AXGestureEvent>;
     doubletap: OutputEmitterRef<AXGestureEvent>;
     press: OutputEmitterRef<AXGestureEvent>;
@@ -108,6 +113,11 @@ declare class AXGestureDirective implements OnDestroy {
      * The underlying Hammer manager, or null when not initialized.
      */
     get manager(): AXGestureManager | null;
+    /**
+     * Suppresses native click propagation when Hammer.js is active so tap/doubletap
+     * outputs are the single source of click handling.
+     */
+    protected onHostClick(event: MouseEvent): void;
     ngOnDestroy(): void;
     private setup;
     private loadHammer;
@@ -115,7 +125,7 @@ declare class AXGestureDirective implements OnDestroy {
     private teardown;
     private readonly onHammerEvent;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXGestureDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXGestureDirective, "[axGesture]", ["axGesture"], { "options": { "alias": "options"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "enablePinch": { "alias": "enablePinch"; "required": false; "isSignal": true; }; "enableRotate": { "alias": "enableRotate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "tap": "tap"; "doubletap": "doubletap"; "press": "press"; "pan": "pan"; "panstart": "panstart"; "panmove": "panmove"; "panend": "panend"; "swipe": "swipe"; "pinch": "pinch"; "rotate": "rotate"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXGestureDirective, "[axGesture]", ["axGesture"], { "options": { "alias": "options"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "enablePinch": { "alias": "enablePinch"; "required": false; "isSignal": true; }; "enableRotate": { "alias": "enableRotate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "tapInterval": { "alias": "tapInterval"; "required": false; "isSignal": true; }; }, { "tap": "tap"; "doubletap": "doubletap"; "press": "press"; "pan": "pan"; "panstart": "panstart"; "panmove": "panmove"; "panend": "panend"; "swipe": "swipe"; "pinch": "pinch"; "rotate": "rotate"; }, never, never, true, never>;
 }
 
 export { AXGestureDirective };

package/types/acorex-cdk-highlight.d.ts

@@ -1,7 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { PipeTransform } from '@angular/core';
 import { AXHighlightOptions, AXHighlightSegment } from '@acorex/core/utils';
-import { SafeHtml } from '@angular/platform-browser';
 
 /**
  * Directive that highlights text within the host element or its descendants.
@@ -43,32 +42,6 @@ declare class AXHighlightDirective {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXHighlightDirective, "[axHighlight]", never, { "axHighlight": { "alias": "axHighlight"; "required": false; "isSignal": true; }; "highlightSelector": { "alias": "highlightSelector"; "required": false; "isSignal": true; }; "highlightOptions": { "alias": "highlightOptions"; "required": false; "isSignal": true; }; "highlightDisabled": { "alias": "highlightDisabled"; "required": false; "isSignal": true; }; }, { "matchCount": "matchCount"; }, never, never, true, never>;
 }
 
-/**
- * Renders text with search-term matches wrapped in `.ax-highlight` spans.
- *
- * Uses a single innerHTML string so Angular control-flow whitespace cannot insert
- * gaps between highlighted and non-highlighted characters.
- *
- * Does not use the `ax-highlight-text` class on the host — that class is reserved for
- * {@link AXHighlightService} DOM wrappers.
- */
-declare class AXHighlightTextComponent {
-    #private;
-    private readonly sanitizer;
-    /** The full text to render. */
-    readonly text: _angular_core.InputSignal<string>;
-    /** The search term or terms to highlight within the text. */
-    readonly query: _angular_core.InputSignal<string | readonly string[]>;
-    /** When true, highlighting is disabled and plain text is shown. */
-    readonly highlightDisabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
-    /** Optional highlight behavior configuration. */
-    readonly highlightOptions: _angular_core.InputSignal<AXHighlightOptions>;
-    protected readonly segments: _angular_core.Signal<AXHighlightSegment[]>;
-    protected readonly highlightedHtml: _angular_core.Signal<SafeHtml>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXHighlightTextComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AXHighlightTextComponent, "ax-highlight-text", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; "highlightDisabled": { "alias": "highlightDisabled"; "required": false; "isSignal": true; }; "highlightOptions": { "alias": "highlightOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
 /**
  * Pure pipe that splits text into highlight segments for template rendering.
  */
@@ -78,4 +51,4 @@ declare class AXHighlightTextPipe implements PipeTransform {
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<AXHighlightTextPipe, "axHighlightText", true>;
 }
 
-export { AXHighlightDirective, AXHighlightTextComponent, AXHighlightTextPipe };
+export { AXHighlightDirective, AXHighlightTextPipe };

package/types/acorex-cdk-horizontal-scroll.d.ts

@@ -45,6 +45,7 @@ declare class AXHorizontalScrollDirective implements OnDestroy {
     private panStartScrollPosition;
     private suppressClickListener;
     private suppressClickTimer;
+    private _isRtl;
     private readonly interactiveSelector;
     private readonly wheelListener;
     protected touchAction(): string | null;
@@ -52,6 +53,8 @@ declare class AXHorizontalScrollDirective implements OnDestroy {
     ngOnDestroy(): void;
     private get nativeElement();
     private isHorizontal;
+    private get rtlSign();
+    private refreshRtlState;
     private getCurrentScrollPosition;
     private getMaxScrollPosition;
     private canScroll;

package/types/acorex-cdk-list-navigation.d.ts

@@ -32,6 +32,11 @@ declare class AXListNavigationDirective {
     private parentNavigationHandler;
     focusOnIndex(index: number): void;
     navigateTo(e: AXListNavigationItemDirective): void;
+    /**
+     * Highlights a list option on pointer hover without moving focus.
+     * Use when focus must stay on an external trigger (e.g. searchable lookup input).
+     */
+    highlightItem(item: AXListNavigationItemDirective): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXListNavigationDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXListNavigationDirective, "[axListNavigation]", ["axListNavigation"], { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, { "onNavigationChanged": "onNavigationChanged"; "onKeypress": "onKeypress"; }, ["childElem"], never, true, never>;
 }

package/types/acorex-cdk-outline.d.ts

@@ -27,6 +27,8 @@ declare class AXOutlineContainerDirective implements OnDestroy, AfterViewInit {
     scrollableElementId: _angular_core.InputSignal<string>;
     private scrollTop;
     private outlineItems;
+    private lastScrollSpyIndex;
+    private heldActiveIndex;
     private scrollableElement;
     private mutationSubject;
     private readonly MUTATION_DEBOUNCE_TIME;
@@ -34,7 +36,25 @@ declare class AXOutlineContainerDirective implements OnDestroy, AfterViewInit {
     outlineItems$: BehaviorSubject<outlineItemType[]>;
     ngOnDestroy(): void;
     ngAfterViewInit(): void;
+    scrollToItem(id: string): void;
+    private resolveScrollEventTarget;
+    private readScrollTop;
+    private handleInContentOutlineLinkClick;
+    private scrollToItemFromHash;
+    private releaseHeldActiveIndex;
+    private stopOngoingSmoothScroll;
+    private getOutlineIdFromHref;
+    private syncLocationHash;
     private scrollChanged;
+    private bindUserScrollIntent;
+    private resolveActiveIndex;
+    /**
+     * Maps scroll position to the active outline item. Sections with little content often
+     * have overlapping activation thresholds; each section gets a minimum scroll slot so
+     * short blocks are not skipped while scrolling.
+     */
+    private resolveByScrollSlots;
+    private applyActiveIndex;
     private setOutlineItems;
     refreshOutlineItems(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXOutlineContainerDirective, never>;

package/types/acorex-cdk-overlay-scrollbar.d.ts

@@ -0,0 +1,155 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, EnvironmentProviders } from '@angular/core';
+
+/** Default delay (ms) before the overlay scrollbar fades out after scroll. */
+declare const AX_OVERLAY_SCROLLBAR_DEFAULT_HIDE_DELAY_MS = 800;
+/** Default pixels scrolled per navigation arrow click. */
+declare const AX_OVERLAY_SCROLLBAR_DEFAULT_NAV_SCROLL_STEP_PX = 40;
+/**
+ * Visual tokens for overlay scrollbars (`--ax-comp-overlay-scrollbar-*`).
+ * Values are applied to `:root` when using {@link provideOverlayScrollbar}, and inherited by scroll hosts.
+ */
+interface AXOverlayScrollbarDesignTokens {
+    size?: string;
+    thumbRadius?: string;
+    trackRadius?: string;
+    trackColor?: string;
+    thumbColor?: string;
+    thumbActiveColor?: string;
+    thumbHoverColor?: string;
+    trackActiveColor?: string;
+    thumbBorderWidth?: string;
+    thumbBorderColor?: string;
+    trackBorderWidth?: string;
+    trackBorderColor?: string;
+    fadeDuration?: string;
+}
+/** Application-wide defaults for {@link AXOverlayScrollbarDirective}. */
+interface AXOverlayScrollbarConfig {
+    /** Milliseconds before the scrollbar rail fades out after scrolling stops. */
+    hideDelay: number;
+    /** When true, shows up/down arrow buttons on the scrollbar rail. */
+    navigationButtons: boolean;
+    /** Pixels to scroll per navigation arrow click. */
+    navScrollStep: number;
+    /** Optional global design tokens (CSS custom properties). */
+    designTokens?: AXOverlayScrollbarDesignTokens;
+}
+declare const AXOverlayScrollbarDefaultConfig: AXOverlayScrollbarConfig;
+type AXPartialOverlayScrollbarConfig = Partial<AXOverlayScrollbarConfig> & {
+    designTokens?: Partial<AXOverlayScrollbarDesignTokens>;
+};
+declare const AX_OVERLAY_SCROLLBAR_CONFIG: InjectionToken<AXOverlayScrollbarConfig>;
+/** Merges partial config with {@link AXOverlayScrollbarDefaultConfig}. */
+declare function overlayScrollbarConfig(config?: AXPartialOverlayScrollbarConfig): AXOverlayScrollbarConfig;
+/** Sets overlay scrollbar CSS variables on the given element. */
+declare function applyOverlayScrollbarDesignTokens(element: HTMLElement, tokens?: AXOverlayScrollbarDesignTokens): void;
+/**
+ * Registers global overlay scrollbar defaults for the application.
+ *
+ * @example
+ * ```ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideOverlayScrollbar({
+ *       hideDelay: 1200,
+ *       navigationButtons: true,
+ *       navScrollStep: 48,
+ *       designTokens: {
+ *         size: '8px',
+ *         thumbColor: 'var(--ax-sys-scroller-thumb-color)',
+ *       },
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+declare function provideOverlayScrollbar(config?: AXPartialOverlayScrollbarConfig): EnvironmentProviders;
+
+declare function clampOverlayScrollbarWidth(px: number): number;
+/**
+ * Custom overlay scrollbar: native scrollbars are hidden; a positioned thumb reflects scroll position.
+ * Styles are injected once by this directive.
+ */
+declare class AXOverlayScrollbarDirective {
+    private readonly host;
+    private readonly destroyRef;
+    private readonly platformId;
+    private readonly document;
+    private readonly appConfig;
+    private rootEl;
+    private railEl;
+    private trackEl;
+    private navUpEl;
+    private navDownEl;
+    private thumbEl;
+    private resizeObserver;
+    private designTokenMutationObserver;
+    private designTokenSyncFrame;
+    private thumbDragPointerId;
+    private pointerOverRail;
+    private trackPressReleaseListener;
+    private unbindRailInteraction;
+    /** Thumb size derived from layout; position updates on scroll without re-measuring scrollHeight. */
+    private thumbLayout;
+    readonly hideDelay: _angular_core.InputSignal<number>;
+    /**
+     * When true, shows browser-style up/down arrow buttons on the rail.
+     * Styling follows track/thumb CSS tokens.
+     */
+    readonly navigationButtons: _angular_core.InputSignal<boolean>;
+    /** Pixels to scroll per arrow click. */
+    readonly navScrollStep: _angular_core.InputSignal<number>;
+    private hideTimer;
+    constructor();
+    /** Host and rail are siblings under the root; mirror CSS variables when the host style/class changes. */
+    private observeHostDesignTokenChanges;
+    private queueDesignTokenSync;
+    /** Rail lives on a wrapper so it stays fixed while the host scrolls. */
+    private ensureScrollRoot;
+    private mountCustomScrollbar;
+    private ensureRailStructure;
+    private createNavButton;
+    private resolveNavScrollStepPx;
+    private scrollByNavStep;
+    private bindRailInteraction;
+    private unmountCustomScrollbar;
+    private remeasureCustomThumb;
+    private syncThumbPosition;
+    /** Move thumb (and scroll position) to the pointer Y on the track. */
+    private jumpScrollToTrackPointer;
+    private onThumbPointerDown;
+    private showScrollbar;
+    private bumpVisibility;
+    private deactivateThumb;
+    private setScrollbarEngaged;
+    private setTrackPressed;
+    private isPointerOverThumbVisual;
+    private beginTrackPressed;
+    private clearTrackPressed;
+    private syncEngagedAfterScroll;
+    private scheduleHide;
+    private clearHideTimer;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AXOverlayScrollbarDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AXOverlayScrollbarDirective, "[axOverlayScrollbar]", ["axOverlayScrollbar"], { "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; "navigationButtons": { "alias": "navigationButtons"; "required": false; "isSignal": true; }; "navScrollStep": { "alias": "navScrollStep"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** CSS custom properties for overlay scrollbar styling (set on the scroll host or in CSS). */
+declare const AX_OVERLAY_SCROLLBAR_CSS_VARS: {
+    readonly size: "--ax-comp-overlay-scrollbar-size";
+    readonly thumbRadius: "--ax-comp-overlay-scrollbar-thumb-radius";
+    readonly trackRadius: "--ax-comp-overlay-scrollbar-track-radius";
+    readonly trackColor: "--ax-comp-overlay-scrollbar-track-color";
+    readonly thumbColor: "--ax-comp-overlay-scrollbar-thumb-color";
+    readonly thumbActiveColor: "--ax-comp-overlay-scrollbar-thumb-active-color";
+    readonly thumbHoverColor: "--ax-comp-overlay-scrollbar-thumb-hover-color";
+    readonly trackActiveColor: "--ax-comp-overlay-scrollbar-track-active-color";
+    readonly thumbBorderWidth: "--ax-comp-overlay-scrollbar-thumb-border-width";
+    readonly thumbBorderColor: "--ax-comp-overlay-scrollbar-thumb-border-color";
+    readonly trackBorderWidth: "--ax-comp-overlay-scrollbar-track-border-width";
+    readonly trackBorderColor: "--ax-comp-overlay-scrollbar-track-border-color";
+    readonly fadeDuration: "--ax-comp-overlay-scrollbar-fade-duration";
+};
+
+export { AXOverlayScrollbarDefaultConfig, AXOverlayScrollbarDirective, AX_OVERLAY_SCROLLBAR_CONFIG, AX_OVERLAY_SCROLLBAR_CSS_VARS, AX_OVERLAY_SCROLLBAR_DEFAULT_HIDE_DELAY_MS, AX_OVERLAY_SCROLLBAR_DEFAULT_NAV_SCROLL_STEP_PX, applyOverlayScrollbarDesignTokens, clampOverlayScrollbarWidth, overlayScrollbarConfig, provideOverlayScrollbar };
+export type { AXOverlayScrollbarConfig, AXOverlayScrollbarDesignTokens, AXPartialOverlayScrollbarConfig };