@odx/angular 12.19.1 → 12.20.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @odx/angular
 
+## 12.20.0
+
+### Minor Changes
+
+- 0bff895: Added scroll for tab bar, z-index fixed for action buttons click event handling
+
+## 12.19.2
+
+### Patch Changes
+
+- a6bc7d1: Fixed spinbox autorepeat and unchanged emits issues
+
 ## 12.19.1
 
 ### Patch Changes

package/cdk/scrollable/README.md

@@ -0,0 +1,3 @@
+# @odx/angular/cdk/scrollable
+
+Secondary entry point of `@odx/angular`. It can be used by importing from `@odx/angular/cdk/scrollable`.

package/cdk/scrollable/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/scrollable.service';

package/cdk/scrollable/lib/scrollable.service.d.ts

@@ -0,0 +1,53 @@
+import { ElementRef, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface ScrollableItem {
+    element: ElementRef<HTMLElement>;
+}
+/**
+ * Service to manage scrollable items within a container, providing functionality to observe item visibility
+ * and navigate through them.
+ */
+export declare class ScrollableService implements OnDestroy {
+    private intersectionObserver?;
+    private scrollContainer?;
+    /**
+     * References to the next and previous scrollable items.
+     *
+     * @type {HTMLElement | null}
+     */
+    readonly nextItem: import("@angular/core").WritableSignal<HTMLElement | null>;
+    /**
+     * References to the previous scrollable item.
+     *
+     * @type {HTMLElement | null}
+     */
+    readonly prevItem: import("@angular/core").WritableSignal<HTMLElement | null>;
+    /** List of currently visible items within the scroll container.
+     *
+     * @type {HTMLElement[]}
+     */
+    readonly visibleItems: import("@angular/core").WritableSignal<HTMLElement[]>;
+    ngOnDestroy(): void;
+    /**
+     * Starts observing the scrollable items within the specified container.
+     *
+     * @param {ElementRef<HTMLElement>} scrollContainer - The container element that holds the scrollable items.
+     * @param {readonly ScrollableItem[]} items - The list of scrollable items to observe.
+     */
+    observe(scrollContainer: ElementRef<HTMLElement>, items: readonly ScrollableItem[]): void;
+    /**
+     * Scrolls the container in the specified direction.
+     *
+     * @param {'next' | 'prev'} direction - The direction to scroll ('next' for right, 'prev' for left).
+     */
+    scroll(direction?: 1 | -1): void;
+    /**
+     * Scrolls the active item into view within the scroll container.
+     *
+     * @param {HTMLElement | null} activeItem - The currently active item to scroll into view.
+     */
+    scrollActiveItemIntoView(activeItem: HTMLElement | null): void;
+    private observeVisibility;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollableService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollableService>;
+}

package/components/spinbox/lib/spinbox.component.d.ts

@@ -1,4 +1,4 @@
-import { AfterViewInit, ElementRef } from '@angular/core';
+import { AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
 import { CustomFormControl } from '@odx/angular/cdk/custom-form-control';
 import * as i0 from "@angular/core";
 /**
@@ -8,8 +8,9 @@ import * as i0 from "@angular/core";
  *
  * @see {CustomFormControl}
  */
-export declare class SpinboxComponent extends CustomFormControl<number> implements AfterViewInit {
-    private readonly takeUntilDestroyed;
+export declare class SpinboxComponent extends CustomFormControl<number> implements AfterViewInit, OnDestroy {
+    private destroyIncrementListener;
+    private destroyDecrementListener;
     private get inputElement();
     protected decrementButton: ElementRef<HTMLButtonElement>;
     protected incrementButton: ElementRef<HTMLButtonElement>;
@@ -18,14 +19,14 @@ export declare class SpinboxComponent extends CustomFormControl<number> implemen
      * The maximum allowable value for the spinbox.
      *
      * @type {number}
-     * @default Infinity
+     * @default Number.POSITIVE_INFINITY
      */
     max: number;
     /**
      * The minimum allowable value for the spinbox.
      *
      * @type {number}
-     * @default -Infinity
+     * @default Number.NEGATIVE_INFINITY
      */
     min: number;
     /**
@@ -37,10 +38,11 @@ export declare class SpinboxComponent extends CustomFormControl<number> implemen
     step: number;
     constructor();
     ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    updateValue(value: number): void;
     protected maxSteps({ code }: KeyboardEvent): void;
-    protected checkValue(): void;
-    protected onInputChange(): void;
-    private registerPressHold;
+    protected checkAndUpdate(): void;
+    private pressAndHold;
     static ɵfac: i0.ɵɵFactoryDeclaration<SpinboxComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SpinboxComponent, "odx-spinbox", never, { "max": { "alias": "max"; "required": false; }; "min": { "alias": "min"; "required": false; }; "step": { "alias": "step"; "required": false; }; }, {}, never, never, true, never>;
     static ngAcceptInputType_max: unknown;

package/components/tab-bar/lib/components/tab-bar-item/tab-bar-item.component.d.ts

@@ -1,5 +1,5 @@
 import { Highlightable } from '@angular/cdk/a11y';
-import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { ElementRef, OnInit } from '@angular/core';
 import * as i0 from "@angular/core";
 /**
  * Represents an individual tab item in a tab bar interface, providing functionalities
@@ -27,13 +27,13 @@ export declare class TabBarItemComponent implements Highlightable, OnInit {
      * @type {boolean}
      * @default false
      */
-    closable: boolean;
+    closable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
     /**
      * Event emitter that fires when the tab is closed. It emits the instance of the tab item component.
      *
      * @emits {TabBarItemComponent}
      */
-    tabClose: EventEmitter<TabBarItemComponent>;
+    tabClose: import("@angular/core").OutputEmitterRef<TabBarItemComponent>;
     ngOnInit(): void;
     /**
      * Sets the tab as active and applies corresponding styles. This method is part of the
@@ -48,6 +48,5 @@ export declare class TabBarItemComponent implements Highlightable, OnInit {
     protected onClick(): void;
     protected handleClose(event: Event): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TabBarItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TabBarItemComponent, "odx-tab-bar-item", never, { "closable": { "alias": "closable"; "required": false; }; }, { "tabClose": "tabClose"; }, never, ["odx-icon", "*"], true, never>;
-    static ngAcceptInputType_closable: unknown;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabBarItemComponent, "odx-tab-bar-item", never, { "closable": { "alias": "closable"; "required": false; "isSignal": true; }; }, { "tabClose": "tabClose"; }, never, ["odx-icon", "*"], true, never>;
 }

package/components/tab-bar/lib/tab-bar.component.d.ts

@@ -1,5 +1,5 @@
 import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';
-import { AfterViewInit, ElementRef, EventEmitter, QueryList } from '@angular/core';
+import { ElementRef } from '@angular/core';
 import { TabBarItemComponent } from './components';
 import { TabChangeEvent } from './models';
 import * as i0 from "@angular/core";
@@ -13,30 +13,18 @@ import * as i0 from "@angular/core";
  * making it accessible and user-friendly. Additionally, it handles overflow with navigational arrows,
  * allowing for a smooth user experience even with a large number of tabs.
  */
-export declare class TabBarComponent implements AfterViewInit {
-    private readonly changeDetector;
+export declare class TabBarComponent {
     private readonly takeUntilDestroyed;
-    private readonly selectedIndex$$;
-    protected activeItem: TabBarItemComponent | null;
-    protected keyManager?: ActiveDescendantKeyManager<TabBarItemComponent>;
-    protected tabBarPanelElement: ElementRef<HTMLElement>;
-    protected tabActionElements: QueryList<ElementRef<HTMLElement>>;
-    protected tabs: QueryList<TabBarItemComponent>;
+    private readonly scrollableService;
+    protected readonly nextTab: import("@angular/core").WritableSignal<HTMLElement | null>;
+    protected readonly prevTab: import("@angular/core").WritableSignal<HTMLElement | null>;
+    protected readonly tabs: import("@angular/core").Signal<readonly TabBarItemComponent[]>;
+    protected readonly activeItem: import("@angular/core").Signal<TabBarItemComponent | null>;
+    protected readonly keyManager: ActiveDescendantKeyManager<TabBarItemComponent>;
+    protected readonly scrollContainerElement: import("@angular/core").Signal<ElementRef<HTMLElement>>;
     readonly element: ElementRef<HTMLElement>;
     /**
-     * Indicates whether the tab bar has overflowed to the left.
-     *
-     * @type {boolean}
-     */
-    overflowLeft: boolean;
-    /**
-     * Indicates whether the tab bar has overflowed to the right.
-     *
-     * @type {boolean}
-     */
-    overflowRight: boolean;
-    /**
-     * Gets or sets the index of the currently selected tab. Use this property to programmatically
+     * Index of the currently selected tab. Use this property to programmatically
      * change the active tab. It responds to changes by updating the active state of the corresponding
      * tab item and adjusting the view if necessary.
      *
@@ -47,7 +35,7 @@ export declare class TabBarComponent implements AfterViewInit {
      * <odx-tab-bar [selectedIndex]="1"></odx-tab-bar>
      * ```
      */
-    set selectedIndex(value: number);
+    selectedIndex: import("@angular/core").ModelSignal<number>;
     /**
      * An EventEmitter that emits whenever a new tab is selected. It provides the `TabChangeEvent`
      * which contains the index of the newly selected tab and the instance of the corresponding
@@ -65,35 +53,25 @@ export declare class TabBarComponent implements AfterViewInit {
      * }
      * ```
      */
-    selectedTabChanged: EventEmitter<TabChangeEvent>;
-    ngAfterViewInit(): void;
+    selectedTabChanged: import("@angular/core").OutputEmitterRef<TabChangeEvent>;
+    constructor();
     /**
-     * Activates the specified tab item.
+     * Activates the specified tab item, making it the currently selected tab.
+     * If the item is already active, no action is taken.
      *
-     * @param {TabBarItemComponent | null} item - The tab item to activate. If not provided or null, the active item will be cleared.
-     *
-     * @example
-     * ```ts
-     * // Activate the first tab item
-     * tabBar.activateItem(tabItems[0]);
-     *
-     * // Clear the active item
-     * tabBar.activateItem(null);
-     * ```
+     * @param {TabBarItemComponent | null} item - The tab item to activate.
      */
     activateItem(item?: TabBarItemComponent | null): void;
     /**
-     * Removes the specified item from the tab bar.
-     * If the removed item is the active item, it sets the previous item as the new active item.
+     * Fires when the specified tab item is removed from the tab bar.
+     * If the item is currently active, the previous tab is activated.
      *
-     * @param {TabBarItemComponent} item - The item to be removed from the tab bar.
+     * @param {TabBarItemComponent} item - The tab item to remove.
      */
     removeItem(item: TabBarItemComponent): void;
     protected onKeydown(event: KeyboardEvent): void;
-    private updatePanelPosition;
-    private updateActionVisbility;
-    private activeItemChange;
+    protected onFocused(): void;
+    protected scrollTabs(direction?: 1 | -1): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<TabBarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TabBarComponent, "odx-tab-bar", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "selectedTabChanged": "selectedTabChanged"; }, ["tabs"], ["*"], true, never>;
-    static ngAcceptInputType_selectedIndex: unknown;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabBarComponent, "odx-tab-bar", never, { "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "selectedTabChanged": "selectedTabChanged"; }, ["tabs"], ["*"], true, never>;
 }

package/esm2022/cdk/scrollable/index.mjs

@@ -0,0 +1,2 @@
+export * from './lib/scrollable.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL3Njcm9sbGFibGUvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9zY3JvbGxhYmxlLnNlcnZpY2UnO1xuIl19

package/esm2022/cdk/scrollable/lib/scrollable.service.mjs

@@ -0,0 +1,108 @@
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Service to manage scrollable items within a container, providing functionality to observe item visibility
+ * and navigate through them.
+ */
+export class ScrollableService {
+    constructor() {
+        /**
+         * References to the next and previous scrollable items.
+         *
+         * @type {HTMLElement | null}
+         */
+        this.nextItem = signal(null);
+        /**
+         * References to the previous scrollable item.
+         *
+         * @type {HTMLElement | null}
+         */
+        this.prevItem = signal(null);
+        /** List of currently visible items within the scroll container.
+         *
+         * @type {HTMLElement[]}
+         */
+        this.visibleItems = signal([]);
+    }
+    ngOnDestroy() {
+        this.intersectionObserver?.disconnect();
+    }
+    /**
+     * Starts observing the scrollable items within the specified container.
+     *
+     * @param {ElementRef<HTMLElement>} scrollContainer - The container element that holds the scrollable items.
+     * @param {readonly ScrollableItem[]} items - The list of scrollable items to observe.
+     */
+    observe(scrollContainer, items) {
+        this.scrollContainer = scrollContainer;
+        if (this.intersectionObserver) {
+            this.intersectionObserver.disconnect();
+        }
+        const allItems = items.map((item) => item.element.nativeElement);
+        if (!this.scrollContainer || allItems.length === 0) {
+            this.nextItem.set(null);
+            this.prevItem.set(null);
+            return;
+        }
+        this.intersectionObserver = this.observeVisibility(allItems, (visible) => {
+            let prevItem = null;
+            let nextItem = null;
+            if (visible.length > 0 && allItems.length > visible.length) {
+                const firstVisibleIndex = allItems.indexOf(visible[0]);
+                if (firstVisibleIndex > 0) {
+                    prevItem = allItems[firstVisibleIndex - 1];
+                }
+                const lastVisibleIndex = allItems.indexOf(visible[visible.length - 1]);
+                if (lastVisibleIndex < allItems.length - 1) {
+                    nextItem = allItems[lastVisibleIndex + 1];
+                }
+            }
+            this.nextItem.set(nextItem);
+            this.prevItem.set(prevItem);
+        });
+    }
+    /**
+     * Scrolls the container in the specified direction.
+     *
+     * @param {'next' | 'prev'} direction - The direction to scroll ('next' for right, 'prev' for left).
+     */
+    scroll(direction = 1) {
+        const container = this.scrollContainer?.nativeElement;
+        if (!container)
+            return;
+        container.scrollBy({ left: (container.clientWidth * direction) / 2 });
+    }
+    /**
+     * Scrolls the active item into view within the scroll container.
+     *
+     * @param {HTMLElement | null} activeItem - The currently active item to scroll into view.
+     */
+    scrollActiveItemIntoView(activeItem) {
+        if (activeItem) {
+            activeItem.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'center' });
+        }
+    }
+    observeVisibility(items, callback) {
+        const visibleMap = new Map();
+        const observer = new IntersectionObserver((entries) => {
+            for (const entry of entries) {
+                const isVisible = entry.isIntersecting && entry.intersectionRatio >= 0.75;
+                visibleMap.set(entry.target, isVisible);
+            }
+            const visible = items.filter((item) => visibleMap.get(item));
+            this.visibleItems.set(visible);
+            callback(visible);
+        }, {
+            root: this.scrollContainer.nativeElement,
+            threshold: 1,
+        });
+        items.forEach((item) => observer.observe(item));
+        return observer;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollableService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollableService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ScrollableService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scrollable.service.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/scrollable/src/lib/scrollable.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, Injectable, OnDestroy, signal } from '@angular/core';\n\nexport interface ScrollableItem {\n  element: ElementRef<HTMLElement>;\n}\n\n/**\n * Service to manage scrollable items within a container, providing functionality to observe item visibility\n * and navigate through them.\n */\n@Injectable()\nexport class ScrollableService implements OnDestroy {\n  private intersectionObserver?: IntersectionObserver;\n  private scrollContainer?: ElementRef<HTMLElement>;\n\n  /**\n   * References to the next and previous scrollable items.\n   *\n   * @type {HTMLElement | null}\n   */\n  public readonly nextItem = signal<HTMLElement | null>(null);\n\n  /**\n   * References to the previous scrollable item.\n   *\n   * @type {HTMLElement | null}\n   */\n  public readonly prevItem = signal<HTMLElement | null>(null);\n\n  /** List of currently visible items within the scroll container.\n   *\n   * @type {HTMLElement[]}\n   */\n  public readonly visibleItems = signal<HTMLElement[]>([]);\n\n  public ngOnDestroy(): void {\n    this.intersectionObserver?.disconnect();\n  }\n\n  /**\n   * Starts observing the scrollable items within the specified container.\n   *\n   * @param {ElementRef<HTMLElement>} scrollContainer - The container element that holds the scrollable items.\n   * @param {readonly ScrollableItem[]} items - The list of scrollable items to observe.\n   */\n  public observe(scrollContainer: ElementRef<HTMLElement>, items: readonly ScrollableItem[]): void {\n    this.scrollContainer = scrollContainer;\n    if (this.intersectionObserver) {\n      this.intersectionObserver.disconnect();\n    }\n\n    const allItems = items.map((item) => item.element.nativeElement);\n    if (!this.scrollContainer || allItems.length === 0) {\n      this.nextItem.set(null);\n      this.prevItem.set(null);\n      return;\n    }\n\n    this.intersectionObserver = this.observeVisibility(allItems, (visible) => {\n      let prevItem: HTMLElement | null = null;\n      let nextItem: HTMLElement | null = null;\n\n      if (visible.length > 0 && allItems.length > visible.length) {\n        const firstVisibleIndex = allItems.indexOf(visible[0]);\n        if (firstVisibleIndex > 0) {\n          prevItem = allItems[firstVisibleIndex - 1];\n        }\n\n        const lastVisibleIndex = allItems.indexOf(visible[visible.length - 1]);\n        if (lastVisibleIndex < allItems.length - 1) {\n          nextItem = allItems[lastVisibleIndex + 1];\n        }\n      }\n\n      this.nextItem.set(nextItem);\n      this.prevItem.set(prevItem);\n    });\n  }\n\n  /**\n   * Scrolls the container in the specified direction.\n   *\n   * @param {'next' | 'prev'} direction - The direction to scroll ('next' for right, 'prev' for left).\n   */\n  public scroll(direction: 1 | -1 = 1): void {\n    const container = this.scrollContainer?.nativeElement;\n    if (!container) return;\n\n    container.scrollBy({ left: (container.clientWidth * direction) / 2 });\n  }\n\n  /**\n   * Scrolls the active item into view within the scroll container.\n   *\n   * @param {HTMLElement | null} activeItem - The currently active item to scroll into view.\n   */\n  public scrollActiveItemIntoView(activeItem: HTMLElement | null): void {\n    if (activeItem) {\n      activeItem.scrollIntoView({ behavior: 'smooth', block: 'nearest', inline: 'center' });\n    }\n  }\n\n  private observeVisibility(items: HTMLElement[], callback: (visible: HTMLElement[]) => void): IntersectionObserver {\n    const visibleMap = new Map<HTMLElement, boolean>();\n    const observer = new IntersectionObserver(\n      (entries) => {\n        for (const entry of entries) {\n          const isVisible = entry.isIntersecting && entry.intersectionRatio >= 0.75;\n          visibleMap.set(entry.target as HTMLElement, isVisible);\n        }\n        const visible = items.filter((item) => visibleMap.get(item));\n        this.visibleItems.set(visible);\n        callback(visible);\n      },\n      {\n        root: this.scrollContainer!.nativeElement,\n        threshold: 1,\n      },\n    );\n\n    items.forEach((item) => observer.observe(item));\n    return observer;\n  }\n}\n"]}

package/esm2022/cdk/scrollable/odx-angular-cdk-scrollable.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2R4LWFuZ3VsYXItY2RrLXNjcm9sbGFibGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL3Njcm9sbGFibGUvc3JjL29keC1hbmd1bGFyLWNkay1zY3JvbGxhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/components/spinbox/lib/spinbox.component.mjs

@@ -4,9 +4,7 @@ import { detectControllerChanges, DisabledController, ReadonlyController } from
 import { ControlDirective, CustomFormControl } from '@odx/angular/cdk/custom-form-control';
 import { IconComponent } from '@odx/angular/components/icon';
 import { CSSComponent } from '@odx/angular/internal';
-import { fromEvents } from '@odx/angular/rxjs';
-import { injectElement, untilDestroyed } from '@odx/angular/utils';
-import { filter, NEVER, startWith, switchMap, tap, timer } from 'rxjs';
+import { injectElement } from '@odx/angular/utils';
 import * as i0 from "@angular/core";
 /**
  * SpinboxComponent is a custom form control for numeric input which allows users to increment and decrement
@@ -21,22 +19,21 @@ let SpinboxComponent = class SpinboxComponent extends CustomFormControl {
     }
     constructor() {
         super(0);
-        this.takeUntilDestroyed = untilDestroyed();
         this.element = injectElement();
         /**
          * The maximum allowable value for the spinbox.
          *
          * @type {number}
-         * @default Infinity
+         * @default Number.POSITIVE_INFINITY
          */
-        this.max = Infinity;
+        this.max = Number.POSITIVE_INFINITY;
         /**
          * The minimum allowable value for the spinbox.
          *
          * @type {number}
-         * @default -Infinity
+         * @default Number.NEGATIVE_INFINITY
          */
-        this.min = -Infinity;
+        this.min = Number.NEGATIVE_INFINITY;
         /**
          * The value increment or decrement step for the spinbox.
          *
@@ -47,15 +44,25 @@ let SpinboxComponent = class SpinboxComponent extends CustomFormControl {
         detectControllerChanges(this).subscribe();
     }
     ngAfterViewInit() {
-        this.registerPressHold(this.decrementButton).subscribe(() => {
+        this.destroyDecrementListener = this.pressAndHold(this.decrementButton.nativeElement, () => {
             this.inputElement?.stepDown();
-            this.onInputChange();
+            this.updateValue(numberAttribute(this.inputElement.value));
         });
-        this.registerPressHold(this.incrementButton).subscribe(() => {
+        this.destroyIncrementListener = this.pressAndHold(this.incrementButton.nativeElement, () => {
             this.inputElement?.stepUp();
-            this.onInputChange();
+            this.updateValue(numberAttribute(this.inputElement.value));
         });
     }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.destroyDecrementListener?.();
+        this.destroyIncrementListener?.();
+    }
+    updateValue(value) {
+        if (this.value === value)
+            return;
+        super.updateValue(value);
+    }
     maxSteps({ code }) {
         if (code === 'End' && this.min !== -Infinity) {
             this.updateValue(this.min);
@@ -64,21 +71,50 @@ let SpinboxComponent = class SpinboxComponent extends CustomFormControl {
             this.updateValue(this.max);
         }
     }
-    checkValue() {
+    checkAndUpdate() {
         const value = numberAttribute(this.inputElement.value);
-        this.updateValue(value < this.min ? this.min : value > this.max ? this.max : value);
-    }
-    onInputChange() {
-        this.updateValue(numberAttribute(this.inputElement.value));
+        const clampedValue = Math.min(this.max, Math.max(this.min, value));
+        this.inputElement.value = clampedValue.toString();
+        this.updateValue(clampedValue);
     }
-    registerPressHold(target) {
-        return fromEvents(target.nativeElement, 'keydown', 'mousedown', 'mouseup', 'keyup').pipe(filter((event) => event?.type !== 'keydown' || ['Space', 'Enter'].includes(event.code)), tap((event) => {
-            event.preventDefault();
-            event.stopPropagation();
-        }), switchMap(({ type }) => (['mouseup', 'keyup'].includes(type) ? NEVER : timer(500, 100).pipe(startWith(undefined)))), this.takeUntilDestroyed());
+    pressAndHold(element, handler, interval = 200) {
+        let timerId;
+        const clearTimer = () => {
+            clearInterval(timerId);
+            timerId = undefined;
+        };
+        const start = () => {
+            handler();
+            timerId = window.setInterval(handler, interval);
+        };
+        const handleKeyDown = (event) => {
+            if ((event.code === 'Space' || event.code === 'Enter') && timerId === undefined) {
+                if (event.code === 'Space') {
+                    event.preventDefault(); // blocks scrolling
+                }
+                start();
+            }
+        };
+        const handleKeyUp = (event) => {
+            if (event.code === 'Space' || event.code === 'Enter') {
+                clearTimer();
+            }
+        };
+        element.addEventListener('mousedown', start);
+        element.addEventListener('mouseup', clearTimer);
+        element.addEventListener('mouseout', clearTimer);
+        element.addEventListener('keydown', handleKeyDown);
+        element.addEventListener('keyup', handleKeyUp);
+        return () => {
+            element.removeEventListener('mousedown', start);
+            element.removeEventListener('mouseup', clearTimer);
+            element.removeEventListener('mouseout', clearTimer);
+            element.removeEventListener('keydown', handleKeyDown);
+            element.removeEventListener('keyup', handleKeyUp);
+        };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SpinboxComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "18.2.13", type: SpinboxComponent, isStandalone: true, selector: "odx-spinbox", inputs: { max: ["max", "max", numberAttribute], min: ["min", "min", numberAttribute], step: ["step", "step", numberAttribute] }, providers: [DisabledController.connect(), ReadonlyController.connect()], viewQueries: [{ propertyName: "decrementButton", first: true, predicate: ["decrementButton"], descendants: true }, { propertyName: "incrementButton", first: true, predicate: ["incrementButton"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #decrementButton><odx-icon name=\"minus\" /></button>\n<input\n  odxControl\n  class=\"odx-spinbox__input\"\n  [disabled]=\"isDisabled\"\n  [readonly]=\"isReadonly\"\n  type=\"number\"\n  [value]=\"value\"\n  [min]=\"min\"\n  [max]=\"max\"\n  [step]=\"step\"\n  (keydown)=\"maxSteps($event)\"\n  (change)=\"onInputChange()\"\n  (blur)=\"checkValue()\"\n/>\n<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #incrementButton><odx-icon name=\"plus\" /></button>\n", dependencies: [{ kind: "directive", type: ControlDirective, selector: "[odxControl]", exportAs: ["odxControl"] }, { kind: "component", type: IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name", "iconSet", "identifier"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "18.2.13", type: SpinboxComponent, isStandalone: true, selector: "odx-spinbox", inputs: { max: ["max", "max", numberAttribute], min: ["min", "min", numberAttribute], step: ["step", "step", numberAttribute] }, providers: [DisabledController.connect(), ReadonlyController.connect()], viewQueries: [{ propertyName: "decrementButton", first: true, predicate: ["decrementButton"], descendants: true }, { propertyName: "incrementButton", first: true, predicate: ["incrementButton"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #decrementButton><odx-icon name=\"minus\" /></button>\n<input\n  odxControl\n  class=\"odx-spinbox__input\"\n  [disabled]=\"isDisabled\"\n  [readonly]=\"isReadonly\"\n  type=\"number\"\n  [value]=\"value\"\n  [min]=\"min\"\n  [max]=\"max\"\n  [step]=\"step\"\n  (keydown)=\"maxSteps($event)\"\n  (change)=\"checkAndUpdate()\"\n  (blur)=\"checkAndUpdate()\"\n/>\n<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #incrementButton><odx-icon name=\"plus\" /></button>\n", dependencies: [{ kind: "directive", type: ControlDirective, selector: "[odxControl]", exportAs: ["odxControl"] }, { kind: "component", type: IconComponent, selector: "odx-icon", inputs: ["inline", "size", "name", "iconSet", "identifier"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
 };
 SpinboxComponent = __decorate([
     CSSComponent('spinbox'),
@@ -87,7 +123,7 @@ SpinboxComponent = __decorate([
 export { SpinboxComponent };
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SpinboxComponent, decorators: [{
             type: Component,
-            args: [{ standalone: true, selector: 'odx-spinbox', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, imports: [ControlDirective, IconComponent], providers: [DisabledController.connect(), ReadonlyController.connect()], template: "<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #decrementButton><odx-icon name=\"minus\" /></button>\n<input\n  odxControl\n  class=\"odx-spinbox__input\"\n  [disabled]=\"isDisabled\"\n  [readonly]=\"isReadonly\"\n  type=\"number\"\n  [value]=\"value\"\n  [min]=\"min\"\n  [max]=\"max\"\n  [step]=\"step\"\n  (keydown)=\"maxSteps($event)\"\n  (change)=\"onInputChange()\"\n  (blur)=\"checkValue()\"\n/>\n<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #incrementButton><odx-icon name=\"plus\" /></button>\n" }]
+            args: [{ standalone: true, selector: 'odx-spinbox', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, imports: [ControlDirective, IconComponent], providers: [DisabledController.connect(), ReadonlyController.connect()], template: "<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #decrementButton><odx-icon name=\"minus\" /></button>\n<input\n  odxControl\n  class=\"odx-spinbox__input\"\n  [disabled]=\"isDisabled\"\n  [readonly]=\"isReadonly\"\n  type=\"number\"\n  [value]=\"value\"\n  [min]=\"min\"\n  [max]=\"max\"\n  [step]=\"step\"\n  (keydown)=\"maxSteps($event)\"\n  (change)=\"checkAndUpdate()\"\n  (blur)=\"checkAndUpdate()\"\n/>\n<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #incrementButton><odx-icon name=\"plus\" /></button>\n" }]
         }], ctorParameters: () => [], propDecorators: { decrementButton: [{
                 type: ViewChild,
                 args: ['decrementButton']
@@ -104,4 +140,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
                 type: Input,
                 args: [{ transform: numberAttribute }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spinbox.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/components/spinbox/src/lib/spinbox.component.ts","../../../../../../../libs/angular/components/spinbox/src/lib/spinbox.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ChangeDetectionStrategy, Component, ElementRef, Input, numberAttribute, ViewChild, ViewEncapsulation } from '@angular/core';\nimport { detectControllerChanges, DisabledController, ReadonlyController } from '@odx/angular';\nimport { ControlDirective, CustomFormControl } from '@odx/angular/cdk/custom-form-control';\nimport { IconComponent } from '@odx/angular/components/icon';\nimport { CSSComponent } from '@odx/angular/internal';\nimport { fromEvents } from '@odx/angular/rxjs';\nimport { injectElement, untilDestroyed } from '@odx/angular/utils';\nimport { filter, NEVER, Observable, startWith, switchMap, tap, timer } from 'rxjs';\n\n/**\n * SpinboxComponent is a custom form control for numeric input which allows users to increment and decrement\n * the value using corresponding buttons. It supports keyboard navigation and automatic boundary checks for the values.\n *  Extends CustomFormControl to provide additional behavior.\n *\n * @see {CustomFormControl}\n */\n@CSSComponent('spinbox')\n@Component({\n  standalone: true,\n  selector: 'odx-spinbox',\n  templateUrl: 'spinbox.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  imports: [ControlDirective, IconComponent],\n  providers: [DisabledController.connect(), ReadonlyController.connect()],\n})\nexport class SpinboxComponent extends CustomFormControl<number> implements AfterViewInit {\n  private readonly takeUntilDestroyed = untilDestroyed();\n\n  private get inputElement(): HTMLInputElement {\n    return this.control?.element.nativeElement as HTMLInputElement;\n  }\n\n  @ViewChild('decrementButton')\n  protected decrementButton!: ElementRef<HTMLButtonElement>;\n\n  @ViewChild('incrementButton')\n  protected incrementButton!: ElementRef<HTMLButtonElement>;\n\n  public readonly element = injectElement();\n\n  /**\n   * The maximum allowable value for the spinbox.\n   *\n   * @type {number}\n   * @default Infinity\n   */\n  @Input({ transform: numberAttribute })\n  public max = Infinity;\n\n  /**\n   * The minimum allowable value for the spinbox.\n   *\n   * @type {number}\n   * @default -Infinity\n   */\n  @Input({ transform: numberAttribute })\n  public min = -Infinity;\n\n  /**\n   * The value increment or decrement step for the spinbox.\n   *\n   * @type {number}\n   * @default 1\n   */\n  @Input({ transform: numberAttribute })\n  public step = 1;\n\n  constructor() {\n    super(0);\n    detectControllerChanges(this).subscribe();\n  }\n\n  public ngAfterViewInit(): void {\n    this.registerPressHold(this.decrementButton).subscribe(() => {\n      this.inputElement?.stepDown();\n      this.onInputChange();\n    });\n    this.registerPressHold(this.incrementButton).subscribe(() => {\n      this.inputElement?.stepUp();\n      this.onInputChange();\n    });\n  }\n\n  protected maxSteps({ code }: KeyboardEvent) {\n    if (code === 'End' && this.min !== -Infinity) {\n      this.updateValue(this.min);\n    } else if (code === 'Home' && this.max !== Infinity) {\n      this.updateValue(this.max);\n    }\n  }\n\n  protected checkValue(): void {\n    const value = numberAttribute(this.inputElement.value);\n    this.updateValue(value < this.min ? this.min : value > this.max ? this.max : value);\n  }\n\n  protected onInputChange(): void {\n    this.updateValue(numberAttribute(this.inputElement.value));\n  }\n\n  private registerPressHold(target: ElementRef<HTMLElement>): Observable<unknown> {\n    return fromEvents(target.nativeElement, 'keydown', 'mousedown', 'mouseup', 'keyup').pipe(\n      filter((event) => event?.type !== 'keydown' || ['Space', 'Enter'].includes((event as KeyboardEvent).code)),\n      tap((event) => {\n        event.preventDefault();\n        event.stopPropagation();\n      }),\n      switchMap(({ type }) => (['mouseup', 'keyup'].includes(type) ? NEVER : timer(500, 100).pipe(startWith(undefined)))),\n      this.takeUntilDestroyed(),\n    );\n  }\n}\n","<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #decrementButton><odx-icon name=\"minus\" /></button>\n<input\n  odxControl\n  class=\"odx-spinbox__input\"\n  [disabled]=\"isDisabled\"\n  [readonly]=\"isReadonly\"\n  type=\"number\"\n  [value]=\"value\"\n  [min]=\"min\"\n  [max]=\"max\"\n  [step]=\"step\"\n  (keydown)=\"maxSteps($event)\"\n  (change)=\"onInputChange()\"\n  (blur)=\"checkValue()\"\n/>\n<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #incrementButton><odx-icon name=\"plus\" /></button>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spinbox.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/components/spinbox/src/lib/spinbox.component.ts","../../../../../../../libs/angular/components/spinbox/src/lib/spinbox.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ChangeDetectionStrategy, Component, ElementRef, Input, numberAttribute, OnDestroy, ViewChild, ViewEncapsulation } from '@angular/core';\nimport { detectControllerChanges, DisabledController, ReadonlyController } from '@odx/angular';\nimport { ControlDirective, CustomFormControl } from '@odx/angular/cdk/custom-form-control';\nimport { IconComponent } from '@odx/angular/components/icon';\nimport { CSSComponent } from '@odx/angular/internal';\nimport { injectElement } from '@odx/angular/utils';\n\n/**\n * SpinboxComponent is a custom form control for numeric input which allows users to increment and decrement\n * the value using corresponding buttons. It supports keyboard navigation and automatic boundary checks for the values.\n *  Extends CustomFormControl to provide additional behavior.\n *\n * @see {CustomFormControl}\n */\n@CSSComponent('spinbox')\n@Component({\n  standalone: true,\n  selector: 'odx-spinbox',\n  templateUrl: 'spinbox.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n  imports: [ControlDirective, IconComponent],\n  providers: [DisabledController.connect(), ReadonlyController.connect()],\n})\nexport class SpinboxComponent extends CustomFormControl<number> implements AfterViewInit, OnDestroy {\n  private destroyIncrementListener!: () => void;\n  private destroyDecrementListener!: () => void;\n  private get inputElement(): HTMLInputElement {\n    return this.control?.element.nativeElement as HTMLInputElement;\n  }\n\n  @ViewChild('decrementButton')\n  protected decrementButton!: ElementRef<HTMLButtonElement>;\n\n  @ViewChild('incrementButton')\n  protected incrementButton!: ElementRef<HTMLButtonElement>;\n\n  public readonly element = injectElement();\n\n  /**\n   * The maximum allowable value for the spinbox.\n   *\n   * @type {number}\n   * @default Number.POSITIVE_INFINITY\n   */\n  @Input({ transform: numberAttribute })\n  public max = Number.POSITIVE_INFINITY;\n\n  /**\n   * The minimum allowable value for the spinbox.\n   *\n   * @type {number}\n   * @default Number.NEGATIVE_INFINITY\n   */\n  @Input({ transform: numberAttribute })\n  public min = Number.NEGATIVE_INFINITY;\n\n  /**\n   * The value increment or decrement step for the spinbox.\n   *\n   * @type {number}\n   * @default 1\n   */\n  @Input({ transform: numberAttribute })\n  public step = 1;\n\n  constructor() {\n    super(0);\n    detectControllerChanges(this).subscribe();\n  }\n\n  public ngAfterViewInit(): void {\n    this.destroyDecrementListener = this.pressAndHold(this.decrementButton.nativeElement, () => {\n      this.inputElement?.stepDown();\n      this.updateValue(numberAttribute(this.inputElement.value));\n    });\n    this.destroyIncrementListener = this.pressAndHold(this.incrementButton.nativeElement, () => {\n      this.inputElement?.stepUp();\n      this.updateValue(numberAttribute(this.inputElement.value));\n    });\n  }\n\n  public override ngOnDestroy(): void {\n    super.ngOnDestroy();\n    this.destroyDecrementListener?.();\n    this.destroyIncrementListener?.();\n  }\n\n  public override updateValue(value: number) {\n    if (this.value === value) return;\n    super.updateValue(value);\n  }\n\n  protected maxSteps({ code }: KeyboardEvent) {\n    if (code === 'End' && this.min !== -Infinity) {\n      this.updateValue(this.min);\n    } else if (code === 'Home' && this.max !== Infinity) {\n      this.updateValue(this.max);\n    }\n  }\n\n  protected checkAndUpdate(): void {\n    const value = numberAttribute(this.inputElement.value);\n    const clampedValue = Math.min(this.max, Math.max(this.min, value));\n    this.inputElement.value = clampedValue.toString();\n    this.updateValue(clampedValue);\n  }\n\n  private pressAndHold(element: HTMLElement, handler: () => void, interval = 200): () => void {\n    let timerId: number | undefined;\n\n    const clearTimer = () => {\n      clearInterval(timerId);\n      timerId = undefined;\n    };\n\n    const start = () => {\n      handler();\n      timerId = window.setInterval(handler, interval);\n    };\n\n    const handleKeyDown = (event: KeyboardEvent) => {\n      if ((event.code === 'Space' || event.code === 'Enter') && timerId === undefined) {\n        if (event.code === 'Space') {\n          event.preventDefault(); // blocks scrolling\n        }\n        start();\n      }\n    };\n\n    const handleKeyUp = (event: KeyboardEvent) => {\n      if (event.code === 'Space' || event.code === 'Enter') {\n        clearTimer();\n      }\n    };\n\n    element.addEventListener('mousedown', start);\n    element.addEventListener('mouseup', clearTimer);\n    element.addEventListener('mouseout', clearTimer);\n    element.addEventListener('keydown', handleKeyDown);\n    element.addEventListener('keyup', handleKeyUp);\n\n    return () => {\n      element.removeEventListener('mousedown', start);\n      element.removeEventListener('mouseup', clearTimer);\n      element.removeEventListener('mouseout', clearTimer);\n      element.removeEventListener('keydown', handleKeyDown);\n      element.removeEventListener('keyup', handleKeyUp);\n    };\n  }\n}\n","<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #decrementButton><odx-icon name=\"minus\" /></button>\n<input\n  odxControl\n  class=\"odx-spinbox__input\"\n  [disabled]=\"isDisabled\"\n  [readonly]=\"isReadonly\"\n  type=\"number\"\n  [value]=\"value\"\n  [min]=\"min\"\n  [max]=\"max\"\n  [step]=\"step\"\n  (keydown)=\"maxSteps($event)\"\n  (change)=\"checkAndUpdate()\"\n  (blur)=\"checkAndUpdate()\"\n/>\n<button [disabled]=\"isDisabled || isReadonly\" type=\"button\" class=\"odx-spinbox__action\" #incrementButton><odx-icon name=\"plus\" /></button>\n"]}