@pg-labs-incubator/cobweb 0.0.0-stage → 0.0.1

package/target/tsc/navigation/base.d.ts

@@ -0,0 +1,320 @@
+import type { JSX } from "solid-js";
+import type { DomProps } from "..";
+/**
+ * DOM properties shared by navigation elements.
+ *
+ * @typeParam E - native function element type
+ */
+export type NavigationElementProps<E extends HTMLElement = HTMLElement> = DomProps<E, JSX.HTMLAttributes<E>>;
+/**
+ * Callback invoked after a destination or tab is activated.
+ *
+ * @param value - value of the activated destination or tab
+ * @param event - event which activated the destination or tab
+ */
+export type NavigationChangeHandler = (value: string, event: Event) => void;
+/**
+ * Callback invoked when a component requests a new open or expanded state.
+ *
+ * @param open - requested state
+ * @param event - event which requested the state
+ */
+export type NavigationOpenChangeHandler = (open: boolean, event: Event) => void;
+/**
+ * Orientation of a navigation composite.
+ */
+export type NavigationOrientation = "horizontal" | "vertical";
+/**
+ * Tab activation behavior.
+ *
+ * | Mode          | Behavior                                                             |
+ * | ------------- | -------------------------------------------------------------------- |
+ * | `"automatic"` | Moving focus to a tab, including with the arrow keys, activates it. |
+ * | `"manual"`    | The arrow keys only move focus; Enter, Space, or a click activates. |
+ */
+export type TabActivationMode = "automatic" | "manual";
+/**
+ * Handlers of a {@link DismissDrag | dismiss drag}.
+ *
+ * A dismiss drag moves a surface from its open position towards its dismissed position at the
+ * inline start edge. The drag reports its offset as a fraction of the distance between the two
+ * positions, positive towards the dismissed position, relative to where the drag started.
+ */
+export interface DismissDragHandlers {
+    /**
+     * Start a drag once a press moved horizontally beyond the touch slop.
+     *
+     * @param event - `pointerdown` event of the press
+     * @returns distance, in pixels, between the open and the dismissed position, or `null` to
+     * decline the drag
+     */
+    begin(event: PointerEvent): number | null;
+    /**
+     * Follow the pointer.
+     *
+     * @param offset - dragged fraction of the distance towards the dismissed position
+     */
+    update(offset: number): void;
+    /**
+     * Release the drag.
+     *
+     * @param offset - dragged fraction of the distance towards the dismissed position
+     * @param velocity - release velocity towards the dismissed position, in fractions of the
+     * distance per second
+     * @param event - event which ended the drag
+     */
+    end(offset: number, velocity: number, event: PointerEvent): void;
+}
+/**
+ * Resolve JSX slots in authored property order before the containing markup is allocated.
+ *
+ * Server rendering evaluates property getters lazily, in the order a renderer reads them. A
+ * component wrapper calls this before its renderer so both server and client construct slot
+ * content in authored order, before the component's own elements, which keeps hydration keys
+ * aligned and the hydrated slot nodes owned by their component.
+ *
+ * @typeParam P - component properties type
+ * @param props - component properties
+ * @param children - controller-provided children, or `undefined` to use `props.children`
+ * @param keys - JSX slot properties, besides `children`, to resolve
+ * @returns properties whose slots are cached, reactive resolved content
+ */
+export declare function resolveNavigationSlots<P extends object>(props: P, children: JSX.Element, keys: readonly string[]): P & {
+    children: JSX.Element;
+};
+/**
+ * Create an element id which is unique within its document.
+ *
+ * The id is derived from Solid's owner-scoped {@link solid-js#createUniqueId | unique id}, which
+ * server rendering and hydration produce identically when components construct ids in the same
+ * order. When `value` is specified, a sanitized form of it is included for readability; it does
+ * **not** contribute to uniqueness, so equal values in different components still produce
+ * distinct ids.
+ *
+ * @param prefix - id prefix, such as `"cw-search-input"`
+ * @param value - optional value included in the id
+ * @returns unique element id
+ */
+export declare function uniqueId(prefix: string, value?: string): string;
+/**
+ * Resolve the selected value of a selection composite.
+ *
+ * The controlled `value` takes precedence over its `selectedValue` alias, which takes precedence
+ * over the initial `defaultValue`. A key which is present with an `undefined` value still takes
+ * precedence, since it denotes a controlled composite without a selection.
+ *
+ * @param props - composite properties
+ * @returns selected value, if any
+ *
+ * @remarks
+ * This reads properties in the caller's tracking context.
+ */
+export declare function selectedValueOf(props: {
+    value?: string;
+    selectedValue?: string;
+    defaultValue?: string;
+}): string | undefined;
+/**
+ * Test whether an element is disabled.
+ *
+ * An element is disabled when it matches `:disabled`, which includes form controls within a
+ * disabled `fieldset`, has a `disabled` attribute, or has `aria-disabled="true"`.
+ *
+ * @param elem - element to test
+ * @returns `true` if, and only if, `elem` is disabled
+ */
+export declare function isDisabledElement(elem: Element): boolean;
+/**
+ * Test whether a control and its ancestors participate in rendered, interactive content.
+ *
+ * This reads the computed style of `element` and its ancestors. Callers performing several tests
+ * in one synchronous read phase pass a shared `visibility` cache so each ancestor is read at most
+ * once.
+ *
+ * @param element - control to test
+ * @param visibility - optional cache shared within one synchronous read phase
+ * @returns `false` if, and only if, the control or an ancestor is `hidden`, `inert`, not
+ * displayed, or invisible
+ */
+export declare function isVisibleElement(element: HTMLElement, visibility?: Map<HTMLElement, boolean>): boolean;
+/**
+ * Register a modal surface, in opening order, with its owner document.
+ *
+ * Registered layers and the document's top-layer elements form one stack, ordered by when each
+ * was registered or opened. {@link isTopModalLayer} uses this order to decide which surface owns
+ * focus containment and keyboard dismissal.
+ *
+ * Register a surface once it is connected: an element rendered from a template belongs to the
+ * template's document until it is inserted.
+ *
+ * @param root - modal surface in its owner document
+ * @returns cleanup function which releases this registration
+ */
+export declare function registerModalLayer(root: Element): () => void;
+/**
+ * Test whether a registered modal surface owns focus and keyboard dismissal in its document.
+ *
+ * Registered surfaces within the top layer, such as dialog-based surfaces, take precedence over
+ * registered in-page surfaces, such as drawers; within each group, the most recently registered
+ * surface owns modality. An unregistered top-layer element which can own modality takes it away
+ * from `root` only when it opened *after* `root` was registered. Manual and hint popovers never
+ * take modality away, so an open tooltip does not disable a newer drawer.
+ *
+ * @param root - previously registered modal surface
+ * @returns `true` if, and only if, `root` owns modality
+ */
+export declare function isTopModalLayer(root: Element): boolean;
+/**
+ * Test whether a value is an element, in any realm.
+ *
+ * Unlike `instanceof HTMLElement`, this also accepts elements of adopted documents and frames.
+ *
+ * @param value - value to test
+ * @returns `true` if, and only if, `value` is an element node
+ */
+export declare function isElementNode(value: unknown): value is HTMLElement;
+/**
+ * Test whether a value is an `a` element, in any realm.
+ *
+ * @param value - value to test
+ * @returns `true` if, and only if, `value` is an `a` element
+ */
+export declare function isAnchorElement(value: unknown): value is HTMLAnchorElement;
+/**
+ * Test whether a value is a `button` element, in any realm.
+ *
+ * @param value - value to test
+ * @returns `true` if, and only if, `value` is a `button` element
+ */
+export declare function isButtonElement(value: unknown): value is HTMLButtonElement;
+/**
+ * Server renderer supplier of client builds.
+ *
+ * Component definitions select their server renderer with
+ * `isServer ? () => renderServer : unreachableServerRender`. Bundlers fold the constant `isServer`
+ * and drop server-only rendering code from client builds; client components never invoke the
+ * supplier.
+ *
+ * @returns never
+ * @throws {@link Error} always
+ */
+export declare function unreachableServerRender(): never;
+/**
+ * Test whether a click on a link asks the browser for a native alternate activation.
+ *
+ * Secondary buttons and modifier keys open links in new tabs or windows, or download them. Such
+ * activations keep their native behavior and do not select the destination.
+ *
+ * @param event - click event
+ * @param elem - activated element
+ * @returns `true` if, and only if, `elem` is a link activated with a modifier or secondary button
+ */
+export declare function isAlternateLinkActivation(event: MouseEvent, elem: Element): boolean;
+/**
+ * Prevent keyboard activation of a disabled link.
+ *
+ * Disabled links cannot use the native `disabled` attribute; this cancels Enter and Space so the
+ * browser does not follow them.
+ *
+ * @param event - keyboard event dispatched to `elem`
+ * @param elem - element receiving the event
+ */
+export declare function preventDisabledLinkKey(event: KeyboardEvent, elem: Element | null): void;
+/**
+ * Resolve the window which owns a node.
+ *
+ * @param node - node, or document, to resolve the window of
+ * @returns owner window, or `undefined` when the node has no browsing context
+ */
+export declare function ownerWindow(node: Node | null): (Window & typeof globalThis) | undefined;
+/**
+ * Read the computed style of an element using its own realm.
+ *
+ * @param element - element to read the computed style of
+ * @returns live computed style declaration
+ */
+export declare function computedStyleOf(element: Element): CSSStyleDeclaration;
+/**
+ * Resolve the `MutationObserver` constructor of the realm which owns a node.
+ *
+ * @param node - node to resolve the constructor for
+ * @returns constructor, or `undefined` when the realm does not support mutation observers
+ */
+export declare function mutationObserverOf(node: Node): typeof MutationObserver | undefined;
+/**
+ * Invoke a callback once a transition of an element's property completes.
+ *
+ * The callback runs on a `transitionend` event of the element for any of `properties`. List a
+ * logical property together with its physical counterpart, such as `inline-size` and `width`,
+ * since browsers may report the transition of a logical property under either name. When the
+ * property does not transition, the callback runs synchronously. When a transition is expected
+ * but its event is not delivered, for example because the element stopped rendering, the callback
+ * runs after the computed transition time plus {@link TRANSITION_GRACE_MSEC}.
+ *
+ * @param elem - element whose transition is awaited
+ * @param properties - names of the transitioned property
+ * @param callback - function invoked at most once
+ * @returns function which cancels a pending callback
+ */
+export declare function afterTransition(elem: HTMLElement, properties: readonly string[], callback: () => void): () => void;
+/**
+ * Collect the enabled, focusable actions which belong directly to a toolbar.
+ *
+ * Actions within a nested toolbar belong to that toolbar. Native controls remain candidates after
+ * roving focus assigns them `tabindex="-1"`; a custom action with an authored negative tab index
+ * is excluded unless `includeControllerAssigned` is `true`.
+ *
+ * @param root - toolbar element
+ * @param includeControllerAssigned - include custom actions whose tab index the toolbar assigned
+ * @returns actions in document order
+ */
+export declare function directActionableChildren(root: Element, includeControllerAssigned?: boolean): HTMLElement[];
+/**
+ * Invoke callback aliases, invoking each distinct callback once.
+ *
+ * Aliases such as `onChange`, `onValueChange`, and `onSelectedChange` frequently reference the
+ * same function; this invokes such a function once, in the order of its first occurrence.
+ *
+ * @typeParam T - callback type
+ * @param callbacks - callbacks to invoke, possibly `undefined`
+ * @param args - arguments to invoke each callback with
+ */
+export declare function dedupeCallbacks<T extends (...args: never[]) => void>(callbacks: readonly (T | undefined)[], ...args: Parameters<T>): void;
+/**
+ * Decide whether a released dismiss drag settles at the dismissed position.
+ *
+ * A fling at least `velocityThreshold` fast settles in its direction. A slower release settles
+ * at the dismissed position if, and only if, it is beyond {@link POSITIONAL_THRESHOLD}, or at it
+ * while moving towards the dismissed position.
+ *
+ * @param fraction - fraction of the distance from the open position to the dismissed position
+ * @param velocity - release velocity towards the dismissed position, in fractions per second
+ * @param velocityThreshold - minimum speed of a fling, in fractions per second
+ * @returns `true` if, and only if, the drag settles at the dismissed position
+ */
+export declare function isDismissedAt(fraction: number, velocity: number, velocityThreshold: number): boolean;
+/**
+ * Horizontal drag which moves a surface towards its dismissed position at the inline start edge.
+ *
+ * The drag starts once the primary pointer moved horizontally beyond the {@link DRAG_SLOP_PX |
+ * touch slop}; a press which moves vertically first is left to scrolling. While dragging, the
+ * pointer is captured, its positions feed a {@link ../surface/drag#DragVelocity | velocity
+ * estimator}, and the click which would follow the release is suppressed. Elements using a
+ * dismiss drag set `touch-action: pan-y`, so the browser does not claim horizontal movement.
+ */
+export declare class DismissDrag {
+    #private;
+    /**
+     * Construct a new dismiss drag.
+     *
+     * @param handlers - drag handlers
+     */
+    constructor(handlers: DismissDragHandlers);
+    /**
+     * Attach the drag to an element, or detach it.
+     *
+     * @param elem - element receiving the drag, or `null` to detach
+     */
+    attach(elem: HTMLElement | null): void;
+}
+export { deferAfterDelegatedCancellation } from "../util/event";

