@malva-ui/core 0.1.12 → 0.1.14

package/drawer/lib/drawer.service.d.ts

@@ -1,66 +0,0 @@
-import type { StaticProvider } from '@angular/core';
-import { InjectionToken } from '@angular/core';
-import type { OverlayConfig, OverlayRef, PositionStrategy } from '@angular/cdk/overlay';
-import type { MlvBaseOverlayConfig } from '@malva-ui/cdk/overlay';
-import { MlvOverlayServiceBase } from '@malva-ui/cdk/overlay';
-import { MlvDrawerRef } from './drawer-ref';
-import * as i0 from "@angular/core";
-export type MlvDrawerPosition = 'left' | 'right' | 'top' | 'bottom';
-export interface MlvDrawerConfig extends MlvBaseOverlayConfig {
-    /** Edge the drawer slides from. Defaults to `'right'`. */
-    position?: MlvDrawerPosition;
-    /** CSS width (left/right) or height (top/bottom) of the panel. */
-    size?: string;
-    /**
-     * CSS max-size ceiling for the panel's sizing axis (width for `left`/`right`,
-     * height for `top`/`bottom`).
-     *
-     * Applied whether or not the drawer is `resizable`, and always additionally
-     * clamped to the viewport so a fixed `size` can never exceed the screen.
-     */
-    maxSize?: string;
-    /** Animation duration in milliseconds. Defaults to `300`. */
-    animationDuration?: number;
-    /**
-     * When true, renders a drag handle on the inward-facing edge.
-     * Enables drag-to-resize and swipe-to-dismiss.
-     */
-    resizable?: boolean;
-    /**
-     * Sorted array of viewport-percentage snap points (0–100).
-     * After drag ends, the panel animates to the nearest snap point.
-     * Only effective when `resizable` is true.
-     */
-    snapPoints?: number[];
-    /**
-     * Initial snap point percentage (0–100) applied when the drawer opens.
-     * Defaults to 100 (full size). Only used when `resizable` is true.
-     */
-    defaultSnap?: number;
-}
-export declare const DRAWER_DATA: InjectionToken<unknown>;
-export declare class MlvDrawerService extends MlvOverlayServiceBase<MlvDrawerConfig, MlvDrawerRef> {
-    /** @protected Panel enter-animation class for drawers. */
-    protected readonly _enterAnimationClass = "mlv-drawer--enter";
-    /** @protected Anchors the drawer to the configured viewport edge. */
-    protected _buildPositionStrategy(config: MlvDrawerConfig): PositionStrategy;
-    /** @protected Drawer backdrop class. */
-    protected _buildOverlayConfig(): OverlayConfig;
-    /** @protected Creates the drawer reference, forwarding position and animation duration. */
-    protected _createRef(overlayRef: OverlayRef, config: MlvDrawerConfig): MlvDrawerRef;
-    /** @protected Provides `MlvDrawerRef` and `DRAWER_DATA` to the opened component. */
-    protected _createProviders(ref: MlvDrawerRef, config: MlvDrawerConfig): StaticProvider[];
-    /** @protected Applies drawer shell classes, hidden-transform var, and panel sizing to the overlay pane. */
-    protected _decoratePanel(panelEl: HTMLElement, config: MlvDrawerConfig): void;
-    /**
-     * @private Combines a configured `maxSize` with the viewport ceiling for the
-     * sizing axis.
-     *
-     * `drawer.scss` cannot help here — Angular injects a component's styles when
-     * that component is first instantiated, and `MlvDrawer` is never constructed
-     * on the service path — so the clamp has to be written onto the pane.
-     */
-    private _resolveMaxSize;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDrawerService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MlvDrawerService>;
-}

package/drawer/lib/generate-routable-drawer-route.d.ts

