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

package/dist/types/kbd/key-element.d.ts

@@ -0,0 +1,28 @@
+import type { ReactNode } from 'react';
+import type { KbdPlatform, ResolvedKey } from '@slotted/core/keys';
+import type { KbdRootProps, KbdSize, KbdVariant } from './kbd.types';
+export interface KeyElementProps {
+    /**
+     * Not named `key`: React reads that attribute off the element itself, so a
+     * prop by that name would never reach this component at all.
+     */
+    resolved: ResolvedKey | undefined;
+    /** A legend the page wrote itself, which wins over the resolved one. */
+    legend: ReactNode | undefined;
+    platform: KbdPlatform | undefined;
+    size: KbdSize;
+    variant: KbdVariant;
+    disabled: boolean;
+    nativeProps: Record<string, unknown>;
+    render: ((props: KbdRootProps) => ReactNode) | undefined;
+}
+/**
+ * The one place the key's DOM is written on the React side.
+ *
+ * `Kbd` and `Shortcut` both produce key caps — one from a token a consumer
+ * named, the other from a token the shortcut parsed — and two copies of this
+ * markup would be two things to keep in step with the contract, the stylesheet
+ * and the harness fragment. There is one.
+ */
+export declare function KeyElement({ resolved, legend, platform, size, variant, disabled, nativeProps, render, }: KeyElementProps): 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=key-element.d.ts.map

package/dist/types/kbd/key-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-element.d.ts","sourceRoot":"","sources":["../../../src/kbd/key-element.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEnE,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAErE,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,EAAE,WAAW,GAAG,SAAS,CAAC;IAClC,wEAAwE;IACxE,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,WAAW,GAAG,SAAS,CAAC;IAClC,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,UAAU,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,YAAY,KAAK,SAAS,CAAC,GAAG,SAAS,CAAC;CAC1D;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,WAAW,EACX,MAAM,GACP,EAAE,eAAe,+TAyCjB"}

package/dist/types/kbd/shortcut.d.ts

@@ -0,0 +1,18 @@
+
+import type { ShortcutProps } from './kbd.types';
+/**
+ * A whole key combination, and the element the HTML Standard says it is:
+ * “nesting a `kbd` element within another `kbd` element represents an actual key
+ * or other unit of input as a portion of a larger input”. shadcn's `KbdGroup` is
+ * a `div`, and Chakra and Radix put the whole combination inside one `kbd` as
+ * text; this is the markup the specification describes.
+ *
+ * `keys` is written once and rendered for the reader's platform. The modifiers
+ * are reordered into that platform's own convention — the Apple Style Guide
+ * writes Fn, Control, Option, Shift, Command, and Microsoft writes the Windows
+ * key ahead of Ctrl, Alt and Shift — so one authored string is right on both.
+ * The escape hatch is composition rather than a fifth prop: a `Shortcut` whose
+ * keys are written by hand is rendered exactly as written.
+ */
+export declare function Shortcut({ children, disabled, keys, legends, messages, names, platform, render, separator, size, variant, ...nativeProps }: ShortcutProps): import("react").JSX.Element | null;
+//# sourceMappingURL=shortcut.d.ts.map

package/dist/types/kbd/shortcut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shortcut.d.ts","sourceRoot":"","sources":["../../../src/kbd/shortcut.tsx"],"names":[],"mappings":"AAAA,OAAO,6BAA6B,CAAC;AAUrC,OAAO,KAAK,EAAwB,aAAa,EAAE,MAAM,aAAa,CAAC;AAEvE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,EACvB,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,MAAM,EACN,SAAS,EACT,IAAI,EACJ,OAAO,EACP,GAAG,WAAW,EACf,EAAE,aAAa,sCAiFf"}

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

@@ -0,0 +1,4 @@
+export { Link } from './link';
+export { LinkDefaultsProvider, useLinkDefaults } from './link-defaults';
+export type { LinkDefaults, LinkDefaultsProviderProps, LinkProps, LinkRootProps, LinkUnderline, LinkVariant, } from './link.types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/link/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACxE,YAAY,EACV,YAAY,EACZ,yBAAyB,EACzB,SAAS,EACT,aAAa,EACb,aAAa,EACb,WAAW,GACZ,MAAM,cAAc,CAAC"}

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