package/target/tsc/navigation/drawer.d.ts

@@ -0,0 +1,301 @@
+import type { JSX } from "solid-js";
+import type { DomComponent, FunctionElement, StyleElement } from "..";
+import type { NavigationChangeHandler, NavigationElementProps, NavigationOpenChangeHandler } from "./base";
+import { DomController } from "../dom/client";
+import "../container/elevation-shadow.css";
+import "./navigation.css";
+/**
+ * Navigation drawer presentation.
+ *
+ * | Variant         | Presentation                                                          |
+ * | --------------- | --------------------------------------------------------------------- |
+ * | `"modal"`       | Slides over the content, which is covered by a scrim and made inert.  |
+ * | `"dismissible"` | Slides in beside the content, pushing it toward the end edge.          |
+ * | `"permanent"`   | Always shown beside the content.                                      |
+ */
+export type NavigationDrawerVariant = "dismissible" | "modal" | "permanent";
+/**
+ * Properties of a navigation drawer.
+ */
+export type NavigationDrawerProps = NavigationElementProps<HTMLElement> & {
+    /**
+     * Drawer presentation.
+     *
+     * @defaultValue `"modal"`
+     */
+    variant?: NavigationDrawerVariant | undefined;
+    /**
+     * Alias for {@link NavigationDrawerProps.variant | `variant`}.
+     */
+    mode?: NavigationDrawerVariant | undefined;
+    /**
+     * Controlled open state of a modal or dismissible drawer.
+     *
+     * When this key is present, the drawer opens and closes only when this value changes;
+     * dismissal requests are reported through {@link NavigationDrawerProps.onOpenChange |
+     * `onOpenChange`}.
+     */
+    open?: boolean | undefined;
+    /**
+     * Initial open state of an uncontrolled modal or dismissible drawer.
+     *
+     * @defaultValue `false`
+     */
+    defaultOpen?: boolean | undefined;
+    /**
+     * Drawer content; `children` are used when this is omitted.
+     */
+    drawerContent?: JSX.Element;
+    /**
+     * Headline shown above the drawer content.
+     */
+    headline?: JSX.Element;
+    /**
+     * Application content beside or behind the drawer.
+     */
+    content?: JSX.Element;
+    /**
+     * Accessible name of a modal drawer's scrim, which dismisses the drawer.
+     *
+     * @defaultValue `"Close navigation menu"`
+     */
+    scrimLabel?: string | undefined;
+    /**
+     * Callback invoked when the drawer requests a new open state.
+     *
+     * @param open - requested state, `false` for a dismissal request
+     * @param event - event which requested the state
+     */
+    onOpenChange?: NavigationOpenChangeHandler | undefined;
+    /**
+     * Allow Escape and scrim clicks to dismiss the drawer.
+     *
+     * @defaultValue `true`
+     */
+    dismissible?: boolean | undefined;
+    /**
+     * Controlled value of the selected destination.
+     *
+     * When any of `value`, `selectedValue`, or `defaultValue` is present, the drawer coordinates
+     * the selection of the {@link ./navigation#NavigationDrawerItem | destinations} within it, as
+     * a navigation rail does; otherwise, each destination keeps its own `selected` state.
+     */
+    value?: string | undefined;
+    /**
+     * Alias for {@link NavigationDrawerProps.value | `value`}.
+     */
+    selectedValue?: string | undefined;
+    /**
+     * Initial value of the selected destination of an uncontrolled, selecting drawer.
+     */
+    defaultValue?: string | undefined;
+    /**
+     * Callback invoked after a destination of a selecting drawer is activated.
+     *
+     * Distinct callbacks run in `onChange`, `onValueChange`, `onSelectedChange` order; identical
+     * references run once.
+     */
+    onChange?: NavigationChangeHandler | undefined;
+    /**
+     * Alias for {@link NavigationDrawerProps.onChange | `onChange`}.
+     */
+    onValueChange?: NavigationChangeHandler | undefined;
+    /**
+     * Alias for {@link NavigationDrawerProps.onChange | `onChange`}.
+     */
+    onSelectedChange?: NavigationChangeHandler | undefined;
+};
+/**
+ * Properties of a labelled group of destinations within a navigation drawer.
+ */
+export type NavigationDrawerSectionProps = NavigationElementProps<HTMLDivElement> & {
+    /**
+     * Section label, which names the group.
+     */
+    label?: JSX.Element;
+};
+/**
+ * Client controller of a navigation drawer.
+ *
+ * # Elements
+ *
+ * | Element                            | Description                                       |
+ * | ---------------------------------- | ------------------------------------------------- |
+ * | `div.cw-NavigationDrawer`          | Style element; lays out the panel and content.    |
+ * | `nav.cw-NavigationDrawer-panel`    | Function element containing the drawer content.   |
+ * | `div.cw-NavigationDrawer-headline` | {@link NavigationDrawerProps.headline} slot.      |
+ * | `div.cw-NavigationDrawer-items`    | Drawer content, which scrolls below the headline. |
+ * | `button.cw-NavigationDrawer-scrim` | Scrim of a modal drawer, which dismisses it.      |
+ * | `div.cw-NavigationDrawer-content`  | {@link NavigationDrawerProps.content} slot.       |
+ *
+ * The panel fills the height of the drawer, but at most the height of the viewport, and stays in
+ * view while the page scrolls, as the sheet of a `ModalNavigationDrawer` fills the window: drawer
+ * content taller than the panel scrolls below the fixed headline.
+ *
+ * # Motion
+ *
+ * A registered progress property of the root moves the panel, fades the scrim, and pushes the
+ * content of a dismissible drawer. Opening uses the default spatial spring and closing the fast
+ * effects spring, as `ModalNavigationDrawer` does; the panel is hidden once closing completes. A
+ * drawer reopened while closing moves back open from where its motion is.
+ *
+ * An open modal drawer follows a horizontal drag of its panel or scrim towards the start edge. On
+ * release, it settles open or dismissed with the positional and velocity thresholds of Compose's
+ * `NavigationDrawer` (half the drawer width, 400dp per second), continuing the release velocity
+ * with the default spatial spring.
+ *
+ * # Modality
+ *
+ * While open, a modal drawer registers itself as a {@link ./base#registerModalLayer | modal
+ * layer}, makes the content inert, moves focus to its first focusable element, contains Tab
+ * focus within the panel and scrim, and dismisses on Escape. Once it closes, focus returns to the
+ * element focused before it opened: the content is live as soon as the drawer closes, and the
+ * panel and scrim are inert while they leave, so focus and presses reach the content during the
+ * closing motion.
+ */
+export declare class NavigationDrawerController extends DomController<NavigationDrawerProps> {
+    #private;
+    /**
+     * Construct a new drawer controller.
+     *
+     * @param props - component properties
+     */
+    constructor(props: NavigationDrawerProps);
+    /**
+     * Apply local properties to component state and styling.
+     *
+     * @see {@link ../dom/client#DomController.applyComponentProps}
+     */
+    protected applyComponentProps(): void;
+    /**
+     * Handle style element replacement before the controller reference is updated.
+     *
+     * @param curr - new style element, or `null` when absent
+     * @see {@link ../dom/client#DomController.onStyleElementChanged}
+     */
+    protected onStyleElementChanged(curr: StyleElement | null): void;
+    /**
+     * Handle function element replacement before the controller reference is updated.
+     *
+     * @param curr - new function element, or `null` when absent
+     * @see {@link ../dom/client#DomController.onFunctionElementChanged}
+     */
+    protected onFunctionElementChanged(curr: FunctionElement<NavigationDrawerProps> | null): void;
+    /**
+     * Release the modal layer, document listeners, pending motion, drag, and selection.
+     *
+     * @see {@link ../dom/client#DomController.onControllerCleanup}
+     */
+    protected onControllerCleanup(): void;
+    /**
+     * Render the component's element tree.
+     *
+     * The tree is static: presentation is applied by {@link
+     * NavigationDrawerController.applyComponentProps}. The headline, drawer content, and content
+     * slots are reactive content.
+     *
+     * @param children - nested component children, possibly an accessor
+     * @param funcRef - callback receiving the native function element
+     * @returns rendered component elements
+     * @see {@link ../dom/client#DomController.render}
+     */
+    protected render(children: JSX.Element, funcRef?: (element: HTMLElement) => void): JSX.Element;
+}
+/**
+ * Material navigation drawer.
+ *
+ * A navigation drawer presents destinations in a 360px panel at the start edge. A {@link
+ * NavigationDrawerVariant | modal} drawer slides over the application content, which it covers
+ * with a scrim; a dismissible drawer slides in beside the content; a permanent drawer is always
+ * shown. Material 3 Expressive recommends an expanded {@link ./navigation#NavigationRail |
+ * navigation rail} for new layouts.
+ *
+ * # States
+ *
+ * The drawer has controlled and uncontrolled open states; see {@link NavigationDrawerProps}. A
+ * drawer which is requested open has the `cw-NavigationDrawer-open` class; a closing drawer stays
+ * shown until its motion completes. A drawer with a `value`, `selectedValue`, or `defaultValue`
+ * coordinates the selection of its destinations.
+ *
+ * # Design
+ *
+ * The drawer is designed through the [`cw-Navigation`](./navigation.yaml) component design
+ * attribute (`drawer` roles), following `NavigationDrawerTokens`. Use {@link
+ * NavigationDrawerSection} to group destinations under a section label.
+ *
+ * # Accessibility
+ *
+ * The panel is a `nav` landmark; name it with `attr:aria-label`. See {@link
+ * NavigationDrawerController} for the modal focus behavior.
+ *
+ * @param props - component properties
+ * @returns rendered component elements
+ */
+export declare const NavigationDrawer: DomComponent<NavigationDrawerProps>;
+/**
+ * Modal navigation drawer, which covers the content with a scrim and dismisses on Escape.
+ *
+ * @param props - component properties
+ * @returns rendered component elements
+ * @see {@link NavigationDrawer}
+ */
+export declare const ModalNavigationDrawer: DomComponent<NavigationDrawerProps>;
+/**
+ * Dismissible navigation drawer, which slides in beside the content and pushes it.
+ *
+ * @param props - component properties
+ * @returns rendered component elements
+ * @see {@link NavigationDrawer}
+ */
+export declare const DismissibleNavigationDrawer: DomComponent<NavigationDrawerProps>;
+/**
+ * Permanent navigation drawer, which is always shown beside the content.
+ *
+ * @param props - component properties
+ * @returns rendered component elements
+ * @see {@link NavigationDrawer}
+ */
+export declare const PermanentNavigationDrawer: DomComponent<NavigationDrawerProps>;
+/**
+ * Client controller of a navigation drawer section.
+ *
+ * The section is a `group` named by its label, when it has one.
+ */
+export declare class NavigationDrawerSectionController extends DomController<NavigationDrawerSectionProps> {
+    #private;
+    /**
+     * Construct a new section controller.
+     *
+     * @param props - component properties
+     */
+    constructor(props: NavigationDrawerSectionProps);
+    /**
+     * Apply local properties to component state and styling.
+     *
+     * @see {@link ../dom/client#DomController.applyComponentProps}
+     */
+    protected applyComponentProps(): void;
+    /**
+     * Render the component's element tree.
+     *
+     * @param children - nested component children, possibly an accessor
+     * @returns rendered component elements
+     * @see {@link ../dom/client#DomController.render}
+     */
+    protected render(children: JSX.Element): JSX.Element;
+}
+/**
+ * Labelled group of destinations within a navigation drawer.
+ *
+ * A section shows its label in the drawer's headline style and is separated from preceding drawer
+ * content by a divider, as the Material 3 navigation drawer anatomy specifies.
+ *
+ * # Design
+ *
+ * Sections are designed through the [`cw-Navigation`](./navigation.yaml) component design
+ * attribute (`drawer` headline and divider roles).
+ *
+ * @param props - component properties
+ * @returns rendered component elements
+ */
+export declare const NavigationDrawerSection: DomComponent<NavigationDrawerSectionProps>;

