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

package/dist/types/toolbar/toolbar-context.d.ts

@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react';
+/**
+ * One unit that gave way, in the order the bar held it.
+ *
+ * `separatorBefore` is derived rather than declared: the bar is the participant
+ * that hid the units, so it is the only one that knows which of its own rules
+ * are now dividing two things that are both in the surface. Fluent asks the
+ * consumer to wire the same outcome with `useIsOverflowGroupVisible`.
+ */
+export interface ToolbarCollapsedUnit {
+    readonly id: string;
+    readonly separatorBefore: boolean;
+}
+export interface ToolbarOverflowValue {
+    /**
+     * Records what a unit becomes in the surface. It is called during render and
+     * keyed by an identifier rather than by the element, because the element is
+     * not known until the ref callback runs and a consumer may put the trigger
+     * anywhere in the bar — including before an item, where a registration made
+     * in an effect would be one render behind.
+     */
+    declare: (id: string, overflow: ReactNode) => void;
+    release: (id: string) => void;
+    /** What the unit with this identifier becomes. */
+    counterpart: (id: string) => ReactNode;
+    /** The control that opens what did not fit. The bar measures it. */
+    registerTrigger: (element: HTMLElement | null) => void;
+    /** The units that gave way, in the order the bar held them. */
+    collapsed: readonly ToolbarCollapsedUnit[];
+    /** The axis the controls run along, which a separator stands across. */
+    orientation: 'horizontal' | 'vertical';
+}
+export declare const ToolbarOverflowContext: import("react").Context<ToolbarOverflowValue>;
+/**
+ * What a unit and the trigger both read. A part rendered outside a bar takes
+ * the empty value rather than throwing: `ToolbarItem` around a control in a
+ * page that is not a toolbar is a box, and a box is a reasonable thing to be.
+ */
+export declare function useToolbarOverflow(): ToolbarOverflowValue;
+/** The attribute that says a unit has somewhere to go. */
+export declare const UNIT_ATTRIBUTE = "data-unit";
+//# sourceMappingURL=toolbar-context.d.ts.map

package/dist/types/toolbar/toolbar-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-context.d.ts","sourceRoot":"","sources":["../../../src/toolbar/toolbar-context.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AAED,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,KAAK,IAAI,CAAC;IACnD,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,kDAAkD;IAClD,WAAW,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,SAAS,CAAC;IACvC,oEAAoE;IACpE,eAAe,EAAE,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IACvD,+DAA+D;IAC/D,SAAS,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC3C,wEAAwE;IACxE,WAAW,EAAE,YAAY,GAAG,UAAU,CAAC;CACxC;AAWD,eAAO,MAAM,sBAAsB,+CAA+C,CAAC;AAEnF;;;;GAIG;AACH,wBAAgB,kBAAkB,yBAEjC;AAED,0DAA0D;AAC1D,eAAO,MAAM,cAAc,cAAc,CAAC"}

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

