@ethlete/cdk 2.8.0 → 2.9.0

package/lib/components/overlay/components/menu/context-menu-trigger.d.ts

@@ -0,0 +1,33 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { OnDestroy } from '@angular/core';
+import { CdkMenuTriggerBase } from './menu-trigger-base';
+import * as i0 from "@angular/core";
+export declare class ContextMenuTracker {
+    private static _openContextMenuTrigger?;
+    update(trigger: CdkContextMenuTrigger): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuTracker, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextMenuTracker>;
+}
+export type ContextMenuCoordinates = {
+    x: number;
+    y: number;
+};
+export declare class CdkContextMenuTrigger extends CdkMenuTriggerBase implements OnDestroy {
+    private readonly _overlay;
+    private readonly _directionality;
+    private readonly _contextMenuTracker;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    constructor();
+    open(coordinates: ContextMenuCoordinates): void;
+    close(): void;
+    _openOnContextMenu(event: MouseEvent): void;
+    private _getOverlayConfig;
+    private _getOverlayPositionStrategy;
+    private _setMenuStackCloseListener;
+    private _subscribeToOutsideClicks;
+    private _open;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkContextMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkContextMenuTrigger, "[cdkContextMenuTriggerFor]", ["cdkContextMenuTriggerFor"], { "menuTemplateRef": { "alias": "cdkContextMenuTriggerFor"; "required": false; }; "menuPosition": { "alias": "cdkContextMenuPosition"; "required": false; }; "menuData": { "alias": "cdkContextMenuTriggerData"; "required": false; }; "disabled": { "alias": "cdkContextMenuDisabled"; "required": false; }; }, { "opened": "cdkContextMenuOpened"; "closed": "cdkContextMenuClosed"; }, never, never, true, never>;
+}

package/lib/components/overlay/components/menu/menu-aim.d.ts

@@ -0,0 +1,34 @@
+import { InjectionToken, OnDestroy } from '@angular/core';
+import { Menu } from './menu-interface';
+import { FocusableElement, PointerFocusTracker } from './pointer-focus-tracker';
+import * as i0 from "@angular/core";
+export interface MenuAim {
+    initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;
+    toggle(doToggle: () => void): void;
+}
+export declare const MENU_AIM: InjectionToken<MenuAim>;
+export interface Toggler {
+    getMenu(): Menu | undefined;
+}
+export declare class TargetMenuAim implements MenuAim, OnDestroy {
+    private readonly _ngZone;
+    private readonly _points;
+    private _menu;
+    private _pointerTracker;
+    private _timeoutId;
+    private readonly _destroyed;
+    ngOnDestroy(): void;
+    initialize(menu: Menu, pointerTracker: PointerFocusTracker<FocusableElement & Toggler>): void;
+    toggle(doToggle: () => void): void;
+    private _startTimeout;
+    private _isMovingToSubmenu;
+    private _getSubmenuBounds;
+    private _checkConfigured;
+    private _subscribeToMouseMoves;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TargetMenuAim, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TargetMenuAim>;
+}
+export declare class CdkTargetMenuAim {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkTargetMenuAim, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkTargetMenuAim, "[cdkTargetMenuAim]", ["cdkTargetMenuAim"], {}, {}, never, never, true, never>;
+}

package/lib/components/overlay/components/menu/menu-bar.d.ts

@@ -0,0 +1,13 @@
+import { AfterContentInit } from '@angular/core';
+import { CdkMenuBase } from './menu-base';
+import * as i0 from "@angular/core";
+export declare class CdkMenuBar extends CdkMenuBase implements AfterContentInit {
+    readonly orientation = "horizontal";
+    readonly isInline = true;
+    ngAfterContentInit(): void;
+    _handleKeyEvent(event: KeyboardEvent): void;
+    private _toggleOpenMenu;
+    private _subscribeToMenuStackEmptied;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBar, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBar, "[cdkMenuBar]", ["cdkMenuBar"], {}, {}, never, never, true, never>;
+}

package/lib/components/overlay/components/menu/menu-base.d.ts

