@cute-widgets/base 20.0.5 → 21.0.0

package/{menu/index.d.ts → types/cute-widgets-base-menu.d.ts}

@@ -1,12 +1,13 @@
 import * as i0 from '@angular/core';
-import { OnDestroy, InjectionToken, TemplateRef, EventEmitter, AfterViewInit, AfterContentInit, OnInit, QueryList, ElementRef, ViewContainerRef, NgZone } from '@angular/core';
-import { AnimationEvent } from '@angular/animations';
-import { FocusOrigin, FocusableOption, FocusMonitor } from '@angular/cdk/a11y';
-import { Direction, Directionality } from '@angular/cdk/bidi';
+import { InjectionToken, OnDestroy, TemplateRef, EventEmitter, AfterViewInit, AfterContentInit, OnInit, QueryList, ElementRef } from '@angular/core';
+import { FocusOrigin, FocusableOption } from '@angular/cdk/a11y';
+import { Direction } from '@angular/cdk/bidi';
+import * as rxjs from 'rxjs';
 import { Subject, Observable } from 'rxjs';
 import * as i1 from '@angular/cdk/menu';
-import { ScrollStrategy, Overlay } from '@angular/cdk/overlay';
-import * as i1$1 from '@angular/common';
+import * as i1$1 from '@angular/cdk/overlay';
+import { ScrollStrategy, OverlayRef, FlexibleConnectedPositionStrategyOrigin } from '@angular/cdk/overlay';
+import * as i7 from '@angular/cdk/scrolling';
 
 /**
  * @license Apache-2.0
@@ -68,6 +69,10 @@ declare class CuteMenuContent implements OnDestroy {
  * code licensed under MIT-style License (https://angular.dev/license).
  */
 
+/**
+ * Injection token used to provide the parent menu to menu-specific components.
+ */
+declare const CUTE_MENU_PANEL: InjectionToken<CuteMenuPanel<any>>;
 /**
  * Interface for a custom menu panel that can be used with `cuteMenuTriggerFor`.
  */
@@ -163,18 +168,6 @@ declare class CuteMenuItem implements FocusableOption, AfterViewInit, OnDestroy
     static ngAcceptInputType_disableRipple: unknown;
 }
 
-/**
- * @license Apache-2.0
- *
- * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
- *
- * You may not use this file except in compliance with the License
- * that can be found at http://www.apache.org/licenses/LICENSE-2.0
- *
- * This code is a modification of the `@angular/material` original
- * code licensed under MIT-style License (https://angular.dev/license).
- */
-
 type MenuShadowElevation = 0 | 1 | 2 | 3;
 /** Reason why the menu was closed. */
 type MenuCloseReason = void | 'click' | 'keydown' | 'tab';
@@ -195,12 +188,6 @@ interface CuteMenuDefaultOptions {
 }
 /** Injection token to be used to override the default options for `mat-menu`. */
 declare const CUTE_MENU_DEFAULT_OPTIONS: InjectionToken<CuteMenuDefaultOptions>;