@@ -0,0 +1,10 @@
+import type { ToolbarDefaults, ToolbarDefaultsProviderProps } from './toolbar.types';
+/** What a toolbar renders as here, before it states anything of its own. */
+export declare function useToolbarDefaults(): ToolbarDefaults;
+/**
+ * An application decides once how its bars are drawn and how they behave — a
+ * product whose bars are all framed and compact says so in one place rather
+ * than on every bar. A bar that states any of them itself still wins.
+ */
+export declare function ToolbarDefaultsProvider({ children, ...defaults }: ToolbarDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=toolbar-defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-defaults.d.ts","sourceRoot":"","sources":["../../../src/toolbar/toolbar-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAYrF,4EAA4E;AAC5E,wBAAgB,kBAAkB,IAAI,eAAe,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,4BAA4B,+BAgB9F"}

package/dist/types/toolbar/toolbar-overflow.d.ts

@@ -0,0 +1,23 @@
+import type { ToolbarOverflowProps } from './toolbar.types';
+/**
+ * The control that opens what did not fit, and the surface holding it.
+ *
+ * It is `menu`'s trigger wearing this family's geometry, so the surface, its
+ * keyboard, its dismissal and its focus return are `menu`'s and are not written
+ * twice. What this family adds is the measurement: the bar decides which units
+ * give way, and the counterparts they declared are rendered here in the order
+ * the bar held them, with a separator wherever one of the bar's own rules sat
+ * between two of them.
+ *
+ * **The `hidden` attribute on the trigger belongs to the bar.** It is written
+ * by `createCollapse` rather than by this component, because the same
+ * measurement that decides whether the control is needed is the one that has to
+ * reveal it to read its width. React writes no `hidden` here, so the two never
+ * disagree.
+ *
+ * A bar with no `ToolbarOverflow` in it collapses nothing and scrolls instead,
+ * which is the same degradation a bar of pinned units gets — one rule rather
+ * than two.
+ */
+export declare function ToolbarOverflow({ align, label, menuRef, ref, render, side, size, ...nativeProps }: ToolbarOverflowProps): import("react").JSX.Element;
+//# sourceMappingURL=toolbar-overflow.d.ts.map

package/dist/types/toolbar/toolbar-overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-overflow.d.ts","sourceRoot":"","sources":["../../../src/toolbar/toolbar-overflow.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAwB,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAgBlF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,KAAK,EACL,OAAO,EACP,GAAG,EACH,MAAM,EACN,IAAI,EACJ,IAAI,EACJ,GAAG,WAAW,EACf,EAAE,oBAAoB,+BAiEtB"}

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

@@ -0,0 +1,49 @@
+import type { ToolbarGroupProps, ToolbarItemProps, ToolbarSeparatorProps, ToolbarSpacerProps } from './toolbar.types';
+/**
+ * One unit the bar may give up, and what it becomes when it does.
+ *
+ * A unit is a direct child of the root, which is deliberately not the same
+ * thing as an item: the keyboard finds items by being focusable, at any depth,
+ * and the collapse acts on the boxes the bar lays out. A `ButtonGroup` inside
+ * one of these is one unit and four items.
+ *
+ * It is only needed under `overflow="menu"`, and only around a control the bar
+ * is allowed to hide. A control placed in a bar unwrapped is a unit too — a
+ * pinned one, because it declares nothing to become.
+ */
+export declare function ToolbarItem({ children, counterpart, ref, render, ...nativeProps }: ToolbarItemProps): 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;
+/**
+ * A run of related controls, announced as a group.
+ *
+ * The distance inside it is half the bar's gap and the distance around it is a
+ * gap and a half, so the boundary between two groups reads wider than the
+ * boundary between two controls — which is what keeps a destructive action off a
+ * frequent one. Its accessible name is the consumer's own `aria-label`: only the
+ * page knows what the run is for.
+ *
+ * The arrows do not stop at its edge. A group is a label around a run, not a
+ * second keyboard: the item list stays linear, which is what the APG's own
+ * multi-row bullet needs.
+ *
+ * It is a unit as well as a part, so `counterpart` on it moves the whole run
+ * into the surface at once — no wrapper around a box the family already owns.
+ */
+export declare function ToolbarGroup({ children, counterpart, ref, render, ...nativeProps }: ToolbarGroupProps): 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;
+/**
+ * A hairline between two runs.
+ *
+ * It is a part of this family rather than a `divider`, because its geometry
+ * belongs to the bar: it is measured against the controls beside it, and it
+ * turns with the bar. `aria-orientation` states the axis of the rule itself,
+ * which is perpendicular to the one the controls run along.
+ */
+export declare function ToolbarSeparator({ ref, render, ...nativeProps }: ToolbarSeparatorProps): 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 free space between two runs, so what follows sits at the end of the bar.
+ *
+ * It replaces a `justify` axis: an axis decides the placement of every control
+ * at once, and what a bar needs is one boundary — the editing controls at the
+ * start, the destructive one at the end.
+ */
+export declare function ToolbarSpacer({ ref, render, ...nativeProps }: ToolbarSpacerProps): 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=toolbar-parts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-parts.d.ts","sourceRoot":"","sources":["../../../src/toolbar/toolbar-parts.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AA2BzB;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,WAAW,EACX,GAAG,EACH,MAAM,EACN,GAAG,WAAW,EACf,EAAE,gBAAgB,+VAWlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,EAC3B,QAAQ,EACR,WAAW,EACX,GAAG,EACH,MAAM,EACN,GAAG,WAAW,EACf,EAAE,iBAAiB,+VAYnB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,qBAAqB,+VAUtF;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,kBAAkB,+VAQhF"}

package/dist/types/toolbar/toolbar.d.ts

@@ -0,0 +1,32 @@
+
+import type { ToolbarProps } from './toolbar.types';
+/**
+ * A set of controls that share one tab stop.
+ *
+ * **The keyboard is the whole point of the role.** `Tab` enters the bar once
+ * and lands on the control that last had focus, the arrows of the flow axis
+ * move between the controls and wrap — from row to row when the bar wrapped,
+ * because the item list is linear — and `Home` and `End` reach the ends. The
+ * cross axis duplicates the pair, which the APG permits and which is what gives
+ * focus a way out of an item that keeps the flow arrows for itself.
+ *
+ * **The items are the consumer's own controls.** Anything focusable inside the
+ * bar is an item, found through `TOOLBAR_ITEM_SELECTOR`, so this library's
+ * `button`, `link`, `checkbox`, `switch` and `text-field` — and a menu trigger,
+ * and a consumer's own control — drop in unwrapped. Radix and Base UI wrap each
+ * item in a component of their own instead. An element that cannot hold focus
+ * is not an item.
+ *
+ * **The bar paints itself and nothing inside it.** Every control keeps its own
+ * fill, its own states and its own step, which is what lets one bar hold a
+ * small icon button beside a medium select. A bar out of action is
+ * `<fieldset disabled>` around it: the platform disables every control inside
+ * and, because a natively disabled control cannot be focused, the arrows skip
+ * exactly those.
+ *
+ * The APG uses the role for three or more controls. That is guidance rather
+ * than a rule here: a role that disappeared when a permission filter removed a
+ * button would be a semantic changing behind the author.
+ */
+export declare function Toolbar({ children, className, loop, onOverflowChange, orientation, overflow, ref, render, size, style, variant, ...nativeProps }: ToolbarProps): import("react").JSX.Element;
+//# sourceMappingURL=toolbar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar.d.ts","sourceRoot":"","sources":["../../../src/toolbar/toolbar.tsx"],"names":[],"mappings":"AAAA,OAAO,qCAAqC,CAAC;AAY7C,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,iBAAiB,CAAC;AAyBtE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,OAAO,CAAC,EACtB,QAAQ,EACR,SAAS,EACT,IAAI,EACJ,gBAAgB,EAChB,WAAW,EACX,QAAQ,EACR,GAAG,EACH,MAAM,EACN,IAAI,EACJ,KAAK,EACL,OAAO,EACP,GAAG,WAAW,EACf,EAAE,YAAY,+BAoKd"}

package/dist/types/toolbar/toolbar.types.d.ts

@@ -0,0 +1,123 @@
+import type { MenuAlign, MenuHandle, MenuSide, MenuSize } from '../menu';
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode, Ref } from 'react';
+/** Which way the bar runs. */
+export type ToolbarOrientation = 'horizontal' | 'vertical';
+/** The step the bar's own inset, gap and separator sit at. */
+export type ToolbarSize = 'sm' | 'md' | 'lg';
+/** Whether the bar paints a ground of its own. */
+export type ToolbarVariant = 'plain' | 'outline';
+/**
+ * What a bar does with more controls than it has room for.
+ *
+ * `wrap` keeps every one of them visible on a second row, and the arrows wrap
+ * from row to row because the item list is linear. `scroll` is one line the
+ * arrows reveal. `menu` is one line whose units give way from the end into a
+ * surface, and it takes what is left over rather than what is convenient to
+ * hide: what must stay visible is what declares no counterpart.
+ */
+export type ToolbarOverflowMode = 'wrap' | 'scroll' | 'menu';
+/**
+ * The accessible name of the control that holds what did not fit. A string is
+ * used verbatim; a function is given the number of units behind the control,
+ * because three dots say nothing about how much is behind them.
+ */
+export type ToolbarOverflowLabel = string | ((hidden: number) => string);
+/** What an application sets once for every toolbar under it. */
+export interface ToolbarDefaults {
+    loop: boolean;
+    orientation: ToolbarOrientation;
+    overflow: ToolbarOverflowMode;
+    size: ToolbarSize;
+    variant: ToolbarVariant;
+}
+export interface ToolbarDefaultsProviderProps extends Partial<ToolbarDefaults> {
+    children?: ReactNode | undefined;
+}
+/** What `render` receives for the bar. */
+export interface ToolbarRootProps extends HTMLAttributes<HTMLElement> {
+    'data-collapsed'?: string | undefined;
+    'data-orientation': ToolbarOrientation;
+    'data-overflow': ToolbarOverflowMode;
+    'data-part': string;
+    'data-size': ToolbarSize;
+    'data-ui': string;
+    'data-variant': ToolbarVariant;
+    role: 'toolbar';
+}
+export interface ToolbarProps extends ComponentPropsWithRef<'div'> {
+    /** Whether the arrows wrap past the ends of the bar. */
+    loop?: boolean | undefined;
+    /** Defaults to the provider, then to `horizontal`. */
+    orientation?: ToolbarOrientation | undefined;
+    /** Defaults to the provider, then to `wrap`. */
+    overflow?: ToolbarOverflowMode | undefined;
+    /**
+     * Reports how many units gave way, once per change. The collapsed set is a
+     * measurement rather than a value, so there is no controlled pair over it: a
+     * consumer who owned it could assert that a bar fits when the layout says it
+     * does not.
+     */
+    onOverflowChange?: ((hidden: number) => void) | undefined;
+    /** Renders the bar into another element. */
+    render?: ((props: ToolbarRootProps) => ReactNode) | undefined;
+    /** Defaults to the provider, then to `md`. Sizes the bar, never its controls. */
+    size?: ToolbarSize | undefined;
+    /** Defaults to the provider, then to `plain`. */
+    variant?: ToolbarVariant | undefined;
+}
+export interface ToolbarGroupProps extends ComponentPropsWithRef<'div'> {
+    /**
+     * What the whole run becomes when the bar has no room for it, under
+     * `overflow="menu"`. A group that declares none is pinned.
+     */
+    counterpart?: ReactNode | undefined;
+    /** Renders the group into another element. */
+    render?: ((props: HTMLAttributes<HTMLElement>) => ReactNode) | undefined;
+}
+export interface ToolbarItemProps extends ComponentPropsWithRef<'div'> {
+    /**
+     * What the control becomes in the surface when the bar has no room for it.
+     * An item that declares none cannot be hidden, which is how a primary action
+     * stays visible: it has nowhere to go, rather than a rank above the others.
+     *
+     * It is deliberately not called `overflow`: that word is the bar's own axis,
+     * and one term with two meanings is the ambiguity the contract exists to
+     * prevent.
+     */
+    counterpart?: ReactNode | undefined;
+    /** Renders the unit into another element. */
+    render?: ((props: HTMLAttributes<HTMLElement>) => ReactNode) | undefined;
+}
+export interface ToolbarOverflowProps extends Omit<ComponentPropsWithRef<'button'>, 'children' | 'ref'> {
+    /** Where the surface sits against the trigger. */
+    align?: MenuAlign | undefined;
+    /**
+     * The accessible name. Defaults to a count — "3 more actions" — because the
+     * mark says nothing about how much is behind it. A bar in another language
+     * replaces the sentence rather than translating three dots.
+     */
+    label?: ToolbarOverflowLabel | undefined;
+    /** Reaches the surface's imperative actions: `open`, `close`, `focus`. */
+    menuRef?: Ref<MenuHandle> | undefined;
+    /** Renders the trigger as the consumer's own control. */
+    render?: ((props: ToolbarOverflowRootProps) => ReactNode) | undefined;
+    ref?: Ref<HTMLElement> | undefined;
+    side?: MenuSide | undefined;
+    /** The surface's own measure, which is `menu`'s axis rather than the bar's. */
+    size?: MenuSize | undefined;
+}
+/** What `render` receives for the control that opens what did not fit. */
+export type ToolbarOverflowRootProps = Omit<ComponentPropsWithRef<'button'>, 'ref'> & {
+    children: ReactNode;
+    'data-part': string;
+    ref?: Ref<HTMLElement> | undefined;
+};
+export interface ToolbarSeparatorProps extends ComponentPropsWithRef<'div'> {
+    /** Renders the rule into another element. */
+    render?: ((props: HTMLAttributes<HTMLElement>) => ReactNode) | undefined;
+}
+export interface ToolbarSpacerProps extends ComponentPropsWithRef<'div'> {
+    /** Renders the spacer into another element. */
+    render?: ((props: HTMLAttributes<HTMLElement>) => ReactNode) | undefined;
+}
+//# sourceMappingURL=toolbar.types.d.ts.map

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

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

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

