@slotted/react 0.0.0-stage → 0.1.0-beta.0

package/dist/types/loading-overlay/loading-overlay.d.ts

@@ -0,0 +1,22 @@
+
+
+
+import type { ReactNode } from 'react';
+import type { LoadingOverlayProps } from './loading-overlay.types';
+/**
+ * A region of the page taken out of reach while a wait the consumer owns runs.
+ *
+ * The content stays: in the document, measured, and the thing the region's
+ * geometry comes from. That is the whole difference from `skeleton`, which
+ * stands in for content that has not arrived, and the reason this family
+ * writes `inert` rather than replacing anything.
+ *
+ * Four things are composed rather than written here. `@slotted/core/loading`
+ * decides when the layer is painted; `@slotted/core/presence` keeps the panel
+ * in the document through the wash's exit; `@slotted/core/focus` moves focus
+ * out of the content before it goes inert and puts it back after; and, in page
+ * scope, `@slotted/core/dismissable-layer` in modal mode makes the rest of the
+ * document inert and locks its scroll.
+ */
+export declare function LoadingOverlay({ cancelLabel, cancellable, children, container, delay, description, indicator, live, loadedLabel, loading, messages, minDuration, onCancel, onReveal, render, renderCancel, scope, size, veil, ...nativeProps }: LoadingOverlayProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+//# sourceMappingURL=loading-overlay.d.ts.map

package/dist/types/loading-overlay/loading-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-overlay.d.ts","sourceRoot":"","sources":["../../../src/loading-overlay/loading-overlay.tsx"],"names":[],"mappings":"AAAA,OAAO,qDAAqD,CAAC;AAC7D,OAAO,2DAA2D,CAAC;AACnE,OAAO,qDAAqD,CAAC;AAS7D,OAAO,KAAK,EAA6B,SAAS,EAAE,MAAM,OAAO,CAAC;AAOlE,OAAO,KAAK,EAGV,mBAAmB,EAEpB,MAAM,yBAAyB,CAAC;AAWjC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,EAC7B,WAAW,EACX,WAAmB,EACnB,QAAQ,EACR,SAAS,EACT,KAAK,EACL,WAAW,EACX,SAAS,EACT,IAAI,EACJ,WAAW,EACX,OAAc,EACd,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,YAAY,EACZ,KAAgB,EAChB,IAAI,EACJ,IAAI,EACJ,GAAG,WAAW,EACf,EAAE,mBAAmB,+TAyNrB"}

package/dist/types/loading-overlay/loading-overlay.types.d.ts

@@ -0,0 +1,145 @@
+import type { LoadingOverlayMessages, PartialMessages } from '@slotted/core/i18n';
+import type { ChangeReason } from '@slotted/core/state';
+import type { ComponentPropsWithRef, ReactNode, SyntheticEvent } from 'react';
+/**
+ * What is covered. `region` is the box the family wraps and the safe default;
+ * `page` is the whole viewport, and `docs/component-features.md` §9 warns
+ * against reaching for it over a local operation.
+ */
+export type LoadingOverlayScope = 'region' | 'page';
+/** How the covered content is obscured. `none` blocks and dims nothing. */
+export type LoadingOverlayVeil = 'wash' | 'blur' | 'none';
+export type LoadingOverlaySize = 'sm' | 'md' | 'lg';
+/**
+ * Whether the wait announces itself. `skeleton`'s own axis and vocabulary:
+ * `off` is for a page that already says the same thing somewhere else.
+ */
+export type LoadingOverlayLive = 'polite' | 'off';
+/**
+ * Why a cancellation was asked for. `dismiss` is the reader pressing the
+ * control; `escape` is the key. There is no third: the family holds no timer
+ * and the application does not ask itself to cancel.
+ */
+export type LoadingOverlayCancelReason = Extract<ChangeReason, 'dismiss' | 'escape'>;
+/**
+ * The ask, and it commits nothing.
+ *
+ * There is deliberately no `cancel()` on it, which is the one place this
+ * request differs from every other in the library. A request can be refused
+ * only where something would otherwise commit, and nothing does here: the
+ * family does not lower `loading`, does not hide itself and does not move
+ * focus. The consumer aborts its own work and lowers `loading` when it has.
+ */
+export interface LoadingOverlayCancelRequest {
+    readonly reason: LoadingOverlayCancelReason;
+    /** The event the ask came from: a press on the control, or the key. */
+    readonly source: SyntheticEvent | KeyboardEvent;
+}
+/** What an application sets once for every overlay under it. */
+export interface LoadingOverlayDefaults {
+    /** How long the wait has to last before anything is painted. */
+    delay?: number | undefined;
+    live?: LoadingOverlayLive | undefined;
+    /** What a screen reader hears when the wait ends. Nothing by default. */
+    loadedLabel?: string | undefined;
+    /** How long a painted layer is held once it has appeared. */
+    minDuration?: number | undefined;
+    size?: LoadingOverlaySize | undefined;
+    veil?: LoadingOverlayVeil | undefined;
+}
+export interface LoadingOverlayDefaultsProviderProps extends LoadingOverlayDefaults {
+    children?: ReactNode | undefined;
+}
+/** Props the family writes on whichever element `render` returns for the root. */
+export interface LoadingOverlayRootProps extends ComponentPropsWithRef<'div'> {
+    'data-part': string;
+    'data-scope': LoadingOverlayScope;
+    'data-size': LoadingOverlaySize;
+    'data-ui': string;
+    'data-veil': LoadingOverlayVeil;
+}
+/**
+ * Props the family writes on whichever element `renderCancel` returns.
+ *
+ * `children` is required rather than optional, which is the one place these
+ * part props differ from the native element's. The family always supplies the
+ * control's words, and a consumer spreading them into a component that
+ * requires children — this library's own Button — would otherwise be told the
+ * spread might supply none.
+ */
+export interface LoadingOverlayCancelProps extends ComponentPropsWithRef<'button'> {
+    children: ReactNode;
+    'data-part': string;
+}
+export interface LoadingOverlayProps extends Omit<ComponentPropsWithRef<'div'>, 'children'> {
+    /**
+     * The content the layer covers. It stays in the document, keeps its
+     * geometry, and goes `inert` while the layer blocks.
+     *
+     * Ignored under `scope="page"`, where what is covered is the application and
+     * this family owns no part of it.
+     */
+    children?: ReactNode | undefined;
+    /**
+     * Whether the data is still on its way. The consumer's own fact: the family
+     * never moves it, so there is no controlled and uncontrolled pair and no
+     * request for it.
+     *
+     * Blocking is the default, because a consumer who forgets the prop sees a
+     * covered region on the first render, while the other default leaves a
+     * region reachable during a real wait and says nothing.
+     */
+    loading?: boolean | undefined;
+    /** Defaults to `region`. */
+    scope?: LoadingOverlayScope | undefined;
+    /** Defaults to the provider, then to `wash`. */
+    veil?: LoadingOverlayVeil | undefined;
+    /** Defaults to the provider, then to `md`. */
+    size?: LoadingOverlaySize | undefined;
+    /** Defaults to the provider, then to `polite`. */
+    live?: LoadingOverlayLive | undefined;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * short line (`label`), painted in the panel and announced once, and the
+     * cancel control's words (`cancel`).
+     */
+    messages?: PartialMessages<LoadingOverlayMessages> | undefined;
+    /** What a screen reader hears when the wait ends. Announced only if given. */
+    loadedLabel?: string | undefined;
+    /** The second line, for what the first cannot hold. Painted, never announced. */
+    description?: ReactNode | undefined;
+    /**
+     * Replaces the mark. The default is `progress-indicator`'s contained loader;
+     * a determinate wait passes `<ProgressBar value={n} />` here.
+     */
+    indicator?: ReactNode | undefined;
+    /** Renders the control that asks to stop. Absent by default. */
+    cancellable?: boolean | undefined;
+    /** What that control says, in place of the catalog's `cancel`. */
+    cancelLabel?: ReactNode | undefined;
+    /**
+     * Asks to stop, carrying the reason and the event. The family commits
+     * nothing: abort the work and lower `loading` when it has stopped.
+     */
+    onCancel?: ((request: LoadingOverlayCancelRequest) => void) | undefined;
+    /**
+     * The moment the covered content is reachable again, which is later than
+     * `loading` turning false whenever `minDuration` is holding the layer. An
+     * application moving focus on the prop would move it under the wash.
+     */
+    onReveal?: (() => void) | undefined;
+    /** Defaults to the provider, then to `0`. */
+    delay?: number | undefined;
+    /** Defaults to the provider, then to `0`. */
+    minDuration?: number | undefined;
+    /**
+     * Where the page-scoped layer is portalled. Defaults to the document body.
+     * Meaningless under `scope="region"`, where the layer belongs to the region.
+     */
+    container?: HTMLElement | null | undefined;
+    /** Renders the region into another element — a `section`, a `li`, a card. */
+    render?: ((props: LoadingOverlayRootProps) => ReactNode) | undefined;
+    /** Renders the control into another element — this library's own Button. */
+    renderCancel?: ((props: LoadingOverlayCancelProps) => ReactNode) | undefined;
+}
+//# sourceMappingURL=loading-overlay.types.d.ts.map

package/dist/types/loading-overlay/loading-overlay.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-overlay.types.d.ts","sourceRoot":"","sources":["../../../src/loading-overlay/loading-overlay.types.ts"],"names":[],"mappings":"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"}

package/dist/types/loading-overlay/use-loading-visibility.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Drives the shared timing machine from React's clock, and reports the moment
+ * a layer that was painted is withdrawn.
+ *
+ * The first answer is computed during render rather than in an effect, because
+ * an effect would paint one frame of the wrong state: with no delay set — the
+ * default — the layer would flash absent for a frame on every mount, which is
+ * the defect this whole mechanism exists to prevent, reintroduced by the
+ * mechanism itself. `skeleton` recorded the finding for the same machine.
+ *
+ * A timer is scheduled only when the machine asks for one, so an application
+ * that sets neither duration pays for no timer at all.
+ *
+ * This is the third copy of the hook in this package, after `skeleton` and
+ * `progress-indicator`. The three are separate because each family is its own
+ * bundle entry point and importing across them would tie two entries together;
+ * the rule they share lives once, in `@slotted/core/loading`, which is the part
+ * that could actually disagree between the two bindings.
+ */
+export declare function useLoadingVisibility({ delay, loading, minDuration, onWithdraw, }: {
+    delay: number;
+    loading: boolean;
+    minDuration: number;
+    onWithdraw?: (() => void) | undefined;
+}): boolean;
+//# sourceMappingURL=use-loading-visibility.d.ts.map

package/dist/types/loading-overlay/use-loading-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-loading-visibility.d.ts","sourceRoot":"","sources":["../../../src/loading-overlay/use-loading-visibility.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,KAAK,EACL,OAAO,EACP,WAAW,EACX,UAAU,GACX,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;CACvC,GAAG,OAAO,CAiCV"}

package/dist/types/markdown/index.d.ts

@@ -0,0 +1,4 @@
+export { Markdown } from './markdown';
+export { MarkdownDefaultsProvider, useMarkdownDefaults } from './markdown-defaults';
+export type { MarkdownDefaults, MarkdownDefaultsProviderProps, MarkdownExtensions, MarkdownExternal, MarkdownProps, MarkdownRenderer, MarkdownRendererProps, MarkdownRenderers, MarkdownRootProps, MarkdownStatus, MarkdownTaskChange, } from './markdown.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/markdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/markdown/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AACpF,YAAY,EACV,gBAAgB,EAChB,6BAA6B,EAC7B,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,EACd,kBAAkB,GACnB,MAAM,kBAAkB,CAAC"}

package/dist/types/markdown/markdown-defaults.d.ts

@@ -0,0 +1,10 @@
+import type { MarkdownDefaults, MarkdownDefaultsProviderProps } from './markdown.types';
+export declare function useMarkdownDefaults(): MarkdownDefaults;
+/**
+ * An application decides once how its documents treat links, alerts, anchors
+ * and URLs. A document that states any of them itself still wins; a nested
+ * provider narrows the decision for one part of the page. Its words come from
+ * the language in force (`SlottedProvider`).
+ */
+export declare function MarkdownDefaultsProvider({ children, ...defaults }: MarkdownDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=markdown-defaults.d.ts.map

package/dist/types/markdown/markdown-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-defaults.d.ts","sourceRoot":"","sources":["../../../src/markdown/markdown-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AAIxF,wBAAgB,mBAAmB,IAAI,gBAAgB,CAEtD;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,6BAA6B,+BAiBhG"}

package/dist/types/markdown/markdown.d.ts

@@ -0,0 +1,18 @@
+
+import type { ReactNode } from 'react';
+import type { MarkdownProps } from './markdown.types';
+/**
+ * A document rendered from a tree, in `prose`'s typography.
+ *
+ * The family never receives HTML. It takes mdast — remark's output as it is,
+ * or marked's through `fromMarkedTokens` — and `prepareMarkdown` from
+ * `@slotted/core/markdown` decides everything that is not an element: which
+ * types render, which URLs survive, the heading ids, the footnote numbers, the
+ * alerts. This component maps each prepared kind to an element, or to the
+ * family that already owns it: `Link`, `CodeBlock`, `Alert`, `Checkbox`.
+ *
+ * Nothing here is state. A task the reader ticks is a request against the
+ * consumer's source, and the box moves when the new tree arrives.
+ */
+export declare function Markdown({ alerts, allow, empty, extensions, external, flow, headingAnchors, headingOffset, idPrefix, isExternal, loading, messages, onRetry, onTaskChange, render, renderers, size, status, streaming, transformUrl, tree, unwrapDisallowed, ...nativeProps }: MarkdownProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/types/markdown/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/markdown/markdown.tsx"],"names":[],"mappings":"AAAA,OAAO,uCAAuC,CAAC;AAc/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAcvC,OAAO,KAAK,EAGV,aAAa,EAKd,MAAM,kBAAkB,CAAC;AAI1B;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,EACvB,MAAM,EACN,KAAK,EACL,KAAK,EACL,UAAU,EACV,QAAQ,EACR,IAAI,EACJ,cAAc,EACd,aAAa,EACb,QAAQ,EACR,UAAU,EACV,OAAe,EACf,QAAQ,EACR,OAAO,EACP,YAAY,EACZ,MAAM,EACN,SAAS,EACT,IAAI,EACJ,MAAgB,EAChB,SAAiB,EACjB,YAAY,EACZ,IAAI,EACJ,gBAAgB,EAChB,GAAG,WAAW,EACf,EAAE,aAAa,+TAwGf"}

package/dist/types/markdown/markdown.types.d.ts

@@ -0,0 +1,105 @@
+import type { MarkdownCustomElement, MarkdownElement, MarkdownKind, MarkdownNode, MarkdownUrlKind } from '@slotted/core/markdown';
+import type { MarkdownMessages, PartialMessages } from '@slotted/core/i18n';
+import type { ChangeRequest } from '@slotted/core/state';
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode } from 'react';
+import type { ProseFlow, ProseSize } from '../prose';
+/** Whether the source arrived. `loading` is separate, because a refresh keeps what is on screen. */
+export type MarkdownStatus = 'ready' | 'error';
+/** Where a link that leaves the application opens. */
+export type MarkdownExternal = 'new-tab' | 'same-tab';
+/** What an application sets once for every document under it. */
+export interface MarkdownDefaults {
+    alerts?: boolean | undefined;
+    allow?: readonly string[] | undefined;
+    external?: MarkdownExternal | undefined;
+    headingAnchors?: boolean | undefined;
+    isExternal?: ((href: string) => boolean) | undefined;
+    transformUrl?: ((url: string, kind: MarkdownUrlKind, node: MarkdownNode) => string | null) | undefined;
+}
+export interface MarkdownDefaultsProviderProps extends MarkdownDefaults {
+    children?: ReactNode | undefined;
+}
+/** What a renderer receives: the prepared element and its children, already rendered. */
+export interface MarkdownRendererProps<E extends MarkdownElement = MarkdownElement> {
+    element: E;
+    children: ReactNode;
+}
+export type MarkdownRenderer<E extends MarkdownElement = MarkdownElement> = (props: MarkdownRendererProps<E>) => ReactNode;
+/** One renderer per kind the document knows; each replaces the family's own element. */
+export type MarkdownRenderers = {
+    [K in Exclude<MarkdownKind, 'custom'>]?: MarkdownRenderer<Extract<MarkdownElement, {
+        kind: K;
+    }>>;
+};
+/** Renderers for node types outside CommonMark and GFM, by the node's own `type`. */
+export type MarkdownExtensions = Record<string, MarkdownRenderer<MarkdownCustomElement>>;
+/** What a task checkbox asks for. The box moves when the consumer's tree does. */
+export interface MarkdownTaskChange {
+    /** The task's place among the document's tasks, counted from zero. */
+    index: number;
+    checked: boolean;
+    /** Where the item starts in the source, when the adapter kept positions. */
+    offset: number | null;
+}
+export interface MarkdownRootProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode | undefined;
+    'aria-busy': true | undefined;
+    'data-empty': true | undefined;
+    'data-flow': ProseFlow;
+    'data-loading': true | undefined;
+    'data-part': string;
+    'data-status': MarkdownStatus;
+    'data-streaming': true | undefined;
+    'data-ui': string;
+}
+export interface MarkdownProps extends Omit<ComponentPropsWithRef<'div'>, 'children'> {
+    /** The document, as mdast — remark's `fromMarkdown`, or `fromMarkedTokens(marked.lexer(source))`. */
+    tree: MarkdownNode | null | undefined;
+    /** The region's type step; falls back to `prose`'s defaults. */
+    size?: ProseSize | undefined;
+    /** The space between blocks; falls back to `prose`'s defaults. */
+    flow?: ProseFlow | undefined;
+    /** `error` replaces the document with the error part. */
+    status?: MarkdownStatus | undefined;
+    /** The source is on its way: a placeholder paragraph, after `skeleton`'s delay. */
+    loading?: boolean | undefined;
+    /** The source is still arriving: the region is busy and nothing is announced per token. */
+    streaming?: boolean | undefined;
+    /** Where a link that leaves the application opens. Defaults to `new-tab`. */
+    external?: MarkdownExternal | undefined;
+    /** Whether each heading carries a permalink. */
+    headingAnchors?: boolean | undefined;
+    /** Added to every heading's depth, clamped to six: `1` under a page's `h1`. */
+    headingOffset?: number | undefined;
+    /** Written before every generated id; required when two documents share a page. */
+    idPrefix?: string | undefined;
+    /** Whether `> [!NOTE]` and its siblings become alerts. Defaults to `true`. */
+    alerts?: boolean | undefined;
+    /** The mdast types that render. Defaults to CommonMark and GFM without `html`. */
+    allow?: readonly string[] | undefined;
+    /** A disallowed node gives its children to its parent. */
+    unwrapDisallowed?: boolean | undefined;
+    /** The URL a link or image takes, or `null` to refuse it. */
+    transformUrl?: ((url: string, kind: MarkdownUrlKind, node: MarkdownNode) => string | null) | undefined;
+    /** Whether a link leaves the application. */
+    isExternal?: ((href: string) => boolean) | undefined;
+    /** Replaces the family's element for a kind. */
+    renderers?: MarkdownRenderers | undefined;
+    /** Renders a node type the family does not know — `math`, `html`, a directive. */
+    extensions?: MarkdownExtensions | undefined;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * empty, error, retry and loading texts, the footnotes heading, the back
+     * link, the heading permalink, and each alert's title (`alerts.note`).
+     */
+    messages?: PartialMessages<MarkdownMessages> | undefined;
+    /** Replaces the empty part's text — the place for the action that creates the first content. */
+    empty?: ReactNode | undefined;
+    /** Enables the task checkboxes. */
+    onTaskChange?: ((change: MarkdownTaskChange, request: ChangeRequest<boolean>) => void) | undefined;
+    /** Draws the retry button in the error part; `keyboard` when the press had no pointer. */
+    onRetry?: ((reason: 'pointer' | 'keyboard') => void) | undefined;
+    /** Renders the root into another element — `article`, `section`. */
+    render?: ((props: MarkdownRootProps) => ReactNode) | undefined;
+}
+//# sourceMappingURL=markdown.types.d.ts.map

package/dist/types/markdown/markdown.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.types.d.ts","sourceRoot":"","sources":["../../../src/markdown/markdown.types.ts"],"names":[],"mappings":"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"}

package/dist/types/menu/index.d.ts

@@ -0,0 +1,6 @@
+export { Menu, MenuSurfaceProvider, MenubarSurfaceProvider, useMenu, useMenuSurface, useMenubarSurface, } from './menu';
+export { MENU_FALLBACK, MenuDefaultsProvider, useMenuDefaults } from './menu-defaults';
+export { MenuContent, MenuTrigger } from './menu-parts';
+export { MenuCheckboxItem, MenuEmpty, MenuGroup, MenuGroupLabel, MenuHeader, MenuItem, MenuItemDescription, MenuItemIcon, MenuItemLabel, MenuItemMeta, MenuItemShortcut, MenuRadioGroup, MenuRadioItem, MenuSeparator, } from './menu-items';
+export type { MenuAlign, MenuChangeRequest, MenuCheckboxItemProps, MenuCheckedChangeRequest, MenuContentProps, MenuContentRootProps, MenuContextValue, MenuDefaults, MenuDefaultsProviderProps, MenuEntry, MenuEmptyProps, MenuFocusTarget, MenuGroupLabelProps, MenuGroupProps, MenuHandle, MenuHeaderProps, MenuItemDescriptionProps, MenuItemIconProps, MenuItemLabelProps, MenuItemMetaProps, MenuItemProps, MenuItemRootProps, MenuItemShortcutProps, MenuMount, MenuOpenReason, PartRef, MenuProps, MenuRadioGroupProps, MenuRadioItemProps, MenuSelectEvent, MenuSeparatorProps, MenuSide, MenuSize, MenuStrategy, MenuSurfaceValue, MenuTone, MenuTriggerProps, MenuTriggerRootProps, MenuValueChangeRequest, MenuValueReason, MenubarSurfaceValue, } from './menu.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/menu/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/menu/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,mBAAmB,EACnB,sBAAsB,EACtB,OAAO,EACP,cAAc,EACd,iBAAiB,GAClB,MAAM,QAAQ,CAAC;AAChB,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvF,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EACL,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,cAAc,EACd,UAAU,EACV,QAAQ,EACR,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,aAAa,GACd,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,SAAS,EACT,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACZ,yBAAyB,EACzB,SAAS,EACT,cAAc,EACd,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,UAAU,EACV,eAAe,EACf,wBAAwB,EACxB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,SAAS,EACT,cAAc,EACd,OAAO,EACP,SAAS,EACT,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,gBAAgB,EAChB,QAAQ,EACR,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACtB,eAAe,EACf,mBAAmB,GACpB,MAAM,cAAc,CAAC"}

package/dist/types/menu/menu-defaults.d.ts

@@ -0,0 +1,28 @@
+import type { MenuDefaults, MenuDefaultsProviderProps } from './menu.types';
+/**
+ * The numbers, and why they are these numbers.
+ *
+ * `side` and `align` put the surface under the start edge of its own button,
+ * where the button's text and the items' labels share one edge; `popover`
+ * centres, because it points at something instead of hanging from it.
+ *
+ * `submenuOpenDelay` is a hundred and fifty milliseconds (M2): short enough
+ * that a deliberate hover is answered before the reader presses, long enough
+ * that a pointer crossing three items on its way down opens none of them.
+ * `submenuCloseDelay` is the window the pointer has to reach the submenu once
+ * it has stopped heading there, and it is spent by `pointer-intent`.
+ *
+ * `hideWhenDetached` is `true` against `popover`'s `false`: a menu whose button
+ * has scrolled out of a pane is a list of commands for a control the reader can
+ * no longer see.
+ */
+export declare const MENU_FALLBACK: MenuDefaults;
+/** The defaults in force here. A menu reads it; a consumer rarely needs to. */
+export declare function useMenuDefaults(): MenuDefaults;
+/**
+ * The decisions an application takes once, in its bootstrap, rather than on
+ * every menu it renders. A menu that states one of them itself still wins,
+ * which is what lets a dense table's row menu differ from the header's.
+ */
+export declare function MenuDefaultsProvider({ children, container, ...overrides }: MenuDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=menu-defaults.d.ts.map

package/dist/types/menu/menu-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-defaults.d.ts","sourceRoot":"","sources":["../../../src/menu/menu-defaults.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAE5E;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,EAAE,YAuB3B,CAAC;AAIF,+EAA+E;AAC/E,wBAAgB,eAAe,IAAI,YAAY,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,SAAS,EACT,GAAG,SAAS,EACb,EAAE,yBAAyB,+BAqC3B"}

package/dist/types/menu/menu-items.d.ts

@@ -0,0 +1,50 @@
+import type { MenuCheckboxItemProps, MenuEmptyProps, MenuGroupLabelProps, MenuGroupProps, MenuHeaderProps, MenuItemDescriptionProps, MenuItemIconProps, MenuItemLabelProps, MenuItemMetaProps, MenuItemProps, MenuItemShortcutProps, MenuRadioGroupProps, MenuRadioItemProps, MenuSeparatorProps } from './menu.types';
+/** The mark in the item's first column: a glyph, or the consumer's own node. */
+export declare function MenuItemIcon({ children, ...nativeProps }: MenuItemIconProps): import("react").JSX.Element;
+export declare function MenuItemLabel({ children, ...nativeProps }: MenuItemLabelProps): import("react").JSX.Element;
+export declare function MenuItemDescription({ children, ...nativeProps }: MenuItemDescriptionProps): import("react").JSX.Element;
+/** What the item holds or counts, in its own column before the shortcut. */
+export declare function MenuItemMeta({ children, ...nativeProps }: MenuItemMetaProps): import("react").JSX.Element;
+/**
+ * The binding printed at the end of the item.
+ *
+ * Every surveyed implementation prints whatever string the consumer wrote, on
+ * every operating system. Here the notation is the library's own — `Mod+K` —
+ * and the legends are the platform's: `⌘K` on a Mac and `Ctrl+K` elsewhere,
+ * decided by the same provider `kbd` reads, so an application states its
+ * audience once.
+ */
+export declare function MenuItemShortcut({ children, keys, ...nativeProps }: MenuItemShortcutProps): import("react").JSX.Element;
+export declare function MenuItem(props: MenuItemProps): import("react").JSX.Element;
+/**
+ * An item that carries a state of its own.
+ *
+ * It does not close the menu by default, and neither does a radio item: a
+ * reader turning three things on in a View menu would otherwise open it three
+ * times. Base UI made the same choice for the same reason, and the pattern
+ * describes `Space` as changing the state without closing.
+ */
+export declare function MenuCheckboxItem({ checked, defaultChecked, onCheckedChange, ...props }: MenuCheckboxItemProps): import("react").JSX.Element;
+/** One value, chosen among the items inside it. */
+export declare function MenuRadioGroup({ children, defaultValue, onValueChange, value, ...nativeProps }: MenuRadioGroupProps): import("react").JSX.Element;
+export declare function MenuRadioItem({ value, ...props }: MenuRadioItemProps): import("react").JSX.Element;
+/**
+ * A set of items with a name. The label is inside the group and named by it,
+ * because a heading outside one belongs to nothing a reader can hear.
+ */
+export declare function MenuGroup({ children, label, ...nativeProps }: MenuGroupProps): import("react").JSX.Element;
+export declare function MenuGroupLabel({ children, ...nativeProps }: MenuGroupLabelProps): import("react").JSX.Element;
+/**
+ * Who the menu belongs to: an avatar, a name, a line under it, above the
+ * commands. Not an item — the arrows and typeahead never reach it, because a
+ * `menu` owns only items, groups and separators — so the surface names it as
+ * its description and a reader hears it once, as the menu opens. The name and
+ * the line under it are `MenuItemLabel` and `MenuItemDescription`; any other
+ * child is the media, set beside both.
+ */
+export declare function MenuHeader({ children, id, ...nativeProps }: MenuHeaderProps): import("react").JSX.Element;
+/** Not focusable and not interactive, which is what the pattern asks of it. */
+export declare function MenuSeparator(nativeProps: MenuSeparatorProps): import("react").JSX.Element;
+/** What a menu whose items were all filtered away says instead of nothing. */
+export declare function MenuEmpty({ children, ...nativeProps }: MenuEmptyProps): import("react").JSX.Element;
+//# sourceMappingURL=menu-items.d.ts.map

package/dist/types/menu/menu-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-items.d.ts","sourceRoot":"","sources":["../../../src/menu/menu-items.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,qBAAqB,EAErB,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,wBAAwB,EACxB,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EAEb,qBAAqB,EACrB,mBAAmB,EACnB,kBAAkB,EAElB,kBAAkB,EAEnB,MAAM,cAAc,CAAC;AAyDtB,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,GAAG,WAAW,EAAE,EAAE,iBAAiB,+BAM3E;AAED,wBAAgB,aAAa,CAAC,EAAE,QAAQ,EAAE,GAAG,WAAW,EAAE,EAAE,kBAAkB,+BAM7E;AAED,wBAAgB,mBAAmB,CAAC,EAAE,QAAQ,EAAE,GAAG,WAAW,EAAE,EAAE,wBAAwB,+BAMzF;AAED,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,GAAG,WAAW,EAAE,EAAE,iBAAiB,+BAM3E;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,WAAW,EAAE,EAAE,qBAAqB,+BAezF;AAoKD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,+BAE5C;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,OAAO,EACP,cAAc,EACd,eAAe,EACf,GAAG,KAAK,EACT,EAAE,qBAAqB,+BAuBvB;AAwBD,mDAAmD;AACnD,wBAAgB,cAAc,CAAC,EAC7B,QAAQ,EACR,YAAY,EACZ,aAAa,EACb,KAAK,EACL,GAAG,WAAW,EACf,EAAE,mBAAmB,+BAuBrB;AAED,wBAAgB,aAAa,CAAC,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,EAAE,kBAAkB,+BAcpE;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,WAAW,EAAE,EAAE,cAAc,+BAc5E;AAED,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,GAAG,WAAW,EAAE,EAAE,mBAAmB,+BAM/E;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,WAAW,EAAE,EAAE,eAAe,+BAgB3E;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,WAAW,EAAE,kBAAkB,+BAI5D;AAED,8EAA8E;AAC9E,wBAAgB,SAAS,CAAC,EAAE,QAAQ,EAAE,GAAG,WAAW,EAAE,EAAE,cAAc,+BAMrE"}

package/dist/types/menu/menu-parts.d.ts

@@ -0,0 +1,23 @@
+import type { MenuContentProps, MenuTriggerProps } from './menu.types';
+/** Every item of a surface, in the order the document holds them. */
+export declare const ITEM_SELECTOR = "[data-part='item']";
+/**
+ * The control that opens the surface.
+ *
+ * It renders three different elements and holds one behaviour. On its own it is
+ * the consumer's control, given through `render`; on a bar it is the bar's own
+ * `menuitem`; inside another menu's surface it is an item of that surface, with
+ * `aria-haspopup` and a chevron at the end that points along the reading
+ * direction.
+ */
+export declare function MenuTrigger({ children, icon, meta, ref, render, ...nativeProps }: MenuTriggerProps): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+/**
+ * The layer and the surface it paints.
+ *
+ * The layer is what the positioner writes `left` and `top` onto and what scales
+ * and fades; the surface is the painted panel, and it is the element carrying
+ * `role="menu"`. Two boxes rather than one, as `tooltip` and `popover` are
+ * built, because the module leaves `transform` alone on purpose.
+ */
+export declare function MenuContent({ children, loading, ref, render, ...nativeProps }: MenuContentProps): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+//# sourceMappingURL=menu-parts.d.ts.map

package/dist/types/menu/menu-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu-parts.d.ts","sourceRoot":"","sources":["../../../src/menu/menu-parts.tsx"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,gBAAgB,EAIhB,gBAAgB,EAEjB,MAAM,cAAc,CAAC;AAyBtB,qEAAqE;AACrE,eAAO,MAAM,aAAa,uBAAuB,CAAC;AAoElD;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,MAAM,EACN,GAAG,WAAW,EACf,EAAE,gBAAgB,+VA4LlB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,gBAAgB,+VA4U/F"}

package/dist/types/menu/menu.d.ts

@@ -0,0 +1,15 @@
+
+
+import type { MenuContextValue, MenuProps, MenuSurfaceValue, MenubarSurfaceValue } from './menu.types';
+export declare const MenuSurfaceProvider: import("react").Provider<MenuSurfaceValue | null>;
+export declare const MenubarSurfaceProvider: import("react").Provider<MenubarSurfaceValue | null>;
+export declare function useMenuSurface(): MenuSurfaceValue | null;
+export declare function useMenubarSurface(): MenubarSurfaceValue | null;
+/**
+ * What the menu around this part says. A trigger, a surface or an item outside
+ * one has no state to report, so this throws rather than rendering markup that
+ * looks right and never opens.
+ */
+export declare function useMenu(): MenuContextValue;
+export declare function Menu({ align, alignOffset, anchor, children, closeOnEscape, closeOnOutsidePress, closeOnSelect, collisionPadding, defaultOpen, disabled, finalFocus, flip, hideWhenDetached, loop, mount, onOpenChange, open, openOnHover, portal, ref, shift, side, sideOffset, size, strategy, submenuCloseDelay, submenuOpenDelay, typeahead, typeaheadTimeout, value, }: MenuProps): import("react").JSX.Element;
+//# sourceMappingURL=menu.d.ts.map

package/dist/types/menu/menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu.d.ts","sourceRoot":"","sources":["../../../src/menu/menu.tsx"],"names":[],"mappings":"AAAA,OAAO,+BAA+B,CAAC;AACvC,OAAO,yCAAyC,CAAC;AAcjD,OAAO,KAAK,EACV,gBAAgB,EAIhB,SAAS,EACT,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAiBtB,eAAO,MAAM,mBAAmB,mDAA8B,CAAC;AAC/D,eAAO,MAAM,sBAAsB,sDAAiC,CAAC;AAErE,wBAAgB,cAAc,IAAI,gBAAgB,GAAG,IAAI,CAExD;AAED,wBAAgB,iBAAiB,IAAI,mBAAmB,GAAG,IAAI,CAE9D;AAED;;;;GAIG;AACH,wBAAgB,OAAO,IAAI,gBAAgB,CAM1C;AAuBD,wBAAgB,IAAI,CAAC,EACnB,KAAK,EACL,WAAW,EACX,MAAM,EACN,QAAQ,EACR,aAAa,EACb,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,QAAQ,EACR,UAAU,EACV,IAAI,EACJ,gBAAgB,EAChB,IAAI,EACJ,KAAK,EACL,YAAY,EACZ,IAAI,EACJ,WAAW,EACX,MAAM,EACN,GAAG,EACH,KAAK,EACL,IAAI,EACJ,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,EACT,gBAAgB,EAChB,KAAK,GACN,EAAE,SAAS,+BA4JX"}