@@ -1,42 +0,0 @@
-import type { Type } from '@angular/core';
-import type { DefaultExport, Route } from '@angular/router';
-import type { MlvDrawerConfig } from './drawer.service';
-/**
- * Generates a route configuration that opens a component inside a routed drawer.
- * When the drawer closes, the router navigates back to the parent route.
- *
- * The component receives the shell's `Injector`, so it can inject `ActivatedRoute`
- * to access route params, resolved data, and query params. It can also inject
- * `MlvDrawerRef` to close itself programmatically.
- *
- * @param component - The component to render inside the drawer. Can be an eager class reference
- *   or a lazy import function (e.g., `() => import('./my-drawer.component')`).
- * @param options - Route path, named outlet, and drawer configuration options.
- * @returns A `Route` object to include in your route configuration.
- *
- * @example
- * ```ts
- * // Lazy-loaded drawer route
- * {
- *   path: 'users',
- *   component: UsersListPage,
- *   children: [
- *     mlvGenerateRoutableDrawerRoute(
- *       () => import('./user-details.component'),
- *       { path: ':id', position: 'right', size: '500px' },
- *     ),
- *   ],
- * }
- *
- * // With guards and resolvers (spread the returned route)
- * {
- *   ...mlvGenerateRoutableDrawerRoute(() => import('./details'), { path: ':id' }),
- *   canActivate: [authGuard],
- *   resolve: { user: userResolver },
- * }
- * ```
- */
-export declare function mlvGenerateRoutableDrawerRoute(component: Type<unknown> | (() => Promise<DefaultExport<Type<unknown>> | Type<unknown>>), { path, outlet, ...drawerOptions }?: {
-    path?: string;
-    outlet?: string;
-} & Omit<MlvDrawerConfig, 'data' | 'injector'>): Route;

package/drawer/lib/routable-drawer.d.ts

@@ -1,30 +0,0 @@
-import * as i0 from "@angular/core";
-/**
- * Invisible shell component that opens a routed component inside a Malva UI drawer.
- *
- * Do not use directly — use `mlvGenerateRoutableDrawerRoute()` to create routes
- * that render their component inside a drawer overlay.
- *
- * @internal
- */
-export default class MlvRoutableDrawer {
-    /** @private The current activated route — provides access to route data and snapshot. */
-    private readonly _route;
-    /** @private The Angular router used for navigating back to the parent route on close. */
-    private readonly _router;
-    /** @private The shell component's injector, passed to the drawer for ActivatedRoute access. */
-    private readonly _injector;
-    /** @private Captures the URL at construction time to detect external navigation. */
-    private readonly _initialUrl;
-    /** @private The Malva UI drawer service used to open the routed component. */
-    private readonly _drawer;
-    constructor();
-    /** @private Computes the relative back URL for lazy-loaded routes. */
-    private get _lazyLoadedBackUrl();
-    /** @private Navigates to parent when the drawer closes and URL hasn't changed externally. */
-    private _onDrawerClosing;
-    /** @private Navigates to the parent route using the computed back URL. */
-    private _navigateToParent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MlvRoutableDrawer, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MlvRoutableDrawer, "mlv-routable-drawer", never, {}, {}, never, never, true, never>;
-}

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

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

package/dropdown/index.d.ts

@@ -1,9 +0,0 @@
-export * from './lib/dropdown-panel/dropdown-panel';
-export * from './lib/select-option';
-export * from './lib/option-matcher';
-export * from './lib/active-descendant';
-export * from './lib/highlight-match.pipe';
-export * from './lib/select-data-source';
-export * from './lib/options-result';
-export * from './lib/options-adapter';
-export * from './lib/reconciliation';

package/dropdown/lib/active-descendant.d.ts