@@ -0,0 +1,5 @@
+export { Tooltip, useTooltip } from './tooltip';
+export { TooltipDefaultsProvider, TOOLTIP_FALLBACK, useTooltipDefaults } from './tooltip-defaults';
+export { TooltipArrow, TooltipContent, TooltipLayer, TooltipTrigger } from './tooltip-parts';
+export type { TooltipAlign, TooltipArrowProps, TooltipChangeRequest, TooltipContentProps, TooltipContentRootProps, TooltipContextValue, TooltipDefaults, TooltipDefaultsProviderProps, TooltipDescribes, TooltipHandle, TooltipLayerProps, TooltipLayerRootProps, TooltipMount, TooltipOpenOn, TooltipOpenReason, TooltipProps, TooltipSide, TooltipSize, TooltipStrategy, TooltipTriggerProps, TooltipTriggerRootProps, TooltipVariant, } from './tooltip.types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tooltip/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACnG,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAC7F,YAAY,EACV,YAAY,EACZ,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,4BAA4B,EAC5B,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,WAAW,EACX,WAAW,EACX,eAAe,EACf,mBAAmB,EACnB,uBAAuB,EACvB,cAAc,GACf,MAAM,iBAAiB,CAAC"}

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

@@ -0,0 +1,39 @@
+import type { TooltipDefaults, TooltipDefaultsProviderProps } from './tooltip.types';
+/**
+ * The numbers, and why they are these numbers.
+ *
+ * `openDelay` is long enough that a pointer crossing a toolbar opens nothing
+ * and short enough that a deliberate hover is answered before the reader gives
+ * up; the surveyed field spans 600 to 1500 and disagrees with itself.
+ * `closeDelay` is the window the pointer has to travel onto the layer, and zero
+ * makes a hoverable tooltip unreachable. `groupDelay` is what stops a row of
+ * icon buttons charging the warmup once per button.
+ */
+export declare const TOOLTIP_FALLBACK: TooltipDefaults;
+/**
+ * When the last tooltip under this provider closed.
+ *
+ * It is one mutable record shared by every tooltip in the subtree, and it is
+ * the whole of the group behaviour: a tooltip asked to open inside
+ * `groupDelay` of that moment opens in the same task instead of waiting. Held
+ * per provider rather than per tooltip, because a value held per tooltip could
+ * not say what "the next one" means.
+ */
+export interface TooltipGroup {
+    lastClosedAt: number;
+}
+/** What a tooltip renders as here, before it states anything of its own. */
+export declare function useTooltipDefaults(): TooltipDefaults;
+/** The window the next tooltip in this subtree opens instantly inside. */
+export declare function useTooltipGroup(): TooltipGroup;
+/**
+ * An application decides once how its tooltips behave and look, rather than
+ * repeating the same twenty props on every one in a product. A tooltip that
+ * states any of them itself still wins.
+ *
+ * `container` is the configuration-once the capability reference asks for on
+ * behalf of the portal: an application shell that builds its own stacking
+ * context names it here, and `document.body` is the default in its absence.
+ */
+export declare function TooltipDefaultsProvider({ children, container, ...defaults }: TooltipDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=tooltip-defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip-defaults.d.ts","sourceRoot":"","sources":["../../../src/tooltip/tooltip-defaults.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,4BAA4B,EAAE,MAAM,iBAAiB,CAAC;AAErF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,EAAE,eAyB9B,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAC;CACtB;AAYD,4EAA4E;AAC5E,wBAAgB,kBAAkB,IAAI,eAAe,CAEpD;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,IAAI,YAAY,CAE9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,QAAQ,EACR,SAAS,EACT,GAAG,QAAQ,EACZ,EAAE,4BAA4B,+BA4B9B"}

package/dist/types/tooltip/tooltip-demo.d.ts

@@ -0,0 +1,33 @@
+import type { ReactNode } from 'react';
+/**
+ * One demonstration: what it is called, what to look at, and the stage that
+ * owns the distance between the examples on it. Every story composes this
+ * rather than laying itself out, so no two examples end up against each other
+ * and no story reaches for an inline style.
+ */
+export declare function Scene({ children, label, layout, note, }: {
+    children: ReactNode;
+    label: string;
+    layout?: 'block' | 'row' | 'stack' | 'prose';
+    note: ReactNode;
+}): import("react").JSX.Element;
+export declare function Grid({ children, columns }: {
+    children: ReactNode;
+    columns?: 1 | 2 | 3;
+}): import("react").JSX.Element;
+/**
+ * The ground every demonstration on this page opens inside.
+ *
+ * A tooltip is portalled to the end of the document by default, which is right
+ * in an application and wrong on a page of stacked scenes: a layer opened in
+ * one scene would draw over the scene above it. `.slotted-demo-viewport` is the
+ * workbench's own box for exactly this — `contain: paint` makes it the
+ * containing block for the layer and clips it to the scene — and every
+ * demonstration here pairs it with `portal={false}`. The one demonstration
+ * about the portal itself says so in its caption.
+ */
+export declare function Viewport({ children, inverse }: {
+    children: ReactNode;
+    inverse?: boolean;
+}): import("react").JSX.Element;
+//# sourceMappingURL=tooltip-demo.d.ts.map

package/dist/types/tooltip/tooltip-demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip-demo.d.ts","sourceRoot":"","sources":["../../../src/tooltip/tooltip-demo.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,EACpB,QAAQ,EACR,KAAK,EACL,MAAgB,EAChB,IAAI,GACL,EAAE;IACD,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,GAAG,OAAO,CAAC;IAC7C,IAAI,EAAE,SAAS,CAAC;CACjB,+BAYA;AAED,wBAAgB,IAAI,CAAC,EAAE,QAAQ,EAAE,OAAW,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;CAAE,+BAM3F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,+BAsBzF"}

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

@@ -0,0 +1,39 @@
+import type { TooltipArrowProps, TooltipContentProps, TooltipLayerProps, TooltipTriggerProps } from './tooltip.types';
+/**
+ * The element the hint is about.
+ *
+ * It renders a `button` and is meant to be given the consumer's own control
+ * through `render`, which is what nearly every tooltip in a product does. The
+ * family writes the ARIA relationship and `data-open` on it and **no
+ * `data-part`**: `data-part` names a part of the family that owns the element,
+ * and sixteen stylesheets in this repository key on `[data-part='root']`, so
+ * claiming a `badge` or a `checkbox` used as a trigger would unstyle it and
+ * nothing would report it.
+ *
+ * A control the page has disabled with the native attribute fires no pointer
+ * events at all, so the one explanation of why it is disabled would be the one
+ * nobody can reach. The reference page shows the two shapes that work:
+ * `aria-disabled` on a control that stays focusable, or a wrapping element
+ * carrying the trigger.
+ */
+export declare function TooltipTrigger({ children, ref, render, ...nativeProps }: TooltipTriggerProps): 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 positioned layer.
+ *
+ * It is the element `packages/core/src/positioner` writes `position`, `left`
+ * and `top` onto, and the one that scales and fades — the module leaves
+ * `transform` alone on purpose, and the family animates `scale` so a consumer's
+ * own `translate` is free too. Its padding is the gap between the trigger and
+ * the painted surface, which is what lets the pointer cross onto a hoverable
+ * tooltip without leaving it.
+ */
+export declare function TooltipLayer({ children, ref, render, ...nativeProps }: TooltipLayerProps): 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 painted surface, and the element the trigger's ARIA relationship names. */
+export declare function TooltipContent({ children, ref, render, ...nativeProps }: TooltipContentProps): 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 mark that points at the anchor. The family draws it; the positioner
+ * measures it and says where it goes. It is hidden from assistive technology,
+ * because it is decoration a reader has no use for.
+ */
+export declare function TooltipArrow({ ref, render, ...nativeProps }: TooltipArrowProps): 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=tooltip-parts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip-parts.d.ts","sourceRoot":"","sources":["../../../src/tooltip/tooltip-parts.tsx"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EAEnB,iBAAiB,EAEjB,mBAAmB,EAEpB,MAAM,iBAAiB,CAAC;AAyBzB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,mBAAmB,+VAwF5F;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,iBAAiB,+VA+LxF;AAED,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,mBAAmB,+VAc5F;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,iBAAiB,+VAqB9E"}

