import { FunctionalComponent } from '../../stencil-public-runtime'; /** Which side of the active tab an inactive one rests on, in physical terms — the stylesheet needs no RTL rule. */ export type TabPark = 'left' | 'right'; /** * Where an inactive tab parks: the side its content will leave to and return from. A tab later in * the strip rests past the trailing edge, an earlier one past the leading edge; under RTL the strip * runs the other way, so the sides swap. A tab not in the order at all parks past the leading edge. */ export declare const tabPark: (tag: string, active: string, order: readonly string[], direction: string) => TabPark; type LookupTabsProps = { /** The tag of the tab showing. Anything else is inactive. */ active: string; /** The tabs, in render order; each value is the panel element. */ panels: [string, unknown][]; regionRef: (el: HTMLDivElement | undefined) => void; /** * Inactive tabs that must stay laid out: the one still leaving. Every other inactive tab is * dormant -- `display: none` -- so a lookup that reaches all eight panels lays out and animates * only the one on screen. Measured on the composite page with the CPU slowed 4x: one lookup cost * 2.6s of main-thread work and froze frames for up to 840ms with seven hidden tabs laid out and * animating under the visible one, 0.7s and 93ms with them dormant (owner, 2026-10-25). * `createTabRegion.beforeSwitch` wakes the incoming tab before it measures it. */ awake?: string[]; }; /** * The tab region of a composite: every panel is mounted always, one of them active and in flow, * the rest absolutely positioned under it, hidden and inert. A switch changes the attributes and * nothing else — the transitions run from the live on-screen values, so a click mid-transition * reverses from wherever the content is. The card around the * region and the head band inside each panel never move: only each panel's `.lookup-slide` region * changes — the outgoing leaves, then the incoming arrives (a rule in vehicle-info-layout.css, * driven by `data-tab-park` / `data-tab-leaving` on the panel's host) — and the region's height * follows the incoming panel (`createTabRegion`). */ export declare const LookupTabs: FunctionalComponent; /** * Drives the region's height. At rest the region is `height: auto` and the active tab, in flow, * sets it. A change — a tab switch, or the active panel growing (a drawer opening) — is animated * from the height the region is actually showing to the new one, then released to `auto` so the * next change starts from a true measurement: * * - `beforeSwitch` runs before the DOM is patched (componentWillRender): it reads the region's * current height and the incoming tab's, once, and pins the region to the current value with * the transition off, so the patch that puts the incoming tab in flow moves nothing on screen; * - `afterSwitch` runs after the patch (componentDidRender): one forced reflow, then the target * with the transition on; * - `observe` watches the active panel with a ResizeObserver and RELEASES the region on a resize * rather than animating it — the panel already animates that distance on the same clock. * * Nothing here gates input: the settle timer only releases the pinned height. */ /** * Undoes what a dormant tab's ``s measured while it was `display: none`. Those * containers pin their height to their content's measured height whenever the content changes, and * a panel that received its answer while dormant measured 0 — so the open ones came back shut, and * service history showed its title and nothing else. An open container pinned at 0 is released to * `auto` here, on waking, before the switch measures the tab; the container pins a real height again * on its next change. Closed containers are left alone. Searched through nested shadow roots. */ export declare const reviveDormantMeasurements: (root: ParentNode | null | undefined) => void; export declare const createTabRegion: (region: () => HTMLElement | undefined) => { beforeSwitch(incoming: Element | undefined, hosts?: { incoming?: HTMLElement; outgoing?: HTMLElement; }): void; afterSwitch(incomingHost?: HTMLElement): void; observe(host: Element | undefined): void; dispose(): void; }; export {};