@malva-ui/core 0.1.12

package/sidebar/lib/sidebar-group/sidebar-group.d.ts

@@ -0,0 +1,127 @@
+import type { ElementRef, TemplateRef } from '@angular/core';
+import type { BooleanInput } from '@angular/cdk/coercion';
+import { MlvPopup, MlvPopupContainer } from '@malva-ui/core/popup';
+import { type MlvBadgeTone } from '@malva-ui/core/badge';
+import { MlvSidebarItemIcon } from '../sidebar-item-icon';
+import { MlvSidebarItem } from '../sidebar-item/sidebar-item';
+import * as i0 from "@angular/core";
+export declare class MlvSidebarGroup {
+    /** @private Parent sidebar context (skipSelf) used to read collapsed/mode state and proxy toggles. */
+    private readonly _parentCtx;
+    /** @private Document handle used to resolve the overlay-rendered flyout panel by id. */
+    private readonly _document;
+    /** @protected Stable id linking the collapsed-mode flyout panel so its focusable items can be resolved. */
+    protected readonly _flyoutId: string;
+    /** Required label for the group header and flyout title. */
+    readonly label: import("@angular/core").InputSignal<string>;
+    /**
+     * Optional badge/count for the group. Rendered as a trailing `mlv-badge` in
+     * the expanded accordion header and next to the flyout title, and as a
+     * `mlv-status-indicator` dot (top-right of the icon button) when the sidebar
+     * is collapsed. `null`/`''` renders nothing.
+     */
+    readonly badge: import("@angular/core").InputSignal<string | number | null>;
+    /** Semantic tone applied to the group badge and the collapsed status dot. */
+    readonly badgeTone: import("@angular/core").InputSignal<MlvBadgeTone>;
+    /** When true, the collapsed-mode status dot pulses to draw attention. */
+    readonly badgePulse: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @private Sidebar i18n slice (used to phrase the badge count in the aria-label). */
+    private readonly _i18n;
+    /** @private ICU resolver for the pluralised notification count. */
+    private readonly _resolver;
+    /** @protected True when a non-empty badge value is set. */
+    protected readonly _hasBadge: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Collapsed icon-button `aria-label`: the group `label()` with the
+     * badge count folded in (e.g. `"Projects, 3 notifications"`), since the
+     * collapsed dot is decorative and carries no text.
+     */
+    protected readonly _resolvedAriaLabel: import("@angular/core").Signal<string>;
+    /** @protected Projected group icon template, rendered in the header and flyout. */
+    protected readonly iconRef: import("@angular/core").Signal<MlvSidebarItemIcon | undefined>;
+    /** @protected Projected sidebar items, used to derive the active-child highlight. */
+    protected readonly _childItems: import("@angular/core").Signal<readonly MlvSidebarItem[]>;
+    /** @protected Template of the group's child items, rendered in the accordion and flyout. */
+    protected readonly childrenTpl: import("@angular/core").Signal<TemplateRef<unknown>>;
+    /** @protected Icon trigger button element, used as the flyout/tooltip anchor and focus target. */
+    protected readonly _triggerBtn: import("@angular/core").Signal<ElementRef<HTMLButtonElement> | undefined>;
+    /** @protected Reference to the flyout popup container (collapsed mode). */
+    protected readonly _flyoutContainer: import("@angular/core").Signal<MlvPopupContainer | undefined>;
+    /** @protected Reference to the flyout popup component for state reading. */
+    protected readonly _flyoutPopup: import("@angular/core").Signal<MlvPopup | undefined>;
+    /** @protected Tooltip popup shown on hover in collapsed mode. */
+    protected readonly _tooltipContainer: import("@angular/core").Signal<MlvPopupContainer | undefined>;
+    /** Whether the accordion is expanded (expanded sidebar mode). */
+    readonly expanded: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * Whether the flyout popup is currently open.
+     * Derived from the popup component's `opened` signal.
+     */
+    readonly flyoutOpen: import("@angular/core").Signal<boolean>;
+    /** True when the parent sidebar is in collapsed (icon-only) mode. */
+    readonly isSidebarCollapsed: import("@angular/core").Signal<boolean>;
+    /** True when at least one child item is active — drives active highlight on the group. */
+    readonly hasActiveChild: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Effective open state of the accordion panel.
+     *
+     * `expanded` is public and writable, so a host that auto-expands the group
+     * owning the active route can set it while the sidebar is collapsed. The
+     * accordion stays mounted in that state (its header fades but keeps the icon
+     * column in place), so honouring the write would open an empty panel inside
+     * the icon rail — a ghost tree line and reserved height — and, because
+     * `#childrenRef` can only be projected once, it would also pull the children
+     * out of the open flyout and leave it showing just its header. Gating on the
+     * collapsed state here makes that unreachable regardless of write order; the
+     * constructor effect still resets `expanded` when collapse begins.
+     */
+    protected readonly _accordionOpen: import("@angular/core").Signal<boolean>;
+    constructor();
+    /**
+     * @private Phrases a badge value for the accessible name. A pure numeric
+     * value is pluralised via the `notifications` ICU key (e.g. `"3
+     * notifications"`); any other value is announced verbatim (e.g. `"New"`).
+     */
+    private _announceBadge;
+    /** Toggles the accordion open/closed state. */
+    toggle(): void;
+    /** @protected Roving keyboard navigation (Arrow/Home/End/Escape) within the open flyout panel. */
+    protected onFlyoutKeydown(event: Event): void;
+    /**
+     * @protected Handles Enter/Space (toggle) and ArrowRight (open) on the
+     * collapsed-mode icon trigger. When the flyout is already open, ArrowDown
+     * enters it (focuses the first item) instead of bubbling to the sidebar
+     * container's roving nav — so an open flyout is never skipped past.
+     */
+    protected onTriggerKeydown(event: Event): void;
+    /**
+     * @protected Closes the flyout and returns focus to the icon trigger when a
+     * child item inside it is activated.
+     *
+     * The menu-button pattern expects the menu to close once a command is
+     * chosen — without this a `routerLink` navigation left the flyout hanging
+     * over the new page. Enter/Space are covered too: `MlvSidebarItem` activates
+     * a button-style row by calling `.click()` on its host, and a projected
+     * anchor dispatches a real click, so both reach this bubbling handler.
+     *
+     * Clicks on the flyout header or on empty panel space are ignored — only a
+     * target inside a `.mlv-sidebar-item` (its host, projected link or button)
+     * counts as an activation.
+     */
+    protected onFlyoutClick(event: Event): void;
+    /**
+     * @protected Closes the flyout when keyboard focus leaves it entirely (Tab
+     * out, or focus moving to another trigger) so it is never left orphaned-open.
+     * Focus moves between items inside the panel, or back to the owning trigger,
+     * are ignored.
+     */
+    protected onFlyoutFocusOut(event: Event): void;
+    /** @private Moves focus to the first focusable item inside the open flyout panel. */
+    private _focusFirstFlyoutItem;
+    /** Opens the tooltip when hovering the icon button (collapsed mode, flyout not open). */
+    protected onIconBtnMouseEnter(): void;
+    /** Closes the tooltip when the pointer leaves the icon button. */
+    protected onIconBtnMouseLeave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarGroup, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSidebarGroup, "mlv-sidebar-group", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "badgeTone": { "alias": "badgeTone"; "required": false; "isSignal": true; }; "badgePulse": { "alias": "badgePulse"; "required": false; "isSignal": true; }; }, {}, ["iconRef", "_childItems"], ["*"], true, never>;
+}