@@ -0,0 +1,10 @@
+import type { LinkDefaults, LinkDefaultsProviderProps } from './link.types';
+export declare function useLinkDefaults(): LinkDefaults;
+/**
+ * An application decides once whether its links are underlined, how they are
+ * painted, and whether a followed destination is marked. A link that states
+ * any of those itself still wins: an explicit prop is never overridden by
+ * context. Its words come from the language in force (`SlottedProvider`).
+ */
+export declare function LinkDefaultsProvider({ children, ...defaults }: LinkDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=link-defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"link-defaults.d.ts","sourceRoot":"","sources":["../../../src/link/link-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAI5E,wBAAgB,eAAe,IAAI,YAAY,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,yBAAyB,+BAcxF"}

package/dist/types/link/link.d.ts

@@ -0,0 +1,18 @@
+
+
+import type { LinkProps } from './link.types';
+/**
+ * Text that goes somewhere. The element is an `a` with an `href`, so the role,
+ * `Enter`, the context menu, the middle click and every modified click are the
+ * platform's; `button` owns the action that has no URL, and `ButtonLink` owns
+ * the navigation that wants the action surface.
+ *
+ * `external` is sugar for a new browsing context, and the three things a new
+ * tab owes the reader — the safe `rel`, the visible marker, the announced
+ * warning — follow the target that is actually resolved. A consumer who writes
+ * `target="_blank"` by hand is telling the family the same fact, and gets the
+ * same answer; a consumer who writes `target="_self"` alongside `external` is
+ * overruling it, and the explicit value wins as it does everywhere else.
+ */
+export declare function Link({ children, disabled, external, href, messages, onAuxClick, onAuxClickCapture, onClick, onClickCapture, onKeyDown, onKeyDownCapture, rel, render, tabIndex, target, underline, variant, visited, ...nativeProps }: LinkProps): 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=link.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../src/link/link.tsx"],"names":[],"mappings":"AAAA,OAAO,+BAA+B,CAAC;AACvC,OAAO,qDAAqD,CAAC;AAQ7D,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,cAAc,CAAC;AAyB7D;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,EACnB,QAAQ,EACR,QAAgB,EAChB,QAAgB,EAChB,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,iBAAiB,EACjB,OAAO,EACP,cAAc,EACd,SAAS,EACT,gBAAgB,EAChB,GAAG,EACH,MAAM,EACN,QAAQ,EACR,MAAM,EACN,SAAS,EACT,OAAO,EACP,OAAO,EACP,GAAG,WAAW,EACf,EAAE,SAAS,+VAsFX"}

package/dist/types/link/link.types.d.ts

@@ -0,0 +1,44 @@
+import type { LinkMessages, PartialMessages } from '@slotted/core/i18n';
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+export type LinkUnderline = 'always' | 'hover' | 'none';
+export type LinkVariant = 'accent' | 'neutral' | 'inverse';
+/** What every link on the page looks like before it states anything of its own. */
+export interface LinkDefaults {
+    underline?: LinkUnderline | undefined;
+    variant?: LinkVariant | undefined;
+    visited?: boolean | undefined;
+}
+export interface LinkDefaultsProviderProps extends LinkDefaults {
+    children?: ReactNode;
+}
+export interface LinkRootProps extends ComponentPropsWithRef<'a'> {
+    children: ReactNode;
+    'data-disabled': true | undefined;
+    'data-part': string;
+    'data-ui': string;
+    'data-underline': LinkUnderline;
+    'data-variant': LinkVariant;
+    'data-visited': true | undefined;
+}
+export interface LinkProps extends ComponentPropsWithRef<'a'> {
+    /**
+     * Unavailable, and still discoverable. The rendered anchor keeps its place
+     * in the tab sequence and loses its destination, which is what stops a
+     * middle click as well as a left one.
+     */
+    disabled?: boolean;
+    /** Opens the destination in a new browsing context, and says so. */
+    external?: boolean;
+    /**
+     * Words laid over the catalog of the language in force: the warning a link
+     * to a new tab announces (`externalHint`).
+     */
+    messages?: PartialMessages<LinkMessages> | undefined;
+    /** Substitutes the rendered element — a router's own link, typically. */
+    render?: (props: LinkRootProps) => ReactNode;
+    underline?: LinkUnderline;
+    variant?: LinkVariant;
+    /** Paints a destination the reader has already followed. */
+    visited?: boolean;
+}
+//# sourceMappingURL=link.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"link.types.d.ts","sourceRoot":"","sources":["../../../src/link/link.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,KAAK,EAAE,qBAAqB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAE9D,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AACxD,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;AAE3D,mFAAmF;AACnF,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IACtC,OAAO,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAClC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,yBAA0B,SAAQ,YAAY;IAC7D,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,MAAM,WAAW,aAAc,SAAQ,qBAAqB,CAAC,GAAG,CAAC;IAC/D,QAAQ,EAAE,SAAS,CAAC;IACpB,eAAe,EAAE,IAAI,GAAG,SAAS,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,aAAa,CAAC;IAChC,cAAc,EAAE,WAAW,CAAC;IAC5B,cAAc,EAAE,IAAI,GAAG,SAAS,CAAC;CAClC;AAED,MAAM,WAAW,SAAU,SAAQ,qBAAqB,CAAC,GAAG,CAAC;IAC3D;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC,YAAY,CAAC,GAAG,SAAS,CAAC;IACrD,yEAAyE;IACzE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,SAAS,CAAC;IAC7C,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB"}

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

@@ -0,0 +1,5 @@
+export { List, useList } from './list';
+export { ListDefaultsProvider, useListDefaults } from './list-defaults';
+export { ListEmpty, ListSection } from './list-parts';
+export type { ListContextValue, ListDefaults, ListDefaultsProviderProps, ListEmptyProps, ListMarker, ListProps, ListRootProps, ListSectionLevel, ListSectionProps, ListSectionRootProps, ListSize, ListVariant, } from './list.types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/list/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACtD,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,yBAAyB,EACzB,cAAc,EACd,UAAU,EACV,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,QAAQ,EACR,WAAW,GACZ,MAAM,cAAc,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { ListDefaults, ListDefaultsProviderProps } from './list.types';
+/** What a list renders as here, before it states anything of its own. */
+export declare function useListDefaults(): ListDefaults;
+/**
+ * An application decides once how its lists are told apart and how much room a
+ * row gets, rather than repeating four props on every list in a product. A list
+ * that states any of them itself still wins: an explicit value is never
+ * overridden by context.
+ */
+export declare function ListDefaultsProvider({ children, ...defaults }: ListDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=list-defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-defaults.d.ts","sourceRoot":"","sources":["../../../src/list/list-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAM5E,yEAAyE;AACzE,wBAAgB,eAAe,IAAI,YAAY,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,yBAAyB,+BAexF"}

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

@@ -0,0 +1,23 @@
+import type { ListEmptyProps, ListSectionProps } from './list.types';
+/**
+ * A group inside the set: an `li` holding a heading and a nested list, which is
+ * the grouping HTML already has. MUI, Angular Material, Primer and React Aria
+ * each leave the heading loose among the rows instead, so a reader hears a
+ * heading inside a set rather than a set with a name.
+ *
+ * The nested list takes the element of the set around it, so a group inside an
+ * ordered list is ordered too, and names itself by the heading — which is what
+ * lets a reader who lands inside the group know which group it is.
+ */
+export declare function ListSection({ children, label, labelProps, level, listProps, render, sticky, ...nativeProps }: ListSectionProps): 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;
+/**
+ * What the set says when it holds nothing. It is an `li`, so the reader hears
+ * "list, one item" and then the message; a message outside the list leaves them
+ * with "list, zero items" and silence, and leaves the words outside the box a
+ * framed set paints.
+ *
+ * The family supplies the box, the height and the muted ink. The words are the
+ * page's, and `result-state` is what goes in here.
+ */
+export declare function ListEmpty({ render, ...nativeProps }: ListEmptyProps): 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=list-parts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list-parts.d.ts","sourceRoot":"","sources":["../../../src/list/list-parts.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAwB,MAAM,cAAc,CAAC;AAE3F;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,KAAK,EACL,UAAU,EACV,KAAW,EACX,SAAS,EACT,MAAM,EACN,MAAc,EACd,GAAG,WAAW,EACf,EAAE,gBAAgB,+VAiClB;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,cAAc,+VAInE"}

package/dist/types/list/list.d.ts

@@ -0,0 +1,27 @@
+
+import type { ListContextValue, ListProps } from './list.types';
+/**
+ * What the set decided, for the rows inside it. A row outside a list is not an
+ * error — an `li` the page wrote itself is still a row — so the value is
+ * optional and every reader falls back to its own default.
+ */
+export declare function useList(): ListContextValue | undefined;
+/**
+ * A vertical run of related rows. The rows are `ListItem`, a family of its own;
+ * this one decides how they are told apart, how much room each gets, what is
+ * painted in the marker column and whether they keep their inline padding, and
+ * hands those four down.
+ *
+ * **`role="list"` is written, and it is not redundant.** The family draws its
+ * own marker, because a row is a content box beside its independent targets and
+ * CSS has no `display` that is both `list-item` and a grid. Safari and
+ * VoiceOver drop list semantics the moment CSS removes the marker, so the role
+ * restores what the layout costs. A consumer who writes their own `role` — a
+ * `menu`, a `listbox` they are wiring themselves — keeps it.
+ *
+ * The set holds no state a consumer can own. Selection with roving focus is
+ * `listbox`'s and `table`'s: ARIA 1.2 does not allow `aria-selected` on
+ * `listitem`, so a selection model here would announce nothing.
+ */
+export declare function List({ inset, loading, marker, ordered, render, size, variant, ...nativeProps }: ListProps): import("react").JSX.Element;
+//# sourceMappingURL=list.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/list/list.tsx"],"names":[],"mappings":"AAAA,OAAO,+BAA+B,CAAC;AAKvC,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAiB,MAAM,cAAc,CAAC;AAI/E;;;;GAIG;AACH,wBAAgB,OAAO,IAAI,gBAAgB,GAAG,SAAS,CAEtD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,EACnB,KAAK,EACL,OAAe,EACf,MAAM,EACN,OAAe,EACf,MAAM,EACN,IAAI,EACJ,OAAO,EACP,GAAG,WAAW,EACf,EAAE,SAAS,+BAwCX"}

package/dist/types/list/list.types.d.ts

@@ -0,0 +1,96 @@
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode } from 'react';
+/** How the rows are told apart. The vocabulary is `accordion`'s. */
+export type ListVariant = 'plain' | 'ruled' | 'framed' | 'separated';
+/** The room a row gets. Density is the application's choice; this is not. */
+export type ListSize = 'sm' | 'md' | 'lg';
+/**
+ * What is painted in the marker column. It is a separate question from
+ * `ordered`: an ordered set whose rows carry their own badges paints no number
+ * and still reads in order.
+ */
+export type ListMarker = 'none' | 'bullet' | 'number';
+/** The heading a group's name is set as. `none` renders a `div`. */
+export type ListSectionLevel = 'none' | '1' | '2' | '3' | '4' | '5' | '6';
+/** What an application sets once for every list under it. */
+export interface ListDefaults {
+    inset: boolean;
+    marker: ListMarker;
+    size: ListSize;
+    variant: ListVariant;
+}
+export interface ListDefaultsProviderProps extends Partial<ListDefaults> {
+    children?: ReactNode | undefined;
+}
+/**
+ * What the set hands each row. Every value here is a fact about the set; a
+ * fact about one row — its tone, its alignment, whether it is selected — never
+ * travels this way.
+ */
+export interface ListContextValue {
+    inset: boolean;
+    marker: ListMarker;
+    ordered: boolean;
+    size: ListSize;
+    variant: ListVariant;
+}
+export interface ListRootProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode | undefined;
+    'data-inset'?: '' | undefined;
+    'data-loading'?: '' | undefined;
+    'data-marker': ListMarker;
+    'data-part': string;
+    'data-size': ListSize;
+    'data-ui': string;
+    'data-variant': ListVariant;
+}
+export interface ListProps extends ComponentPropsWithRef<'ul'> {
+    /**
+     * Takes the rows' inline padding away, for a list inside a box that already
+     * pads its own content — a card body, a dialog. The rule and the fill still
+     * run edge to edge.
+     */
+    inset?: boolean | undefined;
+    /**
+     * `aria-busy` on the set, which ARIA 1.2 §5.2.6 asks of a container whose
+     * rows have not arrived. The family draws no placeholder: `skeleton` owns
+     * that geometry and goes inside the rows.
+     */
+    loading?: boolean | undefined;
+    /** What is painted in the marker column. Defaults to the provider, then `none`. */
+    marker?: ListMarker | undefined;
+    /** Renders an `ol`, so the reading order of the set is a fact and not a look. */
+    ordered?: boolean | undefined;
+    /** Renders the wiring into another element — a `menu`, a router's own list. */
+    render?: ((props: ListRootProps) => ReactNode) | undefined;
+    /** The room a row gets. Defaults to the provider, then to `md`. */
+    size?: ListSize | undefined;
+    /** How the rows are told apart. Defaults to the provider, then to `plain`. */
+    variant?: ListVariant | undefined;
+}
+export interface ListSectionRootProps extends HTMLAttributes<HTMLElement> {
+    children?: ReactNode | undefined;
+    'data-part': string;
+}
+export interface ListSectionProps extends Omit<ComponentPropsWithRef<'li'>, 'children'> {
+    /** The rows of this group. They are nested in a list of their own. */
+    children?: ReactNode | undefined;
+    /** The group's name. */
+    label: ReactNode;
+    /** Reaches the heading element, for an id or a class the page owns. */
+    labelProps?: HTMLAttributes<HTMLElement> | undefined;
+    /** The heading this group's name is set as. Defaults to `3`. */
+    level?: ListSectionLevel | undefined;
+    /** Reaches the nested list element. */
+    listProps?: HTMLAttributes<HTMLElement> | undefined;
+    render?: ((props: ListSectionRootProps) => ReactNode) | undefined;
+    /**
+     * Keeps the group's name in place while its own rows scroll past it. It
+     * takes the set's surface and the library's sticky stack level, which is
+     * what a consumer writing `position: sticky` alone does not get.
+     */
+    sticky?: boolean | undefined;
+}
+export interface ListEmptyProps extends ComponentPropsWithRef<'li'> {
+    render?: ((props: ListSectionRootProps) => ReactNode) | undefined;
+}
+//# sourceMappingURL=list.types.d.ts.map

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

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