@@ -0,0 +1,41 @@
+import { FocusKeyManager, FocusOrigin } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { AfterContentInit, NgZone, OnDestroy, QueryList } from '@angular/core';
+import { Subject } from 'rxjs';
+import { CdkMenuGroup } from './menu-group';
+import { Menu } from './menu-interface';
+import { CdkMenuItem } from './menu-item';
+import { MenuStack, MenuStackItem } from './menu-stack';
+import { PointerFocusTracker } from './pointer-focus-tracker';
+import * as i0 from "@angular/core";
+export declare abstract class CdkMenuBase extends CdkMenuGroup implements Menu, AfterContentInit, OnDestroy {
+    readonly nativeElement: HTMLElement;
+    protected ngZone: NgZone;
+    readonly menuStack: MenuStack;
+    protected readonly menuAim: import("./menu-aim").MenuAim | null;
+    protected readonly dir: Directionality | null;
+    id: string;
+    readonly items: QueryList<CdkMenuItem> | null;
+    orientation: 'horizontal' | 'vertical';
+    isInline: boolean;
+    protected keyManager: FocusKeyManager<CdkMenuItem> | null;
+    protected readonly destroyed: Subject<void>;
+    protected triggerItem?: CdkMenuItem;
+    protected pointerTracker?: PointerFocusTracker<CdkMenuItem>;
+    private _menuStackHasFocus;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    focusFirstItem(focusOrigin?: FocusOrigin): void;
+    focusLastItem(focusOrigin?: FocusOrigin): void;
+    _getTabIndex(): 0 | -1 | null;
+    protected closeOpenMenu(menu: MenuStackItem, options?: {
+        focusParentTrigger?: boolean;
+    }): void;
+    private _setKeyManager;
+    private _subscribeToMenuOpen;
+    private _subscribeToMenuStackClosed;
+    private _subscribeToMenuStackHasFocus;
+    private _setUpPointerTracker;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuBase, never, never, { "id": { "alias": "id"; "required": false; }; }, {}, ["items"], never, false, never>;
+}

package/lib/components/overlay/components/menu/menu-errors.d.ts

@@ -0,0 +1,2 @@
+export declare function throwMissingPointerFocusTracker(): void;
+export declare function throwMissingMenuReference(): void;

package/lib/components/overlay/components/menu/menu-group.d.ts

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

package/lib/components/overlay/components/menu/menu-interface.d.ts

@@ -0,0 +1,11 @@
+import { FocusOrigin } from '@angular/cdk/a11y';
+import { InjectionToken } from '@angular/core';
+import { MenuStackItem } from './menu-stack';
+export declare const CDK_MENU: InjectionToken<Menu>;
+export interface Menu extends MenuStackItem {
+    id: string;
+    nativeElement: HTMLElement;
+    readonly orientation: 'horizontal' | 'vertical';
+    focusFirstItem(focusOrigin: FocusOrigin): void;
+    focusLastItem(focusOrigin: FocusOrigin): void;
+}

package/lib/components/overlay/components/menu/menu-item-checkbox.d.ts