package/sidebar/lib/sidebar-header.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+/**
+ * Marks a sticky top region inside the sidebar.
+ * Applied to a container element that should remain visible at the top when content scrolls.
+ */
+export declare class MlvSidebarHeader {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSidebarHeader, "[mlvSidebarHeader]", never, {}, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,104 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import { MlvPopupContainer } from '@malva-ui/core/popup';
+import { type MlvBadgeTone } from '@malva-ui/core/badge';
+import { MlvSidebarItemIcon } from '../sidebar-item-icon';
+import { MlvSidebarItemTitle } from '../sidebar-item-host';
+import * as i0 from "@angular/core";
+export declare class MlvSidebarItem {
+    /** @private Parent sidebar context providing collapsed/flyout state. */
+    private readonly _ctx;
+    /** @private Host element, scanned for a genuinely focusable projected control. */
+    private readonly _host;
+    /** Accessible label; used as aria-label, fallback text, and tooltip in collapsed mode. */
+    readonly label: import("@angular/core").InputSignal<string>;
+    /** Explicit active state; combined with router link detection in computedActive. */
+    readonly active: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * Optional badge/count shown on this item. Rendered as a trailing
+     * `mlv-badge` when the sidebar is expanded, and as a `mlv-status-indicator`
+     * dot (top-right of the icon) when the sidebar is collapsed — where a full
+     * badge does not fit the icon rail. `null`/`''` renders nothing.
+     *
+     * This is the sanctioned way to attach a badge; it composes with a projected
+     * `[mlvSidebarItemTitle]` (the badge renders after the custom title).
+     */
+    readonly badge: import("@angular/core").InputSignal<string | number | null>;
+    /** Semantic tone applied to both the expanded badge and the collapsed status dot. */
+    readonly badgeTone: import("@angular/core").InputSignal<MlvBadgeTone>;
+    /** When true, the collapsed-mode status dot pulses to draw attention. */
+    readonly badgePulse: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /** @private Sidebar i18n slice (used to phrase the badge count in the aria-label). */
+    private readonly _i18n;
+    /** @private ICU resolver for the pluralised notification count. */
+    private readonly _resolver;
+    /** @protected Icon slot template projected via `[mlvSidebarItemIcon]`. */
+    protected readonly iconRef: import("@angular/core").Signal<MlvSidebarItemIcon | undefined>;
+    /** @protected Custom title template projected via `[mlvSidebarItemTitle]`. */
+    protected readonly titleRef: import("@angular/core").Signal<MlvSidebarItemTitle | undefined>;
+    /** @private Detects Angular router active state from a projected routerLinkActive directive. */
+    private readonly _routerLink;
+    /** True if active() or the nested RouterLinkActive reports active. */
+    readonly computedActive: import("@angular/core").Signal<boolean>;
+    /** True when the sidebar is collapsed and this item is not inside a flyout. */
+    readonly isCollapsed: import("@angular/core").Signal<boolean>;
+    /**
+     * @private True when the projected content contains a genuinely focusable
+     * control (an `<a href>`, `<button>`, form field, or `[tabindex="0"]`).
+     * Populated after render by scanning the host subtree — a projected
+     * `[mlvSidebarItemTitle]` that only contains text/badges does NOT count.
+     */
+    protected readonly _hasProjectedFocusable: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * Whether the host itself is the interactive control. `true` unless the
+     * projected content already contains its own focusable control — the host
+     * then behaves as a `role="button"` (or `role="menuitem"` inside a flyout)
+     * row with `tabindex="0"` and an `aria-label`. When a focusable control IS
+     * projected (e.g. a router `<a>` link), that element is the single
+     * interactive target and the host stays a presentational wrapper, avoiding an
+     * invalid `role="listitem"` (no `role="list"` ancestor) and nested focusable
+     * controls. Detection is by actual focusable content, not by the mere
+     * presence of a title template, so text/badge-only titles stay interactive.
+     */
+    protected readonly _interactiveHost: import("@angular/core").Signal<boolean>;
+    /** @protected True while this item renders inside a collapsed-mode group flyout (a `role="menu"`). */
+    protected readonly _inFlyout: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Resolved host `role`. `null` when the host is a presentational
+     * wrapper around a projected focusable control; otherwise `menuitem` inside a
+     * flyout menu, or `button` for a standalone interactive row.
+     */
+    protected readonly _hostRole: import("@angular/core").Signal<"menuitem" | "button" | null>;
+    /** @protected True when a non-empty badge value is set. */
+    protected readonly _hasBadge: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Resolved host `aria-label`. `null` when the host is a
+     * presentational wrapper around a projected control. Otherwise the item
+     * `label()`, with the badge folded in when set (e.g. `"Inbox, 3
+     * notifications"`) — since the host `aria-label` overrides the visible badge
+     * text, this keeps the count announced in both expanded and collapsed states,
+     * and is the only carrier of the count when the collapsed dot replaces the
+     * badge.
+     */
+    protected readonly _resolvedAriaLabel: import("@angular/core").Signal<string | null>;
+    /** @private Router link active state tracked via afterRenderEffect. */
+    private readonly _routerLinkActive;
+    /** @private Reference to the tooltip container for programmatic open/close. */
+    protected readonly _tooltipContainer: import("@angular/core").Signal<MlvPopupContainer | undefined>;
+    /** @private Registered for automatic cleanup of the routerLinkActive subscription. */
+    private readonly _destroyRef;
+    constructor();
+    /**
+     * @private Phrases a badge value for the accessible name. A pure numeric
+     * value is pluralised via the `notifications` ICU key (e.g. `"3
+     * notifications"`); any other value is announced verbatim (e.g. `"New"`).
+     */
+    private _announceBadge;
+    /** @protected Activates the host on Enter/Space when it is the interactive control. */
+    protected _onKeyActivate(event: Event): void;
+    /** @protected Opens the collapsed-mode tooltip on hover/focus. */
+    protected _onMouseEnter(): void;
+    /** @protected Closes the collapsed-mode tooltip on mouse-leave/blur. */
+    protected _onMouseLeave(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarItem, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSidebarItem, "mlv-sidebar-item", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "badge": { "alias": "badge"; "required": false; "isSignal": true; }; "badgeTone": { "alias": "badgeTone"; "required": false; "isSignal": true; }; "badgePulse": { "alias": "badgePulse"; "required": false; "isSignal": true; }; }, {}, ["iconRef", "titleRef", "_routerLink"], never, true, never>;
+}

package/sidebar/lib/sidebar-item-host.d.ts

@@ -0,0 +1,18 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import { MlvStructural } from '@malva-ui/cdk/utils';
+import * as i0 from "@angular/core";
+export declare class MlvSidebarItemHost {
+    /** Whether the item is the currently active navigation target. */
+    readonly active: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarItemHost, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSidebarItemHost, "[mlvSidebarItem]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class MlvSidebarItemTitle extends MlvStructural {
+    /**
+     * Optional active state on the directive (available but not currently
+     * consumed by `MlvSidebarItem`).
+     */
+    readonly active: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarItemTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSidebarItemTitle, "[mlvSidebarItemTitle]", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/sidebar/lib/sidebar-item-icon.d.ts

@@ -0,0 +1,6 @@
+import { MlvStructural } from '@malva-ui/cdk/utils';
+import * as i0 from "@angular/core";
+export declare class MlvSidebarItemIcon extends MlvStructural {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarItemIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSidebarItemIcon, "[mlvSidebarItemIcon]", never, {}, {}, never, never, true, never>;
+}

package/sidebar/lib/sidebar-mode.d.ts

@@ -0,0 +1,2 @@
+/** MlvLayout mode controlling how the sidebar renders and collapses. */
+export type MlvSidebarMode = 'icon' | 'offcanvas' | 'floating' | 'fixed';

package/sidebar/lib/sidebar-rail/sidebar-rail.d.ts

@@ -0,0 +1,54 @@
+import * as i0 from "@angular/core";
+export declare class MlvSidebarRail {
+    /** Minimum sidebar width in px during drag. */
+    readonly minWidth: import("@angular/core").InputSignal<number>;
+    /** Maximum sidebar width in px during drag. */
+    readonly maxWidth: import("@angular/core").InputSignal<number>;
+    /** Width below which the sidebar snaps to collapsed. */
+    readonly snapThreshold: import("@angular/core").InputSignal<number>;
+    /** @private Sidebar context for reading/writing state. */
+    private readonly _context;
+    /** @private Reference to the host element. */
+    private readonly _elementRef;
+    /** @private Angular zone for running outside zone during drag. */
+    private readonly _ngZone;
+    /** @private Destroy reference for cleanup. */
+    private readonly _destroyRef;
+    /** @protected Whether a drag is in progress. */
+    protected readonly _isDragging: import("@angular/core").WritableSignal<boolean>;
+    /** @protected Current sidebar width in pixels (for ARIA). */
+    protected readonly _currentWidthPx: import("@angular/core").WritableSignal<number>;
+    /** @private Sidebar container element reference, resolved on first drag. */
+    private _sidebarEl;
+    /** @private Stored transition value to restore after drag. */
+    private _savedTransition;
+    /** @private Bound pointermove handler for cleanup. */
+    private readonly _onPointerMoveBound;
+    /** @private Bound pointerup handler for cleanup. */
+    private readonly _onPointerUpBound;
+    /** @private Animation frame ID for drag throttle. */
+    private _rafId;
+    /** @private Whether to snap to collapsed on pointerup. */
+    private _shouldSnap;
+    /** @private Whether to expand from collapsed on pointerup. */
+    private _shouldExpand;
+    /** @private Width to apply after expanding from collapsed state. */
+    private _expandWidth;
+    constructor();
+    /** @protected Handle double-click to toggle collapsed state. */
+    protected _onDoubleClick(): void;
+    /** @protected Handle keyboard navigation. */
+    protected _onKeydown(event: KeyboardEvent): void;
+    /** @protected Handle pointer down to start drag. */
+    protected _onPointerDown(event: PointerEvent): void;
+    /** @private Handle pointer move during drag. */
+    private _onPointerMove;
+    /** @private Handle pointer up to end drag. */
+    private _onPointerUp;
+    /** @private Remove document listeners and reset drag state. */
+    private _cleanup;
+    /** @private Adjust width by a delta, clamping to min/max. */
+    private _adjustWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarRail, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSidebarRail, "mlv-sidebar-rail", never, { "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "snapThreshold": { "alias": "snapThreshold"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/sidebar/lib/sidebar-trigger/sidebar-trigger.d.ts

@@ -0,0 +1,67 @@
+import type { MlvSidebarContextValue } from '../sidebar-context';
+import * as i0 from "@angular/core";
+/**
+ * Sidebar trigger button that toggles the sidebar's collapsed state.
+ * Renders as a transparent icon button visually matching collapsed sidebar
+ * items, so it sits flush with the rest of the sidebar chrome.
+ * Automatically hides itself in fixed mode.
+ *
+ * When the sidebar's effective mode is `'offcanvas'` (either `mode="offcanvas"`
+ * or a `collapseBelow` breakpoint override) the trigger renders as a
+ * hamburger/close menu button instead of the rail collapse chevrons.
+ *
+ * Usage:
+ * ```html
+ * <mlv-sidebar [collapsed]="collapsed()">
+ *   <mlv-sidebar-trigger />
+ * </mlv-sidebar>
+ * ```
+ *
+ * An offcanvas sidebar does not render its projected content while closed, so
+ * a trigger that must reopen the drawer has to live outside `<mlv-sidebar>`.
+ * Point it at the sidebar with the `sidebar` input:
+ *
+ * ```html
+ * <mlv-sidebar #nav collapseBelow="md">…</mlv-sidebar>
+ * <mlv-sidebar-trigger [sidebar]="nav" />
+ * ```
+ */
+export declare class MlvSidebarTrigger {
+    /**
+     * The sidebar this trigger controls, for triggers rendered outside
+     * `<mlv-sidebar>`. Pass the sidebar's template reference
+     * (`<mlv-sidebar #nav />` → `[sidebar]="nav"`). Required whenever the sidebar
+     * can be an offcanvas drawer, because a closed drawer does not render its
+     * projected content — an inner trigger would disappear with it.
+     *
+     * When omitted, the trigger uses the `SIDEBAR_CONTEXT` of its ancestor
+     * sidebar.
+     */
+    readonly sidebar: import("@angular/core").InputSignal<MlvSidebarContextValue | undefined>;
+    /** @protected Localised labels for the sidebar trigger. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvSidebarI18n>;
+    /** @private Ancestor sidebar context, when this trigger is nested in one. */
+    private readonly _injectedContext;
+    /**
+     * @private The context actually driven by this trigger — the explicit
+     * `sidebar` input wins over the injected ancestor context.
+     */
+    private readonly _context;
+    /** @protected Whether the sidebar is collapsed (drawer closed in offcanvas). */
+    protected readonly _collapsed: import("@angular/core").Signal<boolean>;
+    /** @private The sidebar's effective layout mode, responsive override included. */
+    private readonly _mode;
+    /**
+     * @protected True when the sidebar currently behaves as an overlay drawer, so
+     * the trigger renders as a menu button rather than a rail collapse toggle.
+     */
+    protected readonly _isDrawerTrigger: import("@angular/core").Signal<boolean>;
+    /** @protected Whether the trigger should be hidden (fixed mode). */
+    protected readonly _isHidden: import("@angular/core").Signal<boolean>;
+    /** @protected Accessible name matching the current affordance and state. */
+    protected readonly _resolvedAriaLabel: import("@angular/core").Signal<string>;
+    /** @protected Toggle the sidebar collapsed state. */
+    protected _toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarTrigger, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSidebarTrigger, "mlv-sidebar-trigger", never, { "sidebar": { "alias": "sidebar"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/sidebar/lib/sidebar-workspace/sidebar-workspace.d.ts

@@ -0,0 +1,54 @@
+import { MlvSidebarWorkspaceLogo, MlvSidebarWorkspaceText } from './sidebar-workspace.directives';
+import type { MlvSidebarWorkspaceOption, MlvSidebarWorkspaceTemplateContext } from './sidebar-workspace.types';
+import * as i0 from "@angular/core";
+export declare class MlvSidebarWorkspace {
+    /** @private Parent sidebar context supplying the effective collapsed state. */
+    private readonly _sidebarContext;
+    /** @protected Localized strings for the workspace switcher. */
+    protected readonly _i18n: import("@angular/core").Signal<import("@malva-ui/i18n").MlvSidebarI18n>;
+    /** @private ICU message resolver used by the trigger's accessible name. */
+    private readonly _i18nResolver;
+    /**
+     * Workspaces available to the user. A switcher menu is rendered only when
+     * the collection contains more than one workspace.
+     */
+    readonly workspaces: import("@angular/core").InputSignal<readonly MlvSidebarWorkspaceOption[]>;
+    /**
+     * Currently active workspace. Two-way bind with `[(workspace)]` to receive
+     * user selections made in the workspace menu.
+     */
+    readonly workspace: import("@angular/core").ModelSignal<MlvSidebarWorkspaceOption>;
+    /** @protected Optional structural template for workspace logos. */
+    protected readonly _logoTemplate: import("@angular/core").Signal<MlvSidebarWorkspaceLogo | undefined>;
+    /** @protected Optional structural template for workspace text. */
+    protected readonly _textTemplate: import("@angular/core").Signal<MlvSidebarWorkspaceText | undefined>;
+    /** @protected Whether the switcher menu is currently open. */
+    protected readonly _opened: import("@angular/core").WritableSignal<boolean>;
+    /** @protected True when choosing between multiple workspaces is possible. */
+    protected readonly _hasMultiple: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Whether the parent sidebar is collapsed. Workspace switchers
+     * outside a sidebar remain expanded.
+     */
+    protected readonly _isCollapsed: import("@angular/core").Signal<boolean>;
+    /**
+     * @protected Accessible trigger name including the current workspace.
+     */
+    protected readonly _triggerAriaLabel: import("@angular/core").Signal<string>;
+    /**
+     * @protected Selects a workspace from the menu. The menu item directive
+     * closes the overlay and restores focus to the trigger after this handler.
+     */
+    protected _selectWorkspace(workspace: MlvSidebarWorkspaceOption): void;
+    /** @protected Tracks whether an option represents the active workspace. */
+    protected _isSelected(workspace: MlvSidebarWorkspaceOption): boolean;
+    /**
+     * @protected Builds the strongly typed context supplied to the logo and text
+     * structural templates.
+     */
+    protected _templateContext(workspace: MlvSidebarWorkspaceOption): MlvSidebarWorkspaceTemplateContext;
+    /** @protected Produces a compact fallback monogram when no logo is supplied. */
+    protected _initials(label: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarWorkspace, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSidebarWorkspace, "mlv-sidebar-workspace", never, { "workspaces": { "alias": "workspaces"; "required": true; "isSignal": true; }; "workspace": { "alias": "workspace"; "required": true; "isSignal": true; }; }, { "workspace": "workspaceChange"; }, ["_logoTemplate", "_textTemplate"], never, true, never>;
+}

package/sidebar/lib/sidebar-workspace/sidebar-workspace.directives.d.ts

@@ -0,0 +1,19 @@
+import { TemplateRef } from '@angular/core';
+import type { MlvSidebarWorkspaceTemplateContext } from './sidebar-workspace.types';
+import * as i0 from "@angular/core";
+export declare class MlvSidebarWorkspaceLogo {
+    /** Template rendered in both the active trigger and every workspace option. */
+    readonly templateRef: TemplateRef<any>;
+    /** Enables strongly typed `let-workspace` and `let-selected="selected"`. */
+    static ngTemplateContextGuard(_directive: MlvSidebarWorkspaceLogo, _context: unknown): _context is MlvSidebarWorkspaceTemplateContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarWorkspaceLogo, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSidebarWorkspaceLogo, "[mlvSidebarWorkspaceLogo]", never, {}, {}, never, never, true, never>;
+}
+export declare class MlvSidebarWorkspaceText {
+    /** Template rendered in both the active trigger and every workspace option. */
+    readonly templateRef: TemplateRef<any>;
+    /** Enables strongly typed `let-workspace` and `let-selected="selected"`. */
+    static ngTemplateContextGuard(_directive: MlvSidebarWorkspaceText, _context: unknown): _context is MlvSidebarWorkspaceTemplateContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSidebarWorkspaceText, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSidebarWorkspaceText, "[mlvSidebarWorkspaceText]", never, {}, {}, never, never, true, never>;
+}

package/sidebar/lib/sidebar-workspace/sidebar-workspace.types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Workspace data understood by `mlv-sidebar-workspace`.
+ * Consumers may structurally extend this interface with application-specific
+ * fields; `label` remains the accessible name used by the switcher.
+ */
+export interface MlvSidebarWorkspaceOption {
+    /** Stable identifier used to track and compare workspaces. */
+    readonly id: string;
+    /** Human-readable and accessible workspace name. */
+    readonly label: string;
+    /** Optional secondary line rendered by the default text template. */
+    readonly description?: string;
+}
+/** Context supplied to workspace logo and text structural templates. */
+export interface MlvSidebarWorkspaceTemplateContext {
+    /** Workspace being rendered; available through `let-workspace`. */
+    readonly $implicit: MlvSidebarWorkspaceOption;
+    /** Whether this workspace is currently active. */
+    readonly selected: boolean;
+}

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

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

package/skeleton/index.d.ts

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

package/skeleton/lib/skeleton/skeleton.d.ts

@@ -0,0 +1,60 @@
+import type { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+/** Visual shape variant of the skeleton loader. */
+export type MlvSkeletonVariant = 'text' | 'circle' | 'rectangle';
+/**
+ * Skeleton loader component (`mlv-skeleton`) used as a placeholder while content is loading.
+ *
+ * Renders a pulsing placeholder that communicates the shape of the incoming content.
+ * Width and height are bound directly on the host element via `[style.width]` and
+ * `[style.height]`. The component is always `aria-hidden="true"` — it carries no
+ * semantic meaning for assistive technology.
+ *
+ * @example
+ * ```html
+ * <!-- Default rectangle -->
+ * <mlv-skeleton />
+ *
+ * <!-- Circle avatar placeholder -->
+ * <mlv-skeleton variant="circle" width="2.5rem" height="2.5rem" />
+ *
+ * <!-- Text line placeholder -->
+ * <mlv-skeleton variant="text" width="60%" />
+ * ```
+ */
+export declare class MlvSkeleton {
+    /**
+     * Visual shape variant of the skeleton.
+     * - `'rectangle'` (default) — rectangular block
+     * - `'text'` — short rounded pill mimicking a line of text
+     * - `'circle'` — fully rounded circle for avatar/icon placeholders
+     */
+    readonly variant: import("@angular/core").InputSignal<MlvSkeletonVariant>;
+    /**
+     * CSS width applied to the host element.
+     * Accepts any valid CSS width value (e.g. `'100%'`, `'12rem'`, `'200px'`).
+     * Defaults to `'100%'`.
+     */
+    readonly width: import("@angular/core").InputSignal<string>;
+    /**
+     * CSS height applied to the host element.
+     * Accepts any valid CSS height value (e.g. `'1rem'`, `'48px'`).
+     * Defaults to `'1rem'`.
+     */
+    readonly height: import("@angular/core").InputSignal<string>;
+    /**
+     * Whether the pulsing animation is active.
+     * Set to `false` to render a static placeholder (e.g. for reduced-motion or loading states
+     * that should not draw attention). Defaults to `true`.
+     */
+    readonly animated: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
+    /**
+     * CSS duration for the shimmer animation (e.g. `'1s'`, `'0.8s'`, `'2s'`).
+     * Passed as the `--mlv-skeleton-duration` CSS custom property on the host, which
+     * controls the `animation-duration` of the shimmer keyframe.
+     * Defaults to `'2s'` for a slow, professional feel.
+     */
+    readonly animationDuration: import("@angular/core").InputSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSkeleton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MlvSkeleton, "mlv-skeleton", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; "animationDuration": { "alias": "animationDuration"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

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

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

package/slider/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/slider/slider';
+export * from './lib/slider/slider-tooltip-def';

package/slider/lib/slider/slider-tooltip-def.d.ts

@@ -0,0 +1,39 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Identifies the thumb whose tooltip is being rendered.
+ *
+ * Single-value sliders use `'value'`; range sliders use `'min'` and `'max'`.
+ */
+export type MlvSliderTooltipThumb = 'value' | 'min' | 'max';
+/**
+ * Context provided to a custom `[mlvSliderTooltipDef]` template.
+ */
+export interface MlvSliderTooltipDefContext {
+    /** Current thumb value, also exposed as `let-value`. */
+    $implicit: number;
+    /** Current thumb value exposed as the named `value` property. */
+    value: number;
+    /** Semantic identity of the thumb being rendered. */
+    thumb: MlvSliderTooltipThumb;
+}
+/**
+ * Structural directive that provides custom slider tooltip text.
+ *
+ * @example
+ * ```html
+ * <mlv-slider tooltip>
+ *   <ng-template mlvSliderTooltipDef let-value>
+ *     {{ value }}%
+ *   </ng-template>
+ * </mlv-slider>
+ * ```
+ */
+export declare class MlvSliderTooltipDef {
+    /** Template used to render the current thumb value. */
+    readonly templateRef: TemplateRef<any>;
+    /** Type guard for `let-value`, `let-value="value"`, and `let-thumb="thumb"`. */
+    static ngTemplateContextGuard(_dir: MlvSliderTooltipDef, _ctx: unknown): _ctx is MlvSliderTooltipDefContext;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MlvSliderTooltipDef, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MlvSliderTooltipDef, "[mlvSliderTooltipDef]", never, {}, {}, never, never, true, never>;
+}