package/dist/types/list-item/index.d.ts

@@ -0,0 +1,6 @@
+export { ListItem, useListItem } from './list-item';
+export { ListItemButton, ListItemContent, ListItemLink } from './list-item-content';
+export { ListItemDefaultsProvider, useListItemDefaults } from './list-item-defaults';
+export { ListItemActions, ListItemBody, ListItemDescription, ListItemEnd, ListItemLabel, ListItemStart, } from './list-item-parts';
+export type { ListItemAlign, ListItemButtonProps, ListItemButtonRootProps, ListItemContentProps, ListItemContentRootProps, ListItemContextValue, ListItemCurrent, ListItemDefaults, ListItemDefaultsProviderProps, ListItemLinkProps, ListItemLinkRootProps, ListItemProps, ListItemRegionProps, ListItemRegionRootProps, ListItemRootProps, ListItemSize, ListItemTone, } from './list-item.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/list-item/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/list-item/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACpF,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACrF,OAAO,EACL,eAAe,EACf,YAAY,EACZ,mBAAmB,EACnB,WAAW,EACX,aAAa,EACb,aAAa,GACd,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,oBAAoB,EACpB,wBAAwB,EACxB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,6BAA6B,EAC7B,iBAAiB,EACjB,qBAAqB,EACrB,aAAa,EACb,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,EACjB,YAAY,EACZ,YAAY,GACb,MAAM,mBAAmB,CAAC"}