@@ -0,0 +1,9 @@
+import { CdkMenuItemSelectable } from './menu-item-selectable';
+import * as i0 from "@angular/core";
+export declare class CdkMenuItemCheckbox extends CdkMenuItemSelectable {
+    trigger(options?: {
+        keepOpen: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemCheckbox, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemCheckbox, "[cdkMenuItemCheckbox]", ["cdkMenuItemCheckbox"], {}, {}, never, never, true, never>;
+}

package/lib/components/overlay/components/menu/menu-item-radio.d.ts

@@ -0,0 +1,16 @@
+import { OnDestroy } from '@angular/core';
+import { CdkMenuItemSelectable } from './menu-item-selectable';
+import * as i0 from "@angular/core";
+export declare class CdkMenuItemRadio extends CdkMenuItemSelectable implements OnDestroy {
+    private readonly _selectionDispatcher;
+    private _id;
+    private _removeDispatcherListener?;
+    constructor();
+    ngOnDestroy(): void;
+    trigger(options?: {
+        keepOpen: boolean;
+    }): void;
+    private _registerDispatcherListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemRadio, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemRadio, "[cdkMenuItemRadio]", ["cdkMenuItemRadio"], {}, {}, never, never, true, never>;
+}

package/lib/components/overlay/components/menu/menu-item-selectable.d.ts

@@ -0,0 +1,11 @@
+import { BooleanInput } from '@angular/cdk/coercion';
+import { CdkMenuItem } from './menu-item';
+import * as i0 from "@angular/core";
+export declare abstract class CdkMenuItemSelectable extends CdkMenuItem {
+    get checked(): boolean;
+    set checked(value: BooleanInput);
+    private _checked;
+    protected closeOnSpacebarTrigger: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItemSelectable, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItemSelectable, never, never, { "checked": { "alias": "cdkMenuItemChecked"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/components/overlay/components/menu/menu-item.d.ts

@@ -0,0 +1,52 @@
+import { FocusableOption } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { ElementRef, EventEmitter, NgZone, OnDestroy } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Toggler } from './menu-aim';
+import { Menu } from './menu-interface';
+import { CdkMenuTrigger } from './menu-trigger';
+import { FocusableElement } from './pointer-focus-tracker';
+import * as i0 from "@angular/core";
+export declare class CdkMenuItem implements FocusableOption, FocusableElement, Toggler, OnDestroy {
+    protected readonly _dir: Directionality | null;
+    private readonly _inputModalityDetector;
+    readonly _elementRef: ElementRef<HTMLElement>;
+    protected _ngZone: NgZone;
+    private readonly _menuAim;
+    private readonly _menuStack;
+    private readonly _parentMenu;
+    private readonly _menuTrigger;
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    typeaheadLabel: string | null;
+    readonly triggered: EventEmitter<void>;
+    get hasMenu(): boolean;
+    _tabindex: 0 | -1;
+    protected closeOnSpacebarTrigger: boolean;
+    protected readonly destroyed: Subject<void>;
+    constructor();
+    ngOnDestroy(): void;
+    focus(): void;
+    trigger(options?: {
+        keepOpen: boolean;
+    }): void;
+    isMenuOpen(): boolean;
+    getMenu(): Menu | undefined;
+    getMenuTrigger(): CdkMenuTrigger | null;
+    getLabel(): string;
+    _resetTabIndex(): void;
+    _setTabIndex(event?: MouseEvent): void;
+    _onKeydown(event: KeyboardEvent): void;
+    _handleClick(): void;
+    _handleMousedown(event: MouseEvent): void;
+    private _isStandaloneItem;
+    private _backArrowPressed;
+    private _forwardArrowPressed;
+    private _setupMouseEnter;
+    private _isParentVertical;
+    private _setType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuItem, "[cdkMenuItem]", ["cdkMenuItem"], { "disabled": { "alias": "cdkMenuItemDisabled"; "required": false; }; "typeaheadLabel": { "alias": "cdkMenuitemTypeaheadLabel"; "required": false; }; }, { "triggered": "cdkMenuItemTriggered"; }, never, never, true, never>;
+}

package/lib/components/overlay/components/menu/menu-module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "./menu-bar";
+import * as i3 from "./menu";
+import * as i4 from "./menu-item";
+import * as i5 from "./menu-item-radio";
+import * as i6 from "./menu-item-checkbox";
+import * as i7 from "./menu-trigger";
+import * as i8 from "./menu-group";
+import * as i9 from "./context-menu-trigger";
+import * as i10 from "./menu-aim";
+export declare class CdkMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CdkMenuModule, never, [typeof i1.OverlayModule, typeof i2.CdkMenuBar, typeof i3.CdkMenu, typeof i4.CdkMenuItem, typeof i5.CdkMenuItemRadio, typeof i6.CdkMenuItemCheckbox, typeof i7.CdkMenuTrigger, typeof i8.CdkMenuGroup, typeof i9.CdkContextMenuTrigger, typeof i10.CdkTargetMenuAim], [typeof i2.CdkMenuBar, typeof i3.CdkMenu, typeof i4.CdkMenuItem, typeof i5.CdkMenuItemRadio, typeof i6.CdkMenuItemCheckbox, typeof i7.CdkMenuTrigger, typeof i8.CdkMenuGroup, typeof i9.CdkContextMenuTrigger, typeof i10.CdkTargetMenuAim]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CdkMenuModule>;
+}

package/lib/components/overlay/components/menu/menu-stack.d.ts

@@ -0,0 +1,54 @@
+import { InjectionToken, Optional } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare const enum FocusNext {
+    nextItem = 0,
+    previousItem = 1,
+    currentItem = 2
+}
+export interface MenuStackItem {
+    menuStack?: MenuStack;
+}
+export declare const MENU_STACK: InjectionToken<MenuStack>;
+export declare const PARENT_OR_NEW_MENU_STACK_PROVIDER: {
+    provide: InjectionToken<MenuStack>;
+    deps: Optional[][];
+    useFactory: (parentMenuStack?: MenuStack) => MenuStack;
+};
+export declare const PARENT_OR_NEW_INLINE_MENU_STACK_PROVIDER: (orientation: 'vertical' | 'horizontal') => {
+    provide: InjectionToken<MenuStack>;
+    deps: Optional[][];
+    useFactory: (parentMenuStack?: MenuStack) => MenuStack;
+};
+export interface CloseOptions {
+    focusNextOnEmpty?: FocusNext;
+    focusParentTrigger?: boolean;
+}
+export interface MenuStackCloseEvent {
+    item: MenuStackItem;
+    focusParentTrigger?: boolean;
+}
+export declare class MenuStack {
+    readonly id: string;
+    private readonly _elements;
+    private readonly _close;
+    private readonly _empty;
+    private readonly _hasFocus;
+    readonly closed: Observable<MenuStackCloseEvent>;
+    readonly hasFocus: Observable<boolean>;
+    readonly emptied: Observable<FocusNext | undefined>;
+    private _inlineMenuOrientation;
+    static inline(orientation: 'vertical' | 'horizontal'): MenuStack;
+    push(menu: MenuStackItem): void;
+    close(lastItem: MenuStackItem, options?: CloseOptions): void;
+    closeSubMenuOf(lastItem: MenuStackItem): boolean;
+    closeAll(options?: CloseOptions): void;
+    isEmpty(): boolean;
+    length(): number;
+    peek(): MenuStackItem | undefined;
+    hasInlineMenu(): boolean;
+    inlineMenuOrientation(): "vertical" | "horizontal" | null;
+    setHasFocus(hasFocus: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MenuStack, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MenuStack>;
+}

package/lib/components/overlay/components/menu/menu-trigger-base.d.ts

@@ -0,0 +1,33 @@
+import { ConnectedPosition, OverlayRef } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { EventEmitter, InjectionToken, Injector, OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Menu } from './menu-interface';
+import { MenuStack } from './menu-stack';
+import * as i0 from "@angular/core";
+export declare const MENU_TRIGGER: InjectionToken<CdkMenuTriggerBase>;
+export declare abstract class CdkMenuTriggerBase implements OnDestroy {
+    readonly injector: Injector;
+    protected readonly viewContainerRef: ViewContainerRef;
+    protected readonly menuStack: MenuStack;
+    menuPosition: ConnectedPosition[] | null;
+    readonly opened: EventEmitter<void>;
+    readonly closed: EventEmitter<void>;
+    menuTemplateRef: TemplateRef<unknown> | null;
+    menuData: unknown;
+    protected overlayRef: OverlayRef | null;
+    protected readonly destroyed: Subject<void>;
+    protected readonly stopOutsideClicksListener: import("rxjs").Observable<void>;
+    protected childMenu?: Menu;
+    private _menuPortal;
+    private _childMenuInjector?;
+    ngOnDestroy(): void;
+    isOpen(): boolean;
+    registerChildMenu(child: Menu): void;
+    protected getMenuContentPortal(): TemplatePortal<any> | null;
+    protected isElementInsideMenuStack(element: Element): boolean;
+    private _destroyOverlay;
+    private _getChildMenuInjector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuTriggerBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuTriggerBase, never, never, {}, {}, never, never, false, never>;
+}

package/lib/components/overlay/components/menu/menu-trigger.d.ts

@@ -0,0 +1,34 @@
+import { OnDestroy } from '@angular/core';
+import { Menu } from './menu-interface';
+import { CdkMenuTriggerBase } from './menu-trigger-base';
+import * as i0 from "@angular/core";
+export declare class CdkMenuTrigger extends CdkMenuTriggerBase implements OnDestroy {
+    private readonly _elementRef;
+    private readonly _overlay;
+    private readonly _ngZone;
+    private readonly _directionality;
+    private readonly _inputModalityDetector;
+    private readonly _parentMenu;
+    private readonly _menuAim;
+    constructor();
+    toggle(): void;
+    open(): void;
+    close(): void;
+    getMenu(): Menu | undefined;
+    _toggleOnKeydown(event: KeyboardEvent): void;
+    _handleClick(): void;
+    _setHasFocus(hasFocus: boolean): void;
+    private _subscribeToMouseEnter;
+    private _closeSiblingTriggers;
+    private _getOverlayConfig;
+    private _getOverlayPositionStrategy;
+    private _getOverlayPositions;
+    private _registerCloseHandler;
+    private _subscribeToOutsideClicks;
+    private _subscribeToMenuStackHasFocus;
+    private _subscribeToMenuStackClosed;
+    private _setRole;
+    private _setType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenuTrigger, "[cdkMenuTriggerFor]", ["cdkMenuTriggerFor"], { "menuTemplateRef": { "alias": "cdkMenuTriggerFor"; "required": false; }; "menuPosition": { "alias": "cdkMenuPosition"; "required": false; }; "menuData": { "alias": "cdkMenuTriggerData"; "required": false; }; }, { "opened": "cdkMenuOpened"; "closed": "cdkMenuClosed"; }, never, never, true, never>;
+}

package/lib/components/overlay/components/menu/menu.d.ts

@@ -0,0 +1,17 @@
+import { AfterContentInit, EventEmitter, OnDestroy } from '@angular/core';
+import { CdkMenuBase } from './menu-base';
+import * as i0 from "@angular/core";
+export declare class CdkMenu extends CdkMenuBase implements AfterContentInit, OnDestroy {
+    private _parentTrigger;
+    readonly closed: EventEmitter<void>;
+    readonly orientation = "vertical";
+    readonly isInline: boolean;
+    constructor();
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    _handleKeyEvent(event: KeyboardEvent): void;
+    private _toggleMenuFocus;
+    private _subscribeToMenuStackEmptied;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CdkMenu, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CdkMenu, "[cdkMenu]", ["cdkMenu"], {}, { "closed": "closed"; }, never, never, true, never>;
+}

package/lib/components/overlay/components/menu/pointer-focus-tracker.d.ts

@@ -0,0 +1,17 @@
+import { ElementRef, QueryList } from '@angular/core';
+import { Observable } from 'rxjs';
+export interface FocusableElement {
+    _elementRef: ElementRef<HTMLElement>;
+}
+export declare class PointerFocusTracker<T extends FocusableElement> {
+    private readonly _items;
+    readonly entered: Observable<T>;
+    readonly exited: Observable<T>;
+    activeElement?: T;
+    previousElement?: T;
+    private readonly _destroyed;
+    constructor(_items: QueryList<T>);
+    destroy(): void;
+    private _getItemPointerEntries;
+    private _getItemPointerExits;
+}

package/lib/components/overlay/components/menu/public-api.d.ts

@@ -0,0 +1,16 @@
+export * from './context-menu-trigger';
+export * from './menu';
+export * from './menu-aim';
+export * from './menu-bar';
+export * from './menu-base';
+export * from './menu-group';
+export * from './menu-interface';
+export * from './menu-item';
+export * from './menu-item-checkbox';
+export * from './menu-item-radio';
+export * from './menu-item-selectable';
+export * from './menu-module';
+export * from './menu-stack';
+export * from './menu-trigger';
+export * from './menu-trigger-base';
+export * from './pointer-focus-tracker';

package/lib/components/overlay/components/public-api.d.ts

@@ -1,4 +1,5 @@
 export * from './bottom-sheet/public-api';
 export * from './dialog/public-api';
+export * from './menu/public-api';
 export * from './toggletip/public-api';
 export * from './tooltip/public-api';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/cdk",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "exports": {
     ".": {
       "css": "./src/lib/styles/index.css",
@@ -19,9 +19,9 @@
   "peerDependencies": {
     "@angular/common": "^15.2.1 || ^16.0.0",
     "@angular/core": "^15.2.1 || ^16.0.0",
-    "@ethlete/core": "2.7.2",
+    "@ethlete/core": "2.7.4",
     "@angular/animations": "16.1.1",
-    "@ethlete/query": "4.3.3"
+    "@ethlete/query": "4.3.4"
   },
   "module": "fesm2022/ethlete-cdk.mjs",
   "typings": "index.d.ts",

package/src/lib/styles/cursor-drag-scroll.css

@@ -0,0 +1,3 @@
+.et-cursor-drag-scroll--scrolling * {
+  pointer-events: none !important;
+}

package/src/lib/styles/index.css

@@ -1,3 +1,4 @@
 @import './cdk.css';
 @import './easing.css';
 @import './active-tab-underline.css';
+@import './cursor-drag-scroll.css';