@malva-ui/core 0.1.12

package/menu/lib/menu/menu.d.ts

@@ -0,0 +1,149 @@
+import { ElementRef } from '@angular/core';
+import type { WritableSignal } from '@angular/core';
+import { MlvPopup } from '@malva-ui/core/popup';
+import type { MlvDensity } from '@malva-ui/cdk/density';
+import { MlvMenuItem } from './menu-item';
+import type { MlvMenuAccessor } from './menu.types';
+import type { MlvMenubarMenuController } from './menubar.types';
+import * as i0 from "@angular/core";
+/**
+ * Dropdown menu panel (`mlv-menu`).
+ *
+ * Renders a `role="menu"` panel containing `mlv-menu-item`, `mlv-menu-separator`,
+ * and `mlv-menu-group` children. Manages keyboard navigation (ArrowUp, ArrowDown,
+ * Home, End, Escape) via `FocusKeyManager`.
+ *
+ * The menu uses `mlv-popup` for visual chrome (background, border, radius, shadow,
+ * animations). The panel is rendered inside the popup's content template via
+ * `[mlvPopupContent]`, so no DOM manipulation is required.
+ *
+ * @example
+ * ```html
+ * <button [mlvMenuTrigger]="myMenu">Open</button>
+ * <mlv-menu #myMenu>
+ *   <mlv-menu-item (itemClick)="onEdit()">Edit</mlv-menu-item>
+ *   <mlv-menu-separator />
+ *   <mlv-menu-item (itemClick)="onDelete()">Delete</mlv-menu-item>
+ * </mlv-menu>
+ * ```
+ */
+export declare class MlvMenu implements MlvMenuAccessor {
+    /**
+     * @private Element reference for the host element.
+     */
+    readonly _elementRef: ElementRef<any>;
+    /**
+     * @private The popup component managing the overlay chrome (background, border, shadow, animations).
+     * Accessed by `MlvMenuTrigger` to open the overlay and manage animation state.
+     * The menu panel (`mlv-list`) is declared inside this popup's `[mlvPopupContent]` template.
+     */
+    readonly _popup: import("@angular/core").Signal<MlvPopup>;
+    /**
+     * @protected All `mlv-list-item[mlvMenuItem]` children (including those nested in groups).
+     * Used by `FocusKeyManager` for keyboard navigation.
+     */
+    protected readonly _items: import("@angular/core").Signal<readonly MlvMenuItem[]>;
+    /**
+     * Accessible label for the menu panel (`aria-label`).
+     * Use when there is no visible heading that labels the menu.
+     */
+    readonly label: import("@angular/core").InputSignal<string>;
+    /**
+     * Density applied to the menu panel's item rows.
+     *
+     * The panel is portaled to the CDK overlay container, outside the trigger's
+     * DOM tree, so ancestor density classes cannot cascade into it. Forwarded to
+     * the underlying `mlv-popup`, which stamps the resolved `mlv--{density}`
+     * class on the detached panel. When omitted, the global `MlvDensityService`
+     * density applies. Submenus are separate `mlv-menu` instances — set the
+     * input on each when overriding the density of a nested menu tree.
+     */
+    readonly mlvDensity: import("@angular/core").InputSignal<MlvDensity | undefined>;
+    /**
+     * Stable DOM id of the menu panel (`role="menu"` list). Consumed by
+     * `MlvMenuTrigger` to wire `aria-controls` from the trigger to the panel.
+     */
+    readonly panelId: string;
+    /**
+     * Emits when the menu requests to be closed (e.g., Escape key, Tab key,
+     * or after a menu item is activated).
+     */
+    readonly closed: import("@angular/core").OutputEmitterRef<void>;
+    /**
+     * @private Whether the panel is currently open. Set by `MlvMenuTrigger`.
+     */
+    readonly _isOpen: WritableSignal<boolean>;
+    /**
+     * @private Parent menu that opened this menu as a submenu.
+     */
+    private _parentMenu;
+    /**
+     * @private Controller supplied by the opening `MlvMenuTrigger` when this
+     * menu is a top-level menubar dropdown. Enables ArrowRight / ArrowLeft at the
+     * top level of the panel to cross to the adjacent menubar menu. `null` for
+     * standalone menus and submenus.
+     */
+    private _menubarController;
+    /**
+     * @private `FocusKeyManager` managing the menu items.
+     * Initialized lazily when items are first available.
+     */
+    private _keyManager;
+    /**
+     * @private Subscription to the key manager's `change` stream, used to keep the
+     * roving tabindex in sync when type-ahead moves the active item asynchronously.
+     */
+    private _changeSub;
+    constructor();
+    /**
+     * Focuses the first non-disabled item in the menu.
+     * Called by `MlvMenuTrigger` when the menu opens via keyboard ArrowDown or Enter.
+     */
+    focusFirstItem(): void;
+    /**
+     * Focuses the last non-disabled item in the menu.
+     * Called by `MlvMenuTrigger` when the menu opens via keyboard ArrowUp.
+     */
+    focusLastItem(): void;
+    /**
+     * Closes the menu panel by emitting the `closed` output.
+     * Called by `MlvMenuItem` after item activation and by the keyboard handler.
+     */
+    close(): void;
+    /**
+     * Closes this menu panel and any ancestor menu panels.
+     * Called by submenu items so selecting a nested action dismisses the full menu stack.
+     */
+    closeAll(): void;
+    /**
+     * Registers the parent menu that owns this menu when it is opened as a submenu.
+     * Called by `MlvMenuTrigger` while opening submenu overlays.
+     */
+    registerParentMenu(parentMenu: MlvMenuAccessor | null): void;
+    /**
+     * Registers (or clears) the menubar controller when this menu is opened as a
+     * top-level menubar dropdown. Called by `MlvMenuTrigger` while opening.
+     */
+    registerMenubarController(controller: MlvMenubarMenuController | null): void;
+    /**
+     * @protected Routes keydown events to `FocusKeyManager` and handles Escape / Tab.
+     */
+    protected _onKeydown(event: KeyboardEvent): void;
+    /**
+     * @private Creates or replaces the `FocusKeyManager` with the current items.
+     * Skips items whose `disabled` property is `true`.
+     *
+     * `withTypeAhead()` enables type-to-focus (press a letter to jump to the
+     * first matching item by its `getLabel()`). Type-ahead matching is debounced
+     * and can move the active item outside of `_onKeydown`, so the manager's
+     * `change` stream is used to keep the roving tabindex in sync.
+     */
+    private _initKeyManager;
+    /**
+     * @private Updates `_tabIndex` on every item so that only the active item
+     * has `tabindex="0"` (roving tabindex pattern). All other items have `-1`.
+     */
+    private _syncTabIndices;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvMenu, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvMenu, "mlv-menu", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "mlvDensity": { "alias": "mlvDensity"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, ["_items"], ["*"], true, never>;
+}

package/menu/lib/menu/menu.types.d.ts

@@ -0,0 +1,13 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Interface that a menu exposes to its child `MenuItemComponent` instances.
+ * Used via the `MENU_TOKEN` injection token for decoupled parent–child communication.
+ */
+export interface MlvMenuAccessor {
+    /** Closes this menu panel. */
+    close(): void;
+    /** Closes this menu panel and any ancestor menu panels. */
+    closeAll(): void;
+}
+/** Injection token for the parent menu. */
+export declare const MENU_TOKEN: InjectionToken<MlvMenuAccessor>;

package/menu/lib/menu/menubar.d.ts

@@ -0,0 +1,131 @@
+import { MlvMenuTrigger } from './menu-trigger';
+import type { MlvMenubarAccessor, MlvMenubarItem } from './menubar.types';
+import * as i0 from "@angular/core";
+/**
+ * Horizontal application menu bar (`mlv-menubar`) — a File / Edit / View style
+ * row of top-level menu triggers, implementing the
+ * [WAI-ARIA Menubar pattern](https://www.w3.org/WAI/ARIA/apg/patterns/menubar/).
+ *
+ * Wrap a set of `[mlvMenuTrigger]` elements. Each trigger opens a standard
+ * `mlv-menu` dropdown; the bar coordinates them:
+ *
+ * - `role="menubar"` container with a **roving tabindex** across the top-level
+ *   items (only the active item is in the tab order).
+ * - `ArrowLeft` / `ArrowRight` move between top-level items (wrapping); `Home` /
+ *   `End` jump to the first / last; printable characters type-ahead by label.
+ * - `ArrowDown` / `Enter` / `Space` open the focused item's menu with focus on
+ *   its first item; `ArrowUp` opens with focus on the last item (handled by the
+ *   trigger).
+ * - While any dropdown is open, hovering or arrowing to another top-level item
+ *   closes the current menu and opens the sibling (hover-follow only-while-open).
+ * - `ArrowRight` / `ArrowLeft` at the top level of an open dropdown cross to the
+ *   adjacent menubar menu; a focused submenu trigger's own `ArrowRight` wins.
+ * - `Escape` closes the menu and restores focus to its top-level item.
+ *
+ * Declare the `mlv-menu` panels **as siblings of the menubar** (outside its
+ * content), so the bar's `contentChildren` query only picks up the top-level
+ * triggers — see the example below.
+ *
+ * @example
+ * ```html
+ * <mlv-menubar aria-label="Main">
+ *   <button mlvButton variant="transparent" [mlvMenuTrigger]="fileMenu">File</button>
+ *   <button mlvButton variant="transparent" [mlvMenuTrigger]="editMenu">Edit</button>
+ * </mlv-menubar>
+ *
+ * <mlv-menu #fileMenu label="File">
+ *   <mlv-list-item mlvMenuItem (itemClick)="onNew()">New</mlv-list-item>
+ * </mlv-menu>
+ * <mlv-menu #editMenu label="Edit">
+ *   <mlv-list-item mlvMenuItem (itemClick)="onUndo()">Undo</mlv-list-item>
+ * </mlv-menu>
+ * ```
+ */
+export declare class MlvMenubar implements MlvMenubarAccessor {
+    /** @private Host element reference. */
+    private readonly _elementRef;
+    /**
+     * @private The `aria-label` the consumer placed directly on the `<mlv-menubar>`
+     * element, captured before the host binding runs. Used as the accessible-name
+     * fallback so a natively-provided `aria-label` is preserved when the `label`
+     * input is not used — without it the `[attr.aria-label]` host binding would
+     * clobber the consumer's attribute with `null`.
+     */
+    protected readonly _initialAriaLabel: string | null;
+    /**
+     * @protected The top-level `[mlvMenuTrigger]` children, in DOM order. Only
+     * direct descendants of the menubar are found — the `mlv-menu` dropdown
+     * panels are declared as siblings, so their items and submenu triggers are
+     * never picked up here.
+     */
+    protected readonly _items: import("@angular/core").Signal<readonly MlvMenuTrigger[]>;
+    /**
+     * Accessible label for the menubar (`aria-label`). Use when there is no
+     * visible heading that labels the bar.
+     */
+    readonly label: import("@angular/core").InputSignal<string>;
+    /**
+     * @private `FocusKeyManager` managing the roving tabindex and horizontal
+     * arrow / Home / End / type-ahead navigation across top-level items.
+     */
+    private _keyManager;
+    /**
+     * @private Subscription to the key manager's `change` stream, keeping the
+     * roving tabindex in sync when type-ahead moves the active item.
+     */
+    private _changeSub;
+    /**
+     * @private The top-level item whose dropdown is currently open, or `null`
+     * when the whole bar is closed.
+     */
+    private _openItem;
+    constructor();
+    /** Host element of the menubar (used as a click-outside exclusion). */
+    get hostElement(): HTMLElement;
+    /**
+     * Records `item` as the open dropdown, closing any previously-open sibling
+     * and syncing the roving tabindex so the bar's active item follows the open
+     * menu. Called by a child trigger from its open path.
+     */
+    notifyItemOpened(item: MlvMenubarItem): void;
+    /** Clears the open-item record when `item`'s dropdown closes. */
+    notifyItemClosed(item: MlvMenubarItem): void;
+    /** Whether any dropdown in the bar is currently open. */
+    hasOpenMenu(): boolean;
+    /**
+     * Hover-follow: while a dropdown is already open, opening the hovered item's
+     * dropdown (which, via `notifyItemOpened`, closes the previous one). Does
+     * nothing when the bar is fully closed or the item is disabled/already open.
+     */
+    onItemPointerEnter(item: MlvMenubarItem): void;
+    /**
+     * Crosses from the open dropdown to an adjacent top-level item's menu,
+     * wrapping over disabled items, and opens it with focus on its first item.
+     */
+    openAdjacentItemMenu(from: MlvMenubarItem, dir: 1 | -1): void;
+    /**
+     * @protected Menubar-level keyboard handler.
+     *
+     * Opening keys (`Enter`, `Space`, `ArrowDown`, `ArrowUp`) are handled by the
+     * focused trigger itself, so they are ignored here. Everything else is routed
+     * to `FocusKeyManager` for horizontal navigation, Home/End, and type-ahead.
+     * If a dropdown is open when the active item changes, the newly-focused item's
+     * menu is opened (open-follow).
+     */
+    protected _onKeydown(event: KeyboardEvent): void;
+    /**
+     * @private Creates or replaces the `FocusKeyManager` with the current items,
+     * using horizontal orientation, wrap, Home/End and type-ahead, skipping
+     * disabled items. Sets the first item active so the bar has a tabbable entry.
+     */
+    private _initKeyManager;
+    /**
+     * @private Updates `_tabIndex` on every item so that only the active item has
+     * `tabindex="0"` (roving tabindex). All others get `-1`.
+     */
+    private _syncTabIndices;
+    /** @private The non-disabled top-level items, in DOM order. */
+    private _navigableItems;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvMenubar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvMenubar, "mlv-menubar", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, ["_items"], ["*"], true, never>;
+}

package/menu/lib/menu/menubar.types.d.ts

@@ -0,0 +1,82 @@
+import { InjectionToken } from '@angular/core';
+import type { WritableSignal } from '@angular/core';
+import type { FocusableOption } from '@angular/cdk/a11y';
+/**
+ * The subset of the `MlvMenuTrigger` API a `mlv-menubar` needs to
+ * coordinate its top-level items (roving tabindex, arrow navigation, and the
+ * "open-follow" behaviour where moving to a sibling while a menu is open opens
+ * that sibling's menu).
+ *
+ * `MlvMenuTrigger` implements this shape at runtime when it is a direct
+ * child of a `mlv-menubar` (i.e. it can inject {@link MENUBAR_TOKEN}).
+ */
+export interface MlvMenubarItem extends FocusableOption {
+    /** Whether this top-level item is disabled — used by the bar's `skipPredicate`. */
+    readonly disabledBoolean: boolean;
+    /**
+     * Roving tabindex signal for this item — `0` for the currently active item,
+     * `-1` for every other item. Written by the parent `mlv-menubar`.
+     */
+    readonly _tabIndex: WritableSignal<number>;
+    /** Whether this item's dropdown menu is currently open. */
+    isMenuOpen(): boolean;
+    /** Opens this item's dropdown without moving focus into the panel. */
+    openMenu(): void;
+    /** Closes this item's dropdown. */
+    closeMenu(): void;
+    /** Opens this item's dropdown and moves focus to the first menu item. */
+    openMenuWithFirstItemFocused(): void;
+    /** Opens this item's dropdown and moves focus to the last menu item. */
+    openMenuWithLastItemFocused(): void;
+    /** Returns the item's visible text label, used for menubar type-ahead. */
+    getLabel(): string;
+}
+/**
+ * Accessor a `mlv-menubar` exposes to its child triggers via {@link MENUBAR_TOKEN}.
+ * Child triggers use it to report open/close state and to request sibling-menu
+ * navigation, without importing the concrete `MlvMenubar`.
+ */
+export interface MlvMenubarAccessor {
+    /**
+     * Host element of the menubar. Passed to `MlvPopupService` as a click-outside
+     * exclusion so that clicking a sibling top-level item switches menus instead
+     * of dismissing the open dropdown.
+     */
+    readonly hostElement: HTMLElement;
+    /**
+     * Called by a child when its dropdown opens. The bar records the open item,
+     * closes any previously-open sibling, and syncs the roving tabindex.
+     */
+    notifyItemOpened(item: MlvMenubarItem): void;
+    /** Called by a child when its dropdown closes. */
+    notifyItemClosed(item: MlvMenubarItem): void;
+    /**
+     * Called on `mouseenter` of a child. Opens the hovered item's dropdown **only
+     * while another dropdown in the bar is already open** (hover-follow); does
+     * nothing when the bar is fully closed.
+     */
+    onItemPointerEnter(item: MlvMenubarItem): void;
+    /** Whether any dropdown in the bar is currently open. */
+    hasOpenMenu(): boolean;
+    /**
+     * Moves to the item adjacent to `from` (wrapping over disabled items) and
+     * opens its dropdown with focus on the first item. Called from within an open
+     * dropdown on ArrowRight (`dir = 1`) or ArrowLeft (`dir = -1`) to cross to a
+     * sibling menubar menu.
+     */
+    openAdjacentItemMenu(from: MlvMenubarItem, dir: 1 | -1): void;
+}
+/**
+ * Controller a menubar dropdown uses to cross to a sibling menubar menu when
+ * ArrowRight / ArrowLeft is pressed at the top level of the open dropdown.
+ * Registered on the `MlvMenu` by the opening `MlvMenuTrigger` when
+ * (and only when) that trigger is a menubar child.
+ */
+export interface MlvMenubarMenuController {
+    /** Cross to the next menubar item's menu (in-menu ArrowRight). */
+    openNextItemMenu(): void;
+    /** Cross to the previous menubar item's menu (in-menu ArrowLeft). */
+    openPreviousItemMenu(): void;
+}
+/** Injection token for the parent `mlv-menubar`. */
+export declare const MENUBAR_TOKEN: InjectionToken<MlvMenubarAccessor>;

package/menu/lib/menu/submenu-aim.d.ts

@@ -0,0 +1,10 @@
+/** Cursor history used by the submenu safe-triangle algorithm. */
+export interface MlvSubmenuAimState {
+    lastX: number;
+    lastY: number;
+    submenuRect: DOMRect;
+    side: 'right' | 'left';
+    cursorEnteredSubmenu: boolean;
+}
+/** Returns whether the current pointer trajectory is heading into a submenu. */
+export declare function isCursorHeadingToSubmenu(currentX: number, currentY: number, state: MlvSubmenuAimState): boolean;

package/menu/malva-ui-core-menu.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/menu" />
+export * from './index';

package/notification/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/notification.types';
+export * from './lib/notification-ref';
+export * from './lib/notification-item/notification-item';
+export * from './lib/notification.service';

package/notification/lib/notification-item/notification-item.d.ts

@@ -0,0 +1,20 @@
+import type { OnDestroy, OnInit } from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { LucideInfo, LucideCircleCheck, LucideCircleAlert, LucideTriangleAlert } from '@lucide/angular';
+import { MlvAbstractToastItem } from '@malva-ui/core/toast';
+import type { MlvInternalNotification, MlvNotificationAction } from '../notification.types';
+import * as i0 from "@angular/core";
+export declare class MlvNotificationItem extends MlvAbstractToastItem<MlvInternalNotification> implements OnInit, OnDestroy {
+    /** @protected The component's i18n strings signal. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvNotificationI18n>;
+    /** @protected Lucide icon class selected from the notification tone. */
+    protected readonly toneIcon: import("@angular/core").Signal<typeof LucideCircleCheck | typeof LucideCircleAlert | typeof LucideTriangleAlert | typeof LucideInfo>;
+    /** @protected Template branch of dynamic content, when supplied. */
+    protected readonly _templateContent: import("@angular/core").Signal<TemplateRef<import("@malva-ui/core/notification").MlvNotificationTemplateContext<unknown>> | null>;
+    /** @protected Component branch of dynamic content, when supplied. */
+    protected readonly _componentContent: import("@angular/core").Signal<import("@angular/core").Type<unknown> | null>;
+    /** @protected Invokes an action's callback and then dismisses the notification. */
+    protected onActionClick(action: MlvNotificationAction): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvNotificationItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvNotificationItem, "mlv-notification-item", never, {}, {}, never, never, true, never>;
+}

package/notification/lib/notification-ref.d.ts

@@ -0,0 +1,12 @@
+import { MlvToastRef } from '@malva-ui/core/toast';
+/**
+ * Handle returned by `MlvNotificationService.show()` and
+ * `MlvNotificationService.open()`.
+ *
+ * Component content can inject this class and template content receives it in
+ * its context.
+ *
+ * @typeParam D - Type of the data supplied for this notification.
+ */
+export declare class MlvNotificationRef<D = unknown> extends MlvToastRef<D> {
+}

package/notification/lib/notification.service.d.ts

@@ -0,0 +1,43 @@
+import type { MlvIAbstractToastComponent, MlvToastPoliteness, MlvToastPosition } from '@malva-ui/core/toast';
+import { MlvAbstractToastService, MlvToastContainer } from '@malva-ui/core/toast';
+import type { MlvInternalNotification, MlvNotificationContent, MlvNotificationConfig, MlvNotificationOpenConfig, MlvNotificationTone } from './notification.types';
+import { MlvNotificationItem } from './notification-item/notification-item';
+import { MlvNotificationRef } from './notification-ref';
+import * as i0 from "@angular/core";
+type NotificationConfigWithoutTitleAndTone = Omit<MlvNotificationConfig, 'title' | 'tone'>;
+export declare class MlvNotificationService extends MlvAbstractToastService<MlvNotificationConfig, MlvInternalNotification, MlvIAbstractToastComponent<MlvInternalNotification>, MlvNotificationRef> {
+    /** @protected Overlay container component reused from `@malva-ui/core/toast`. */
+    protected readonly containerType: typeof MlvToastContainer;
+    /** @protected Concrete item component the container renders for each notification. */
+    protected readonly toastItemType: typeof MlvNotificationItem;
+    /**
+     * @protected Announces the title, description, and the labels of any action
+     * buttons — a keyboard or screen-reader user needs to know an action exists,
+     * since notifications never steal focus. Returns `null` for template and
+     * component content, whose rendered text the service cannot read.
+     */
+    protected resolveAnnouncement(config: MlvNotificationConfig): {
+        message: string;
+        politeness: MlvToastPoliteness;
+    } | null;
+    /** @protected Builds a fully-resolved internal notification from user config, applying defaults. */
+    protected buildItem(id: string, config: MlvNotificationConfig, ref: MlvNotificationRef): MlvInternalNotification;
+    /**
+     * Opens escaped string, template, or component content as a notification.
+     *
+     * Template content receives `MlvNotificationTemplateContext`; component content
+     * can inject `MlvNotificationRef`, `NOTIFICATION_DATA`, and
+     * `NOTIFICATION_CONFIG`.
+     */
+    open<D = unknown>(content: MlvNotificationContent<D>, config?: MlvNotificationOpenConfig<D>): MlvNotificationRef<D>;
+    /** @protected Creates a data-aware reference for each notification. */
+    protected _createRef(id: string, position: MlvToastPosition, config: MlvNotificationConfig): MlvNotificationRef;
+    success(title: string, config?: NotificationConfigWithoutTitleAndTone): MlvNotificationRef;
+    error(title: string, config?: NotificationConfigWithoutTitleAndTone): MlvNotificationRef;
+    warning(title: string, config?: NotificationConfigWithoutTitleAndTone): MlvNotificationRef;
+    info(title: string, config?: NotificationConfigWithoutTitleAndTone): MlvNotificationRef;
+    tone(v: MlvNotificationTone, title: string, config?: NotificationConfigWithoutTitleAndTone): MlvNotificationRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvNotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MlvNotificationService>;
+}
+export {};

package/notification/lib/notification.types.d.ts

@@ -0,0 +1,52 @@
+import type { MlvBaseToastConfig, MlvInternalBaseToast } from '@malva-ui/core/toast';
+import type { Injector, TemplateRef, Type } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import type { MlvTone } from '@malva-ui/cdk/utils';
+import type { MlvNotificationRef } from './notification-ref';
+export type MlvNotificationTone = MlvTone | 'default';
+export interface MlvNotificationAction {
+    label: string;
+    action: () => void;
+    variant?: 'primary' | 'secondary';
+}
+export interface MlvNotificationConfig<D = unknown> extends MlvBaseToastConfig<D> {
+    title: string;
+    description?: string;
+    tone?: MlvNotificationTone;
+    actions?: MlvNotificationAction[];
+    /** Override the auto-selected icon. Pass null to hide the icon. */
+    showIcon?: boolean;
+}
+/** Options for `MlvNotificationService.open()` where content is supplied separately. */
+export interface MlvNotificationOpenConfig<D = unknown> extends MlvBaseToastConfig<D> {
+    description?: string;
+    tone?: MlvNotificationTone;
+    actions?: MlvNotificationAction[];
+    showIcon?: boolean;
+}
+/** Context exposed when `MlvNotificationService.open()` receives a `TemplateRef`. */
+export interface MlvNotificationTemplateContext<D = unknown> {
+    $implicit: MlvNotificationRef<D>;
+    ref: MlvNotificationRef<D>;
+    data: D;
+    config: Readonly<MlvNotificationOpenConfig<D>>;
+}
+/** Content accepted by `MlvNotificationService.open()`. Strings are rendered as escaped text. */
+export type MlvNotificationContent<D = unknown> = string | TemplateRef<MlvNotificationTemplateContext<D>> | Type<unknown>;
+/** Data available to component content opened through `MlvNotificationService.open()`. */
+export declare const NOTIFICATION_DATA: InjectionToken<unknown>;
+/** Configuration available to component content opened through `MlvNotificationService.open()`. */
+export declare const NOTIFICATION_CONFIG: InjectionToken<Readonly<MlvNotificationOpenConfig<unknown>>>;
+export interface MlvInternalNotification extends MlvInternalBaseToast {
+    title: string;
+    description: string;
+    tone: MlvNotificationTone;
+    actions: MlvNotificationAction[];
+    showIcon: boolean;
+    /** Dynamic template/component content; strings use the existing title rendering path. */
+    content?: Exclude<MlvNotificationContent, string>;
+    /** Context supplied to dynamic template content. */
+    contentContext?: MlvNotificationTemplateContext;
+    /** Per-item injector supplied to dynamic template/component content. */
+    contentInjector?: Injector;
+}

package/notification/malva-ui-core-notification.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@malva-ui/core/notification" />
+export * from './index';

package/number-input/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/number-input/number-input';