package/dist/types/list-item/list-item-content.d.ts

@@ -0,0 +1,39 @@
+import type { ListItemButtonProps, ListItemContentProps, ListItemLinkProps } from './list-item.types';
+/**
+ * Three components rather than one `as` prop, because the three are three
+ * different accessibility trees: a row that is read, a row that is one command,
+ * a row that is one destination. A string that picks between them turns a typo
+ * into a `div` no reader can reach, and nothing says so.
+ */
+/**
+ * A row that is read. It answers no pointer state, because it promises no
+ * interaction; anything the page put in `ListItemActions` is its own target and
+ * its own to disable.
+ */
+export declare function ListItemContent({ render, ...nativeProps }: ListItemContentProps): 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 row that is one command. The `button` carries the disabled state for both
+ * of the two that withdraw it, so a loading row cannot run the same command
+ * twice — which is what `docs/component-features.md` §2.5 asks of every loading
+ * control, alongside keeping the width and the accessible name.
+ */
+export declare function ListItemButton({ render, type, ...nativeProps }: ListItemButtonProps): 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 row that is one destination. An anchor has no native disabled, so a blocked
+ * one takes `aria-disabled="true"` and keeps its destination in the DOM: that
+ * attribute means perceivable but not operable, and an element under it stays
+ * focusable — so a reader can still reach the row and hear the description that
+ * says why it is unavailable. Taking the `href` away would be `disabled`
+ * semantics wearing an `aria-disabled` name.
+ *
+ * The activation is refused instead, and the same handler covers both ways in:
+ * a pointer, and `Enter` on a focused anchor, which the platform also delivers
+ * as a click.
+ *
+ * The handler composes. While the row is operable the consumer's own runs
+ * untouched; while it is not, the family stops the interaction rather than
+ * passing it on, because a control that cannot act does not report having
+ * acted.
+ */
+export declare function ListItemLink({ href, onClick, render, ...nativeProps }: ListItemLinkProps): 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=list-item-content.d.ts.map