package/dist/types/tooltip/tooltip.d.ts

@@ -0,0 +1,27 @@
+
+import type { TooltipContextValue, TooltipProps } from './tooltip.types';
+/** Read by the layer, which is the only part that holds a positioner. */
+export declare function useTooltipReposition(): {
+    current: (() => void) | undefined;
+};
+/**
+ * What the tooltip around this part says. A trigger or a layer outside one has
+ * no state to report and nothing to be anchored to, so this throws rather than
+ * rendering markup that looks right and never opens.
+ */
+export declare function useTooltip(): TooltipContextValue;
+/**
+ * A short, non-interactive sentence about the element under the pointer or
+ * under focus.
+ *
+ * This component owns the state and **renders nothing**. The trigger stays
+ * where the consumer wrote it and the layer is portalled to the end of the
+ * document, so no single element could hold both — which is why the family's
+ * namesake is not the component that renders `data-part="root"` here.
+ *
+ * What it does not hold is as deliberate as what it does. The layer never takes
+ * focus and never holds a control: the APG's tooltip pattern says so, and names
+ * the non-modal dialog for the other case, which is `Popover`.
+ */
+export declare function Tooltip({ align, alignOffset, arrow, arrowPadding, children, closeDelay, closeOnPress, collisionPadding, defaultOpen, describes, disabled, flip, hideWhenDetached, hoverable, mount, onOpenChange, open, openDelay, openOn, portal, ref, shift, side, sideOffset, size, strategy, touchDelay, variant, whenClipped, }: TooltipProps): import("react").JSX.Element;
+//# sourceMappingURL=tooltip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.d.ts","sourceRoot":"","sources":["../../../src/tooltip/tooltip.tsx"],"names":[],"mappings":"AAAA,OAAO,qCAAqC,CAAC;AAgB7C,OAAO,KAAK,EAAE,mBAAmB,EAAqB,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAa5F,yEAAyE;AACzE,wBAAgB,oBAAoB;aALsB,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS;EAOjF;AAED;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,mBAAmB,CAQhD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,EACtB,KAAK,EACL,WAAW,EACX,KAAK,EACL,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,SAAS,EACT,QAAQ,EACR,IAAI,EACJ,gBAAgB,EAChB,SAAS,EACT,KAAK,EACL,YAAY,EACZ,IAAI,EACJ,SAAS,EACT,MAAM,EACN,MAAM,EACN,GAAG,EACH,KAAK,EACL,IAAI,EACJ,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,OAAO,EACP,WAAW,GACZ,EAAE,YAAY,+BA+Md"}