package/target/tsc/navigation/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Material 3 navigation and navigation-adjacent components.
+ *
+ * This barrel keeps the public navigation surface together while implementations are split by
+ * interaction family. Native links, buttons, search inputs, and landmarks are used throughout;
+ * composite controls implement their keyboard behavior in their respective client controllers.
+ *
+ * @packageDocumentation
+ */
+import "./navigation.css";
+export type { NavigationChangeHandler, NavigationElementProps, NavigationOpenChangeHandler, NavigationOrientation, TabActivationMode } from "./base";
+export type { TabListProps, TabPanelProps, TabProps, TabsProps } from "./tabs";
+export type { NavigationContainerProps, NavigationItemProps } from "./navigation";
+export type { NavigationDrawerProps, NavigationDrawerSectionProps, NavigationDrawerVariant } from "./drawer";
+export type { AppBarItemProps, AppBarLayoutProps, BottomAppBarProps, TopAppBarProps, TopAppBarScrollBehavior, TopAppBarVariant } from "./app-bar";
+export type { FloatingToolbarExitDirection, FloatingToolbarItemProps, FloatingToolbarProps } from "./toolbar";
+export type { SearchAppBarProps, SearchBarProps } from "./search";
+export type { ScrollbarProps, ScrollFieldProps } from "./scroll";
+export { LeadingIconTab, PrimaryTabRow, SecondaryTabRow, Tab, TabController, TabList, TabListController, TabPanel, TabPanelController, TabRow, Tabs, TabsController } from "./tabs";
+export { NavigationBar, FlexibleNavigationBar, NavigationBarItem, NavigationController, NavigationDrawerItem, NavigationItem, NavigationItemController, NavigationRail, NavigationRailItem, ShortNavigationBar, ShortNavigationBarItem, WideNavigationRailItem, WideNavigationRail } from "./navigation";
+export { DismissibleNavigationDrawer, ModalNavigationDrawer, NavigationDrawer, NavigationDrawerController, NavigationDrawerSection, NavigationDrawerSectionController, PermanentNavigationDrawer } from "./drawer";
+export { AppBarColumn, AppBarItem, AppBarLayoutController, AppBarRow, BottomAppBar, BottomAppBarController, CenterAlignedTopAppBar, LargeFlexibleTopAppBar, LargeTopAppBar, MediumFlexibleTopAppBar, MediumTopAppBar, SmallTopAppBar, TopAppBar, TopAppBarController, TwoRowsTopAppBar } from "./app-bar";
+export { DockedToolbar, FloatingToolbar, FloatingToolbarController, FloatingToolbarItem, HorizontalFloatingToolbar, VerticalFloatingToolbar } from "./toolbar";
+export { DockedSearchBar, SearchAppBar, SearchBar, SearchBarController, SearchView } from "./search";
+export { HorizontalScrollbar, Scrollbar, ScrollbarController, ScrollField, ScrollFieldController, VerticalScrollbar } from "./scroll";

package/target/tsc/navigation/navigation.css.d.ts

@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: MPL-2.0
+
+export {};