package/dist/types/list-item/list-item-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-item-content.d.ts","sourceRoot":"","sources":["../../../src/list-item/list-item-content.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,mBAAmB,EAEnB,oBAAoB,EAEpB,iBAAiB,EAElB,MAAM,mBAAmB,CAAC;AAE3B;;;;;GAKG;AAEH;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,oBAAoB,+VAU/E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAAE,MAAM,EAAE,IAAe,EAAE,GAAG,WAAW,EAAE,EAAE,mBAAmB,+VAa9F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,iBAAiB,+VAoBxF"}

package/dist/types/list-item/list-item-defaults.d.ts

@@ -0,0 +1,10 @@
+import type { ListItemDefaults, ListItemDefaultsProviderProps } from './list-item.types';
+/** What a row renders as here, before the list or the row states anything. */
+export declare function useListItemDefaults(): ListItemDefaults;
+/**
+ * An application decides once how its rows are aligned, how far they are inset
+ * and whether a title the row cannot grow for is clipped. A row that states any
+ * of them itself still wins, and so does the list between the two.
+ */
+export declare function ListItemDefaultsProvider({ children, ...defaults }: ListItemDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=list-item-defaults.d.ts.map

package/dist/types/list-item/list-item-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-item-defaults.d.ts","sourceRoot":"","sources":["../../../src/list-item/list-item-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,6BAA6B,EAAE,MAAM,mBAAmB,CAAC;AAYzF,8EAA8E;AAC9E,wBAAgB,mBAAmB,IAAI,gBAAgB,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,EAAE,EAAE,6BAA6B,+BAgBhG"}

package/dist/types/list-item/list-item-parts.d.ts

@@ -0,0 +1,37 @@
+import type { ListItemRegionProps } from './list-item.types';
+/**
+ * The leading column: an icon, an avatar, a `Checkbox`. The column is the
+ * control glyph's own width, so whatever stands in it lands on the same line as
+ * every other row's.
+ *
+ * It is the slot and not the control. A row that drew its own check would be a
+ * second answer to the question `checkbox` already owns, and a chooser here is
+ * also what announces a selection the row only paints.
+ */
+export declare const ListItemStart: ({ render, ...nativeProps }: ListItemRegionProps) => 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 text column, and the one box in the row that may shrink. */
+export declare const ListItemBody: ({ render, ...nativeProps }: ListItemRegionProps) => 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 title. It clips under `truncate`, isolates its own direction so a title
+ * in another script leaves the row around it alone, and breaks a single
+ * unbroken token — a URL, a commit hash — rather than pushing the metadata out.
+ */
+export declare const ListItemLabel: ({ render, ...nativeProps }: ListItemRegionProps) => 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 lines under the title. They clip with it, never instead of it. */
+export declare const ListItemDescription: ({ render, ...nativeProps }: ListItemRegionProps) => 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;
+/**
+ * Trailing metadata that is part of what the row says — a timestamp, a count, a
+ * `Badge`. It is inside the box, so it is part of the row's own name for a
+ * reader and part of its target for a pointer. Anything that acts is
+ * `ListItemActions`.
+ */
+export declare const ListItemEnd: ({ render, ...nativeProps }: ListItemRegionProps) => 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;
+/**
+ * Independent targets, and a **sibling** of the box rather than its child.
+ * Interactive content may not nest inside `a` or `button`, so a row that
+ * navigates and also deletes has to put its two controls side by side. Every
+ * surveyed implementation lets a consumer nest them instead and produces HTML
+ * no browser can make focusable.
+ */
+export declare const ListItemActions: ({ render, ...nativeProps }: ListItemRegionProps) => 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=list-item-parts.d.ts.map

package/dist/types/list-item/list-item-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-item-parts.d.ts","sourceRoot":"","sources":["../../../src/list-item/list-item-parts.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAA2B,MAAM,mBAAmB,CAAC;AAUtF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,+BAhB2B,mBAAmB,gWAgB5B,CAAC;AAE7C,mEAAmE;AACnE,eAAO,MAAM,YAAY,+BAnB4B,mBAAmB,gWAmB9B,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,aAAa,+BA1B2B,mBAAmB,gWA0B5B,CAAC;AAE7C,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,+BA7BqB,mBAAmB,gWA6BhB,CAAC;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,WAAW,+BArC6B,mBAAmB,gWAqChC,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,+BA9CyB,mBAAmB,gWA8CxB,CAAC"}

package/dist/types/list-item/list-item.d.ts

@@ -0,0 +1,25 @@
+
+import type { ListItemContextValue, ListItemProps } from './list-item.types';
+/**
+ * The two states the box inside the row has to answer. A content component
+ * outside a row is not an error — the fallback says the box is operable — so a
+ * page composing its own row still gets a working control.
+ */
+export declare function useListItem(): ListItemContextValue;
+/**
+ * One entry of a `List`: the `li`, and every state the row paints. The box that
+ * is read, hovered, focused and sometimes activated is `ListItemContent`,
+ * `ListItemButton` or `ListItemLink`, and `ListItemActions` is that box's
+ * sibling — interactive content may not nest inside `a` or `button`.
+ *
+ * Four values come from the list when the row does not state them: `variant`,
+ * `size`, `marker` and `inset`. Everything else is a fact about this row.
+ *
+ * **No state attribute the roles model forbids reaches the `li`.** ARIA 1.2
+ * deprecates `aria-disabled` on `listitem`, so `disabled` is painted from
+ * `data-disabled` and the attribute that means it is written on the box.
+ * `aria-current` is inherited by the role and is not deprecated, so `current`
+ * is announced here.
+ */
+export declare function ListItem({ align, children, current, disabled, inset, loading, marker, position, render, selected, setSize, size, tone, truncate, variant, ...nativeProps }: ListItemProps): import("react").JSX.Element;
+//# sourceMappingURL=list-item.d.ts.map

package/dist/types/list-item/list-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-item.d.ts","sourceRoot":"","sources":["../../../src/list-item/list-item.tsx"],"names":[],"mappings":"AAAA,OAAO,yCAAyC,CAAC;AAOjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAqB,MAAM,mBAAmB,CAAC;AAIhG;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,oBAAoB,CAElD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,EACvB,KAAK,EACL,QAAQ,EACR,OAAe,EACf,QAAgB,EAChB,KAAK,EACL,OAAe,EACf,MAAM,EACN,QAAQ,EACR,MAAM,EACN,QAAgB,EAChB,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,OAAO,EACP,GAAG,WAAW,EACf,EAAE,aAAa,+BAoDf"}