@@ -1,64 +0,0 @@
-import type { Signal } from '@angular/core';
-/**
- * Builds the deterministic DOM `id` for the option row at `index` within a
- * listbox, matching the id `mlv-dropdown-panel` stamps on each option. An
- * owning combobox / autocomplete computes the same id to point its input's
- * `aria-activedescendant` at the active row.
- *
- * This is the single source of truth for the activedescendant option-id format
- * (`<listboxId>-option-<index>`), shared by `mlv-dropdown-panel`,
- * `mlv-combobox`, and `[mlvAutocomplete]` so the id the panel renders and the
- * id the trigger references can never drift.
- *
- * @param listboxId - The id of the listbox that owns the option.
- * @param index - The option's flat index within the listbox.
- * @returns The option's DOM id, e.g. `"my-listbox-option-3"`.
- */
-export declare function optionId(listboxId: string, index: number): string;
-/**
- * Signal-backed bookkeeping for the "active option" index of a WAI-ARIA
- * activedescendant keyboard model — the shared engine behind `mlv-combobox`
- * and `[mlvAutocomplete]`, where DOM focus stays on the text input and the
- * highlighted option is tracked purely by index (mirrored into the input's
- * `aria-activedescendant`).
- *
- * The active index is `-1` when no option is active. {@link move} advances it
- * with wrap-around, treating a first move from `-1` as landing on the first
- * (forward) or last (backward) option; {@link first} / {@link last} jump to the
- * ends; {@link reset} clears it back to `-1`. The current option count is read
- * lazily through the accessor supplied at construction, so the owner can back it
- * with any signal / computed (e.g. a filtered-options length) without pushing
- * the count on every keystroke.
- */
-export declare class MlvActiveDescendant {
-    private readonly _count;
-    /** @private The active option index; `-1` = no active option. */
-    private readonly _index;
-    /**
-     * The active option index as a read-only signal; `-1` when no option is
-     * active. Read it reactively (template / effect) or imperatively (call it in
-     * an event handler) — both track the same underlying state.
-     */
-    readonly index: Signal<number>;
-    /**
-     * @param _count Accessor returning the current number of navigable options.
-     * Read lazily on each {@link move} / {@link first} / {@link last} call, so it
-     * always reflects the live count (e.g. after the options are filtered).
-     */
-    constructor(_count: () => number);
-    /**
-     * Advances the active option by `delta` with wrap-around. With no option
-     * active (`-1`), a forward move (`delta > 0`) lands on the first option and a
-     * backward move (`delta < 0`) on the last; otherwise the index wraps modulo
-     * the option count. Resets to `-1` when there are no options.
-     *
-     * @param delta Step to move by (`+1` next, `-1` previous).
-     */
-    move(delta: number): void;
-    /** Activates the first option. No-op when there are no options. */
-    first(): void;
-    /** Activates the last option. No-op when there are no options. */
-    last(): void;
-    /** Clears the active option back to `-1` (nothing active). */
-    reset(): void;
-}

package/dropdown/lib/dropdown-panel/dropdown-panel.d.ts