-/**
- * @docs-private
- * @deprecated No longer used, will be removed.
- * @breaking-change 21.0.0
- */
-declare function CUTE_MENU_DEFAULT_OPTIONS_FACTORY(): CuteMenuDefaultOptions;
 declare class CuteMenu implements CuteMenuPanel<CuteMenuItem>, AfterContentInit, OnInit, OnDestroy {
     private _elementRef;
     private _changeDetectorRef;
@@ -213,18 +200,21 @@ declare class CuteMenu implements CuteMenuPanel<CuteMenuItem>, AfterContentInit,
     private _previousElevation;
     private _elevationPrefix;
     private _baseElevation;
+    protected _animationsDisabled: boolean;
+    /** All items inside the menu. Includes items nested inside another menu. */
+    _allItems: QueryList<CuteMenuItem> | undefined;
+    /** Only the direct descendant menu items. */
+    _directDescendantItems: QueryList<CuteMenuItem>;
     /** Config object to be passed into the menu's ngClass */
     protected _classList: {
         [key: string]: boolean;
     };
     /** Current state of the panel animation. */
-    protected _panelAnimationState: 'void' | 'enter';
-    /** Only the direct descendant menu items. */
-    _directDescendantItems: QueryList<CuteMenuItem>;
+    _panelAnimationState: 'void' | 'enter';
     /** Emits whenever an animation on the menu completes. */
-    readonly _animationDone: Subject<AnimationEvent>;
+    readonly _animationDone: Subject<"void" | "enter">;
     /** Whether the menu is animating. */
-    _isAnimating: boolean | undefined;
+    _isAnimating: i0.WritableSignal<boolean>;
     /** Parent menu of the current menu panel. */
     parentMenu: CuteMenuPanel | undefined;
     /** Layout direction of the menu. */
@@ -251,8 +241,6 @@ declare class CuteMenu implements CuteMenuPanel<CuteMenuItem>, AfterContentInit,
     hasBackdrop?: boolean;
     /** @docs-private */
     templateRef: TemplateRef<any>;
-    /** All items inside the menu. Includes items nested inside another menu. */
-    _allItems: QueryList<CuteMenuItem> | undefined;
     /**
      * List of the items inside a menu.
      * @deprecated
@@ -264,7 +252,7 @@ declare class CuteMenu implements CuteMenuPanel<CuteMenuItem>, AfterContentInit,
      */
     lazyContent: CuteMenuContent | undefined;
     /**
-     * This method takes classes set on the host mat-menu element and applies them on the
+     * This method takes classes set on the host cute-menu element and applies them on the
      * menu template that displays in the overlay container.  Otherwise, it's difficult
      * to style the containing menu from outside the component.
      * @param classes list of class names
@@ -281,7 +269,7 @@ declare class CuteMenu implements CuteMenuPanel<CuteMenuItem>, AfterContentInit,
     /** Stream that emits whenever the hovered menu item changes. */
     _hovered(): Observable<CuteMenuItem>;
     /** Handle a keyboard event from the menu, delegating to the appropriate action. */
-    protected _handleKeydown(event: KeyboardEvent): void;
+    _handleKeydown(event: KeyboardEvent): void;
     /**
      * Handle a mouse event from the menu, delegating to the appropriate action.
      * @param event
@@ -305,17 +293,14 @@ declare class CuteMenu implements CuteMenuPanel<CuteMenuItem>, AfterContentInit,
     /**
      * Adds classes to the menu panel based on its position. Can be used by
      * consumers to add specific styling based on the position.
-     * @param posX Position of the menu along the x axis.
-     * @param posY Position of the menu along the y axis.
+     * @param posX Position of the menu along the x-axis.
+     * @param posY Position of the menu along the y-axis.
      */
     setPositionClasses(posX?: MenuPositionX, posY?: MenuPositionY): void;
-    /** Starts the entered animation. */
-    _startAnimation(): void;
-    /** Resets the panel animation to its initial state. */
-    _resetAnimation(): void;
     /** Callback that is invoked when the panel animation completes. */
-    _onAnimationDone(event: AnimationEvent): void;
-    _onAnimationStart(event: AnimationEvent): void;
+    _onAnimationDone(state: string): void;
+    _onAnimationStart(state: string): void;
+    _setIsOpen(isOpen: boolean): void;
     /**
      * Sets up a stream that will keep track of any newly-added menu items and will update the list
      * of direct descendants. We collect the descendants this way, because `_allItems` can include
@@ -345,106 +330,78 @@ declare class CuteMenu implements CuteMenuPanel<CuteMenuItem>, AfterContentInit,
 
 /** Injection token that determines the scroll handling while the menu is open. */
 declare const CUTE_MENU_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
-/** @docs-private */
-declare function CUTE_MENU_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
-/** @docs-private */
-declare const CUTE_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER: {
-    provide: InjectionToken<() => ScrollStrategy>;
-    deps: (typeof Overlay)[];
-    useFactory: typeof CUTE_MENU_SCROLL_STRATEGY_FACTORY;
-};
+/**
+ * Default top padding of the menu panel.
+ * @deprecated No longer being used. Will be removed.
+ * @breaking-change 15.0.0
+ */
+declare const MENU_PANEL_TOP_PADDING = 8;
 /** Directive applied to an element that should trigger a `cute-menu`. */
-declare class CuteMenuTrigger implements AfterContentInit, OnDestroy {
-    private _overlay;
-    private _element;
+declare abstract class CuteMenuTriggerBase implements OnDestroy {
+    private readonly _canHaveBackdrop;
+    protected _element: ElementRef<HTMLElement>;
     private _viewContainerRef;
-    private _menuItemInstance;
+    protected _menuItemInstance: CuteMenuItem;
     private _dir;
     private _focusMonitor;
-    private _ngZone?;
+    private _ngZone;
+    private _injector;
+    private _scrollStrategy;
+    private _changeDetectorRef;
+    private _animationsDisabled;
     private _portal;
-    private _overlayRef;
+    protected _overlayRef: OverlayRef | null;
     private _menuOpen;
     private _closingActionsSubscription;
-    private _hoverSubscription;
     private _menuCloseSubscription;
-    private readonly _scrollStrategy;
-    private _changeDetectorRef;
+    private _pendingRemoval;
     /**
      * We're specifically looking for a `CuteMenu` here since the generic `CuteMenuPanel`
      * interface lacks some functionality around nested menus and animations.
      */
-    private readonly _parentCuteMenu;
+    protected _parentCuteMenu: CuteMenu | undefined;
     /**
      * Cached value of the padding of the parent menu panel.
-     * Used to offset submenus to compensate for the padding.
+     * Used to offset sub-menus to compensate for the padding.
      */
     private _parentInnerPadding;
-    /**
-     * Handles touch start events on the trigger.
-     * Needs to be an arrow function, so we can easily use addEventListener and removeEventListener.
-     */
-    private _handleTouchStart;
-    _openedBy: Exclude<FocusOrigin, 'program' | null> | undefined;
-    /** References the menu instance that the trigger is associated with. */
-    get menu(): CuteMenuPanel | null;
-    set menu(menu: CuteMenuPanel | null);
-    private _menu;
-    /** Data to be passed along to any lazily rendered content. */
-    menuData: any;
-    /**
-     * Whether focus should be restored when the menu is closed.
-     * Note that disabling this option can have accessibility implications, and
-     * it's up to you to manage focus if you decide to turn it off.
-     */
-    restoreFocus: boolean;
+    protected _openedBy: Exclude<FocusOrigin, 'program' | null> | undefined;
+    /** Data that will be passed to the menu panel. */
+    abstract menuData: any;
+    /** Whether focus should be restored when the menu is closed. */
+    abstract restoreFocus: boolean;
+    /** Element reference that can be used in class compositions. */
+    get elementRef(): Readonly<ElementRef<HTMLElement>>;
+    /** Menu currently assigned to the trigger. */
+    protected get _menu(): CuteMenuPanel | null;
+    protected set _menu(menu: CuteMenuPanel | null);
+    private _menuInternal;
     /** Event emitted when the associated menu is opened. */
-    readonly menuOpened: EventEmitter<void>;
+    abstract menuOpened: EventEmitter<void>;
     /** Event emitted when the associated menu is closed. */
-    readonly menuClosed: EventEmitter<void>;
-    constructor(overlay: Overlay, element: ElementRef<HTMLElement>, viewContainerRef: ViewContainerRef, scrollStrategy: any, parentMenu: CuteMenuPanel, menuItemInstance: CuteMenuItem, dir: Directionality, focusMonitor: FocusMonitor, ngZone: NgZone);
-    /**
-     * @deprecated `focusMonitor` will become a required parameter.
-     * @breaking-change 8.0.0
-     */
-    constructor(overlay: Overlay, element: ElementRef<HTMLElement>, viewContainerRef: ViewContainerRef, scrollStrategy: any, parentMenu: CuteMenuPanel, menuItemInstance: CuteMenuItem, dir: Directionality, focusMonitor?: FocusMonitor | null);
-    /**
-     * @deprecated `ngZone` will become a required parameter.
-     * @breaking-change 15.0.0
-     */
-    constructor(overlay: Overlay, element: ElementRef<HTMLElement>, viewContainerRef: ViewContainerRef, scrollStrategy: any, parentMenu: CuteMenuPanel, menuItemInstance: CuteMenuItem, dir: Directionality, focusMonitor: FocusMonitor);
-    ngAfterContentInit(): void;
+    abstract menuClosed: EventEmitter<void>;
+    /** Gets the origin for the overlay. */
+    protected abstract _getOverlayOrigin(): FlexibleConnectedPositionStrategyOrigin;
+    protected abstract _getOutsideClickStream(overlayRef: OverlayRef): Observable<unknown>;
+    protected constructor(_canHaveBackdrop: boolean);
     ngOnDestroy(): void;
     /** Whether the menu is open. */
     get menuOpen(): boolean;
     /** The text direction of the containing app. */
     get dir(): Direction;
-    get elementRef(): Readonly<ElementRef<HTMLElement>>;
-    /** Whether the menu triggers a submenu or a top-level one. */
-    triggersSubmenu(): boolean;
-    /** Toggles the menu between the open and closed states. */
-    toggleMenu(): void;
-    /** Opens the menu. */
-    openMenu(): void;
-    /** Closes the menu. */
-    closeMenu(): void;
+    /** Whether the menu triggers a sub-menu or a top-level one. */
+    protected _triggersSubmenu(): boolean;
+    protected _closeMenu(): void;
+    /** Internal method to open menu providing option to auto focus on first item. */
+    protected _openMenu(autoFocus: boolean): void;
     /**
      * Focuses the menu trigger.
      * @param origin Source of the menu trigger's focus.
-     * @param options Focus options
+     * @param options Optional focus options.
      */
     focus(origin?: FocusOrigin, options?: FocusOptions): void;
-    /**
-     * Updates the position of the menu to ensure that it fits all options within the viewport.
-     */
-    updatePosition(): void;
     /** Closes the menu and does the necessary cleanup. */
-    private _destroyMenu;
-    /**
-     * This method sets the menu state to open and focuses the first item if
-     * the menu was opened via the keyboard.
-     */
-    private _initMenu;
+    protected _destroyMenu(reason: MenuCloseReason): void;
     /** Updates the menu elevation based on the amount of parent menus that it has. */
     private _setMenuElevation;
     private _setIsMenuOpen;
@@ -467,12 +424,83 @@ declare class CuteMenuTrigger implements AfterContentInit, OnDestroy {
     /**
      * Sets the appropriate positions on a position strategy
      * so the overlay connects with the trigger correctly.
-     * @param menu Menu panel
-     * @param positionStrategy Strategy whose position is to update.
+     * @param menu Menu panel.
+     * @param positionStrategy Strategy whose position to update.
      */
     private _setPosition;
     /** Returns a stream that emits whenever an action that should close the menu occurs. */
     private _menuClosingActions;
+    /** Gets the portal that should be attached to the overlay. */
+    private _getPortal;
+    /**
+     * Determines whether the trigger owns a specific menu panel, at the current point in time.
+     * This allows us to distinguish the case where the same panel is passed into multiple triggers
+     * and multiple are open at a time.
+     */
+    private _ownsMenu;
+    /**
+     * Detect if the trigger element is aria-disabled, indicating it should behave as
+     * disabled and not open the menu.
+     */
+    private _triggerIsAriaDisabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteMenuTriggerBase, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteMenuTriggerBase, never, never, {}, {}, never, never, true, never>;
+}
+
+/** Directive applied to an element that should trigger a `mat-menu`. */
+declare class CuteMenuTrigger extends CuteMenuTriggerBase implements AfterContentInit, OnDestroy {
+    private _cleanupTouchstart;
+    private _hoverSubscription;
+    /**
+     * @deprecated
+     * @breaking-change 8.0.0
+     */
+    get _deprecatedCuteMenuTriggerFor(): CuteMenuPanel | null;
+    set _deprecatedCuteMenuTriggerFor(v: CuteMenuPanel | null);
+    /** References the menu instance that the trigger is associated with. */
+    get menu(): CuteMenuPanel | null;
+    set menu(menu: CuteMenuPanel | null);
+    /** Data to be passed along to any lazily-rendered content. */
+    menuData: any;
+    /**
+     * Whether focus should be restored when the menu is closed.
+     * Note that disabling this option can have accessibility implications
+     * and it's up to you to manage focus, if you decide to turn it off.
+     */
+    restoreFocus: boolean;
+    /** Event emitted when the associated menu is opened. */
+    readonly menuOpened: EventEmitter<void>;
+    /**
+     * Event emitted when the associated menu is opened.
+     * @deprecated Switch to `menuOpened` instead
+     * @breaking-change 8.0.0
+     */
+    readonly onMenuOpen: EventEmitter<void>;
+    /** Event emitted when the associated menu is closed. */
+    readonly menuClosed: EventEmitter<void>;
+    /**
+     * Event emitted when the associated menu is closed.
+     * @deprecated Switch to `menuClosed` instead
+     * @breaking-change 8.0.0
+     */
+    readonly onMenuClose: EventEmitter<void>;
+    constructor(...args: unknown[]);
+    /** Whether the menu triggers a sub-menu or a top-level one. */
+    triggersSubmenu(): boolean;
+    /** Toggles the menu between the open and closed states. */
+    toggleMenu(): void;
+    /** Opens the menu. */
+    openMenu(): void;
+    /** Closes the menu. */
+    closeMenu(): void;
+    /**
+     * Updates the position of the menu to ensure that it fits all options within the viewport.
+     */
+    updatePosition(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    protected _getOverlayOrigin(): i0.ElementRef<HTMLElement>;
+    protected _getOutsideClickStream(overlayRef: OverlayRef): rxjs.Observable<MouseEvent>;
     /** Handles mouse presses on the trigger. */
     _handleMousedown(event: MouseEvent): void;
     /** Handles key presses on the trigger. */
@@ -481,17 +509,70 @@ declare class CuteMenuTrigger implements AfterContentInit, OnDestroy {
     _handleClick(event: MouseEvent): void;
     /** Handles the cases where the user hovers over the trigger. */
     private _handleHover;
-    /** Gets the portal that should be attached to the overlay. */
-    private _getPortal;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CuteMenuTrigger, [null, null, null, null, { optional: true; }, { optional: true; self: true; }, { optional: true; }, null, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteMenuTrigger, "[cuteMenuTriggerFor]", ["cuteMenuTrigger"], { "menu": { "alias": "cuteMenuTriggerFor"; "required": false; }; "menuData": { "alias": "cuteMenuTriggerData"; "required": false; }; "restoreFocus": { "alias": "cuteMenuTriggerRestoreFocus"; "required": false; }; }, { "menuOpened": "menuOpened"; "menuClosed": "menuClosed"; }, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteMenuTrigger, "[cute-menu-trigger-for], [cuteMenuTriggerFor]", ["cuteMenuTrigger"], { "_deprecatedCuteMenuTriggerFor": { "alias": "cute-menu-trigger-for"; "required": false; }; "menu": { "alias": "cuteMenuTriggerFor"; "required": false; }; "menuData": { "alias": "cuteMenuTriggerData"; "required": false; }; "restoreFocus": { "alias": "cuteMenuTriggerRestoreFocus"; "required": false; }; }, { "menuOpened": "menuOpened"; "onMenuOpen": "onMenuOpen"; "menuClosed": "menuClosed"; "onMenuClose": "onMenuClose"; }, never, never, true, never>;
+}
+
+/**
+ * Trigger that opens a menu whenever the user right-clicks within its host element.
+ */
+declare class CuteContextMenuTrigger extends CuteMenuTriggerBase implements OnDestroy {
+    private _point;
+    private _triggerPressedControl;
+    private _rootNode;
+    private _document;
+    private _viewportRuler;
+    private _scrollDispatcher;
+    private _scrollSubscription;
+    /** References the menu instance that the trigger is associated with. */
+    get menu(): CuteMenuPanel | null;
+    set menu(menu: CuteMenuPanel | null);
+    /** Data to be passed along to any lazily-rendered content. */
+    menuData: any;
+    /**
+     * Whether focus should be restored when the menu is closed.
+     * Note that disabling this option can have accessibility implications
+     * and it's up to you to manage focus, if you decide to turn it off.
+     */
+    restoreFocus: boolean;
+    /** Whether the context menu is disabled. */
+    disabled: boolean;
+    /** Event emitted when the associated menu is opened. */
+    readonly menuOpened: EventEmitter<void>;
+    /** Event emitted when the associated menu is closed. */
+    readonly menuClosed: EventEmitter<void>;
+    constructor();
+    ngOnDestroy(): void;
+    /** Handler for `contextmenu` events. */
+    protected _handleContextMenuEvent(event: MouseEvent): void;
+    protected _destroyMenu(reason: MenuCloseReason): void;
+    protected _getOverlayOrigin(): {
+        x: number;
+        y: number;
+        initialX: number;
+        initialY: number;
+        initialScrollX: number;
+        initialScrollY: number;
+    };
+    protected _getOutsideClickStream(overlayRef: OverlayRef): rxjs.Observable<MouseEvent>;
+    /** Checks whether an element is within the trigger or the opened overlay. */
+    private _isWithinMenuOrTrigger;
+    /** Opens the context menu. */
+    private _openContextMenu;
+    /** Initializes the point representing the origin relative to which the menu will be rendered. */
+    private _initializePoint;
+    /** Refreshes the position of the overlay. */
+    private _updatePosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuteContextMenuTrigger, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuteContextMenuTrigger, "[cuteContextMenuTriggerFor]", ["cuteContextMenuTrigger"], { "menu": { "alias": "cuteContextMenuTriggerFor"; "required": true; }; "menuData": { "alias": "cuteContextMenuTriggerData"; "required": false; }; "restoreFocus": { "alias": "cuteContextMenuTriggerRestoreFocus"; "required": false; }; "disabled": { "alias": "cuteContextMenuTriggerDisabled"; "required": false; }; }, { "menuOpened": "menuOpened"; "menuClosed": "menuClosed"; }, never, never, true, never>;
+    static ngAcceptInputType_disabled: unknown;
 }
 
 declare class CuteMenuModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<CuteMenuModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteMenuModule, never, [typeof i1$1.CommonModule, typeof i1$1.CommonModule, typeof CuteMenu, typeof CuteMenuItem, typeof CuteMenuContent, typeof CuteMenuTrigger], [typeof i1$1.CommonModule, typeof CuteMenu, typeof CuteMenuItem, typeof CuteMenuContent, typeof CuteMenuTrigger]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CuteMenuModule, never, [typeof i1$1.OverlayModule, typeof CuteMenu, typeof CuteMenuItem, typeof CuteMenuContent, typeof CuteMenuTrigger, typeof CuteContextMenuTrigger], [typeof i7.CdkScrollableModule, typeof CuteMenu, typeof CuteMenuItem, typeof CuteMenuContent, typeof CuteMenuTrigger, typeof CuteContextMenuTrigger]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CuteMenuModule>;
 }
 
-export { CUTE_MENU_CONTENT, CUTE_MENU_DEFAULT_OPTIONS, CUTE_MENU_DEFAULT_OPTIONS_FACTORY, CUTE_MENU_SCROLL_STRATEGY, CUTE_MENU_SCROLL_STRATEGY_FACTORY, CUTE_MENU_SCROLL_STRATEGY_FACTORY_PROVIDER, CuteMenu, CuteMenuContent, CuteMenuItem, CuteMenuModule, CuteMenuTrigger };
-export type { CuteMenuDefaultOptions, MenuCloseReason, MenuPositionX, MenuPositionY, MenuShadowElevation };
+export { CUTE_MENU_CONTENT, CUTE_MENU_DEFAULT_OPTIONS, CUTE_MENU_PANEL, CUTE_MENU_SCROLL_STRATEGY, CuteContextMenuTrigger, CuteMenu, CuteMenuContent, CuteMenuItem, CuteMenuModule, CuteMenuTrigger, MENU_PANEL_TOP_PADDING };
+export type { CuteMenuDefaultOptions, CuteMenuPanel, MenuCloseReason, MenuPositionX, MenuPositionY, MenuShadowElevation };

package/{progress/index.d.ts → types/cute-widgets-base-progress.d.ts}

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { EventEmitter, InjectionToken } from '@angular/core';
+import { InjectionToken, EventEmitter } from '@angular/core';
 import { CuteBaseControl } from '@cute-widgets/base/abstract';
 import { ThemeColor } from '@cute-widgets/base/core';
 import * as i1 from '@angular/common';

package/{radio/index.d.ts → types/cute-widgets-base-radio.d.ts}

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
-import { DoCheck, ElementRef, EventEmitter, InjectionToken, AfterContentInit, OnDestroy, QueryList } from '@angular/core';
+import { InjectionToken, DoCheck, ElementRef, EventEmitter, AfterContentInit, OnDestroy, QueryList } from '@angular/core';
 import { FocusOrigin } from '@angular/cdk/a11y';
-import { RelativeSize, ThemeColor } from '@cute-widgets/base/core';
+import { ThemeColor, RelativeSize } from '@cute-widgets/base/core';
 import { CuteInputControl } from '@cute-widgets/base/abstract';
 import { ControlValueAccessor } from '@angular/forms';
 import * as i1 from '@angular/common';

package/{sidenav/index.d.ts → types/cute-widgets-base-sidenav.d.ts}

@@ -3,7 +3,7 @@ import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
 import * as i2 from '@angular/cdk/scrolling';
 import { CdkScrollable } from '@angular/cdk/scrolling';
 import * as i0 from '@angular/core';
-import { InjectionToken, AfterContentInit, DoCheck, OnDestroy, QueryList, AfterViewInit, EventEmitter, ElementRef } from '@angular/core';
+import { InjectionToken, AfterViewInit, OnDestroy, AfterContentInit, DoCheck, QueryList, EventEmitter, ElementRef } from '@angular/core';
 import { Subject, Observable } from 'rxjs';
 import { CuteLayoutControl, Expandable } from '@cute-widgets/base/abstract';
 import * as i1 from '@angular/common';

package/{snack-bar/index.d.ts → types/cute-widgets-base-snack-bar.d.ts}

@@ -1,7 +1,7 @@
 import { OverlayRef, ComponentType } from '@angular/cdk/overlay';
 import { Subject, Observable } from 'rxjs';
 import * as i0 from '@angular/core';
-import { ViewContainerRef, InjectionToken, OnDestroy, ElementRef, WritableSignal, ComponentRef, EmbeddedViewRef, TemplateRef } from '@angular/core';
+import { InjectionToken, ViewContainerRef, OnDestroy, ElementRef, WritableSignal, ComponentRef, EmbeddedViewRef, TemplateRef } from '@angular/core';
 import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal, DomPortal } from '@angular/cdk/portal';
 import { AriaLivePoliteness } from '@angular/cdk/a11y';
 import { Direction } from '@angular/cdk/bidi';

package/{sort/index.d.ts → types/cute-widgets-base-sort.d.ts}

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { OnChanges, OnDestroy, OnInit, EventEmitter, SimpleChanges, InjectionToken, Optional, AfterViewInit } from '@angular/core';
+import { InjectionToken, OnChanges, OnDestroy, OnInit, EventEmitter, SimpleChanges, Optional, AfterViewInit } from '@angular/core';
 import { Subject, Observable } from 'rxjs';
 import * as i1 from '@angular/common';
 

package/{table/index.d.ts → types/cute-widgets-base-table.d.ts}

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, OnInit } from '@angular/core';
 import * as i2 from '@angular/cdk/table';
-import { CdkTable, CdkCellDef, CdkHeaderCellDef, CdkFooterCellDef, CdkColumnDef, CdkHeaderCell, CdkFooterCell, CdkCell, CdkHeaderRowDef, CdkFooterRowDef, CdkRowDef, CdkHeaderRow, CdkFooterRow, CdkRow, CdkNoDataRow, CdkTextColumn } from '@angular/cdk/table';
+import { CdkTable, CdkCell, CdkCellDef, CdkColumnDef, CdkFooterCell, CdkFooterCellDef, CdkHeaderCell, CdkHeaderCellDef, CdkFooterRow, CdkFooterRowDef, CdkHeaderRow, CdkHeaderRowDef, CdkNoDataRow, CdkRow, CdkRowDef, CdkTextColumn } from '@angular/cdk/table';
 import { ThemeColor } from '@cute-widgets/base/core';
 import { BehaviorSubject } from 'rxjs';
 import { DataSource } from '@angular/cdk/collections';

package/{tree/index.d.ts → types/cute-widgets-base-tree.d.ts}

@@ -1,7 +1,7 @@
 import * as i1 from '@angular/cdk/tree';
-import { CdkTreeNode, CdkTreeNodeDef, CdkNestedTreeNode, CdkTreeNodePadding, CdkTreeNodeOutlet, CdkTree, CdkTreeNodeToggle, TreeControl, FlatTreeControl } from '@angular/cdk/tree';
+import { CdkNestedTreeNode, CdkTreeNodeDef, CdkTreeNode, CdkTreeNodePadding, CdkTreeNodeOutlet, CdkTree, CdkTreeNodeToggle, FlatTreeControl, TreeControl } from '@angular/cdk/tree';
 import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, AfterContentInit, ViewContainerRef, EventEmitter } from '@angular/core';
+import { AfterContentInit, OnDestroy, OnInit, ViewContainerRef, EventEmitter } from '@angular/core';
 import { DataSource, CollectionViewer } from '@angular/cdk/collections';
 import { Observable } from 'rxjs';