@@ -1,178 +0,0 @@
-import type { TemplateRef } from '@angular/core';
-import type { BooleanInput } from '@angular/cdk/coercion';
-import type { MlvSelectOption } from '../select-option';
-import * as i0 from "@angular/core";
-/**
- * One option within a rendered group, paired with its flat index into the
- * panel's `options()` array. The flat index (not a group-local index) is what
- * the panel forwards to {@link MlvDropdownPanel.optionId} and matches
- * against `activeIndex`, so an owning combobox's activedescendant model stays
- * aligned regardless of grouping.
- */
-interface DropdownOptionEntry<T> {
-    readonly option: MlvSelectOption<T>;
-    readonly index: number;
-}
-/**
- * A rendered cluster of consecutive options that share the same group label.
- * `label`/`headerId` are `null` for an ungrouped (headerless) run.
- */
-interface DropdownOptionGroup<T> {
-    readonly label: string | null;
-    readonly headerId: string | null;
-    readonly entries: DropdownOptionEntry<T>[];
-}
-export declare class MlvDropdownPanel<T> {
-    /**
-     * Chooses the single scroll owner for this panel.
-     *
-     * Standalone panels scroll themselves. Panels composed inside `mlv-popup`
-     * delegate to the popup so the DOM never contains nested scroll regions.
-     */
-    readonly scrollMode: import("@angular/core").InputSignal<"self" | "parent">;
-    readonly minHeight: import("@angular/core").InputSignal<number>;
-    readonly maxHeight: import("@angular/core").InputSignal<number>;
-    readonly options: import("@angular/core").InputSignal<MlvSelectOption<T>[]>;
-    /** Whether multiple options can be selected. */
-    readonly multiple: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
-    readonly selectedValues: import("@angular/core").InputSignal<T[]>;
-    readonly itemTemplate: import("@angular/core").InputSignal<TemplateRef<{
-        $implicit: MlvSelectOption<T>;
-    }> | null>;
-    /**
-     * Focus strategy forwarded to the inner aria listbox.
-     *
-     * - `'roving'` (default) — DOM focus moves onto the active option (`tabindex`).
-     *   Used by `mlv-select`.
-     * - `'activedescendant'` — DOM focus stays on the owning trigger/input; the
-     *   active option is tracked via `aria-activedescendant`. Used by
-     *   `mlv-combobox`, whose text input must retain focus so typing keeps
-     *   working while navigating options.
-     */
-    readonly focusMode: import("@angular/core").InputSignal<"roving" | "activedescendant">;
-    /**
-     * Index of the option that is visually "active" (highlighted) under the
-     * activedescendant model. `-1` (default) means no active option. The panel
-     * renders a deterministic `[id]` on each option (`<listboxId>-option-<index>`)
-     * so an owning combobox can point its input's `aria-activedescendant` at the
-     * active row and keep the highlight in sync.
-     */
-    readonly activeIndex: import("@angular/core").InputSignal<number>;
-    /**
-     * Optional HTML `id` to assign to the inner `<mlv-list>` listbox element.
-     * Allows a parent combobox or select to reference this listbox via `aria-controls`.
-     */
-    readonly listboxId: import("@angular/core").InputSignal<string | null>;
-    /**
-     * When non-empty, the default option row emphasises the matched substring of
-     * this query inside each suggestion label (case- and diacritic-insensitive;
-     * see {@link MlvHighlightMatchPipe}). Ignored for rows rendered by a custom
-     * {@link itemTemplate}. Empty (default) renders the label as plain text —
-     * ungrouped, un-highlighted lists are byte-for-byte unchanged.
-     */
-    readonly highlightQuery: import("@angular/core").InputSignal<string>;
-    /**
-     * When `true`, the panel renders a loading affordance instead of the option
-     * list / empty state — used by `[mlvAutocomplete]` while an async `search`
-     * resolves. The {@link loadingText} is announced politely.
-     */
-    readonly loading: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * Text shown (and announced) inside the loading affordance while
-     * {@link loading} is `true`. Localise by binding a translated string.
-     * @default 'Loading…'
-     */
-    readonly loadingText: import("@angular/core").InputSignal<string>;
-    /**
-     * When `true`, a page beyond the first is being fetched: renders a polite
-     * bottom status row (`loadingText`) after the last option. The listbox and
-     * existing options stay interactive.
-     * @default false
-     */
-    readonly loadingMore: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
-    /**
-     * Whether more pages exist. When `true` the panel observes its scroll owner
-     * and emits {@link loadMore} as the user nears the end of the list.
-     * @default false
-     */
-    readonly hasMore: import("@angular/core").InputSignalWithTransform<boolean, BooleanInput>;
-    /** Distance (px) from the end of the scroll owner at which {@link loadMore} fires. */
-    readonly infiniteScrollThreshold: import("@angular/core").InputSignal<number>;
-    /** Emits when the user scrolls within `infiniteScrollThreshold` of the end while `hasMore`. */
-    readonly loadMore: import("@angular/core").OutputEmitterRef<void>;
-    /**
-     * @protected Effective listbox id forwarded to the aria `Listbox.id` input on
-     * the inner `<mlv-list>`. Uses the consumer-provided {@link listboxId} when
-     * set, otherwise a stable generated fallback so the rendered listbox always
-     * carries a valid unique DOM id (aria would otherwise mint its own, breaking
-     * a parent trigger's `aria-controls` linkage).
-     */
-    protected readonly _resolvedListboxId: import("@angular/core").Signal<string>;
-    /** @private Stable generated id used when no `listboxId` is supplied. */
-    private readonly _fallbackListboxId;
-    /**
-     * @protected Whether the current options declare groups (at least one option
-     * carries a non-empty `group`). When `false` the template renders the exact
-     * flat option list as before — plain / ungrouped arrays are unaffected.
-     */
-    protected readonly _isGrouped: import("@angular/core").Signal<boolean>;
-    /**
-     * @protected The options clustered into consecutive same-group runs for
-     * rendering under sticky headers. Consecutive-run grouping (no reordering)
-     * keeps DOM order identical to the flat `options()` order, so option indices,
-     * `optionId`, `activeIndex`, and aria's DOM-order navigation all stay aligned.
-     * Each entry retains its flat index into `options()`. A run of options without
-     * a group (empty/undefined) becomes a headerless cluster (`label: null`).
-     */
-    protected readonly _groups: import("@angular/core").Signal<DropdownOptionGroup<T>[]>;
-    /** @protected Effective max panel height in px — the `maxHeight` input when set, else the viewport-derived default. */
-    protected readonly _calculatedMaxHeight: import("@angular/core").Signal<number>;
-    readonly valueChange: import("@angular/core").OutputEmitterRef<readonly T[]>;
-    /** @private Selection service coordinating focus-first requests from a parent select/combobox. */
-    private readonly _selectionService;
-    /** @private Set of currently selected values for O(1) membership checks. */
-    private readonly _selectedSet;
-    /** @private Default max panel height (px) derived from the viewport height. */
-    private readonly _defaultMaxHeight;
-    /** @private The inner selectable list directive, used to move focus to the first option. */
-    private readonly _listSelectable;
-    /** @private The panel's own scrollbar (`scrollMode="self"` only). */
-    private readonly _scrollbar;
-    /** @private The sentinel-hosted infinite-scroll directive, re-checked after each option append. */
-    private readonly _infiniteScroll;
-    /**
-     * @protected The element that actually scrolls: the panel's own scrollbar
-     * viewport (`scrollMode="self"`) or the nearest ancestor `mlv-scrollbar`
-     * viewport — the owning `mlv-popup`'s — in parent mode. Resolved after the
-     * first render; the sentinel directive stays disabled until then.
-     */
-    protected readonly _scrollContainer: import("@angular/core").WritableSignal<HTMLElement | null>;
-    /**
-     * @private Whether the scroll-owner lookup has already run. It needs the first
-     * render, so a `null` {@link _scrollContainer} before that means "not resolved
-     * yet", not "no owner" — the dev warning must not fire on it.
-     */
-    private readonly _scrollOwnerResolved;
-    /** @private Latches the dev-mode "no scroll owner" warning to once per panel. */
-    private _warnedNoScrollOwner;
-    /** @private Host element, used to scroll the active option into view (activedescendant model). */
-    private readonly _host;
-    /** @private Angular-provided document used to access the browser viewport safely. */
-    private readonly _document;
-    constructor();
-    isValueSelected(value: T): boolean;
-    /**
-     * Deterministic DOM `id` for the option at `index`, forwarded to aria's
-     * `ngOption` id. An owning combobox computes the same id (via the shared
-     * {@link optionId} helper) to wire its input's `aria-activedescendant`.
-     */
-    optionId(index: number): string;
-    /**
-     * Re-emits the aria listbox selection. `@angular/aria`'s `ngListbox` emits the
-     * selected values array directly (unlike CdkListbox's `ListboxValueChangeEvent`).
-     */
-    onValueChange(values: readonly T[]): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MlvDropdownPanel<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<MlvDropdownPanel<any>, "mlv-dropdown-panel", never, { "scrollMode": { "alias": "scrollMode"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "selectedValues": { "alias": "selectedValues"; "required": false; "isSignal": true; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; "isSignal": true; }; "focusMode": { "alias": "focusMode"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "listboxId": { "alias": "listboxId"; "required": false; "isSignal": true; }; "highlightQuery": { "alias": "highlightQuery"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "loadingMore": { "alias": "loadingMore"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": false; "isSignal": true; }; "infiniteScrollThreshold": { "alias": "infiniteScrollThreshold"; "required": false; "isSignal": true; }; }, { "loadMore": "loadMore"; "valueChange": "valueChange"; }, never, ["*"], true, never>;
-}
-export {};

package/dropdown/lib/highlight-match.pipe.d.ts

@@ -1,27 +0,0 @@
-import type { PipeTransform } from '@angular/core';
-import type { MlvMatchSegment } from './option-matcher';
-import * as i0 from "@angular/core";
-/**
- * Splits a label into matched / unmatched {@link MlvMatchSegment}s for the given
- * query so a template can emphasise the matched substring (case- and
- * diacritic-insensitive; see {@link matchSegments}). Used by
- * `mlv-dropdown-panel` to highlight the query inside each suggestion.
- *
- * @example
- * ```html
- * @for (seg of option.label | mlvHighlightMatch:query; track $index) {
- *   @if (seg.matched) { <mark>{{ seg.text }}</mark> }
- *   @else { {{ seg.text }} }
- * }
- * ```
- */
-export declare class MlvHighlightMatchPipe implements PipeTransform {
-    /**
-     * @param label - The label to segment. Nullish input yields an empty result.
-     * @param query - The query to highlight; empty query returns one unmatched
-     *   segment containing the whole label.
-     */
-    transform(label: string | null | undefined, query: string): MlvMatchSegment[];
-    static ɵfac: i0.ɵɵFactoryDeclaration<MlvHighlightMatchPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<MlvHighlightMatchPipe, "mlvHighlightMatch", true>;
-}

package/dropdown/lib/option-matcher.d.ts

@@ -1,87 +0,0 @@
-import { normalizeForMatch } from '@malva-ui/cdk/utils';
-import type { MlvSelectOption } from './select-option';
-export { normalizeForMatch };
-/**
- * A contiguous slice of a label produced by {@link matchSegments}, tagged with
- * whether it is part of the query match. Rendered by consumers (e.g. the
- * dropdown panel's suggestion highlighting) as `<mark>` for matched slices and
- * plain text otherwise.
- */
-export interface MlvMatchSegment {
-    /** The original (non-folded) label text for this slice. */
-    readonly text: string;
-    /** Whether this slice is part of the matched query substring. */
-    readonly matched: boolean;
-}
-/**
- * Predicate deciding whether an option satisfies the current query. The default
- * ({@link defaultOptionMatcher}) is a case- and diacritic-insensitive substring
- * match on the option label. Provide a custom matcher to a combobox / the
- * `[mlvAutocomplete]` directive to change how suggestions are filtered (e.g.
- * fuzzy, token-prefix, or matching against a secondary field).
- *
- * A matcher receives the already-trimmed, non-empty query — an empty query is
- * short-circuited by {@link filterOptions} to return every option.
- */
-export type MlvOptionMatcher<T> = (option: MlvSelectOption<T>, query: string) => boolean;
-/**
- * The default option matcher: a case- and diacritic-insensitive substring match
- * on {@link MlvSelectOption.label}. An empty (or whitespace-only) query matches
- * every option.
- *
- * @param option - The option to test.
- * @param query - The current search query (already trimmed by callers).
- * @returns Whether the option label contains the query.
- */
-export declare function defaultOptionMatcher<T>(option: MlvSelectOption<T>, query: string): boolean;
-/**
- * Filters a list of resolved options against a query using `matcher`
- * ({@link defaultOptionMatcher} by default), then ranks **prefix matches
- * first** ({@link rankPrefixMatchesFirst}) so the top suggestion is the one an
- * inline completion can extend (`"Pe"` ranks `"Pear"` above `"Grape"`). A blank
- * query returns a shallow copy of every option — the "show everything" state a
- * combobox / autocomplete shows on focus. This is the single shared
- * implementation of the substring filter that previously lived inline in
- * `mlv-combobox`.
- *
- * @param options - The resolved options to filter.
- * @param query - The raw search query (trimmed internally).
- * @param matcher - Optional custom predicate; defaults to substring matching.
- * @returns The matcher-satisfying options, prefix matches ranked first (all
- *   options, unranked, for a blank query).
- */
-export declare function filterOptions<T>(options: readonly MlvSelectOption<T>[], query: string, matcher?: MlvOptionMatcher<T>): MlvSelectOption<T>[];
-/**
- * Stable-partitions filtered options so labels that **start with** the query
- * (case- and diacritic-insensitive) come before the remaining matches, keeping
- * the original relative order inside each partition.
- *
- * Grouped options ({@link MlvSelectOption.group}) are ranked **within each
- * consecutive same-group run** only — runs themselves never move or merge, so
- * the panel's consecutive-run group rendering (sticky headers, flat-index
- * alignment) is preserved. An ungrouped list is a single run and gets the full
- * prefix-first ordering.
- *
- * @param options - The already-filtered options.
- * @param query - The trimmed, non-empty query.
- * @returns The options with prefix matches ranked first per group run.
- */
-export declare function rankPrefixMatchesFirst<T>(options: readonly MlvSelectOption<T>[], query: string): MlvSelectOption<T>[];
-/**
- * Splits `label` into matched / unmatched {@link MlvMatchSegment}s for the first
- * occurrence of `query`, so consumers can emphasise the matched substring in a
- * suggestion (e.g. wrapping matched slices in `<mark>`).
- *
- * Matching is case- and diacritic-insensitive ({@link normalizeForMatch}); the
- * returned segment `text` preserves the **original** label casing/diacritics.
- * Because NFD folding can change string length (e.g. `"é"` → `"e"` + combining
- * mark), the search runs over a per-code-point folded projection with an index
- * map back to the original code points, keeping the highlighted slice aligned
- * with the source label. Only the first match is highlighted.
- *
- * @param label - The option label to segment.
- * @param query - The query to highlight within the label.
- * @returns Ordered segments covering the whole label; a single unmatched
- *   segment when the query is empty or not found.
- */
-export declare function matchSegments(label: string, query: string): MlvMatchSegment[];